Source file src/github.com/stretchr/objx/type_specific_codegen_test.go

Documentation: github.com/stretchr/objx

     1  package objx_test
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/stretchr/objx"
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  /*
    12  Tests for Inter (interface{} and []interface{})
    13  */
    14  func TestInter(t *testing.T) {
    15  	val := interface{}("something")
    16  	m := objx.Map{"value": val, "nothing": nil}
    17  
    18  	assert.Equal(t, val, m.Get("value").Inter())
    19  	assert.Equal(t, val, m.Get("value").MustInter())
    20  	assert.Equal(t, interface{}(nil), m.Get("nothing").Inter())
    21  	assert.Equal(t, val, m.Get("nothing").Inter("something"))
    22  	assert.Panics(t, func() {
    23  		m.Get("age").MustInter()
    24  	})
    25  }
    26  
    27  func TestInterSlice(t *testing.T) {
    28  	val := interface{}("something")
    29  	m := objx.Map{"value": []interface{}{val}, "nothing": nil}
    30  
    31  	assert.Equal(t, val, m.Get("value").InterSlice()[0])
    32  	assert.Equal(t, val, m.Get("value").MustInterSlice()[0])
    33  	assert.Equal(t, []interface{}(nil), m.Get("nothing").InterSlice())
    34  	assert.Equal(t, val, m.Get("nothing").InterSlice([]interface{}{interface{}("something")})[0])
    35  	assert.Panics(t, func() {
    36  		m.Get("nothing").MustInterSlice()
    37  	})
    38  }
    39  
    40  func TestIsInter(t *testing.T) {
    41  	m := objx.Map{"data": interface{}("something")}
    42  
    43  	assert.True(t, m.Get("data").IsInter())
    44  }
    45  
    46  func TestIsInterSlice(t *testing.T) {
    47  	m := objx.Map{"data": []interface{}{interface{}("something")}}
    48  
    49  	assert.True(t, m.Get("data").IsInterSlice())
    50  }
    51  
    52  func TestEachInter(t *testing.T) {
    53  	m := objx.Map{"data": []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}}
    54  	count := 0
    55  	replacedVals := make([]interface{}, 0)
    56  	assert.Equal(t, m.Get("data"), m.Get("data").EachInter(func(i int, val interface{}) bool {
    57  		count++
    58  		replacedVals = append(replacedVals, val)
    59  
    60  		// abort early
    61  		return i != 2
    62  	}))
    63  
    64  	assert.Equal(t, count, 3)
    65  	assert.Equal(t, replacedVals[0], m.Get("data").MustInterSlice()[0])
    66  	assert.Equal(t, replacedVals[1], m.Get("data").MustInterSlice()[1])
    67  	assert.Equal(t, replacedVals[2], m.Get("data").MustInterSlice()[2])
    68  }
    69  
    70  func TestWhereInter(t *testing.T) {
    71  	m := objx.Map{"data": []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}}
    72  
    73  	selected := m.Get("data").WhereInter(func(i int, val interface{}) bool {
    74  		return i%2 == 0
    75  	}).MustInterSlice()
    76  
    77  	assert.Equal(t, 3, len(selected))
    78  }
    79  
    80  func TestGroupInter(t *testing.T) {
    81  	m := objx.Map{"data": []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}}
    82  
    83  	grouped := m.Get("data").GroupInter(func(i int, val interface{}) string {
    84  		return fmt.Sprintf("%v", i%2 == 0)
    85  	}).Data().(map[string][]interface{})
    86  
    87  	assert.Equal(t, 2, len(grouped))
    88  	assert.Equal(t, 3, len(grouped["true"]))
    89  	assert.Equal(t, 3, len(grouped["false"]))
    90  }
    91  
    92  func TestReplaceInter(t *testing.T) {
    93  	m := objx.Map{"data": []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}}
    94  	rawArr := m.Get("data").MustInterSlice()
    95  
    96  	replaced := m.Get("data").ReplaceInter(func(index int, val interface{}) interface{} {
    97  		if index < len(rawArr)-1 {
    98  			return rawArr[index+1]
    99  		}
   100  		return rawArr[0]
   101  	})
   102  	replacedArr := replaced.MustInterSlice()
   103  
   104  	if assert.Equal(t, 6, len(replacedArr)) {
   105  		assert.Equal(t, replacedArr[0], rawArr[1])
   106  		assert.Equal(t, replacedArr[1], rawArr[2])
   107  		assert.Equal(t, replacedArr[2], rawArr[3])
   108  		assert.Equal(t, replacedArr[3], rawArr[4])
   109  		assert.Equal(t, replacedArr[4], rawArr[5])
   110  		assert.Equal(t, replacedArr[5], rawArr[0])
   111  	}
   112  }
   113  
   114  func TestCollectInter(t *testing.T) {
   115  	m := objx.Map{"data": []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}}
   116  
   117  	collected := m.Get("data").CollectInter(func(index int, val interface{}) interface{} {
   118  		return index
   119  	})
   120  	collectedArr := collected.MustInterSlice()
   121  
   122  	if assert.Equal(t, 6, len(collectedArr)) {
   123  		assert.Equal(t, collectedArr[0], 0)
   124  		assert.Equal(t, collectedArr[1], 1)
   125  		assert.Equal(t, collectedArr[2], 2)
   126  		assert.Equal(t, collectedArr[3], 3)
   127  		assert.Equal(t, collectedArr[4], 4)
   128  		assert.Equal(t, collectedArr[5], 5)
   129  	}
   130  }
   131  
   132  /*
   133  Tests for Bool (bool and []bool)
   134  */
   135  func TestBool(t *testing.T) {
   136  	val := bool(true)
   137  	m := objx.Map{"value": val, "nothing": nil}
   138  
   139  	assert.Equal(t, val, m.Get("value").Bool())
   140  	assert.Equal(t, val, m.Get("value").MustBool())
   141  	assert.Equal(t, bool(false), m.Get("nothing").Bool())
   142  	assert.Equal(t, val, m.Get("nothing").Bool(true))
   143  	assert.Panics(t, func() {
   144  		m.Get("age").MustBool()
   145  	})
   146  }
   147  
   148  func TestBoolSlice(t *testing.T) {
   149  	val := bool(true)
   150  	m := objx.Map{"value": []bool{val}, "nothing": nil}
   151  
   152  	assert.Equal(t, val, m.Get("value").BoolSlice()[0])
   153  	assert.Equal(t, val, m.Get("value").MustBoolSlice()[0])
   154  	assert.Equal(t, []bool(nil), m.Get("nothing").BoolSlice())
   155  	assert.Equal(t, val, m.Get("nothing").BoolSlice([]bool{bool(true)})[0])
   156  	assert.Panics(t, func() {
   157  		m.Get("nothing").MustBoolSlice()
   158  	})
   159  }
   160  
   161  func TestIsBool(t *testing.T) {
   162  	m := objx.Map{"data": bool(true)}
   163  
   164  	assert.True(t, m.Get("data").IsBool())
   165  }
   166  
   167  func TestIsBoolSlice(t *testing.T) {
   168  	m := objx.Map{"data": []bool{bool(true)}}
   169  
   170  	assert.True(t, m.Get("data").IsBoolSlice())
   171  }
   172  
   173  func TestEachBool(t *testing.T) {
   174  	m := objx.Map{"data": []bool{bool(true), bool(true), bool(true), bool(true), bool(true)}}
   175  	count := 0
   176  	replacedVals := make([]bool, 0)
   177  	assert.Equal(t, m.Get("data"), m.Get("data").EachBool(func(i int, val bool) bool {
   178  		count++
   179  		replacedVals = append(replacedVals, val)
   180  
   181  		// abort early
   182  		return i != 2
   183  	}))
   184  
   185  	assert.Equal(t, count, 3)
   186  	assert.Equal(t, replacedVals[0], m.Get("data").MustBoolSlice()[0])
   187  	assert.Equal(t, replacedVals[1], m.Get("data").MustBoolSlice()[1])
   188  	assert.Equal(t, replacedVals[2], m.Get("data").MustBoolSlice()[2])
   189  }
   190  
   191  func TestWhereBool(t *testing.T) {
   192  	m := objx.Map{"data": []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}}
   193  
   194  	selected := m.Get("data").WhereBool(func(i int, val bool) bool {
   195  		return i%2 == 0
   196  	}).MustBoolSlice()
   197  
   198  	assert.Equal(t, 3, len(selected))
   199  }
   200  
   201  func TestGroupBool(t *testing.T) {
   202  	m := objx.Map{"data": []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}}
   203  
   204  	grouped := m.Get("data").GroupBool(func(i int, val bool) string {
   205  		return fmt.Sprintf("%v", i%2 == 0)
   206  	}).Data().(map[string][]bool)
   207  
   208  	assert.Equal(t, 2, len(grouped))
   209  	assert.Equal(t, 3, len(grouped["true"]))
   210  	assert.Equal(t, 3, len(grouped["false"]))
   211  }
   212  
   213  func TestReplaceBool(t *testing.T) {
   214  	m := objx.Map{"data": []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}}
   215  	rawArr := m.Get("data").MustBoolSlice()
   216  
   217  	replaced := m.Get("data").ReplaceBool(func(index int, val bool) bool {
   218  		if index < len(rawArr)-1 {
   219  			return rawArr[index+1]
   220  		}
   221  		return rawArr[0]
   222  	})
   223  	replacedArr := replaced.MustBoolSlice()
   224  
   225  	if assert.Equal(t, 6, len(replacedArr)) {
   226  		assert.Equal(t, replacedArr[0], rawArr[1])
   227  		assert.Equal(t, replacedArr[1], rawArr[2])
   228  		assert.Equal(t, replacedArr[2], rawArr[3])
   229  		assert.Equal(t, replacedArr[3], rawArr[4])
   230  		assert.Equal(t, replacedArr[4], rawArr[5])
   231  		assert.Equal(t, replacedArr[5], rawArr[0])
   232  	}
   233  }
   234  
   235  func TestCollectBool(t *testing.T) {
   236  	m := objx.Map{"data": []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}}
   237  
   238  	collected := m.Get("data").CollectBool(func(index int, val bool) interface{} {
   239  		return index
   240  	})
   241  	collectedArr := collected.MustInterSlice()
   242  
   243  	if assert.Equal(t, 6, len(collectedArr)) {
   244  		assert.Equal(t, collectedArr[0], 0)
   245  		assert.Equal(t, collectedArr[1], 1)
   246  		assert.Equal(t, collectedArr[2], 2)
   247  		assert.Equal(t, collectedArr[3], 3)
   248  		assert.Equal(t, collectedArr[4], 4)
   249  		assert.Equal(t, collectedArr[5], 5)
   250  	}
   251  }
   252  
   253  /*
   254  Tests for Str (string and []string)
   255  */
   256  func TestStr(t *testing.T) {
   257  	val := string("hello")
   258  	m := objx.Map{"value": val, "nothing": nil}
   259  
   260  	assert.Equal(t, val, m.Get("value").Str())
   261  	assert.Equal(t, val, m.Get("value").MustStr())
   262  	assert.Equal(t, string(""), m.Get("nothing").Str())
   263  	assert.Equal(t, val, m.Get("nothing").Str("hello"))
   264  	assert.Panics(t, func() {
   265  		m.Get("age").MustStr()
   266  	})
   267  }
   268  
   269  func TestStrSlice(t *testing.T) {
   270  	val := string("hello")
   271  	m := objx.Map{"value": []string{val}, "nothing": nil}
   272  
   273  	assert.Equal(t, val, m.Get("value").StrSlice()[0])
   274  	assert.Equal(t, val, m.Get("value").MustStrSlice()[0])
   275  	assert.Equal(t, []string(nil), m.Get("nothing").StrSlice())
   276  	assert.Equal(t, val, m.Get("nothing").StrSlice([]string{string("hello")})[0])
   277  	assert.Panics(t, func() {
   278  		m.Get("nothing").MustStrSlice()
   279  	})
   280  }
   281  
   282  func TestIsStr(t *testing.T) {
   283  	m := objx.Map{"data": string("hello")}
   284  
   285  	assert.True(t, m.Get("data").IsStr())
   286  }
   287  
   288  func TestIsStrSlice(t *testing.T) {
   289  	m := objx.Map{"data": []string{string("hello")}}
   290  
   291  	assert.True(t, m.Get("data").IsStrSlice())
   292  }
   293  
   294  func TestEachStr(t *testing.T) {
   295  	m := objx.Map{"data": []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}}
   296  	count := 0
   297  	replacedVals := make([]string, 0)
   298  	assert.Equal(t, m.Get("data"), m.Get("data").EachStr(func(i int, val string) bool {
   299  		count++
   300  		replacedVals = append(replacedVals, val)
   301  
   302  		// abort early
   303  		return i != 2
   304  	}))
   305  
   306  	assert.Equal(t, count, 3)
   307  	assert.Equal(t, replacedVals[0], m.Get("data").MustStrSlice()[0])
   308  	assert.Equal(t, replacedVals[1], m.Get("data").MustStrSlice()[1])
   309  	assert.Equal(t, replacedVals[2], m.Get("data").MustStrSlice()[2])
   310  }
   311  
   312  func TestWhereStr(t *testing.T) {
   313  	m := objx.Map{"data": []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}}
   314  
   315  	selected := m.Get("data").WhereStr(func(i int, val string) bool {
   316  		return i%2 == 0
   317  	}).MustStrSlice()
   318  
   319  	assert.Equal(t, 3, len(selected))
   320  }
   321  
   322  func TestGroupStr(t *testing.T) {
   323  	m := objx.Map{"data": []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}}
   324  
   325  	grouped := m.Get("data").GroupStr(func(i int, val string) string {
   326  		return fmt.Sprintf("%v", i%2 == 0)
   327  	}).Data().(map[string][]string)
   328  
   329  	assert.Equal(t, 2, len(grouped))
   330  	assert.Equal(t, 3, len(grouped["true"]))
   331  	assert.Equal(t, 3, len(grouped["false"]))
   332  }
   333  
   334  func TestReplaceStr(t *testing.T) {
   335  	m := objx.Map{"data": []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}}
   336  	rawArr := m.Get("data").MustStrSlice()
   337  
   338  	replaced := m.Get("data").ReplaceStr(func(index int, val string) string {
   339  		if index < len(rawArr)-1 {
   340  			return rawArr[index+1]
   341  		}
   342  		return rawArr[0]
   343  	})
   344  	replacedArr := replaced.MustStrSlice()
   345  
   346  	if assert.Equal(t, 6, len(replacedArr)) {
   347  		assert.Equal(t, replacedArr[0], rawArr[1])
   348  		assert.Equal(t, replacedArr[1], rawArr[2])
   349  		assert.Equal(t, replacedArr[2], rawArr[3])
   350  		assert.Equal(t, replacedArr[3], rawArr[4])
   351  		assert.Equal(t, replacedArr[4], rawArr[5])
   352  		assert.Equal(t, replacedArr[5], rawArr[0])
   353  	}
   354  }
   355  
   356  func TestCollectStr(t *testing.T) {
   357  	m := objx.Map{"data": []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}}
   358  
   359  	collected := m.Get("data").CollectStr(func(index int, val string) interface{} {
   360  		return index
   361  	})
   362  	collectedArr := collected.MustInterSlice()
   363  
   364  	if assert.Equal(t, 6, len(collectedArr)) {
   365  		assert.Equal(t, collectedArr[0], 0)
   366  		assert.Equal(t, collectedArr[1], 1)
   367  		assert.Equal(t, collectedArr[2], 2)
   368  		assert.Equal(t, collectedArr[3], 3)
   369  		assert.Equal(t, collectedArr[4], 4)
   370  		assert.Equal(t, collectedArr[5], 5)
   371  	}
   372  }
   373  
   374  /*
   375  Tests for Int (int and []int)
   376  */
   377  func TestInt(t *testing.T) {
   378  	val := int(1)
   379  	m := objx.Map{"value": val, "nothing": nil}
   380  
   381  	assert.Equal(t, val, m.Get("value").Int())
   382  	assert.Equal(t, val, m.Get("value").MustInt())
   383  	assert.Equal(t, int(0), m.Get("nothing").Int())
   384  	assert.Equal(t, val, m.Get("nothing").Int(1))
   385  	assert.Panics(t, func() {
   386  		m.Get("age").MustInt()
   387  	})
   388  }
   389  
   390  func TestIntSlice(t *testing.T) {
   391  	val := int(1)
   392  	m := objx.Map{"value": []int{val}, "nothing": nil}
   393  
   394  	assert.Equal(t, val, m.Get("value").IntSlice()[0])
   395  	assert.Equal(t, val, m.Get("value").MustIntSlice()[0])
   396  	assert.Equal(t, []int(nil), m.Get("nothing").IntSlice())
   397  	assert.Equal(t, val, m.Get("nothing").IntSlice([]int{int(1)})[0])
   398  	assert.Panics(t, func() {
   399  		m.Get("nothing").MustIntSlice()
   400  	})
   401  }
   402  
   403  func TestIsInt(t *testing.T) {
   404  	m := objx.Map{"data": int(1)}
   405  
   406  	assert.True(t, m.Get("data").IsInt())
   407  }
   408  
   409  func TestIsIntSlice(t *testing.T) {
   410  	m := objx.Map{"data": []int{int(1)}}
   411  
   412  	assert.True(t, m.Get("data").IsIntSlice())
   413  }
   414  
   415  func TestEachInt(t *testing.T) {
   416  	m := objx.Map{"data": []int{int(1), int(1), int(1), int(1), int(1)}}
   417  	count := 0
   418  	replacedVals := make([]int, 0)
   419  	assert.Equal(t, m.Get("data"), m.Get("data").EachInt(func(i int, val int) bool {
   420  		count++
   421  		replacedVals = append(replacedVals, val)
   422  
   423  		// abort early
   424  		return i != 2
   425  	}))
   426  
   427  	assert.Equal(t, count, 3)
   428  	assert.Equal(t, replacedVals[0], m.Get("data").MustIntSlice()[0])
   429  	assert.Equal(t, replacedVals[1], m.Get("data").MustIntSlice()[1])
   430  	assert.Equal(t, replacedVals[2], m.Get("data").MustIntSlice()[2])
   431  }
   432  
   433  func TestWhereInt(t *testing.T) {
   434  	m := objx.Map{"data": []int{int(1), int(1), int(1), int(1), int(1), int(1)}}
   435  
   436  	selected := m.Get("data").WhereInt(func(i int, val int) bool {
   437  		return i%2 == 0
   438  	}).MustIntSlice()
   439  
   440  	assert.Equal(t, 3, len(selected))
   441  }
   442  
   443  func TestGroupInt(t *testing.T) {
   444  	m := objx.Map{"data": []int{int(1), int(1), int(1), int(1), int(1), int(1)}}
   445  
   446  	grouped := m.Get("data").GroupInt(func(i int, val int) string {
   447  		return fmt.Sprintf("%v", i%2 == 0)
   448  	}).Data().(map[string][]int)
   449  
   450  	assert.Equal(t, 2, len(grouped))
   451  	assert.Equal(t, 3, len(grouped["true"]))
   452  	assert.Equal(t, 3, len(grouped["false"]))
   453  }
   454  
   455  func TestReplaceInt(t *testing.T) {
   456  	m := objx.Map{"data": []int{int(1), int(1), int(1), int(1), int(1), int(1)}}
   457  	rawArr := m.Get("data").MustIntSlice()
   458  
   459  	replaced := m.Get("data").ReplaceInt(func(index int, val int) int {
   460  		if index < len(rawArr)-1 {
   461  			return rawArr[index+1]
   462  		}
   463  		return rawArr[0]
   464  	})
   465  	replacedArr := replaced.MustIntSlice()
   466  
   467  	if assert.Equal(t, 6, len(replacedArr)) {
   468  		assert.Equal(t, replacedArr[0], rawArr[1])
   469  		assert.Equal(t, replacedArr[1], rawArr[2])
   470  		assert.Equal(t, replacedArr[2], rawArr[3])
   471  		assert.Equal(t, replacedArr[3], rawArr[4])
   472  		assert.Equal(t, replacedArr[4], rawArr[5])
   473  		assert.Equal(t, replacedArr[5], rawArr[0])
   474  	}
   475  }
   476  
   477  func TestCollectInt(t *testing.T) {
   478  	m := objx.Map{"data": []int{int(1), int(1), int(1), int(1), int(1), int(1)}}
   479  
   480  	collected := m.Get("data").CollectInt(func(index int, val int) interface{} {
   481  		return index
   482  	})
   483  	collectedArr := collected.MustInterSlice()
   484  
   485  	if assert.Equal(t, 6, len(collectedArr)) {
   486  		assert.Equal(t, collectedArr[0], 0)
   487  		assert.Equal(t, collectedArr[1], 1)
   488  		assert.Equal(t, collectedArr[2], 2)
   489  		assert.Equal(t, collectedArr[3], 3)
   490  		assert.Equal(t, collectedArr[4], 4)
   491  		assert.Equal(t, collectedArr[5], 5)
   492  	}
   493  }
   494  
   495  /*
   496  Tests for Int8 (int8 and []int8)
   497  */
   498  func TestInt8(t *testing.T) {
   499  	val := int8(1)
   500  	m := objx.Map{"value": val, "nothing": nil}
   501  
   502  	assert.Equal(t, val, m.Get("value").Int8())
   503  	assert.Equal(t, val, m.Get("value").MustInt8())
   504  	assert.Equal(t, int8(0), m.Get("nothing").Int8())
   505  	assert.Equal(t, val, m.Get("nothing").Int8(1))
   506  	assert.Panics(t, func() {
   507  		m.Get("age").MustInt8()
   508  	})
   509  }
   510  
   511  func TestInt8Slice(t *testing.T) {
   512  	val := int8(1)
   513  	m := objx.Map{"value": []int8{val}, "nothing": nil}
   514  
   515  	assert.Equal(t, val, m.Get("value").Int8Slice()[0])
   516  	assert.Equal(t, val, m.Get("value").MustInt8Slice()[0])
   517  	assert.Equal(t, []int8(nil), m.Get("nothing").Int8Slice())
   518  	assert.Equal(t, val, m.Get("nothing").Int8Slice([]int8{int8(1)})[0])
   519  	assert.Panics(t, func() {
   520  		m.Get("nothing").MustInt8Slice()
   521  	})
   522  }
   523  
   524  func TestIsInt8(t *testing.T) {
   525  	m := objx.Map{"data": int8(1)}
   526  
   527  	assert.True(t, m.Get("data").IsInt8())
   528  }
   529  
   530  func TestIsInt8Slice(t *testing.T) {
   531  	m := objx.Map{"data": []int8{int8(1)}}
   532  
   533  	assert.True(t, m.Get("data").IsInt8Slice())
   534  }
   535  
   536  func TestEachInt8(t *testing.T) {
   537  	m := objx.Map{"data": []int8{int8(1), int8(1), int8(1), int8(1), int8(1)}}
   538  	count := 0
   539  	replacedVals := make([]int8, 0)
   540  	assert.Equal(t, m.Get("data"), m.Get("data").EachInt8(func(i int, val int8) bool {
   541  		count++
   542  		replacedVals = append(replacedVals, val)
   543  
   544  		// abort early
   545  		return i != 2
   546  	}))
   547  
   548  	assert.Equal(t, count, 3)
   549  	assert.Equal(t, replacedVals[0], m.Get("data").MustInt8Slice()[0])
   550  	assert.Equal(t, replacedVals[1], m.Get("data").MustInt8Slice()[1])
   551  	assert.Equal(t, replacedVals[2], m.Get("data").MustInt8Slice()[2])
   552  }
   553  
   554  func TestWhereInt8(t *testing.T) {
   555  	m := objx.Map{"data": []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}}
   556  
   557  	selected := m.Get("data").WhereInt8(func(i int, val int8) bool {
   558  		return i%2 == 0
   559  	}).MustInt8Slice()
   560  
   561  	assert.Equal(t, 3, len(selected))
   562  }
   563  
   564  func TestGroupInt8(t *testing.T) {
   565  	m := objx.Map{"data": []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}}
   566  
   567  	grouped := m.Get("data").GroupInt8(func(i int, val int8) string {
   568  		return fmt.Sprintf("%v", i%2 == 0)
   569  	}).Data().(map[string][]int8)
   570  
   571  	assert.Equal(t, 2, len(grouped))
   572  	assert.Equal(t, 3, len(grouped["true"]))
   573  	assert.Equal(t, 3, len(grouped["false"]))
   574  }
   575  
   576  func TestReplaceInt8(t *testing.T) {
   577  	m := objx.Map{"data": []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}}
   578  	rawArr := m.Get("data").MustInt8Slice()
   579  
   580  	replaced := m.Get("data").ReplaceInt8(func(index int, val int8) int8 {
   581  		if index < len(rawArr)-1 {
   582  			return rawArr[index+1]
   583  		}
   584  		return rawArr[0]
   585  	})
   586  	replacedArr := replaced.MustInt8Slice()
   587  
   588  	if assert.Equal(t, 6, len(replacedArr)) {
   589  		assert.Equal(t, replacedArr[0], rawArr[1])
   590  		assert.Equal(t, replacedArr[1], rawArr[2])
   591  		assert.Equal(t, replacedArr[2], rawArr[3])
   592  		assert.Equal(t, replacedArr[3], rawArr[4])
   593  		assert.Equal(t, replacedArr[4], rawArr[5])
   594  		assert.Equal(t, replacedArr[5], rawArr[0])
   595  	}
   596  }
   597  
   598  func TestCollectInt8(t *testing.T) {
   599  	m := objx.Map{"data": []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}}
   600  
   601  	collected := m.Get("data").CollectInt8(func(index int, val int8) interface{} {
   602  		return index
   603  	})
   604  	collectedArr := collected.MustInterSlice()
   605  
   606  	if assert.Equal(t, 6, len(collectedArr)) {
   607  		assert.Equal(t, collectedArr[0], 0)
   608  		assert.Equal(t, collectedArr[1], 1)
   609  		assert.Equal(t, collectedArr[2], 2)
   610  		assert.Equal(t, collectedArr[3], 3)
   611  		assert.Equal(t, collectedArr[4], 4)
   612  		assert.Equal(t, collectedArr[5], 5)
   613  	}
   614  }
   615  
   616  /*
   617  Tests for Int16 (int16 and []int16)
   618  */
   619  func TestInt16(t *testing.T) {
   620  	val := int16(1)
   621  	m := objx.Map{"value": val, "nothing": nil}
   622  
   623  	assert.Equal(t, val, m.Get("value").Int16())
   624  	assert.Equal(t, val, m.Get("value").MustInt16())
   625  	assert.Equal(t, int16(0), m.Get("nothing").Int16())
   626  	assert.Equal(t, val, m.Get("nothing").Int16(1))
   627  	assert.Panics(t, func() {
   628  		m.Get("age").MustInt16()
   629  	})
   630  }
   631  
   632  func TestInt16Slice(t *testing.T) {
   633  	val := int16(1)
   634  	m := objx.Map{"value": []int16{val}, "nothing": nil}
   635  
   636  	assert.Equal(t, val, m.Get("value").Int16Slice()[0])
   637  	assert.Equal(t, val, m.Get("value").MustInt16Slice()[0])
   638  	assert.Equal(t, []int16(nil), m.Get("nothing").Int16Slice())
   639  	assert.Equal(t, val, m.Get("nothing").Int16Slice([]int16{int16(1)})[0])
   640  	assert.Panics(t, func() {
   641  		m.Get("nothing").MustInt16Slice()
   642  	})
   643  }
   644  
   645  func TestIsInt16(t *testing.T) {
   646  	m := objx.Map{"data": int16(1)}
   647  
   648  	assert.True(t, m.Get("data").IsInt16())
   649  }
   650  
   651  func TestIsInt16Slice(t *testing.T) {
   652  	m := objx.Map{"data": []int16{int16(1)}}
   653  
   654  	assert.True(t, m.Get("data").IsInt16Slice())
   655  }
   656  
   657  func TestEachInt16(t *testing.T) {
   658  	m := objx.Map{"data": []int16{int16(1), int16(1), int16(1), int16(1), int16(1)}}
   659  	count := 0
   660  	replacedVals := make([]int16, 0)
   661  	assert.Equal(t, m.Get("data"), m.Get("data").EachInt16(func(i int, val int16) bool {
   662  		count++
   663  		replacedVals = append(replacedVals, val)
   664  
   665  		// abort early
   666  		return i != 2
   667  	}))
   668  
   669  	assert.Equal(t, count, 3)
   670  	assert.Equal(t, replacedVals[0], m.Get("data").MustInt16Slice()[0])
   671  	assert.Equal(t, replacedVals[1], m.Get("data").MustInt16Slice()[1])
   672  	assert.Equal(t, replacedVals[2], m.Get("data").MustInt16Slice()[2])
   673  }
   674  
   675  func TestWhereInt16(t *testing.T) {
   676  	m := objx.Map{"data": []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}}
   677  
   678  	selected := m.Get("data").WhereInt16(func(i int, val int16) bool {
   679  		return i%2 == 0
   680  	}).MustInt16Slice()
   681  
   682  	assert.Equal(t, 3, len(selected))
   683  }
   684  
   685  func TestGroupInt16(t *testing.T) {
   686  	m := objx.Map{"data": []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}}
   687  
   688  	grouped := m.Get("data").GroupInt16(func(i int, val int16) string {
   689  		return fmt.Sprintf("%v", i%2 == 0)
   690  	}).Data().(map[string][]int16)
   691  
   692  	assert.Equal(t, 2, len(grouped))
   693  	assert.Equal(t, 3, len(grouped["true"]))
   694  	assert.Equal(t, 3, len(grouped["false"]))
   695  }
   696  
   697  func TestReplaceInt16(t *testing.T) {
   698  	m := objx.Map{"data": []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}}
   699  	rawArr := m.Get("data").MustInt16Slice()
   700  
   701  	replaced := m.Get("data").ReplaceInt16(func(index int, val int16) int16 {
   702  		if index < len(rawArr)-1 {
   703  			return rawArr[index+1]
   704  		}
   705  		return rawArr[0]
   706  	})
   707  	replacedArr := replaced.MustInt16Slice()
   708  
   709  	if assert.Equal(t, 6, len(replacedArr)) {
   710  		assert.Equal(t, replacedArr[0], rawArr[1])
   711  		assert.Equal(t, replacedArr[1], rawArr[2])
   712  		assert.Equal(t, replacedArr[2], rawArr[3])
   713  		assert.Equal(t, replacedArr[3], rawArr[4])
   714  		assert.Equal(t, replacedArr[4], rawArr[5])
   715  		assert.Equal(t, replacedArr[5], rawArr[0])
   716  	}
   717  }
   718  
   719  func TestCollectInt16(t *testing.T) {
   720  	m := objx.Map{"data": []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}}
   721  
   722  	collected := m.Get("data").CollectInt16(func(index int, val int16) interface{} {
   723  		return index
   724  	})
   725  	collectedArr := collected.MustInterSlice()
   726  
   727  	if assert.Equal(t, 6, len(collectedArr)) {
   728  		assert.Equal(t, collectedArr[0], 0)
   729  		assert.Equal(t, collectedArr[1], 1)
   730  		assert.Equal(t, collectedArr[2], 2)
   731  		assert.Equal(t, collectedArr[3], 3)
   732  		assert.Equal(t, collectedArr[4], 4)
   733  		assert.Equal(t, collectedArr[5], 5)
   734  	}
   735  }
   736  
   737  /*
   738  Tests for Int32 (int32 and []int32)
   739  */
   740  func TestInt32(t *testing.T) {
   741  	val := int32(1)
   742  	m := objx.Map{"value": val, "nothing": nil}
   743  
   744  	assert.Equal(t, val, m.Get("value").Int32())
   745  	assert.Equal(t, val, m.Get("value").MustInt32())
   746  	assert.Equal(t, int32(0), m.Get("nothing").Int32())
   747  	assert.Equal(t, val, m.Get("nothing").Int32(1))
   748  	assert.Panics(t, func() {
   749  		m.Get("age").MustInt32()
   750  	})
   751  }
   752  
   753  func TestInt32Slice(t *testing.T) {
   754  	val := int32(1)
   755  	m := objx.Map{"value": []int32{val}, "nothing": nil}
   756  
   757  	assert.Equal(t, val, m.Get("value").Int32Slice()[0])
   758  	assert.Equal(t, val, m.Get("value").MustInt32Slice()[0])
   759  	assert.Equal(t, []int32(nil), m.Get("nothing").Int32Slice())
   760  	assert.Equal(t, val, m.Get("nothing").Int32Slice([]int32{int32(1)})[0])
   761  	assert.Panics(t, func() {
   762  		m.Get("nothing").MustInt32Slice()
   763  	})
   764  }
   765  
   766  func TestIsInt32(t *testing.T) {
   767  	m := objx.Map{"data": int32(1)}
   768  
   769  	assert.True(t, m.Get("data").IsInt32())
   770  }
   771  
   772  func TestIsInt32Slice(t *testing.T) {
   773  	m := objx.Map{"data": []int32{int32(1)}}
   774  
   775  	assert.True(t, m.Get("data").IsInt32Slice())
   776  }
   777  
   778  func TestEachInt32(t *testing.T) {
   779  	m := objx.Map{"data": []int32{int32(1), int32(1), int32(1), int32(1), int32(1)}}
   780  	count := 0
   781  	replacedVals := make([]int32, 0)
   782  	assert.Equal(t, m.Get("data"), m.Get("data").EachInt32(func(i int, val int32) bool {
   783  		count++
   784  		replacedVals = append(replacedVals, val)
   785  
   786  		// abort early
   787  		return i != 2
   788  	}))
   789  
   790  	assert.Equal(t, count, 3)
   791  	assert.Equal(t, replacedVals[0], m.Get("data").MustInt32Slice()[0])
   792  	assert.Equal(t, replacedVals[1], m.Get("data").MustInt32Slice()[1])
   793  	assert.Equal(t, replacedVals[2], m.Get("data").MustInt32Slice()[2])
   794  }
   795  
   796  func TestWhereInt32(t *testing.T) {
   797  	m := objx.Map{"data": []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}}
   798  
   799  	selected := m.Get("data").WhereInt32(func(i int, val int32) bool {
   800  		return i%2 == 0
   801  	}).MustInt32Slice()
   802  
   803  	assert.Equal(t, 3, len(selected))
   804  }
   805  
   806  func TestGroupInt32(t *testing.T) {
   807  	m := objx.Map{"data": []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}}
   808  
   809  	grouped := m.Get("data").GroupInt32(func(i int, val int32) string {
   810  		return fmt.Sprintf("%v", i%2 == 0)
   811  	}).Data().(map[string][]int32)
   812  
   813  	assert.Equal(t, 2, len(grouped))
   814  	assert.Equal(t, 3, len(grouped["true"]))
   815  	assert.Equal(t, 3, len(grouped["false"]))
   816  }
   817  
   818  func TestReplaceInt32(t *testing.T) {
   819  	m := objx.Map{"data": []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}}
   820  	rawArr := m.Get("data").MustInt32Slice()
   821  
   822  	replaced := m.Get("data").ReplaceInt32(func(index int, val int32) int32 {
   823  		if index < len(rawArr)-1 {
   824  			return rawArr[index+1]
   825  		}
   826  		return rawArr[0]
   827  	})
   828  	replacedArr := replaced.MustInt32Slice()
   829  
   830  	if assert.Equal(t, 6, len(replacedArr)) {
   831  		assert.Equal(t, replacedArr[0], rawArr[1])
   832  		assert.Equal(t, replacedArr[1], rawArr[2])
   833  		assert.Equal(t, replacedArr[2], rawArr[3])
   834  		assert.Equal(t, replacedArr[3], rawArr[4])
   835  		assert.Equal(t, replacedArr[4], rawArr[5])
   836  		assert.Equal(t, replacedArr[5], rawArr[0])
   837  	}
   838  }
   839  
   840  func TestCollectInt32(t *testing.T) {
   841  	m := objx.Map{"data": []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}}
   842  
   843  	collected := m.Get("data").CollectInt32(func(index int, val int32) interface{} {
   844  		return index
   845  	})
   846  	collectedArr := collected.MustInterSlice()
   847  
   848  	if assert.Equal(t, 6, len(collectedArr)) {
   849  		assert.Equal(t, collectedArr[0], 0)
   850  		assert.Equal(t, collectedArr[1], 1)
   851  		assert.Equal(t, collectedArr[2], 2)
   852  		assert.Equal(t, collectedArr[3], 3)
   853  		assert.Equal(t, collectedArr[4], 4)
   854  		assert.Equal(t, collectedArr[5], 5)
   855  	}
   856  }
   857  
   858  /*
   859  Tests for Int64 (int64 and []int64)
   860  */
   861  func TestInt64(t *testing.T) {
   862  	val := int64(1)
   863  	m := objx.Map{"value": val, "nothing": nil}
   864  
   865  	assert.Equal(t, val, m.Get("value").Int64())
   866  	assert.Equal(t, val, m.Get("value").MustInt64())
   867  	assert.Equal(t, int64(0), m.Get("nothing").Int64())
   868  	assert.Equal(t, val, m.Get("nothing").Int64(1))
   869  	assert.Panics(t, func() {
   870  		m.Get("age").MustInt64()
   871  	})
   872  }
   873  
   874  func TestInt64Slice(t *testing.T) {
   875  	val := int64(1)
   876  	m := objx.Map{"value": []int64{val}, "nothing": nil}
   877  
   878  	assert.Equal(t, val, m.Get("value").Int64Slice()[0])
   879  	assert.Equal(t, val, m.Get("value").MustInt64Slice()[0])
   880  	assert.Equal(t, []int64(nil), m.Get("nothing").Int64Slice())
   881  	assert.Equal(t, val, m.Get("nothing").Int64Slice([]int64{int64(1)})[0])
   882  	assert.Panics(t, func() {
   883  		m.Get("nothing").MustInt64Slice()
   884  	})
   885  }
   886  
   887  func TestIsInt64(t *testing.T) {
   888  	m := objx.Map{"data": int64(1)}
   889  
   890  	assert.True(t, m.Get("data").IsInt64())
   891  }
   892  
   893  func TestIsInt64Slice(t *testing.T) {
   894  	m := objx.Map{"data": []int64{int64(1)}}
   895  
   896  	assert.True(t, m.Get("data").IsInt64Slice())
   897  }
   898  
   899  func TestEachInt64(t *testing.T) {
   900  	m := objx.Map{"data": []int64{int64(1), int64(1), int64(1), int64(1), int64(1)}}
   901  	count := 0
   902  	replacedVals := make([]int64, 0)
   903  	assert.Equal(t, m.Get("data"), m.Get("data").EachInt64(func(i int, val int64) bool {
   904  		count++
   905  		replacedVals = append(replacedVals, val)
   906  
   907  		// abort early
   908  		return i != 2
   909  	}))
   910  
   911  	assert.Equal(t, count, 3)
   912  	assert.Equal(t, replacedVals[0], m.Get("data").MustInt64Slice()[0])
   913  	assert.Equal(t, replacedVals[1], m.Get("data").MustInt64Slice()[1])
   914  	assert.Equal(t, replacedVals[2], m.Get("data").MustInt64Slice()[2])
   915  }
   916  
   917  func TestWhereInt64(t *testing.T) {
   918  	m := objx.Map{"data": []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}}
   919  
   920  	selected := m.Get("data").WhereInt64(func(i int, val int64) bool {
   921  		return i%2 == 0
   922  	}).MustInt64Slice()
   923  
   924  	assert.Equal(t, 3, len(selected))
   925  }
   926  
   927  func TestGroupInt64(t *testing.T) {
   928  	m := objx.Map{"data": []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}}
   929  
   930  	grouped := m.Get("data").GroupInt64(func(i int, val int64) string {
   931  		return fmt.Sprintf("%v", i%2 == 0)
   932  	}).Data().(map[string][]int64)
   933  
   934  	assert.Equal(t, 2, len(grouped))
   935  	assert.Equal(t, 3, len(grouped["true"]))
   936  	assert.Equal(t, 3, len(grouped["false"]))
   937  }
   938  
   939  func TestReplaceInt64(t *testing.T) {
   940  	m := objx.Map{"data": []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}}
   941  	rawArr := m.Get("data").MustInt64Slice()
   942  
   943  	replaced := m.Get("data").ReplaceInt64(func(index int, val int64) int64 {
   944  		if index < len(rawArr)-1 {
   945  			return rawArr[index+1]
   946  		}
   947  		return rawArr[0]
   948  	})
   949  	replacedArr := replaced.MustInt64Slice()
   950  
   951  	if assert.Equal(t, 6, len(replacedArr)) {
   952  		assert.Equal(t, replacedArr[0], rawArr[1])
   953  		assert.Equal(t, replacedArr[1], rawArr[2])
   954  		assert.Equal(t, replacedArr[2], rawArr[3])
   955  		assert.Equal(t, replacedArr[3], rawArr[4])
   956  		assert.Equal(t, replacedArr[4], rawArr[5])
   957  		assert.Equal(t, replacedArr[5], rawArr[0])
   958  	}
   959  }
   960  
   961  func TestCollectInt64(t *testing.T) {
   962  	m := objx.Map{"data": []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}}
   963  
   964  	collected := m.Get("data").CollectInt64(func(index int, val int64) interface{} {
   965  		return index
   966  	})
   967  	collectedArr := collected.MustInterSlice()
   968  
   969  	if assert.Equal(t, 6, len(collectedArr)) {
   970  		assert.Equal(t, collectedArr[0], 0)
   971  		assert.Equal(t, collectedArr[1], 1)
   972  		assert.Equal(t, collectedArr[2], 2)
   973  		assert.Equal(t, collectedArr[3], 3)
   974  		assert.Equal(t, collectedArr[4], 4)
   975  		assert.Equal(t, collectedArr[5], 5)
   976  	}
   977  }
   978  
   979  /*
   980  Tests for Uint (uint and []uint)
   981  */
   982  func TestUint(t *testing.T) {
   983  	val := uint(1)
   984  	m := objx.Map{"value": val, "nothing": nil}
   985  
   986  	assert.Equal(t, val, m.Get("value").Uint())
   987  	assert.Equal(t, val, m.Get("value").MustUint())
   988  	assert.Equal(t, uint(0), m.Get("nothing").Uint())
   989  	assert.Equal(t, val, m.Get("nothing").Uint(1))
   990  	assert.Panics(t, func() {
   991  		m.Get("age").MustUint()
   992  	})
   993  }
   994  
   995  func TestUintSlice(t *testing.T) {
   996  	val := uint(1)
   997  	m := objx.Map{"value": []uint{val}, "nothing": nil}
   998  
   999  	assert.Equal(t, val, m.Get("value").UintSlice()[0])
  1000  	assert.Equal(t, val, m.Get("value").MustUintSlice()[0])
  1001  	assert.Equal(t, []uint(nil), m.Get("nothing").UintSlice())
  1002  	assert.Equal(t, val, m.Get("nothing").UintSlice([]uint{uint(1)})[0])
  1003  	assert.Panics(t, func() {
  1004  		m.Get("nothing").MustUintSlice()
  1005  	})
  1006  }
  1007  
  1008  func TestIsUint(t *testing.T) {
  1009  	m := objx.Map{"data": uint(1)}
  1010  
  1011  	assert.True(t, m.Get("data").IsUint())
  1012  }
  1013  
  1014  func TestIsUintSlice(t *testing.T) {
  1015  	m := objx.Map{"data": []uint{uint(1)}}
  1016  
  1017  	assert.True(t, m.Get("data").IsUintSlice())
  1018  }
  1019  
  1020  func TestEachUint(t *testing.T) {
  1021  	m := objx.Map{"data": []uint{uint(1), uint(1), uint(1), uint(1), uint(1)}}
  1022  	count := 0
  1023  	replacedVals := make([]uint, 0)
  1024  	assert.Equal(t, m.Get("data"), m.Get("data").EachUint(func(i int, val uint) bool {
  1025  		count++
  1026  		replacedVals = append(replacedVals, val)
  1027  
  1028  		// abort early
  1029  		return i != 2
  1030  	}))
  1031  
  1032  	assert.Equal(t, count, 3)
  1033  	assert.Equal(t, replacedVals[0], m.Get("data").MustUintSlice()[0])
  1034  	assert.Equal(t, replacedVals[1], m.Get("data").MustUintSlice()[1])
  1035  	assert.Equal(t, replacedVals[2], m.Get("data").MustUintSlice()[2])
  1036  }
  1037  
  1038  func TestWhereUint(t *testing.T) {
  1039  	m := objx.Map{"data": []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}}
  1040  
  1041  	selected := m.Get("data").WhereUint(func(i int, val uint) bool {
  1042  		return i%2 == 0
  1043  	}).MustUintSlice()
  1044  
  1045  	assert.Equal(t, 3, len(selected))
  1046  }
  1047  
  1048  func TestGroupUint(t *testing.T) {
  1049  	m := objx.Map{"data": []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}}
  1050  
  1051  	grouped := m.Get("data").GroupUint(func(i int, val uint) string {
  1052  		return fmt.Sprintf("%v", i%2 == 0)
  1053  	}).Data().(map[string][]uint)
  1054  
  1055  	assert.Equal(t, 2, len(grouped))
  1056  	assert.Equal(t, 3, len(grouped["true"]))
  1057  	assert.Equal(t, 3, len(grouped["false"]))
  1058  }
  1059  
  1060  func TestReplaceUint(t *testing.T) {
  1061  	m := objx.Map{"data": []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}}
  1062  	rawArr := m.Get("data").MustUintSlice()
  1063  
  1064  	replaced := m.Get("data").ReplaceUint(func(index int, val uint) uint {
  1065  		if index < len(rawArr)-1 {
  1066  			return rawArr[index+1]
  1067  		}
  1068  		return rawArr[0]
  1069  	})
  1070  	replacedArr := replaced.MustUintSlice()
  1071  
  1072  	if assert.Equal(t, 6, len(replacedArr)) {
  1073  		assert.Equal(t, replacedArr[0], rawArr[1])
  1074  		assert.Equal(t, replacedArr[1], rawArr[2])
  1075  		assert.Equal(t, replacedArr[2], rawArr[3])
  1076  		assert.Equal(t, replacedArr[3], rawArr[4])
  1077  		assert.Equal(t, replacedArr[4], rawArr[5])
  1078  		assert.Equal(t, replacedArr[5], rawArr[0])
  1079  	}
  1080  }
  1081  
  1082  func TestCollectUint(t *testing.T) {
  1083  	m := objx.Map{"data": []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}}
  1084  
  1085  	collected := m.Get("data").CollectUint(func(index int, val uint) interface{} {
  1086  		return index
  1087  	})
  1088  	collectedArr := collected.MustInterSlice()
  1089  
  1090  	if assert.Equal(t, 6, len(collectedArr)) {
  1091  		assert.Equal(t, collectedArr[0], 0)
  1092  		assert.Equal(t, collectedArr[1], 1)
  1093  		assert.Equal(t, collectedArr[2], 2)
  1094  		assert.Equal(t, collectedArr[3], 3)
  1095  		assert.Equal(t, collectedArr[4], 4)
  1096  		assert.Equal(t, collectedArr[5], 5)
  1097  	}
  1098  }
  1099  
  1100  /*
  1101  Tests for Uint8 (uint8 and []uint8)
  1102  */
  1103  func TestUint8(t *testing.T) {
  1104  	val := uint8(1)
  1105  	m := objx.Map{"value": val, "nothing": nil}
  1106  
  1107  	assert.Equal(t, val, m.Get("value").Uint8())
  1108  	assert.Equal(t, val, m.Get("value").MustUint8())
  1109  	assert.Equal(t, uint8(0), m.Get("nothing").Uint8())
  1110  	assert.Equal(t, val, m.Get("nothing").Uint8(1))
  1111  	assert.Panics(t, func() {
  1112  		m.Get("age").MustUint8()
  1113  	})
  1114  }
  1115  
  1116  func TestUint8Slice(t *testing.T) {
  1117  	val := uint8(1)
  1118  	m := objx.Map{"value": []uint8{val}, "nothing": nil}
  1119  
  1120  	assert.Equal(t, val, m.Get("value").Uint8Slice()[0])
  1121  	assert.Equal(t, val, m.Get("value").MustUint8Slice()[0])
  1122  	assert.Equal(t, []uint8(nil), m.Get("nothing").Uint8Slice())
  1123  	assert.Equal(t, val, m.Get("nothing").Uint8Slice([]uint8{uint8(1)})[0])
  1124  	assert.Panics(t, func() {
  1125  		m.Get("nothing").MustUint8Slice()
  1126  	})
  1127  }
  1128  
  1129  func TestIsUint8(t *testing.T) {
  1130  	m := objx.Map{"data": uint8(1)}
  1131  
  1132  	assert.True(t, m.Get("data").IsUint8())
  1133  }
  1134  
  1135  func TestIsUint8Slice(t *testing.T) {
  1136  	m := objx.Map{"data": []uint8{uint8(1)}}
  1137  
  1138  	assert.True(t, m.Get("data").IsUint8Slice())
  1139  }
  1140  
  1141  func TestEachUint8(t *testing.T) {
  1142  	m := objx.Map{"data": []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}}
  1143  	count := 0
  1144  	replacedVals := make([]uint8, 0)
  1145  	assert.Equal(t, m.Get("data"), m.Get("data").EachUint8(func(i int, val uint8) bool {
  1146  		count++
  1147  		replacedVals = append(replacedVals, val)
  1148  
  1149  		// abort early
  1150  		return i != 2
  1151  	}))
  1152  
  1153  	assert.Equal(t, count, 3)
  1154  	assert.Equal(t, replacedVals[0], m.Get("data").MustUint8Slice()[0])
  1155  	assert.Equal(t, replacedVals[1], m.Get("data").MustUint8Slice()[1])
  1156  	assert.Equal(t, replacedVals[2], m.Get("data").MustUint8Slice()[2])
  1157  }
  1158  
  1159  func TestWhereUint8(t *testing.T) {
  1160  	m := objx.Map{"data": []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}}
  1161  
  1162  	selected := m.Get("data").WhereUint8(func(i int, val uint8) bool {
  1163  		return i%2 == 0
  1164  	}).MustUint8Slice()
  1165  
  1166  	assert.Equal(t, 3, len(selected))
  1167  }
  1168  
  1169  func TestGroupUint8(t *testing.T) {
  1170  	m := objx.Map{"data": []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}}
  1171  
  1172  	grouped := m.Get("data").GroupUint8(func(i int, val uint8) string {
  1173  		return fmt.Sprintf("%v", i%2 == 0)
  1174  	}).Data().(map[string][]uint8)
  1175  
  1176  	assert.Equal(t, 2, len(grouped))
  1177  	assert.Equal(t, 3, len(grouped["true"]))
  1178  	assert.Equal(t, 3, len(grouped["false"]))
  1179  }
  1180  
  1181  func TestReplaceUint8(t *testing.T) {
  1182  	m := objx.Map{"data": []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}}
  1183  	rawArr := m.Get("data").MustUint8Slice()
  1184  
  1185  	replaced := m.Get("data").ReplaceUint8(func(index int, val uint8) uint8 {
  1186  		if index < len(rawArr)-1 {
  1187  			return rawArr[index+1]
  1188  		}
  1189  		return rawArr[0]
  1190  	})
  1191  	replacedArr := replaced.MustUint8Slice()
  1192  
  1193  	if assert.Equal(t, 6, len(replacedArr)) {
  1194  		assert.Equal(t, replacedArr[0], rawArr[1])
  1195  		assert.Equal(t, replacedArr[1], rawArr[2])
  1196  		assert.Equal(t, replacedArr[2], rawArr[3])
  1197  		assert.Equal(t, replacedArr[3], rawArr[4])
  1198  		assert.Equal(t, replacedArr[4], rawArr[5])
  1199  		assert.Equal(t, replacedArr[5], rawArr[0])
  1200  	}
  1201  }
  1202  
  1203  func TestCollectUint8(t *testing.T) {
  1204  	m := objx.Map{"data": []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}}
  1205  
  1206  	collected := m.Get("data").CollectUint8(func(index int, val uint8) interface{} {
  1207  		return index
  1208  	})
  1209  	collectedArr := collected.MustInterSlice()
  1210  
  1211  	if assert.Equal(t, 6, len(collectedArr)) {
  1212  		assert.Equal(t, collectedArr[0], 0)
  1213  		assert.Equal(t, collectedArr[1], 1)
  1214  		assert.Equal(t, collectedArr[2], 2)
  1215  		assert.Equal(t, collectedArr[3], 3)
  1216  		assert.Equal(t, collectedArr[4], 4)
  1217  		assert.Equal(t, collectedArr[5], 5)
  1218  	}
  1219  }
  1220  
  1221  /*
  1222  Tests for Uint16 (uint16 and []uint16)
  1223  */
  1224  func TestUint16(t *testing.T) {
  1225  	val := uint16(1)
  1226  	m := objx.Map{"value": val, "nothing": nil}
  1227  
  1228  	assert.Equal(t, val, m.Get("value").Uint16())
  1229  	assert.Equal(t, val, m.Get("value").MustUint16())
  1230  	assert.Equal(t, uint16(0), m.Get("nothing").Uint16())
  1231  	assert.Equal(t, val, m.Get("nothing").Uint16(1))
  1232  	assert.Panics(t, func() {
  1233  		m.Get("age").MustUint16()
  1234  	})
  1235  }
  1236  
  1237  func TestUint16Slice(t *testing.T) {
  1238  	val := uint16(1)
  1239  	m := objx.Map{"value": []uint16{val}, "nothing": nil}
  1240  
  1241  	assert.Equal(t, val, m.Get("value").Uint16Slice()[0])
  1242  	assert.Equal(t, val, m.Get("value").MustUint16Slice()[0])
  1243  	assert.Equal(t, []uint16(nil), m.Get("nothing").Uint16Slice())
  1244  	assert.Equal(t, val, m.Get("nothing").Uint16Slice([]uint16{uint16(1)})[0])
  1245  	assert.Panics(t, func() {
  1246  		m.Get("nothing").MustUint16Slice()
  1247  	})
  1248  }
  1249  
  1250  func TestIsUint16(t *testing.T) {
  1251  	m := objx.Map{"data": uint16(1)}
  1252  
  1253  	assert.True(t, m.Get("data").IsUint16())
  1254  }
  1255  
  1256  func TestIsUint16Slice(t *testing.T) {
  1257  	m := objx.Map{"data": []uint16{uint16(1)}}
  1258  
  1259  	assert.True(t, m.Get("data").IsUint16Slice())
  1260  }
  1261  
  1262  func TestEachUint16(t *testing.T) {
  1263  	m := objx.Map{"data": []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}}
  1264  	count := 0
  1265  	replacedVals := make([]uint16, 0)
  1266  	assert.Equal(t, m.Get("data"), m.Get("data").EachUint16(func(i int, val uint16) bool {
  1267  		count++
  1268  		replacedVals = append(replacedVals, val)
  1269  
  1270  		// abort early
  1271  		return i != 2
  1272  	}))
  1273  
  1274  	assert.Equal(t, count, 3)
  1275  	assert.Equal(t, replacedVals[0], m.Get("data").MustUint16Slice()[0])
  1276  	assert.Equal(t, replacedVals[1], m.Get("data").MustUint16Slice()[1])
  1277  	assert.Equal(t, replacedVals[2], m.Get("data").MustUint16Slice()[2])
  1278  }
  1279  
  1280  func TestWhereUint16(t *testing.T) {
  1281  	m := objx.Map{"data": []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}}
  1282  
  1283  	selected := m.Get("data").WhereUint16(func(i int, val uint16) bool {
  1284  		return i%2 == 0
  1285  	}).MustUint16Slice()
  1286  
  1287  	assert.Equal(t, 3, len(selected))
  1288  }
  1289  
  1290  func TestGroupUint16(t *testing.T) {
  1291  	m := objx.Map{"data": []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}}
  1292  
  1293  	grouped := m.Get("data").GroupUint16(func(i int, val uint16) string {
  1294  		return fmt.Sprintf("%v", i%2 == 0)
  1295  	}).Data().(map[string][]uint16)
  1296  
  1297  	assert.Equal(t, 2, len(grouped))
  1298  	assert.Equal(t, 3, len(grouped["true"]))
  1299  	assert.Equal(t, 3, len(grouped["false"]))
  1300  }
  1301  
  1302  func TestReplaceUint16(t *testing.T) {
  1303  	m := objx.Map{"data": []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}}
  1304  	rawArr := m.Get("data").MustUint16Slice()
  1305  
  1306  	replaced := m.Get("data").ReplaceUint16(func(index int, val uint16) uint16 {
  1307  		if index < len(rawArr)-1 {
  1308  			return rawArr[index+1]
  1309  		}
  1310  		return rawArr[0]
  1311  	})
  1312  	replacedArr := replaced.MustUint16Slice()
  1313  
  1314  	if assert.Equal(t, 6, len(replacedArr)) {
  1315  		assert.Equal(t, replacedArr[0], rawArr[1])
  1316  		assert.Equal(t, replacedArr[1], rawArr[2])
  1317  		assert.Equal(t, replacedArr[2], rawArr[3])
  1318  		assert.Equal(t, replacedArr[3], rawArr[4])
  1319  		assert.Equal(t, replacedArr[4], rawArr[5])
  1320  		assert.Equal(t, replacedArr[5], rawArr[0])
  1321  	}
  1322  }
  1323  
  1324  func TestCollectUint16(t *testing.T) {
  1325  	m := objx.Map{"data": []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}}
  1326  
  1327  	collected := m.Get("data").CollectUint16(func(index int, val uint16) interface{} {
  1328  		return index
  1329  	})
  1330  	collectedArr := collected.MustInterSlice()
  1331  
  1332  	if assert.Equal(t, 6, len(collectedArr)) {
  1333  		assert.Equal(t, collectedArr[0], 0)
  1334  		assert.Equal(t, collectedArr[1], 1)
  1335  		assert.Equal(t, collectedArr[2], 2)
  1336  		assert.Equal(t, collectedArr[3], 3)
  1337  		assert.Equal(t, collectedArr[4], 4)
  1338  		assert.Equal(t, collectedArr[5], 5)
  1339  	}
  1340  }
  1341  
  1342  /*
  1343  Tests for Uint32 (uint32 and []uint32)
  1344  */
  1345  func TestUint32(t *testing.T) {
  1346  	val := uint32(1)
  1347  	m := objx.Map{"value": val, "nothing": nil}
  1348  
  1349  	assert.Equal(t, val, m.Get("value").Uint32())
  1350  	assert.Equal(t, val, m.Get("value").MustUint32())
  1351  	assert.Equal(t, uint32(0), m.Get("nothing").Uint32())
  1352  	assert.Equal(t, val, m.Get("nothing").Uint32(1))
  1353  	assert.Panics(t, func() {
  1354  		m.Get("age").MustUint32()
  1355  	})
  1356  }
  1357  
  1358  func TestUint32Slice(t *testing.T) {
  1359  	val := uint32(1)
  1360  	m := objx.Map{"value": []uint32{val}, "nothing": nil}
  1361  
  1362  	assert.Equal(t, val, m.Get("value").Uint32Slice()[0])
  1363  	assert.Equal(t, val, m.Get("value").MustUint32Slice()[0])
  1364  	assert.Equal(t, []uint32(nil), m.Get("nothing").Uint32Slice())
  1365  	assert.Equal(t, val, m.Get("nothing").Uint32Slice([]uint32{uint32(1)})[0])
  1366  	assert.Panics(t, func() {
  1367  		m.Get("nothing").MustUint32Slice()
  1368  	})
  1369  }
  1370  
  1371  func TestIsUint32(t *testing.T) {
  1372  	m := objx.Map{"data": uint32(1)}
  1373  
  1374  	assert.True(t, m.Get("data").IsUint32())
  1375  }
  1376  
  1377  func TestIsUint32Slice(t *testing.T) {
  1378  	m := objx.Map{"data": []uint32{uint32(1)}}
  1379  
  1380  	assert.True(t, m.Get("data").IsUint32Slice())
  1381  }
  1382  
  1383  func TestEachUint32(t *testing.T) {
  1384  	m := objx.Map{"data": []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}}
  1385  	count := 0
  1386  	replacedVals := make([]uint32, 0)
  1387  	assert.Equal(t, m.Get("data"), m.Get("data").EachUint32(func(i int, val uint32) bool {
  1388  		count++
  1389  		replacedVals = append(replacedVals, val)
  1390  
  1391  		// abort early
  1392  		return i != 2
  1393  	}))
  1394  
  1395  	assert.Equal(t, count, 3)
  1396  	assert.Equal(t, replacedVals[0], m.Get("data").MustUint32Slice()[0])
  1397  	assert.Equal(t, replacedVals[1], m.Get("data").MustUint32Slice()[1])
  1398  	assert.Equal(t, replacedVals[2], m.Get("data").MustUint32Slice()[2])
  1399  }
  1400  
  1401  func TestWhereUint32(t *testing.T) {
  1402  	m := objx.Map{"data": []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}}
  1403  
  1404  	selected := m.Get("data").WhereUint32(func(i int, val uint32) bool {
  1405  		return i%2 == 0
  1406  	}).MustUint32Slice()
  1407  
  1408  	assert.Equal(t, 3, len(selected))
  1409  }
  1410  
  1411  func TestGroupUint32(t *testing.T) {
  1412  	m := objx.Map{"data": []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}}
  1413  
  1414  	grouped := m.Get("data").GroupUint32(func(i int, val uint32) string {
  1415  		return fmt.Sprintf("%v", i%2 == 0)
  1416  	}).Data().(map[string][]uint32)
  1417  
  1418  	assert.Equal(t, 2, len(grouped))
  1419  	assert.Equal(t, 3, len(grouped["true"]))
  1420  	assert.Equal(t, 3, len(grouped["false"]))
  1421  }
  1422  
  1423  func TestReplaceUint32(t *testing.T) {
  1424  	m := objx.Map{"data": []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}}
  1425  	rawArr := m.Get("data").MustUint32Slice()
  1426  
  1427  	replaced := m.Get("data").ReplaceUint32(func(index int, val uint32) uint32 {
  1428  		if index < len(rawArr)-1 {
  1429  			return rawArr[index+1]
  1430  		}
  1431  		return rawArr[0]
  1432  	})
  1433  	replacedArr := replaced.MustUint32Slice()
  1434  
  1435  	if assert.Equal(t, 6, len(replacedArr)) {
  1436  		assert.Equal(t, replacedArr[0], rawArr[1])
  1437  		assert.Equal(t, replacedArr[1], rawArr[2])
  1438  		assert.Equal(t, replacedArr[2], rawArr[3])
  1439  		assert.Equal(t, replacedArr[3], rawArr[4])
  1440  		assert.Equal(t, replacedArr[4], rawArr[5])
  1441  		assert.Equal(t, replacedArr[5], rawArr[0])
  1442  	}
  1443  }
  1444  
  1445  func TestCollectUint32(t *testing.T) {
  1446  	m := objx.Map{"data": []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}}
  1447  
  1448  	collected := m.Get("data").CollectUint32(func(index int, val uint32) interface{} {
  1449  		return index
  1450  	})
  1451  	collectedArr := collected.MustInterSlice()
  1452  
  1453  	if assert.Equal(t, 6, len(collectedArr)) {
  1454  		assert.Equal(t, collectedArr[0], 0)
  1455  		assert.Equal(t, collectedArr[1], 1)
  1456  		assert.Equal(t, collectedArr[2], 2)
  1457  		assert.Equal(t, collectedArr[3], 3)
  1458  		assert.Equal(t, collectedArr[4], 4)
  1459  		assert.Equal(t, collectedArr[5], 5)
  1460  	}
  1461  }
  1462  
  1463  /*
  1464  Tests for Uint64 (uint64 and []uint64)
  1465  */
  1466  func TestUint64(t *testing.T) {
  1467  	val := uint64(1)
  1468  	m := objx.Map{"value": val, "nothing": nil}
  1469  
  1470  	assert.Equal(t, val, m.Get("value").Uint64())
  1471  	assert.Equal(t, val, m.Get("value").MustUint64())
  1472  	assert.Equal(t, uint64(0), m.Get("nothing").Uint64())
  1473  	assert.Equal(t, val, m.Get("nothing").Uint64(1))
  1474  	assert.Panics(t, func() {
  1475  		m.Get("age").MustUint64()
  1476  	})
  1477  }
  1478  
  1479  func TestUint64Slice(t *testing.T) {
  1480  	val := uint64(1)
  1481  	m := objx.Map{"value": []uint64{val}, "nothing": nil}
  1482  
  1483  	assert.Equal(t, val, m.Get("value").Uint64Slice()[0])
  1484  	assert.Equal(t, val, m.Get("value").MustUint64Slice()[0])
  1485  	assert.Equal(t, []uint64(nil), m.Get("nothing").Uint64Slice())
  1486  	assert.Equal(t, val, m.Get("nothing").Uint64Slice([]uint64{uint64(1)})[0])
  1487  	assert.Panics(t, func() {
  1488  		m.Get("nothing").MustUint64Slice()
  1489  	})
  1490  }
  1491  
  1492  func TestIsUint64(t *testing.T) {
  1493  	m := objx.Map{"data": uint64(1)}
  1494  
  1495  	assert.True(t, m.Get("data").IsUint64())
  1496  }
  1497  
  1498  func TestIsUint64Slice(t *testing.T) {
  1499  	m := objx.Map{"data": []uint64{uint64(1)}}
  1500  
  1501  	assert.True(t, m.Get("data").IsUint64Slice())
  1502  }
  1503  
  1504  func TestEachUint64(t *testing.T) {
  1505  	m := objx.Map{"data": []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}}
  1506  	count := 0
  1507  	replacedVals := make([]uint64, 0)
  1508  	assert.Equal(t, m.Get("data"), m.Get("data").EachUint64(func(i int, val uint64) bool {
  1509  		count++
  1510  		replacedVals = append(replacedVals, val)
  1511  
  1512  		// abort early
  1513  		return i != 2
  1514  	}))
  1515  
  1516  	assert.Equal(t, count, 3)
  1517  	assert.Equal(t, replacedVals[0], m.Get("data").MustUint64Slice()[0])
  1518  	assert.Equal(t, replacedVals[1], m.Get("data").MustUint64Slice()[1])
  1519  	assert.Equal(t, replacedVals[2], m.Get("data").MustUint64Slice()[2])
  1520  }
  1521  
  1522  func TestWhereUint64(t *testing.T) {
  1523  	m := objx.Map{"data": []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}}
  1524  
  1525  	selected := m.Get("data").WhereUint64(func(i int, val uint64) bool {
  1526  		return i%2 == 0
  1527  	}).MustUint64Slice()
  1528  
  1529  	assert.Equal(t, 3, len(selected))
  1530  }
  1531  
  1532  func TestGroupUint64(t *testing.T) {
  1533  	m := objx.Map{"data": []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}}
  1534  
  1535  	grouped := m.Get("data").GroupUint64(func(i int, val uint64) string {
  1536  		return fmt.Sprintf("%v", i%2 == 0)
  1537  	}).Data().(map[string][]uint64)
  1538  
  1539  	assert.Equal(t, 2, len(grouped))
  1540  	assert.Equal(t, 3, len(grouped["true"]))
  1541  	assert.Equal(t, 3, len(grouped["false"]))
  1542  }
  1543  
  1544  func TestReplaceUint64(t *testing.T) {
  1545  	m := objx.Map{"data": []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}}
  1546  	rawArr := m.Get("data").MustUint64Slice()
  1547  
  1548  	replaced := m.Get("data").ReplaceUint64(func(index int, val uint64) uint64 {
  1549  		if index < len(rawArr)-1 {
  1550  			return rawArr[index+1]
  1551  		}
  1552  		return rawArr[0]
  1553  	})
  1554  	replacedArr := replaced.MustUint64Slice()
  1555  
  1556  	if assert.Equal(t, 6, len(replacedArr)) {
  1557  		assert.Equal(t, replacedArr[0], rawArr[1])
  1558  		assert.Equal(t, replacedArr[1], rawArr[2])
  1559  		assert.Equal(t, replacedArr[2], rawArr[3])
  1560  		assert.Equal(t, replacedArr[3], rawArr[4])
  1561  		assert.Equal(t, replacedArr[4], rawArr[5])
  1562  		assert.Equal(t, replacedArr[5], rawArr[0])
  1563  	}
  1564  }
  1565  
  1566  func TestCollectUint64(t *testing.T) {
  1567  	m := objx.Map{"data": []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}}
  1568  
  1569  	collected := m.Get("data").CollectUint64(func(index int, val uint64) interface{} {
  1570  		return index
  1571  	})
  1572  	collectedArr := collected.MustInterSlice()
  1573  
  1574  	if assert.Equal(t, 6, len(collectedArr)) {
  1575  		assert.Equal(t, collectedArr[0], 0)
  1576  		assert.Equal(t, collectedArr[1], 1)
  1577  		assert.Equal(t, collectedArr[2], 2)
  1578  		assert.Equal(t, collectedArr[3], 3)
  1579  		assert.Equal(t, collectedArr[4], 4)
  1580  		assert.Equal(t, collectedArr[5], 5)
  1581  	}
  1582  }
  1583  
  1584  /*
  1585  Tests for Uintptr (uintptr and []uintptr)
  1586  */
  1587  func TestUintptr(t *testing.T) {
  1588  	val := uintptr(1)
  1589  	m := objx.Map{"value": val, "nothing": nil}
  1590  
  1591  	assert.Equal(t, val, m.Get("value").Uintptr())
  1592  	assert.Equal(t, val, m.Get("value").MustUintptr())
  1593  	assert.Equal(t, uintptr(0), m.Get("nothing").Uintptr())
  1594  	assert.Equal(t, val, m.Get("nothing").Uintptr(1))
  1595  	assert.Panics(t, func() {
  1596  		m.Get("age").MustUintptr()
  1597  	})
  1598  }
  1599  
  1600  func TestUintptrSlice(t *testing.T) {
  1601  	val := uintptr(1)
  1602  	m := objx.Map{"value": []uintptr{val}, "nothing": nil}
  1603  
  1604  	assert.Equal(t, val, m.Get("value").UintptrSlice()[0])
  1605  	assert.Equal(t, val, m.Get("value").MustUintptrSlice()[0])
  1606  	assert.Equal(t, []uintptr(nil), m.Get("nothing").UintptrSlice())
  1607  	assert.Equal(t, val, m.Get("nothing").UintptrSlice([]uintptr{uintptr(1)})[0])
  1608  	assert.Panics(t, func() {
  1609  		m.Get("nothing").MustUintptrSlice()
  1610  	})
  1611  }
  1612  
  1613  func TestIsUintptr(t *testing.T) {
  1614  	m := objx.Map{"data": uintptr(1)}
  1615  
  1616  	assert.True(t, m.Get("data").IsUintptr())
  1617  }
  1618  
  1619  func TestIsUintptrSlice(t *testing.T) {
  1620  	m := objx.Map{"data": []uintptr{uintptr(1)}}
  1621  
  1622  	assert.True(t, m.Get("data").IsUintptrSlice())
  1623  }
  1624  
  1625  func TestEachUintptr(t *testing.T) {
  1626  	m := objx.Map{"data": []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}}
  1627  	count := 0
  1628  	replacedVals := make([]uintptr, 0)
  1629  	assert.Equal(t, m.Get("data"), m.Get("data").EachUintptr(func(i int, val uintptr) bool {
  1630  		count++
  1631  		replacedVals = append(replacedVals, val)
  1632  
  1633  		// abort early
  1634  		return i != 2
  1635  	}))
  1636  
  1637  	assert.Equal(t, count, 3)
  1638  	assert.Equal(t, replacedVals[0], m.Get("data").MustUintptrSlice()[0])
  1639  	assert.Equal(t, replacedVals[1], m.Get("data").MustUintptrSlice()[1])
  1640  	assert.Equal(t, replacedVals[2], m.Get("data").MustUintptrSlice()[2])
  1641  }
  1642  
  1643  func TestWhereUintptr(t *testing.T) {
  1644  	m := objx.Map{"data": []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}}
  1645  
  1646  	selected := m.Get("data").WhereUintptr(func(i int, val uintptr) bool {
  1647  		return i%2 == 0
  1648  	}).MustUintptrSlice()
  1649  
  1650  	assert.Equal(t, 3, len(selected))
  1651  }
  1652  
  1653  func TestGroupUintptr(t *testing.T) {
  1654  	m := objx.Map{"data": []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}}
  1655  
  1656  	grouped := m.Get("data").GroupUintptr(func(i int, val uintptr) string {
  1657  		return fmt.Sprintf("%v", i%2 == 0)
  1658  	}).Data().(map[string][]uintptr)
  1659  
  1660  	assert.Equal(t, 2, len(grouped))
  1661  	assert.Equal(t, 3, len(grouped["true"]))
  1662  	assert.Equal(t, 3, len(grouped["false"]))
  1663  }
  1664  
  1665  func TestReplaceUintptr(t *testing.T) {
  1666  	m := objx.Map{"data": []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}}
  1667  	rawArr := m.Get("data").MustUintptrSlice()
  1668  
  1669  	replaced := m.Get("data").ReplaceUintptr(func(index int, val uintptr) uintptr {
  1670  		if index < len(rawArr)-1 {
  1671  			return rawArr[index+1]
  1672  		}
  1673  		return rawArr[0]
  1674  	})
  1675  	replacedArr := replaced.MustUintptrSlice()
  1676  
  1677  	if assert.Equal(t, 6, len(replacedArr)) {
  1678  		assert.Equal(t, replacedArr[0], rawArr[1])
  1679  		assert.Equal(t, replacedArr[1], rawArr[2])
  1680  		assert.Equal(t, replacedArr[2], rawArr[3])
  1681  		assert.Equal(t, replacedArr[3], rawArr[4])
  1682  		assert.Equal(t, replacedArr[4], rawArr[5])
  1683  		assert.Equal(t, replacedArr[5], rawArr[0])
  1684  	}
  1685  }
  1686  
  1687  func TestCollectUintptr(t *testing.T) {
  1688  	m := objx.Map{"data": []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}}
  1689  
  1690  	collected := m.Get("data").CollectUintptr(func(index int, val uintptr) interface{} {
  1691  		return index
  1692  	})
  1693  	collectedArr := collected.MustInterSlice()
  1694  
  1695  	if assert.Equal(t, 6, len(collectedArr)) {
  1696  		assert.Equal(t, collectedArr[0], 0)
  1697  		assert.Equal(t, collectedArr[1], 1)
  1698  		assert.Equal(t, collectedArr[2], 2)
  1699  		assert.Equal(t, collectedArr[3], 3)
  1700  		assert.Equal(t, collectedArr[4], 4)
  1701  		assert.Equal(t, collectedArr[5], 5)
  1702  	}
  1703  }
  1704  
  1705  /*
  1706  Tests for Float32 (float32 and []float32)
  1707  */
  1708  func TestFloat32(t *testing.T) {
  1709  	val := float32(1)
  1710  	m := objx.Map{"value": val, "nothing": nil}
  1711  
  1712  	assert.Equal(t, val, m.Get("value").Float32())
  1713  	assert.Equal(t, val, m.Get("value").MustFloat32())
  1714  	assert.Equal(t, float32(0), m.Get("nothing").Float32())
  1715  	assert.Equal(t, val, m.Get("nothing").Float32(1))
  1716  	assert.Panics(t, func() {
  1717  		m.Get("age").MustFloat32()
  1718  	})
  1719  }
  1720  
  1721  func TestFloat32Slice(t *testing.T) {
  1722  	val := float32(1)
  1723  	m := objx.Map{"value": []float32{val}, "nothing": nil}
  1724  
  1725  	assert.Equal(t, val, m.Get("value").Float32Slice()[0])
  1726  	assert.Equal(t, val, m.Get("value").MustFloat32Slice()[0])
  1727  	assert.Equal(t, []float32(nil), m.Get("nothing").Float32Slice())
  1728  	assert.Equal(t, val, m.Get("nothing").Float32Slice([]float32{float32(1)})[0])
  1729  	assert.Panics(t, func() {
  1730  		m.Get("nothing").MustFloat32Slice()
  1731  	})
  1732  }
  1733  
  1734  func TestIsFloat32(t *testing.T) {
  1735  	m := objx.Map{"data": float32(1)}
  1736  
  1737  	assert.True(t, m.Get("data").IsFloat32())
  1738  }
  1739  
  1740  func TestIsFloat32Slice(t *testing.T) {
  1741  	m := objx.Map{"data": []float32{float32(1)}}
  1742  
  1743  	assert.True(t, m.Get("data").IsFloat32Slice())
  1744  }
  1745  
  1746  func TestEachFloat32(t *testing.T) {
  1747  	m := objx.Map{"data": []float32{float32(1), float32(1), float32(1), float32(1), float32(1)}}
  1748  	count := 0
  1749  	replacedVals := make([]float32, 0)
  1750  	assert.Equal(t, m.Get("data"), m.Get("data").EachFloat32(func(i int, val float32) bool {
  1751  		count++
  1752  		replacedVals = append(replacedVals, val)
  1753  
  1754  		// abort early
  1755  		return i != 2
  1756  	}))
  1757  
  1758  	assert.Equal(t, count, 3)
  1759  	assert.Equal(t, replacedVals[0], m.Get("data").MustFloat32Slice()[0])
  1760  	assert.Equal(t, replacedVals[1], m.Get("data").MustFloat32Slice()[1])
  1761  	assert.Equal(t, replacedVals[2], m.Get("data").MustFloat32Slice()[2])
  1762  }
  1763  
  1764  func TestWhereFloat32(t *testing.T) {
  1765  	m := objx.Map{"data": []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}}
  1766  
  1767  	selected := m.Get("data").WhereFloat32(func(i int, val float32) bool {
  1768  		return i%2 == 0
  1769  	}).MustFloat32Slice()
  1770  
  1771  	assert.Equal(t, 3, len(selected))
  1772  }
  1773  
  1774  func TestGroupFloat32(t *testing.T) {
  1775  	m := objx.Map{"data": []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}}
  1776  
  1777  	grouped := m.Get("data").GroupFloat32(func(i int, val float32) string {
  1778  		return fmt.Sprintf("%v", i%2 == 0)
  1779  	}).Data().(map[string][]float32)
  1780  
  1781  	assert.Equal(t, 2, len(grouped))
  1782  	assert.Equal(t, 3, len(grouped["true"]))
  1783  	assert.Equal(t, 3, len(grouped["false"]))
  1784  }
  1785  
  1786  func TestReplaceFloat32(t *testing.T) {
  1787  	m := objx.Map{"data": []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}}
  1788  	rawArr := m.Get("data").MustFloat32Slice()
  1789  
  1790  	replaced := m.Get("data").ReplaceFloat32(func(index int, val float32) float32 {
  1791  		if index < len(rawArr)-1 {
  1792  			return rawArr[index+1]
  1793  		}
  1794  		return rawArr[0]
  1795  	})
  1796  	replacedArr := replaced.MustFloat32Slice()
  1797  
  1798  	if assert.Equal(t, 6, len(replacedArr)) {
  1799  		assert.Equal(t, replacedArr[0], rawArr[1])
  1800  		assert.Equal(t, replacedArr[1], rawArr[2])
  1801  		assert.Equal(t, replacedArr[2], rawArr[3])
  1802  		assert.Equal(t, replacedArr[3], rawArr[4])
  1803  		assert.Equal(t, replacedArr[4], rawArr[5])
  1804  		assert.Equal(t, replacedArr[5], rawArr[0])
  1805  	}
  1806  }
  1807  
  1808  func TestCollectFloat32(t *testing.T) {
  1809  	m := objx.Map{"data": []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}}
  1810  
  1811  	collected := m.Get("data").CollectFloat32(func(index int, val float32) interface{} {
  1812  		return index
  1813  	})
  1814  	collectedArr := collected.MustInterSlice()
  1815  
  1816  	if assert.Equal(t, 6, len(collectedArr)) {
  1817  		assert.Equal(t, collectedArr[0], 0)
  1818  		assert.Equal(t, collectedArr[1], 1)
  1819  		assert.Equal(t, collectedArr[2], 2)
  1820  		assert.Equal(t, collectedArr[3], 3)
  1821  		assert.Equal(t, collectedArr[4], 4)
  1822  		assert.Equal(t, collectedArr[5], 5)
  1823  	}
  1824  }
  1825  
  1826  /*
  1827  Tests for Float64 (float64 and []float64)
  1828  */
  1829  func TestFloat64(t *testing.T) {
  1830  	val := float64(1)
  1831  	m := objx.Map{"value": val, "nothing": nil}
  1832  
  1833  	assert.Equal(t, val, m.Get("value").Float64())
  1834  	assert.Equal(t, val, m.Get("value").MustFloat64())
  1835  	assert.Equal(t, float64(0), m.Get("nothing").Float64())
  1836  	assert.Equal(t, val, m.Get("nothing").Float64(1))
  1837  	assert.Panics(t, func() {
  1838  		m.Get("age").MustFloat64()
  1839  	})
  1840  }
  1841  
  1842  func TestFloat64Slice(t *testing.T) {
  1843  	val := float64(1)
  1844  	m := objx.Map{"value": []float64{val}, "nothing": nil}
  1845  
  1846  	assert.Equal(t, val, m.Get("value").Float64Slice()[0])
  1847  	assert.Equal(t, val, m.Get("value").MustFloat64Slice()[0])
  1848  	assert.Equal(t, []float64(nil), m.Get("nothing").Float64Slice())
  1849  	assert.Equal(t, val, m.Get("nothing").Float64Slice([]float64{float64(1)})[0])
  1850  	assert.Panics(t, func() {
  1851  		m.Get("nothing").MustFloat64Slice()
  1852  	})
  1853  }
  1854  
  1855  func TestIsFloat64(t *testing.T) {
  1856  	m := objx.Map{"data": float64(1)}
  1857  
  1858  	assert.True(t, m.Get("data").IsFloat64())
  1859  }
  1860  
  1861  func TestIsFloat64Slice(t *testing.T) {
  1862  	m := objx.Map{"data": []float64{float64(1)}}
  1863  
  1864  	assert.True(t, m.Get("data").IsFloat64Slice())
  1865  }
  1866  
  1867  func TestEachFloat64(t *testing.T) {
  1868  	m := objx.Map{"data": []float64{float64(1), float64(1), float64(1), float64(1), float64(1)}}
  1869  	count := 0
  1870  	replacedVals := make([]float64, 0)
  1871  	assert.Equal(t, m.Get("data"), m.Get("data").EachFloat64(func(i int, val float64) bool {
  1872  		count++
  1873  		replacedVals = append(replacedVals, val)
  1874  
  1875  		// abort early
  1876  		return i != 2
  1877  	}))
  1878  
  1879  	assert.Equal(t, count, 3)
  1880  	assert.Equal(t, replacedVals[0], m.Get("data").MustFloat64Slice()[0])
  1881  	assert.Equal(t, replacedVals[1], m.Get("data").MustFloat64Slice()[1])
  1882  	assert.Equal(t, replacedVals[2], m.Get("data").MustFloat64Slice()[2])
  1883  }
  1884  
  1885  func TestWhereFloat64(t *testing.T) {
  1886  	m := objx.Map{"data": []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}}
  1887  
  1888  	selected := m.Get("data").WhereFloat64(func(i int, val float64) bool {
  1889  		return i%2 == 0
  1890  	}).MustFloat64Slice()
  1891  
  1892  	assert.Equal(t, 3, len(selected))
  1893  }
  1894  
  1895  func TestGroupFloat64(t *testing.T) {
  1896  	m := objx.Map{"data": []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}}
  1897  
  1898  	grouped := m.Get("data").GroupFloat64(func(i int, val float64) string {
  1899  		return fmt.Sprintf("%v", i%2 == 0)
  1900  	}).Data().(map[string][]float64)
  1901  
  1902  	assert.Equal(t, 2, len(grouped))
  1903  	assert.Equal(t, 3, len(grouped["true"]))
  1904  	assert.Equal(t, 3, len(grouped["false"]))
  1905  }
  1906  
  1907  func TestReplaceFloat64(t *testing.T) {
  1908  	m := objx.Map{"data": []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}}
  1909  	rawArr := m.Get("data").MustFloat64Slice()
  1910  
  1911  	replaced := m.Get("data").ReplaceFloat64(func(index int, val float64) float64 {
  1912  		if index < len(rawArr)-1 {
  1913  			return rawArr[index+1]
  1914  		}
  1915  		return rawArr[0]
  1916  	})
  1917  	replacedArr := replaced.MustFloat64Slice()
  1918  
  1919  	if assert.Equal(t, 6, len(replacedArr)) {
  1920  		assert.Equal(t, replacedArr[0], rawArr[1])
  1921  		assert.Equal(t, replacedArr[1], rawArr[2])
  1922  		assert.Equal(t, replacedArr[2], rawArr[3])
  1923  		assert.Equal(t, replacedArr[3], rawArr[4])
  1924  		assert.Equal(t, replacedArr[4], rawArr[5])
  1925  		assert.Equal(t, replacedArr[5], rawArr[0])
  1926  	}
  1927  }
  1928  
  1929  func TestCollectFloat64(t *testing.T) {
  1930  	m := objx.Map{"data": []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}}
  1931  
  1932  	collected := m.Get("data").CollectFloat64(func(index int, val float64) interface{} {
  1933  		return index
  1934  	})
  1935  	collectedArr := collected.MustInterSlice()
  1936  
  1937  	if assert.Equal(t, 6, len(collectedArr)) {
  1938  		assert.Equal(t, collectedArr[0], 0)
  1939  		assert.Equal(t, collectedArr[1], 1)
  1940  		assert.Equal(t, collectedArr[2], 2)
  1941  		assert.Equal(t, collectedArr[3], 3)
  1942  		assert.Equal(t, collectedArr[4], 4)
  1943  		assert.Equal(t, collectedArr[5], 5)
  1944  	}
  1945  }
  1946  
  1947  /*
  1948  Tests for Complex64 (complex64 and []complex64)
  1949  */
  1950  func TestComplex64(t *testing.T) {
  1951  	val := complex64(1)
  1952  	m := objx.Map{"value": val, "nothing": nil}
  1953  
  1954  	assert.Equal(t, val, m.Get("value").Complex64())
  1955  	assert.Equal(t, val, m.Get("value").MustComplex64())
  1956  	assert.Equal(t, complex64(0), m.Get("nothing").Complex64())
  1957  	assert.Equal(t, val, m.Get("nothing").Complex64(1))
  1958  	assert.Panics(t, func() {
  1959  		m.Get("age").MustComplex64()
  1960  	})
  1961  }
  1962  
  1963  func TestComplex64Slice(t *testing.T) {
  1964  	val := complex64(1)
  1965  	m := objx.Map{"value": []complex64{val}, "nothing": nil}
  1966  
  1967  	assert.Equal(t, val, m.Get("value").Complex64Slice()[0])
  1968  	assert.Equal(t, val, m.Get("value").MustComplex64Slice()[0])
  1969  	assert.Equal(t, []complex64(nil), m.Get("nothing").Complex64Slice())
  1970  	assert.Equal(t, val, m.Get("nothing").Complex64Slice([]complex64{complex64(1)})[0])
  1971  	assert.Panics(t, func() {
  1972  		m.Get("nothing").MustComplex64Slice()
  1973  	})
  1974  }
  1975  
  1976  func TestIsComplex64(t *testing.T) {
  1977  	m := objx.Map{"data": complex64(1)}
  1978  
  1979  	assert.True(t, m.Get("data").IsComplex64())
  1980  }
  1981  
  1982  func TestIsComplex64Slice(t *testing.T) {
  1983  	m := objx.Map{"data": []complex64{complex64(1)}}
  1984  
  1985  	assert.True(t, m.Get("data").IsComplex64Slice())
  1986  }
  1987  
  1988  func TestEachComplex64(t *testing.T) {
  1989  	m := objx.Map{"data": []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}}
  1990  	count := 0
  1991  	replacedVals := make([]complex64, 0)
  1992  	assert.Equal(t, m.Get("data"), m.Get("data").EachComplex64(func(i int, val complex64) bool {
  1993  		count++
  1994  		replacedVals = append(replacedVals, val)
  1995  
  1996  		// abort early
  1997  		return i != 2
  1998  	}))
  1999  
  2000  	assert.Equal(t, count, 3)
  2001  	assert.Equal(t, replacedVals[0], m.Get("data").MustComplex64Slice()[0])
  2002  	assert.Equal(t, replacedVals[1], m.Get("data").MustComplex64Slice()[1])
  2003  	assert.Equal(t, replacedVals[2], m.Get("data").MustComplex64Slice()[2])
  2004  }
  2005  
  2006  func TestWhereComplex64(t *testing.T) {
  2007  	m := objx.Map{"data": []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}}
  2008  
  2009  	selected := m.Get("data").WhereComplex64(func(i int, val complex64) bool {
  2010  		return i%2 == 0
  2011  	}).MustComplex64Slice()
  2012  
  2013  	assert.Equal(t, 3, len(selected))
  2014  }
  2015  
  2016  func TestGroupComplex64(t *testing.T) {
  2017  	m := objx.Map{"data": []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}}
  2018  
  2019  	grouped := m.Get("data").GroupComplex64(func(i int, val complex64) string {
  2020  		return fmt.Sprintf("%v", i%2 == 0)
  2021  	}).Data().(map[string][]complex64)
  2022  
  2023  	assert.Equal(t, 2, len(grouped))
  2024  	assert.Equal(t, 3, len(grouped["true"]))
  2025  	assert.Equal(t, 3, len(grouped["false"]))
  2026  }
  2027  
  2028  func TestReplaceComplex64(t *testing.T) {
  2029  	m := objx.Map{"data": []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}}
  2030  	rawArr := m.Get("data").MustComplex64Slice()
  2031  
  2032  	replaced := m.Get("data").ReplaceComplex64(func(index int, val complex64) complex64 {
  2033  		if index < len(rawArr)-1 {
  2034  			return rawArr[index+1]
  2035  		}
  2036  		return rawArr[0]
  2037  	})
  2038  	replacedArr := replaced.MustComplex64Slice()
  2039  
  2040  	if assert.Equal(t, 6, len(replacedArr)) {
  2041  		assert.Equal(t, replacedArr[0], rawArr[1])
  2042  		assert.Equal(t, replacedArr[1], rawArr[2])
  2043  		assert.Equal(t, replacedArr[2], rawArr[3])
  2044  		assert.Equal(t, replacedArr[3], rawArr[4])
  2045  		assert.Equal(t, replacedArr[4], rawArr[5])
  2046  		assert.Equal(t, replacedArr[5], rawArr[0])
  2047  	}
  2048  }
  2049  
  2050  func TestCollectComplex64(t *testing.T) {
  2051  	m := objx.Map{"data": []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}}
  2052  
  2053  	collected := m.Get("data").CollectComplex64(func(index int, val complex64) interface{} {
  2054  		return index
  2055  	})
  2056  	collectedArr := collected.MustInterSlice()
  2057  
  2058  	if assert.Equal(t, 6, len(collectedArr)) {
  2059  		assert.Equal(t, collectedArr[0], 0)
  2060  		assert.Equal(t, collectedArr[1], 1)
  2061  		assert.Equal(t, collectedArr[2], 2)
  2062  		assert.Equal(t, collectedArr[3], 3)
  2063  		assert.Equal(t, collectedArr[4], 4)
  2064  		assert.Equal(t, collectedArr[5], 5)
  2065  	}
  2066  }
  2067  
  2068  /*
  2069  Tests for Complex128 (complex128 and []complex128)
  2070  */
  2071  func TestComplex128(t *testing.T) {
  2072  	val := complex128(1)
  2073  	m := objx.Map{"value": val, "nothing": nil}
  2074  
  2075  	assert.Equal(t, val, m.Get("value").Complex128())
  2076  	assert.Equal(t, val, m.Get("value").MustComplex128())
  2077  	assert.Equal(t, complex128(0), m.Get("nothing").Complex128())
  2078  	assert.Equal(t, val, m.Get("nothing").Complex128(1))
  2079  	assert.Panics(t, func() {
  2080  		m.Get("age").MustComplex128()
  2081  	})
  2082  }
  2083  
  2084  func TestComplex128Slice(t *testing.T) {
  2085  	val := complex128(1)
  2086  	m := objx.Map{"value": []complex128{val}, "nothing": nil}
  2087  
  2088  	assert.Equal(t, val, m.Get("value").Complex128Slice()[0])
  2089  	assert.Equal(t, val, m.Get("value").MustComplex128Slice()[0])
  2090  	assert.Equal(t, []complex128(nil), m.Get("nothing").Complex128Slice())
  2091  	assert.Equal(t, val, m.Get("nothing").Complex128Slice([]complex128{complex128(1)})[0])
  2092  	assert.Panics(t, func() {
  2093  		m.Get("nothing").MustComplex128Slice()
  2094  	})
  2095  }
  2096  
  2097  func TestIsComplex128(t *testing.T) {
  2098  	m := objx.Map{"data": complex128(1)}
  2099  
  2100  	assert.True(t, m.Get("data").IsComplex128())
  2101  }
  2102  
  2103  func TestIsComplex128Slice(t *testing.T) {
  2104  	m := objx.Map{"data": []complex128{complex128(1)}}
  2105  
  2106  	assert.True(t, m.Get("data").IsComplex128Slice())
  2107  }
  2108  
  2109  func TestEachComplex128(t *testing.T) {
  2110  	m := objx.Map{"data": []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}}
  2111  	count := 0
  2112  	replacedVals := make([]complex128, 0)
  2113  	assert.Equal(t, m.Get("data"), m.Get("data").EachComplex128(func(i int, val complex128) bool {
  2114  		count++
  2115  		replacedVals = append(replacedVals, val)
  2116  
  2117  		// abort early
  2118  		return i != 2
  2119  	}))
  2120  
  2121  	assert.Equal(t, count, 3)
  2122  	assert.Equal(t, replacedVals[0], m.Get("data").MustComplex128Slice()[0])
  2123  	assert.Equal(t, replacedVals[1], m.Get("data").MustComplex128Slice()[1])
  2124  	assert.Equal(t, replacedVals[2], m.Get("data").MustComplex128Slice()[2])
  2125  }
  2126  
  2127  func TestWhereComplex128(t *testing.T) {
  2128  	m := objx.Map{"data": []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}}
  2129  
  2130  	selected := m.Get("data").WhereComplex128(func(i int, val complex128) bool {
  2131  		return i%2 == 0
  2132  	}).MustComplex128Slice()
  2133  
  2134  	assert.Equal(t, 3, len(selected))
  2135  }
  2136  
  2137  func TestGroupComplex128(t *testing.T) {
  2138  	m := objx.Map{"data": []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}}
  2139  
  2140  	grouped := m.Get("data").GroupComplex128(func(i int, val complex128) string {
  2141  		return fmt.Sprintf("%v", i%2 == 0)
  2142  	}).Data().(map[string][]complex128)
  2143  
  2144  	assert.Equal(t, 2, len(grouped))
  2145  	assert.Equal(t, 3, len(grouped["true"]))
  2146  	assert.Equal(t, 3, len(grouped["false"]))
  2147  }
  2148  
  2149  func TestReplaceComplex128(t *testing.T) {
  2150  	m := objx.Map{"data": []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}}
  2151  	rawArr := m.Get("data").MustComplex128Slice()
  2152  
  2153  	replaced := m.Get("data").ReplaceComplex128(func(index int, val complex128) complex128 {
  2154  		if index < len(rawArr)-1 {
  2155  			return rawArr[index+1]
  2156  		}
  2157  		return rawArr[0]
  2158  	})
  2159  	replacedArr := replaced.MustComplex128Slice()
  2160  
  2161  	if assert.Equal(t, 6, len(replacedArr)) {
  2162  		assert.Equal(t, replacedArr[0], rawArr[1])
  2163  		assert.Equal(t, replacedArr[1], rawArr[2])
  2164  		assert.Equal(t, replacedArr[2], rawArr[3])
  2165  		assert.Equal(t, replacedArr[3], rawArr[4])
  2166  		assert.Equal(t, replacedArr[4], rawArr[5])
  2167  		assert.Equal(t, replacedArr[5], rawArr[0])
  2168  	}
  2169  }
  2170  
  2171  func TestCollectComplex128(t *testing.T) {
  2172  	m := objx.Map{"data": []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}}
  2173  
  2174  	collected := m.Get("data").CollectComplex128(func(index int, val complex128) interface{} {
  2175  		return index
  2176  	})
  2177  	collectedArr := collected.MustInterSlice()
  2178  
  2179  	if assert.Equal(t, 6, len(collectedArr)) {
  2180  		assert.Equal(t, collectedArr[0], 0)
  2181  		assert.Equal(t, collectedArr[1], 1)
  2182  		assert.Equal(t, collectedArr[2], 2)
  2183  		assert.Equal(t, collectedArr[3], 3)
  2184  		assert.Equal(t, collectedArr[4], 4)
  2185  		assert.Equal(t, collectedArr[5], 5)
  2186  	}
  2187  }
  2188  

View as plain text