diff options
Diffstat (limited to 'vendor/github.com/stretchr/objx')
| -rw-r--r-- | vendor/github.com/stretchr/objx/.codeclimate.yml | 8 | ||||
| -rw-r--r-- | vendor/github.com/stretchr/objx/.travis.yml | 13 | ||||
| -rw-r--r-- | vendor/github.com/stretchr/objx/README.md | 2 | ||||
| -rw-r--r-- | vendor/github.com/stretchr/objx/Taskfile.yml | 1 | ||||
| -rw-r--r-- | vendor/github.com/stretchr/objx/accessors.go | 151 | ||||
| -rw-r--r-- | vendor/github.com/stretchr/objx/accessors_test.go | 204 | ||||
| -rw-r--r-- | vendor/github.com/stretchr/objx/codegen/template_test.txt | 169 | ||||
| -rw-r--r-- | vendor/github.com/stretchr/objx/codegen/types_list.txt | 2 | ||||
| -rw-r--r-- | vendor/github.com/stretchr/objx/constants.go | 13 | ||||
| -rw-r--r-- | vendor/github.com/stretchr/objx/conversions.go | 9 | ||||
| -rw-r--r-- | vendor/github.com/stretchr/objx/map.go | 44 | ||||
| -rw-r--r-- | vendor/github.com/stretchr/objx/map_test.go | 55 | ||||
| -rw-r--r-- | vendor/github.com/stretchr/objx/type_specific_codegen.go | 23 | ||||
| -rw-r--r-- | vendor/github.com/stretchr/objx/type_specific_codegen_test.go | 3306 |
14 files changed, 1954 insertions, 2046 deletions
diff --git a/vendor/github.com/stretchr/objx/.codeclimate.yml b/vendor/github.com/stretchr/objx/.codeclimate.yml index 010d4ccd5..559fa399c 100644 --- a/vendor/github.com/stretchr/objx/.codeclimate.yml +++ b/vendor/github.com/stretchr/objx/.codeclimate.yml @@ -10,4 +10,12 @@ exclude_patterns: - ".github/" - "vendor/" - "codegen/" +- "*.yml" +- ".*.yml" +- "*.md" +- "Gopkg.*" - "doc.go" +- "type_specific_codegen_test.go" +- "type_specific_codegen.go" +- ".gitignore" +- "LICENSE" diff --git a/vendor/github.com/stretchr/objx/.travis.yml b/vendor/github.com/stretchr/objx/.travis.yml index a63efa59d..df30dbb70 100644 --- a/vendor/github.com/stretchr/objx/.travis.yml +++ b/vendor/github.com/stretchr/objx/.travis.yml @@ -1,8 +1,9 @@ language: go go: + - 1.6 + - 1.7 - 1.8 - 1.9 - - tip env: global: @@ -14,12 +15,14 @@ before_script: - ./cc-test-reporter before-build install: -- go get github.com/go-task/task/cmd/task + - wget https://github.com/go-task/task/releases/download/v1.4.4/task_linux_amd64.tar.gz + - tar xf task_linux_amd64.tar.gz + - mv task $HOME/gopath/bin script: -- task dl-deps -- task lint -- task test-coverage + - task dl-deps + - task lint + - task test-coverage after_script: - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT diff --git a/vendor/github.com/stretchr/objx/README.md b/vendor/github.com/stretchr/objx/README.md index be5750c94..8fc8fa277 100644 --- a/vendor/github.com/stretchr/objx/README.md +++ b/vendor/github.com/stretchr/objx/README.md @@ -74,7 +74,7 @@ To update Objx to the latest version, run: go get -u github.com/stretchr/objx ### Supported go versions -We support the lastest two major Go versions, which are 1.8 and 1.9 at the moment. +We support the lastest four major Go versions, which are 1.6, 1.7, 1.8 and 1.9 at the moment. ## Contributing Please feel free to submit issues, fork the repository and send pull requests! diff --git a/vendor/github.com/stretchr/objx/Taskfile.yml b/vendor/github.com/stretchr/objx/Taskfile.yml index f8035641f..7d0199450 100644 --- a/vendor/github.com/stretchr/objx/Taskfile.yml +++ b/vendor/github.com/stretchr/objx/Taskfile.yml @@ -5,7 +5,6 @@ dl-deps: desc: Downloads cli dependencies cmds: - go get -u github.com/golang/lint/golint - - go get -u github.com/golang/dep/cmd/dep update-deps: desc: Updates dependencies diff --git a/vendor/github.com/stretchr/objx/accessors.go b/vendor/github.com/stretchr/objx/accessors.go index 204356a22..78939426d 100644 --- a/vendor/github.com/stretchr/objx/accessors.go +++ b/vendor/github.com/stretchr/objx/accessors.go @@ -6,9 +6,17 @@ import ( "strings" ) -// arrayAccesRegexString is the regex used to extract the array number -// from the access path -const arrayAccesRegexString = `^(.+)\[([0-9]+)\]$` +const ( + // PathSeparator is the character used to separate the elements + // of the keypath. + // + // For example, `location.address.city` + PathSeparator string = "." + + // arrayAccesRegexString is the regex used to extract the array number + // from the access path + arrayAccesRegexString = `^(.+)\[([0-9]+)\]$` +) // arrayAccesRegex is the compiled arrayAccesRegexString var arrayAccesRegex = regexp.MustCompile(arrayAccesRegexString) @@ -46,103 +54,60 @@ func (m Map) Set(selector string, value interface{}) Map { return m } +// getIndex returns the index, which is hold in s by two braches. +// It also returns s withour the index part, e.g. name[1] will return (1, name). +// If no index is found, -1 is returned +func getIndex(s string) (int, string) { + arrayMatches := arrayAccesRegex.FindStringSubmatch(s) + if len(arrayMatches) > 0 { + // Get the key into the map + selector := arrayMatches[1] + // Get the index into the array at the key + // We know this cannt fail because arrayMatches[2] is an int for sure + index, _ := strconv.Atoi(arrayMatches[2]) + return index, selector + } + return -1, s +} + // access accesses the object using the selector and performs the // appropriate action. -func access(current, selector, value interface{}, isSet bool) interface{} { - switch selector.(type) { - case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64: - if array, ok := current.([]interface{}); ok { - index := intFromInterface(selector) - if index >= len(array) { - return nil - } - return array[index] - } - return nil - - case string: - selStr := selector.(string) - selSegs := strings.SplitN(selStr, PathSeparator, 2) - thisSel := selSegs[0] - index := -1 - var err error - - if strings.Contains(thisSel, "[") { - arrayMatches := arrayAccesRegex.FindStringSubmatch(thisSel) - if len(arrayMatches) > 0 { - // Get the key into the map - thisSel = arrayMatches[1] +func access(current interface{}, selector string, value interface{}, isSet bool) interface{} { + selSegs := strings.SplitN(selector, PathSeparator, 2) + thisSel := selSegs[0] + index := -1 - // Get the index into the array at the key - index, err = strconv.Atoi(arrayMatches[2]) + if strings.Contains(thisSel, "[") { + index, thisSel = getIndex(thisSel) + } - if err != nil { - // This should never happen. If it does, something has gone - // seriously wrong. Panic. - panic("objx: Array index is not an integer. Must use array[int].") - } - } - } - if curMap, ok := current.(Map); ok { - current = map[string]interface{}(curMap) - } - // get the object in question - switch current.(type) { - case map[string]interface{}: - curMSI := current.(map[string]interface{}) - if len(selSegs) <= 1 && isSet { - curMSI[thisSel] = value - return nil - } - current = curMSI[thisSel] - default: - current = nil + if curMap, ok := current.(Map); ok { + current = map[string]interface{}(curMap) + } + // get the object in question + switch current.(type) { + case map[string]interface{}: + curMSI := current.(map[string]interface{}) + if len(selSegs) <= 1 && isSet { + curMSI[thisSel] = value + return nil } - // do we need to access the item of an array? - if index > -1 { - if array, ok := current.([]interface{}); ok { - if index < len(array) { - current = array[index] - } else { - current = nil - } + current = curMSI[thisSel] + default: + current = nil + } + // do we need to access the item of an array? + if index > -1 { + if array, ok := current.([]interface{}); ok { + if index < len(array) { + current = array[index] + } else { + current = nil } } - if len(selSegs) > 1 { - current = access(current, selSegs[1], value, isSet) - } } - return current -} - -// intFromInterface converts an interface object to the largest -// representation of an unsigned integer using a type switch and -// assertions -func intFromInterface(selector interface{}) int { - var value int - switch selector.(type) { - case int: - value = selector.(int) - case int8: - value = int(selector.(int8)) - case int16: - value = int(selector.(int16)) - case int32: - value = int(selector.(int32)) - case int64: - value = int(selector.(int64)) - case uint: - value = int(selector.(uint)) - case uint8: - value = int(selector.(uint8)) - case uint16: - value = int(selector.(uint16)) - case uint32: - value = int(selector.(uint32)) - case uint64: - value = int(selector.(uint64)) - default: - return 0 + if len(selSegs) > 1 { + current = access(current, selSegs[1], value, isSet) } - return value + return current } diff --git a/vendor/github.com/stretchr/objx/accessors_test.go b/vendor/github.com/stretchr/objx/accessors_test.go index f6be310f7..965e4e77f 100644 --- a/vendor/github.com/stretchr/objx/accessors_test.go +++ b/vendor/github.com/stretchr/objx/accessors_test.go @@ -1,238 +1,174 @@ -package objx +package objx_test import ( "testing" + "github.com/stretchr/objx" "github.com/stretchr/testify/assert" ) func TestAccessorsAccessGetSingleField(t *testing.T) { - current := Map{"name": "Tyler"} + m := objx.Map{"name": "Tyler"} - assert.Equal(t, "Tyler", current.Get("name").Data()) + assert.Equal(t, "Tyler", m.Get("name").Data()) } func TestAccessorsAccessGetSingleFieldInt(t *testing.T) { - current := Map{"name": 10} + m := objx.Map{"name": 10} - assert.Equal(t, 10, current.Get("name").Data()) + assert.Equal(t, 10, m.Get("name").Data()) } func TestAccessorsAccessGetDeep(t *testing.T) { - current := Map{ - "name": Map{ + m := objx.Map{ + "name": objx.Map{ "first": "Tyler", "last": "Bunnell", }, } - assert.Equal(t, "Tyler", current.Get("name.first").Data()) - assert.Equal(t, "Bunnell", current.Get("name.last").Data()) + assert.Equal(t, "Tyler", m.Get("name.first").Data()) + assert.Equal(t, "Bunnell", m.Get("name.last").Data()) } func TestAccessorsAccessGetDeepDeep(t *testing.T) { - current := Map{ - "one": Map{ - "two": Map{ - "three": Map{ + m := objx.Map{ + "one": objx.Map{ + "two": objx.Map{ + "three": objx.Map{ "four": 4, }, }, }, } - assert.Equal(t, 4, current.Get("one.two.three.four").Data()) + assert.Equal(t, 4, m.Get("one.two.three.four").Data()) } func TestAccessorsAccessGetInsideArray(t *testing.T) { - current := Map{ + m := objx.Map{ "names": []interface{}{ - Map{ + objx.Map{ "first": "Tyler", "last": "Bunnell", }, - Map{ + objx.Map{ "first": "Capitol", "last": "Bollocks", }, }, } - assert.Equal(t, "Tyler", current.Get("names[0].first").Data()) - assert.Equal(t, "Bunnell", current.Get("names[0].last").Data()) - assert.Equal(t, "Capitol", current.Get("names[1].first").Data()) - assert.Equal(t, "Bollocks", current.Get("names[1].last").Data()) + assert.Equal(t, "Tyler", m.Get("names[0].first").Data()) + assert.Equal(t, "Bunnell", m.Get("names[0].last").Data()) + assert.Equal(t, "Capitol", m.Get("names[1].first").Data()) + assert.Equal(t, "Bollocks", m.Get("names[1].last").Data()) - assert.Nil(t, current.Get("names[2]").Data()) -} - -func TestAccessorsAccessGetFromArrayWithInt(t *testing.T) { - current := []interface{}{ - map[string]interface{}{ - "first": "Tyler", - "last": "Bunnell", - }, - map[string]interface{}{ - "first": "Capitol", - "last": "Bollocks", - }, - } - one := access(current, 0, nil, false) - two := access(current, 1, nil, false) - three := access(current, 2, nil, false) - - assert.Equal(t, "Tyler", one.(map[string]interface{})["first"]) - assert.Equal(t, "Capitol", two.(map[string]interface{})["first"]) - assert.Nil(t, three) -} - -func TestAccessorsAccessGetFromArrayWithIntTypes(t *testing.T) { - current := []interface{}{ - "abc", - "def", - } - assert.Equal(t, "abc", access(current, 0, nil, false)) - assert.Equal(t, "def", access(current, 1, nil, false)) - assert.Nil(t, access(current, 2, nil, false)) - - assert.Equal(t, "abc", access(current, int8(0), nil, false)) - assert.Equal(t, "def", access(current, int8(1), nil, false)) - assert.Nil(t, access(current, int8(2), nil, false)) - - assert.Equal(t, "abc", access(current, int16(0), nil, false)) - assert.Equal(t, "def", access(current, int16(1), nil, false)) - assert.Nil(t, access(current, int16(2), nil, false)) - - assert.Equal(t, "abc", access(current, int32(0), nil, false)) - assert.Equal(t, "def", access(current, int32(1), nil, false)) - assert.Nil(t, access(current, int32(2), nil, false)) - - assert.Equal(t, "abc", access(current, int64(0), nil, false)) - assert.Equal(t, "def", access(current, int64(1), nil, false)) - assert.Nil(t, access(current, int64(2), nil, false)) - - assert.Equal(t, "abc", access(current, uint(0), nil, false)) - assert.Equal(t, "def", access(current, uint(1), nil, false)) - assert.Nil(t, access(current, uint(2), nil, false)) - - assert.Equal(t, "abc", access(current, uint8(0), nil, false)) - assert.Equal(t, "def", access(current, uint8(1), nil, false)) - assert.Nil(t, access(current, uint8(2), nil, false)) - - assert.Equal(t, "abc", access(current, uint16(0), nil, false)) - assert.Equal(t, "def", access(current, uint16(1), nil, false)) - assert.Nil(t, access(current, uint16(2), nil, false)) - - assert.Equal(t, "abc", access(current, uint32(0), nil, false)) - assert.Equal(t, "def", access(current, uint32(1), nil, false)) - assert.Nil(t, access(current, uint32(2), nil, false)) - - assert.Equal(t, "abc", access(current, uint64(0), nil, false)) - assert.Equal(t, "def", access(current, uint64(1), nil, false)) - assert.Nil(t, access(current, uint64(2), nil, false)) -} - -func TestAccessorsAccessGetFromArrayWithIntError(t *testing.T) { - current := Map{"name": "Tyler"} - - assert.Nil(t, access(current, 0, nil, false)) + assert.Nil(t, m.Get("names[2]").Data()) + assert.Nil(t, m.Get("names[]").Data()) + assert.Nil(t, m.Get("names1]]").Data()) + assert.Nil(t, m.Get("names[1]]").Data()) + assert.Nil(t, m.Get("names[[1]]").Data()) + assert.Nil(t, m.Get("names[[1]").Data()) + assert.Nil(t, m.Get("names[[1").Data()) } func TestAccessorsGet(t *testing.T) { - current := Map{"name": "Tyler"} + m := objx.Map{"name": "Tyler"} - assert.Equal(t, "Tyler", current.Get("name").Data()) + assert.Equal(t, "Tyler", m.Get("name").Data()) } func TestAccessorsAccessSetSingleField(t *testing.T) { - current := Map{"name": "Tyler"} + m := objx.Map{"name": "Tyler"} - current.Set("name", "Mat") - current.Set("age", 29) + m.Set("name", "Mat") + m.Set("age", 29) - assert.Equal(t, current["name"], "Mat") - assert.Equal(t, current["age"], 29) + assert.Equal(t, m.Get("name").Data(), "Mat") + assert.Equal(t, m.Get("age").Data(), 29) } func TestAccessorsAccessSetSingleFieldNotExisting(t *testing.T) { - current := Map{ + m := objx.Map{ "first": "Tyler", "last": "Bunnell", } - current.Set("name", "Mat") + m.Set("name", "Mat") - assert.Equal(t, current["name"], "Mat") + assert.Equal(t, m.Get("name").Data(), "Mat") } func TestAccessorsAccessSetDeep(t *testing.T) { - current := Map{ - "name": Map{ + m := objx.Map{ + "name": objx.Map{ "first": "Tyler", "last": "Bunnell", }, } - current.Set("name.first", "Mat") - current.Set("name.last", "Ryer") + m.Set("name.first", "Mat") + m.Set("name.last", "Ryer") - assert.Equal(t, "Mat", current.Get("name.first").Data()) - assert.Equal(t, "Ryer", current.Get("name.last").Data()) + assert.Equal(t, "Mat", m.Get("name.first").Data()) + assert.Equal(t, "Ryer", m.Get("name.last").Data()) } func TestAccessorsAccessSetDeepDeep(t *testing.T) { - current := Map{ - "one": Map{ - "two": Map{ - "three": Map{ - "four": 4}, + m := objx.Map{ + "one": objx.Map{ + "two": objx.Map{ + "three": objx.Map{ + "four": 4, + }, }, }, } - current.Set("one.two.three.four", 5) + m.Set("one.two.three.four", 5) - assert.Equal(t, 5, current.Get("one.two.three.four").Data()) + assert.Equal(t, 5, m.Get("one.two.three.four").Data()) } func TestAccessorsAccessSetArray(t *testing.T) { - current := Map{ + m := objx.Map{ "names": []interface{}{"Tyler"}, } - current.Set("names[0]", "Mat") + m.Set("names[0]", "Mat") - assert.Equal(t, "Mat", current.Get("names[0]").Data()) + assert.Equal(t, "Mat", m.Get("names[0]").Data()) } func TestAccessorsAccessSetInsideArray(t *testing.T) { - current := Map{ + m := objx.Map{ "names": []interface{}{ - Map{ + objx.Map{ "first": "Tyler", "last": "Bunnell", }, - Map{ + objx.Map{ "first": "Capitol", "last": "Bollocks", }, }, } - current.Set("names[0].first", "Mat") - current.Set("names[0].last", "Ryer") - current.Set("names[1].first", "Captain") - current.Set("names[1].last", "Underpants") + m.Set("names[0].first", "Mat") + m.Set("names[0].last", "Ryer") + m.Set("names[1].first", "Captain") + m.Set("names[1].last", "Underpants") - assert.Equal(t, "Mat", current.Get("names[0].first").Data()) - assert.Equal(t, "Ryer", current.Get("names[0].last").Data()) - assert.Equal(t, "Captain", current.Get("names[1].first").Data()) - assert.Equal(t, "Underpants", current.Get("names[1].last").Data()) + assert.Equal(t, "Mat", m.Get("names[0].first").Data()) + assert.Equal(t, "Ryer", m.Get("names[0].last").Data()) + assert.Equal(t, "Captain", m.Get("names[1].first").Data()) + assert.Equal(t, "Underpants", m.Get("names[1].last").Data()) } func TestAccessorsSet(t *testing.T) { - current := Map{"name": "Tyler"} + m := objx.Map{"name": "Tyler"} - current.Set("name", "Mat") + m.Set("name", "Mat") - assert.Equal(t, "Mat", current.Get("name").data) + assert.Equal(t, "Mat", m.Get("name").Data()) } diff --git a/vendor/github.com/stretchr/objx/codegen/template_test.txt b/vendor/github.com/stretchr/objx/codegen/template_test.txt index 7643af390..6490cb2df 100644 --- a/vendor/github.com/stretchr/objx/codegen/template_test.txt +++ b/vendor/github.com/stretchr/objx/codegen/template_test.txt @@ -1,121 +1,120 @@ /* Tests for {4} ({1} and []{1}) */ - func Test{4}(t *testing.T) { - val := {1}( {2} ) - - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").{4}()) - assert.Equal(t, val, New(m).Get("value").Must{4}()) - assert.Equal(t, {1}({3}), New(m).Get("nothing").{4}()) - assert.Equal(t, val, New(m).Get("nothing").{4}({2})) - assert.Panics(t, func() { - New(m).Get("age").Must{4}() - }) + val := {1}({2}) + m := objx.Map{"value": val, "nothing": nil} + + assert.Equal(t, val, m.Get("value").{4}()) + assert.Equal(t, val, m.Get("value").Must{4}()) + assert.Equal(t, {1}({3}), m.Get("nothing").{4}()) + assert.Equal(t, val, m.Get("nothing").{4}({2})) + assert.Panics(t, func() { + m.Get("age").Must{4}() + }) } func Test{4}Slice(t *testing.T) { - val := {1}( {2} ) - - m := map[string]interface{}{"value": []{1}{ val }, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").{4}Slice()[0]) - assert.Equal(t, val, New(m).Get("value").Must{4}Slice()[0]) - assert.Equal(t, []{1}(nil), New(m).Get("nothing").{4}Slice()) - assert.Equal(t, val, New(m).Get("nothing").{4}Slice( []{1}{ {1}({2}) } )[0]) - assert.Panics(t, func() { - New(m).Get("nothing").Must{4}Slice() - }) + val := {1}({2}) + m := objx.Map{"value": []{1}{ val }, "nothing": nil} + + assert.Equal(t, val, m.Get("value").{4}Slice()[0]) + assert.Equal(t, val, m.Get("value").Must{4}Slice()[0]) + assert.Equal(t, []{1}(nil), m.Get("nothing").{4}Slice()) + assert.Equal(t, val, m.Get("nothing").{4}Slice([]{1}{{1}({2})})[0]) + assert.Panics(t, func() { + m.Get("nothing").Must{4}Slice() + }) } func TestIs{4}(t *testing.T) { - v := &Value{data: {1}({2})} - assert.True(t, v.Is{4}()) + m := objx.Map{"data": {1}({2})} + assert.True(t, m.Get("data").Is{4}()) } func TestIs{4}Slice(t *testing.T) { - v := &Value{data: []{1}{ {1}({2}) }} - assert.True(t, v.Is{4}Slice()) + m := objx.Map{"data": []{1}{{1}({2})}} + + assert.True(t, m.Get("data").Is{4}Slice()) } func TestEach{4}(t *testing.T) { - v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }} - count := 0 - replacedVals := make([]{1}, 0) - assert.Equal(t, v, v.Each{4}(func(i int, val {1}) bool { - count++ - replacedVals = append(replacedVals, val) - - // abort early + m := objx.Map{"data": []{1}{{1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2})}} + count := 0 + replacedVals := make([]{1}, 0) + assert.Equal(t, m.Get("data"), m.Get("data").Each{4}(func(i int, val {1}) bool { + count++ + replacedVals = append(replacedVals, val) + + // abort early return i != 2 - })) + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.Must{4}Slice()[0]) - assert.Equal(t, replacedVals[1], v.Must{4}Slice()[1]) - assert.Equal(t, replacedVals[2], v.Must{4}Slice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").Must{4}Slice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").Must{4}Slice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").Must{4}Slice()[2]) } func TestWhere{4}(t *testing.T) { - v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }} + m := objx.Map{"data": []{1}{{1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2})}} - selected := v.Where{4}(func(i int, val {1}) bool { - return i%2==0 - }).Must{4}Slice() + selected := m.Get("data").Where{4}(func(i int, val {1}) bool { + return i%2 == 0 + }).Must{4}Slice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroup{4}(t *testing.T) { - v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }} + m := objx.Map{"data": []{1}{{1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2})}} - grouped := v.Group{4}(func(i int, val {1}) string { - return fmt.Sprintf("%v", i%2==0) - }).data.(map[string][]{1}) + grouped := m.Get("data").Group{4}(func(i int, val {1}) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]{1}) - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplace{4}(t *testing.T) { - v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }} - - rawArr := v.Must{4}Slice() - - replaced := v.Replace{4}(func(index int, val {1}) {1} { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.Must{4}Slice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []{1}{{1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2})}} + rawArr := m.Get("data").Must{4}Slice() + + replaced := m.Get("data").Replace{4}(func(index int, val {1}) {1} { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.Must{4}Slice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollect{4}(t *testing.T) { - v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }} - - collected := v.Collect{4}(func(index int, val {1}) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []{1}{{1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2})}} + + collected := m.Get("data").Collect{4}(func(index int, val {1}) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } diff --git a/vendor/github.com/stretchr/objx/codegen/types_list.txt b/vendor/github.com/stretchr/objx/codegen/types_list.txt index 069d43d8e..932139d57 100644 --- a/vendor/github.com/stretchr/objx/codegen/types_list.txt +++ b/vendor/github.com/stretchr/objx/codegen/types_list.txt @@ -1,6 +1,6 @@ Interface,interface{},"something",nil,Inter Map,map[string]interface{},map[string]interface{}{"name":"Tyler"},nil,MSI -ObjxMap,(Map),New(1),New(nil),ObjxMap +ObjxMap,(objx.Map),objx.New(1),objx.New(nil),ObjxMap Bool,bool,true,false,Bool String,string,"hello","",Str Int,int,1,0,Int diff --git a/vendor/github.com/stretchr/objx/constants.go b/vendor/github.com/stretchr/objx/constants.go deleted file mode 100644 index f9eb42a25..000000000 --- a/vendor/github.com/stretchr/objx/constants.go +++ /dev/null @@ -1,13 +0,0 @@ -package objx - -const ( - // PathSeparator is the character used to separate the elements - // of the keypath. - // - // For example, `location.address.city` - PathSeparator string = "." - - // SignatureSeparator is the character that is used to - // separate the Base64 string from the security signature. - SignatureSeparator = "_" -) diff --git a/vendor/github.com/stretchr/objx/conversions.go b/vendor/github.com/stretchr/objx/conversions.go index 5e020f310..ca1c2dec6 100644 --- a/vendor/github.com/stretchr/objx/conversions.go +++ b/vendor/github.com/stretchr/objx/conversions.go @@ -9,6 +9,10 @@ import ( "net/url" ) +// SignatureSeparator is the character that is used to +// separate the Base64 string from the security signature. +const SignatureSeparator = "_" + // JSON converts the contained object to a JSON string // representation func (m Map) JSON() (string, error) { @@ -40,10 +44,7 @@ func (m Map) Base64() (string, error) { } encoder := base64.NewEncoder(base64.StdEncoding, &buf) - _, err = encoder.Write([]byte(jsonData)) - if err != nil { - return "", err - } + _, _ = encoder.Write([]byte(jsonData)) _ = encoder.Close() return buf.String(), nil diff --git a/vendor/github.com/stretchr/objx/map.go b/vendor/github.com/stretchr/objx/map.go index 406bc8926..95149c06a 100644 --- a/vendor/github.com/stretchr/objx/map.go +++ b/vendor/github.com/stretchr/objx/map.go @@ -97,12 +97,50 @@ func MustFromJSON(jsonString string) Map { // // Returns an error if the JSON is invalid. func FromJSON(jsonString string) (Map, error) { - var data interface{} - err := json.Unmarshal([]byte(jsonString), &data) + var m Map + err := json.Unmarshal([]byte(jsonString), &m) if err != nil { return Nil, err } - return New(data), nil + m.tryConvertFloat64() + return m, nil +} + +func (m Map) tryConvertFloat64() { + for k, v := range m { + switch v.(type) { + case float64: + f := v.(float64) + if float64(int(f)) == f { + m[k] = int(f) + } + case map[string]interface{}: + t := New(v) + t.tryConvertFloat64() + m[k] = t + case []interface{}: + m[k] = tryConvertFloat64InSlice(v.([]interface{})) + } + } +} + +func tryConvertFloat64InSlice(s []interface{}) []interface{} { + for k, v := range s { + switch v.(type) { + case float64: + f := v.(float64) + if float64(int(f)) == f { + s[k] = int(f) + } + case map[string]interface{}: + t := New(v) + t.tryConvertFloat64() + s[k] = t + case []interface{}: + s[k] = tryConvertFloat64InSlice(v.([]interface{})) + } + } + return s } // FromBase64 creates a new Obj containing the data specified diff --git a/vendor/github.com/stretchr/objx/map_test.go b/vendor/github.com/stretchr/objx/map_test.go index aa8e536b8..5cda629dd 100644 --- a/vendor/github.com/stretchr/objx/map_test.go +++ b/vendor/github.com/stretchr/objx/map_test.go @@ -92,6 +92,61 @@ func TestMapFromJSONWithError(t *testing.T) { assert.Nil(t, m) } +func TestConversionJSONInt(t *testing.T) { + jsonString := + `{ + "a": 1, + "b": { + "data": 1 + }, + "c": [1], + "d": [[1]] + }` + m, err := objx.FromJSON(jsonString) + + assert.Nil(t, err) + require.NotNil(t, m) + assert.Equal(t, 1, m.Get("a").Int()) + assert.Equal(t, 1, m.Get("b.data").Int()) + + assert.True(t, m.Get("c").IsInterSlice()) + assert.Equal(t, 1, m.Get("c").InterSlice()[0]) + + assert.True(t, m.Get("d").IsInterSlice()) + assert.Equal(t, []interface{}{1}, m.Get("d").InterSlice()[0]) +} + +func TestJSONSliceInt(t *testing.T) { + jsonString := + `{ + "a": [ + {"b": 1}, + {"c": 2} + ] + }` + m, err := objx.FromJSON(jsonString) + + assert.Nil(t, err) + require.NotNil(t, m) + assert.Equal(t, []objx.Map{objx.Map{"b": 1}, objx.Map{"c": 2}}, m.Get("a").ObjxMapSlice()) +} + +func TestJSONSliceMixed(t *testing.T) { + jsonString := + `{ + "a": [ + {"b": 1}, + "a" + ] + }` + m, err := objx.FromJSON(jsonString) + + assert.Nil(t, err) + require.NotNil(t, m) + + assert.Nil(t, m.Get("a").ObjxMapSlice()) +} + func TestMapFromBase64String(t *testing.T) { base64String := "eyJuYW1lIjoiTWF0In0=" o, err := objx.FromBase64(base64String) diff --git a/vendor/github.com/stretchr/objx/type_specific_codegen.go b/vendor/github.com/stretchr/objx/type_specific_codegen.go index 202a91f8c..de4240955 100644 --- a/vendor/github.com/stretchr/objx/type_specific_codegen.go +++ b/vendor/github.com/stretchr/objx/type_specific_codegen.go @@ -276,13 +276,28 @@ func (v *Value) MustObjxMap() Map { // ObjxMapSlice gets the value as a [](Map), returns the optionalDefault // value or nil if the value is not a [](Map). func (v *Value) ObjxMapSlice(optionalDefault ...[](Map)) [](Map) { - if s, ok := v.data.([](Map)); ok { + if s, ok := v.data.([]Map); ok { return s } - if len(optionalDefault) == 1 { - return optionalDefault[0] + s, ok := v.data.([]interface{}) + if !ok { + if len(optionalDefault) == 1 { + return optionalDefault[0] + } else { + return nil + } } - return nil + + result := make([]Map, len(s)) + for i := range s { + switch s[i].(type) { + case Map: + result[i] = s[i].(Map) + default: + return nil + } + } + return result } // MustObjxMapSlice gets the value as a [](Map). diff --git a/vendor/github.com/stretchr/objx/type_specific_codegen_test.go b/vendor/github.com/stretchr/objx/type_specific_codegen_test.go index c79c7e034..4b7514602 100644 --- a/vendor/github.com/stretchr/objx/type_specific_codegen_test.go +++ b/vendor/github.com/stretchr/objx/type_specific_codegen_test.go @@ -1,2448 +1,2350 @@ -package objx +package objx_test import ( "fmt" "testing" + "github.com/stretchr/objx" "github.com/stretchr/testify/assert" ) /* Tests for Inter (interface{} and []interface{}) */ - func TestInter(t *testing.T) { - val := interface{}("something") + val := interface{}("something") + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Inter()) - assert.Equal(t, val, New(m).Get("value").MustInter()) - assert.Equal(t, interface{}(nil), New(m).Get("nothing").Inter()) - assert.Equal(t, val, New(m).Get("nothing").Inter("something")) - assert.Panics(t, func() { - New(m).Get("age").MustInter() - }) + assert.Equal(t, val, m.Get("value").Inter()) + assert.Equal(t, val, m.Get("value").MustInter()) + assert.Equal(t, interface{}(nil), m.Get("nothing").Inter()) + assert.Equal(t, val, m.Get("nothing").Inter("something")) + assert.Panics(t, func() { + m.Get("age").MustInter() + }) } func TestInterSlice(t *testing.T) { - val := interface{}("something") + val := interface{}("something") + m := objx.Map{"value": []interface{}{ val }, "nothing": nil} - m := map[string]interface{}{"value": []interface{}{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").InterSlice()[0]) - assert.Equal(t, val, New(m).Get("value").MustInterSlice()[0]) - assert.Equal(t, []interface{}(nil), New(m).Get("nothing").InterSlice()) - assert.Equal(t, val, New(m).Get("nothing").InterSlice([]interface{}{interface{}("something")})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustInterSlice() - }) + assert.Equal(t, val, m.Get("value").InterSlice()[0]) + assert.Equal(t, val, m.Get("value").MustInterSlice()[0]) + assert.Equal(t, []interface{}(nil), m.Get("nothing").InterSlice()) + assert.Equal(t, val, m.Get("nothing").InterSlice([]interface{}{interface{}("something")})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustInterSlice() + }) } func TestIsInter(t *testing.T) { - v := &Value{data: interface{}("something")} - assert.True(t, v.IsInter()) + m := objx.Map{"data": interface{}("something")} + assert.True(t, m.Get("data").IsInter()) } func TestIsInterSlice(t *testing.T) { - v := &Value{data: []interface{}{interface{}("something")}} - assert.True(t, v.IsInterSlice()) + m := objx.Map{"data": []interface{}{interface{}("something")}} + + assert.True(t, m.Get("data").IsInterSlice()) } func TestEachInter(t *testing.T) { - v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} - count := 0 - replacedVals := make([]interface{}, 0) - assert.Equal(t, v, v.EachInter(func(i int, val interface{}) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} + count := 0 + replacedVals := make([]interface{}, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachInter(func(i int, val interface{}) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustInterSlice()[0]) - assert.Equal(t, replacedVals[1], v.MustInterSlice()[1]) - assert.Equal(t, replacedVals[2], v.MustInterSlice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustInterSlice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustInterSlice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustInterSlice()[2]) } func TestWhereInter(t *testing.T) { - v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} - - selected := v.WhereInter(func(i int, val interface{}) bool { - return i%2 == 0 - }).MustInterSlice() + m := objx.Map{"data": []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} + selected := m.Get("data").WhereInter(func(i int, val interface{}) bool { + return i%2 == 0 + }).MustInterSlice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupInter(t *testing.T) { - v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} + m := objx.Map{"data": []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} + grouped := m.Get("data").GroupInter(func(i int, val interface{}) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]interface{}) - grouped := v.GroupInter(func(i int, val interface{}) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]interface{}) - - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceInter(t *testing.T) { - v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} - - rawArr := v.MustInterSlice() - - replaced := v.ReplaceInter(func(index int, val interface{}) interface{} { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustInterSlice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} + rawArr := m.Get("data").MustInterSlice() + replaced := m.Get("data").ReplaceInter(func(index int, val interface{}) interface{} { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustInterSlice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectInter(t *testing.T) { - v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} - - collected := v.CollectInter(func(index int, val interface{}) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}} + collected := m.Get("data").CollectInter(func(index int, val interface{}) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for MSI (map[string]interface{} and []map[string]interface{}) */ - func TestMSI(t *testing.T) { - val := map[string]interface{}(map[string]interface{}{"name": "Tyler"}) + val := map[string]interface{}(map[string]interface{}{"name":"Tyler"}) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").MSI()) - assert.Equal(t, val, New(m).Get("value").MustMSI()) - assert.Equal(t, map[string]interface{}(nil), New(m).Get("nothing").MSI()) - assert.Equal(t, val, New(m).Get("nothing").MSI(map[string]interface{}{"name": "Tyler"})) - assert.Panics(t, func() { - New(m).Get("age").MustMSI() - }) + assert.Equal(t, val, m.Get("value").MSI()) + assert.Equal(t, val, m.Get("value").MustMSI()) + assert.Equal(t, map[string]interface{}(nil), m.Get("nothing").MSI()) + assert.Equal(t, val, m.Get("nothing").MSI(map[string]interface{}{"name":"Tyler"})) + assert.Panics(t, func() { + m.Get("age").MustMSI() + }) } func TestMSISlice(t *testing.T) { - val := map[string]interface{}(map[string]interface{}{"name": "Tyler"}) + val := map[string]interface{}(map[string]interface{}{"name":"Tyler"}) + m := objx.Map{"value": []map[string]interface{}{ val }, "nothing": nil} - m := map[string]interface{}{"value": []map[string]interface{}{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").MSISlice()[0]) - assert.Equal(t, val, New(m).Get("value").MustMSISlice()[0]) - assert.Equal(t, []map[string]interface{}(nil), New(m).Get("nothing").MSISlice()) - assert.Equal(t, val, New(m).Get("nothing").MSISlice([]map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"})})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustMSISlice() - }) + assert.Equal(t, val, m.Get("value").MSISlice()[0]) + assert.Equal(t, val, m.Get("value").MustMSISlice()[0]) + assert.Equal(t, []map[string]interface{}(nil), m.Get("nothing").MSISlice()) + assert.Equal(t, val, m.Get("nothing").MSISlice([]map[string]interface{}{map[string]interface{}(map[string]interface{}{"name":"Tyler"})})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustMSISlice() + }) } func TestIsMSI(t *testing.T) { - v := &Value{data: map[string]interface{}(map[string]interface{}{"name": "Tyler"})} - assert.True(t, v.IsMSI()) + m := objx.Map{"data": map[string]interface{}(map[string]interface{}{"name":"Tyler"})} + assert.True(t, m.Get("data").IsMSI()) } func TestIsMSISlice(t *testing.T) { - v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} - assert.True(t, v.IsMSISlice()) + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name":"Tyler"})}} + + assert.True(t, m.Get("data").IsMSISlice()) } func TestEachMSI(t *testing.T) { - v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} - count := 0 - replacedVals := make([]map[string]interface{}, 0) - assert.Equal(t, v, v.EachMSI(func(i int, val map[string]interface{}) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"})}} + count := 0 + replacedVals := make([]map[string]interface{}, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachMSI(func(i int, val map[string]interface{}) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustMSISlice()[0]) - assert.Equal(t, replacedVals[1], v.MustMSISlice()[1]) - assert.Equal(t, replacedVals[2], v.MustMSISlice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustMSISlice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustMSISlice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustMSISlice()[2]) } func TestWhereMSI(t *testing.T) { - v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} - - selected := v.WhereMSI(func(i int, val map[string]interface{}) bool { - return i%2 == 0 - }).MustMSISlice() + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"})}} + selected := m.Get("data").WhereMSI(func(i int, val map[string]interface{}) bool { + return i%2 == 0 + }).MustMSISlice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupMSI(t *testing.T) { - v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"})}} + grouped := m.Get("data").GroupMSI(func(i int, val map[string]interface{}) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]map[string]interface{}) - grouped := v.GroupMSI(func(i int, val map[string]interface{}) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]map[string]interface{}) - - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceMSI(t *testing.T) { - v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} - - rawArr := v.MustMSISlice() - - replaced := v.ReplaceMSI(func(index int, val map[string]interface{}) map[string]interface{} { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustMSISlice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"})}} + rawArr := m.Get("data").MustMSISlice() + replaced := m.Get("data").ReplaceMSI(func(index int, val map[string]interface{}) map[string]interface{} { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustMSISlice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectMSI(t *testing.T) { - v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} - - collected := v.CollectMSI(func(index int, val map[string]interface{}) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"}), map[string]interface{}(map[string]interface{}{"name":"Tyler"})}} + collected := m.Get("data").CollectMSI(func(index int, val map[string]interface{}) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* - Tests for ObjxMap ((Map) and [](Map)) + Tests for ObjxMap ((objx.Map) and [](objx.Map)) */ - func TestObjxMap(t *testing.T) { - val := (Map)(New(1)) + val := (objx.Map)(objx.New(1)) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").ObjxMap()) - assert.Equal(t, val, New(m).Get("value").MustObjxMap()) - assert.Equal(t, (Map)(New(nil)), New(m).Get("nothing").ObjxMap()) - assert.Equal(t, val, New(m).Get("nothing").ObjxMap(New(1))) - assert.Panics(t, func() { - New(m).Get("age").MustObjxMap() - }) + assert.Equal(t, val, m.Get("value").ObjxMap()) + assert.Equal(t, val, m.Get("value").MustObjxMap()) + assert.Equal(t, (objx.Map)(objx.New(nil)), m.Get("nothing").ObjxMap()) + assert.Equal(t, val, m.Get("nothing").ObjxMap(objx.New(1))) + assert.Panics(t, func() { + m.Get("age").MustObjxMap() + }) } func TestObjxMapSlice(t *testing.T) { - val := (Map)(New(1)) + val := (objx.Map)(objx.New(1)) + m := objx.Map{"value": [](objx.Map){ val }, "nothing": nil} - m := map[string]interface{}{"value": [](Map){val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").ObjxMapSlice()[0]) - assert.Equal(t, val, New(m).Get("value").MustObjxMapSlice()[0]) - assert.Equal(t, [](Map)(nil), New(m).Get("nothing").ObjxMapSlice()) - assert.Equal(t, val, New(m).Get("nothing").ObjxMapSlice([](Map){(Map)(New(1))})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustObjxMapSlice() - }) + assert.Equal(t, val, m.Get("value").ObjxMapSlice()[0]) + assert.Equal(t, val, m.Get("value").MustObjxMapSlice()[0]) + assert.Equal(t, [](objx.Map)(nil), m.Get("nothing").ObjxMapSlice()) + assert.Equal(t, val, m.Get("nothing").ObjxMapSlice([](objx.Map){(objx.Map)(objx.New(1))})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustObjxMapSlice() + }) } func TestIsObjxMap(t *testing.T) { - v := &Value{data: (Map)(New(1))} - assert.True(t, v.IsObjxMap()) + m := objx.Map{"data": (objx.Map)(objx.New(1))} + assert.True(t, m.Get("data").IsObjxMap()) } func TestIsObjxMapSlice(t *testing.T) { - v := &Value{data: [](Map){(Map)(New(1))}} - assert.True(t, v.IsObjxMapSlice()) + m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1))}} + + assert.True(t, m.Get("data").IsObjxMapSlice()) } func TestEachObjxMap(t *testing.T) { - v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}} - count := 0 - replacedVals := make([](Map), 0) - assert.Equal(t, v, v.EachObjxMap(func(i int, val Map) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} + count := 0 + replacedVals := make([](objx.Map), 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachObjxMap(func(i int, val (objx.Map)) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustObjxMapSlice()[0]) - assert.Equal(t, replacedVals[1], v.MustObjxMapSlice()[1]) - assert.Equal(t, replacedVals[2], v.MustObjxMapSlice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustObjxMapSlice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustObjxMapSlice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustObjxMapSlice()[2]) } func TestWhereObjxMap(t *testing.T) { - v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}} - - selected := v.WhereObjxMap(func(i int, val Map) bool { - return i%2 == 0 - }).MustObjxMapSlice() + m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} + selected := m.Get("data").WhereObjxMap(func(i int, val (objx.Map)) bool { + return i%2 == 0 + }).MustObjxMapSlice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupObjxMap(t *testing.T) { - v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}} + m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} + grouped := m.Get("data").GroupObjxMap(func(i int, val (objx.Map)) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][](objx.Map)) - grouped := v.GroupObjxMap(func(i int, val Map) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][](Map)) - - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceObjxMap(t *testing.T) { - v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}} - - rawArr := v.MustObjxMapSlice() - - replaced := v.ReplaceObjxMap(func(index int, val Map) Map { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustObjxMapSlice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} + rawArr := m.Get("data").MustObjxMapSlice() + replaced := m.Get("data").ReplaceObjxMap(func(index int, val (objx.Map)) (objx.Map) { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustObjxMapSlice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectObjxMap(t *testing.T) { - v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}} - - collected := v.CollectObjxMap(func(index int, val Map) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} + collected := m.Get("data").CollectObjxMap(func(index int, val (objx.Map)) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Bool (bool and []bool) */ - func TestBool(t *testing.T) { - val := bool(true) + val := bool(true) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Bool()) - assert.Equal(t, val, New(m).Get("value").MustBool()) - assert.Equal(t, bool(false), New(m).Get("nothing").Bool()) - assert.Equal(t, val, New(m).Get("nothing").Bool(true)) - assert.Panics(t, func() { - New(m).Get("age").MustBool() - }) + assert.Equal(t, val, m.Get("value").Bool()) + assert.Equal(t, val, m.Get("value").MustBool()) + assert.Equal(t, bool(false), m.Get("nothing").Bool()) + assert.Equal(t, val, m.Get("nothing").Bool(true)) + assert.Panics(t, func() { + m.Get("age").MustBool() + }) } func TestBoolSlice(t *testing.T) { - val := bool(true) + val := bool(true) + m := objx.Map{"value": []bool{ val }, "nothing": nil} - m := map[string]interface{}{"value": []bool{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").BoolSlice()[0]) - assert.Equal(t, val, New(m).Get("value").MustBoolSlice()[0]) - assert.Equal(t, []bool(nil), New(m).Get("nothing").BoolSlice()) - assert.Equal(t, val, New(m).Get("nothing").BoolSlice([]bool{bool(true)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustBoolSlice() - }) + assert.Equal(t, val, m.Get("value").BoolSlice()[0]) + assert.Equal(t, val, m.Get("value").MustBoolSlice()[0]) + assert.Equal(t, []bool(nil), m.Get("nothing").BoolSlice()) + assert.Equal(t, val, m.Get("nothing").BoolSlice([]bool{bool(true)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustBoolSlice() + }) } func TestIsBool(t *testing.T) { - v := &Value{data: bool(true)} - assert.True(t, v.IsBool()) + m := objx.Map{"data": bool(true)} + assert.True(t, m.Get("data").IsBool()) } func TestIsBoolSlice(t *testing.T) { - v := &Value{data: []bool{bool(true)}} - assert.True(t, v.IsBoolSlice()) + m := objx.Map{"data": []bool{bool(true)}} + + assert.True(t, m.Get("data").IsBoolSlice()) } func TestEachBool(t *testing.T) { - v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true)}} - count := 0 - replacedVals := make([]bool, 0) - assert.Equal(t, v, v.EachBool(func(i int, val bool) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []bool{bool(true), bool(true), bool(true), bool(true), bool(true)}} + count := 0 + replacedVals := make([]bool, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachBool(func(i int, val bool) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustBoolSlice()[0]) - assert.Equal(t, replacedVals[1], v.MustBoolSlice()[1]) - assert.Equal(t, replacedVals[2], v.MustBoolSlice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustBoolSlice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustBoolSlice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustBoolSlice()[2]) } func TestWhereBool(t *testing.T) { - v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}} + m := objx.Map{"data": []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}} + selected := m.Get("data").WhereBool(func(i int, val bool) bool { + return i%2 == 0 + }).MustBoolSlice() - selected := v.WhereBool(func(i int, val bool) bool { - return i%2 == 0 - }).MustBoolSlice() - - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupBool(t *testing.T) { - v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}} - - grouped := v.GroupBool(func(i int, val bool) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]bool) + m := objx.Map{"data": []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}} + grouped := m.Get("data").GroupBool(func(i int, val bool) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]bool) - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceBool(t *testing.T) { - v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}} - - rawArr := v.MustBoolSlice() - - replaced := v.ReplaceBool(func(index int, val bool) bool { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustBoolSlice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}} + rawArr := m.Get("data").MustBoolSlice() + replaced := m.Get("data").ReplaceBool(func(index int, val bool) bool { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustBoolSlice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectBool(t *testing.T) { - v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}} - - collected := v.CollectBool(func(index int, val bool) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}} + collected := m.Get("data").CollectBool(func(index int, val bool) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Str (string and []string) */ - func TestStr(t *testing.T) { - val := string("hello") + val := string("hello") + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Str()) - assert.Equal(t, val, New(m).Get("value").MustStr()) - assert.Equal(t, string(""), New(m).Get("nothing").Str()) - assert.Equal(t, val, New(m).Get("nothing").Str("hello")) - assert.Panics(t, func() { - New(m).Get("age").MustStr() - }) + assert.Equal(t, val, m.Get("value").Str()) + assert.Equal(t, val, m.Get("value").MustStr()) + assert.Equal(t, string(""), m.Get("nothing").Str()) + assert.Equal(t, val, m.Get("nothing").Str("hello")) + assert.Panics(t, func() { + m.Get("age").MustStr() + }) } func TestStrSlice(t *testing.T) { - val := string("hello") + val := string("hello") + m := objx.Map{"value": []string{ val }, "nothing": nil} - m := map[string]interface{}{"value": []string{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").StrSlice()[0]) - assert.Equal(t, val, New(m).Get("value").MustStrSlice()[0]) - assert.Equal(t, []string(nil), New(m).Get("nothing").StrSlice()) - assert.Equal(t, val, New(m).Get("nothing").StrSlice([]string{string("hello")})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustStrSlice() - }) + assert.Equal(t, val, m.Get("value").StrSlice()[0]) + assert.Equal(t, val, m.Get("value").MustStrSlice()[0]) + assert.Equal(t, []string(nil), m.Get("nothing").StrSlice()) + assert.Equal(t, val, m.Get("nothing").StrSlice([]string{string("hello")})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustStrSlice() + }) } func TestIsStr(t *testing.T) { - v := &Value{data: string("hello")} - assert.True(t, v.IsStr()) + m := objx.Map{"data": string("hello")} + assert.True(t, m.Get("data").IsStr()) } func TestIsStrSlice(t *testing.T) { - v := &Value{data: []string{string("hello")}} - assert.True(t, v.IsStrSlice()) + m := objx.Map{"data": []string{string("hello")}} + + assert.True(t, m.Get("data").IsStrSlice()) } func TestEachStr(t *testing.T) { - v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} - count := 0 - replacedVals := make([]string, 0) - assert.Equal(t, v, v.EachStr(func(i int, val string) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} + count := 0 + replacedVals := make([]string, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachStr(func(i int, val string) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustStrSlice()[0]) - assert.Equal(t, replacedVals[1], v.MustStrSlice()[1]) - assert.Equal(t, replacedVals[2], v.MustStrSlice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustStrSlice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustStrSlice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustStrSlice()[2]) } func TestWhereStr(t *testing.T) { - v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} - - selected := v.WhereStr(func(i int, val string) bool { - return i%2 == 0 - }).MustStrSlice() + m := objx.Map{"data": []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} + selected := m.Get("data").WhereStr(func(i int, val string) bool { + return i%2 == 0 + }).MustStrSlice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupStr(t *testing.T) { - v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} - - grouped := v.GroupStr(func(i int, val string) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]string) + m := objx.Map{"data": []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} + grouped := m.Get("data").GroupStr(func(i int, val string) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]string) - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceStr(t *testing.T) { - v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} - - rawArr := v.MustStrSlice() - - replaced := v.ReplaceStr(func(index int, val string) string { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustStrSlice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} + rawArr := m.Get("data").MustStrSlice() + replaced := m.Get("data").ReplaceStr(func(index int, val string) string { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustStrSlice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectStr(t *testing.T) { - v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} - - collected := v.CollectStr(func(index int, val string) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}} + collected := m.Get("data").CollectStr(func(index int, val string) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Int (int and []int) */ - func TestInt(t *testing.T) { - val := int(1) + val := int(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Int()) - assert.Equal(t, val, New(m).Get("value").MustInt()) - assert.Equal(t, int(0), New(m).Get("nothing").Int()) - assert.Equal(t, val, New(m).Get("nothing").Int(1)) - assert.Panics(t, func() { - New(m).Get("age").MustInt() - }) + assert.Equal(t, val, m.Get("value").Int()) + assert.Equal(t, val, m.Get("value").MustInt()) + assert.Equal(t, int(0), m.Get("nothing").Int()) + assert.Equal(t, val, m.Get("nothing").Int(1)) + assert.Panics(t, func() { + m.Get("age").MustInt() + }) } func TestIntSlice(t *testing.T) { - val := int(1) + val := int(1) + m := objx.Map{"value": []int{ val }, "nothing": nil} - m := map[string]interface{}{"value": []int{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").IntSlice()[0]) - assert.Equal(t, val, New(m).Get("value").MustIntSlice()[0]) - assert.Equal(t, []int(nil), New(m).Get("nothing").IntSlice()) - assert.Equal(t, val, New(m).Get("nothing").IntSlice([]int{int(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustIntSlice() - }) + assert.Equal(t, val, m.Get("value").IntSlice()[0]) + assert.Equal(t, val, m.Get("value").MustIntSlice()[0]) + assert.Equal(t, []int(nil), m.Get("nothing").IntSlice()) + assert.Equal(t, val, m.Get("nothing").IntSlice([]int{int(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustIntSlice() + }) } func TestIsInt(t *testing.T) { - v := &Value{data: int(1)} - assert.True(t, v.IsInt()) + m := objx.Map{"data": int(1)} + assert.True(t, m.Get("data").IsInt()) } func TestIsIntSlice(t *testing.T) { - v := &Value{data: []int{int(1)}} - assert.True(t, v.IsIntSlice()) + m := objx.Map{"data": []int{int(1)}} + + assert.True(t, m.Get("data").IsIntSlice()) } func TestEachInt(t *testing.T) { - v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1)}} - count := 0 - replacedVals := make([]int, 0) - assert.Equal(t, v, v.EachInt(func(i int, val int) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []int{int(1), int(1), int(1), int(1), int(1)}} + count := 0 + replacedVals := make([]int, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachInt(func(i int, val int) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustIntSlice()[0]) - assert.Equal(t, replacedVals[1], v.MustIntSlice()[1]) - assert.Equal(t, replacedVals[2], v.MustIntSlice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustIntSlice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustIntSlice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustIntSlice()[2]) } func TestWhereInt(t *testing.T) { - v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1), int(1)}} - - selected := v.WhereInt(func(i int, val int) bool { - return i%2 == 0 - }).MustIntSlice() + m := objx.Map{"data": []int{int(1), int(1), int(1), int(1), int(1), int(1)}} + selected := m.Get("data").WhereInt(func(i int, val int) bool { + return i%2 == 0 + }).MustIntSlice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupInt(t *testing.T) { - v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1), int(1)}} + m := objx.Map{"data": []int{int(1), int(1), int(1), int(1), int(1), int(1)}} + grouped := m.Get("data").GroupInt(func(i int, val int) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]int) - grouped := v.GroupInt(func(i int, val int) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]int) - - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceInt(t *testing.T) { - v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1), int(1)}} - - rawArr := v.MustIntSlice() - - replaced := v.ReplaceInt(func(index int, val int) int { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustIntSlice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []int{int(1), int(1), int(1), int(1), int(1), int(1)}} + rawArr := m.Get("data").MustIntSlice() + replaced := m.Get("data").ReplaceInt(func(index int, val int) int { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustIntSlice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectInt(t *testing.T) { - v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1), int(1)}} - - collected := v.CollectInt(func(index int, val int) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []int{int(1), int(1), int(1), int(1), int(1), int(1)}} + collected := m.Get("data").CollectInt(func(index int, val int) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Int8 (int8 and []int8) */ - func TestInt8(t *testing.T) { - val := int8(1) + val := int8(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Int8()) - assert.Equal(t, val, New(m).Get("value").MustInt8()) - assert.Equal(t, int8(0), New(m).Get("nothing").Int8()) - assert.Equal(t, val, New(m).Get("nothing").Int8(1)) - assert.Panics(t, func() { - New(m).Get("age").MustInt8() - }) + assert.Equal(t, val, m.Get("value").Int8()) + assert.Equal(t, val, m.Get("value").MustInt8()) + assert.Equal(t, int8(0), m.Get("nothing").Int8()) + assert.Equal(t, val, m.Get("nothing").Int8(1)) + assert.Panics(t, func() { + m.Get("age").MustInt8() + }) } func TestInt8Slice(t *testing.T) { - val := int8(1) + val := int8(1) + m := objx.Map{"value": []int8{ val }, "nothing": nil} - m := map[string]interface{}{"value": []int8{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Int8Slice()[0]) - assert.Equal(t, val, New(m).Get("value").MustInt8Slice()[0]) - assert.Equal(t, []int8(nil), New(m).Get("nothing").Int8Slice()) - assert.Equal(t, val, New(m).Get("nothing").Int8Slice([]int8{int8(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustInt8Slice() - }) + assert.Equal(t, val, m.Get("value").Int8Slice()[0]) + assert.Equal(t, val, m.Get("value").MustInt8Slice()[0]) + assert.Equal(t, []int8(nil), m.Get("nothing").Int8Slice()) + assert.Equal(t, val, m.Get("nothing").Int8Slice([]int8{int8(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustInt8Slice() + }) } func TestIsInt8(t *testing.T) { - v := &Value{data: int8(1)} - assert.True(t, v.IsInt8()) + m := objx.Map{"data": int8(1)} + assert.True(t, m.Get("data").IsInt8()) } func TestIsInt8Slice(t *testing.T) { - v := &Value{data: []int8{int8(1)}} - assert.True(t, v.IsInt8Slice()) + m := objx.Map{"data": []int8{int8(1)}} + + assert.True(t, m.Get("data").IsInt8Slice()) } func TestEachInt8(t *testing.T) { - v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1)}} - count := 0 - replacedVals := make([]int8, 0) - assert.Equal(t, v, v.EachInt8(func(i int, val int8) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []int8{int8(1), int8(1), int8(1), int8(1), int8(1)}} + count := 0 + replacedVals := make([]int8, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachInt8(func(i int, val int8) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustInt8Slice()[0]) - assert.Equal(t, replacedVals[1], v.MustInt8Slice()[1]) - assert.Equal(t, replacedVals[2], v.MustInt8Slice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustInt8Slice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustInt8Slice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustInt8Slice()[2]) } func TestWhereInt8(t *testing.T) { - v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}} - - selected := v.WhereInt8(func(i int, val int8) bool { - return i%2 == 0 - }).MustInt8Slice() + m := objx.Map{"data": []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}} + selected := m.Get("data").WhereInt8(func(i int, val int8) bool { + return i%2 == 0 + }).MustInt8Slice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupInt8(t *testing.T) { - v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}} + m := objx.Map{"data": []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}} + grouped := m.Get("data").GroupInt8(func(i int, val int8) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]int8) - grouped := v.GroupInt8(func(i int, val int8) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]int8) - - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceInt8(t *testing.T) { - v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}} - - rawArr := v.MustInt8Slice() - - replaced := v.ReplaceInt8(func(index int, val int8) int8 { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustInt8Slice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}} + rawArr := m.Get("data").MustInt8Slice() + replaced := m.Get("data").ReplaceInt8(func(index int, val int8) int8 { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustInt8Slice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectInt8(t *testing.T) { - v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}} - - collected := v.CollectInt8(func(index int, val int8) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}} + collected := m.Get("data").CollectInt8(func(index int, val int8) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Int16 (int16 and []int16) */ - func TestInt16(t *testing.T) { - val := int16(1) + val := int16(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Int16()) - assert.Equal(t, val, New(m).Get("value").MustInt16()) - assert.Equal(t, int16(0), New(m).Get("nothing").Int16()) - assert.Equal(t, val, New(m).Get("nothing").Int16(1)) - assert.Panics(t, func() { - New(m).Get("age").MustInt16() - }) + assert.Equal(t, val, m.Get("value").Int16()) + assert.Equal(t, val, m.Get("value").MustInt16()) + assert.Equal(t, int16(0), m.Get("nothing").Int16()) + assert.Equal(t, val, m.Get("nothing").Int16(1)) + assert.Panics(t, func() { + m.Get("age").MustInt16() + }) } func TestInt16Slice(t *testing.T) { - val := int16(1) + val := int16(1) + m := objx.Map{"value": []int16{ val }, "nothing": nil} - m := map[string]interface{}{"value": []int16{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Int16Slice()[0]) - assert.Equal(t, val, New(m).Get("value").MustInt16Slice()[0]) - assert.Equal(t, []int16(nil), New(m).Get("nothing").Int16Slice()) - assert.Equal(t, val, New(m).Get("nothing").Int16Slice([]int16{int16(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustInt16Slice() - }) + assert.Equal(t, val, m.Get("value").Int16Slice()[0]) + assert.Equal(t, val, m.Get("value").MustInt16Slice()[0]) + assert.Equal(t, []int16(nil), m.Get("nothing").Int16Slice()) + assert.Equal(t, val, m.Get("nothing").Int16Slice([]int16{int16(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustInt16Slice() + }) } func TestIsInt16(t *testing.T) { - v := &Value{data: int16(1)} - assert.True(t, v.IsInt16()) + m := objx.Map{"data": int16(1)} + assert.True(t, m.Get("data").IsInt16()) } func TestIsInt16Slice(t *testing.T) { - v := &Value{data: []int16{int16(1)}} - assert.True(t, v.IsInt16Slice()) + m := objx.Map{"data": []int16{int16(1)}} + + assert.True(t, m.Get("data").IsInt16Slice()) } func TestEachInt16(t *testing.T) { - v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1)}} - count := 0 - replacedVals := make([]int16, 0) - assert.Equal(t, v, v.EachInt16(func(i int, val int16) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []int16{int16(1), int16(1), int16(1), int16(1), int16(1)}} + count := 0 + replacedVals := make([]int16, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachInt16(func(i int, val int16) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustInt16Slice()[0]) - assert.Equal(t, replacedVals[1], v.MustInt16Slice()[1]) - assert.Equal(t, replacedVals[2], v.MustInt16Slice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustInt16Slice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustInt16Slice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustInt16Slice()[2]) } func TestWhereInt16(t *testing.T) { - v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}} - - selected := v.WhereInt16(func(i int, val int16) bool { - return i%2 == 0 - }).MustInt16Slice() + m := objx.Map{"data": []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}} + selected := m.Get("data").WhereInt16(func(i int, val int16) bool { + return i%2 == 0 + }).MustInt16Slice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupInt16(t *testing.T) { - v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}} + m := objx.Map{"data": []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}} + grouped := m.Get("data").GroupInt16(func(i int, val int16) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]int16) - grouped := v.GroupInt16(func(i int, val int16) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]int16) - - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceInt16(t *testing.T) { - v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}} - - rawArr := v.MustInt16Slice() - - replaced := v.ReplaceInt16(func(index int, val int16) int16 { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustInt16Slice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}} + rawArr := m.Get("data").MustInt16Slice() + replaced := m.Get("data").ReplaceInt16(func(index int, val int16) int16 { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustInt16Slice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectInt16(t *testing.T) { - v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}} - - collected := v.CollectInt16(func(index int, val int16) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}} + collected := m.Get("data").CollectInt16(func(index int, val int16) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Int32 (int32 and []int32) */ - func TestInt32(t *testing.T) { - val := int32(1) + val := int32(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Int32()) - assert.Equal(t, val, New(m).Get("value").MustInt32()) - assert.Equal(t, int32(0), New(m).Get("nothing").Int32()) - assert.Equal(t, val, New(m).Get("nothing").Int32(1)) - assert.Panics(t, func() { - New(m).Get("age").MustInt32() - }) + assert.Equal(t, val, m.Get("value").Int32()) + assert.Equal(t, val, m.Get("value").MustInt32()) + assert.Equal(t, int32(0), m.Get("nothing").Int32()) + assert.Equal(t, val, m.Get("nothing").Int32(1)) + assert.Panics(t, func() { + m.Get("age").MustInt32() + }) } func TestInt32Slice(t *testing.T) { - val := int32(1) + val := int32(1) + m := objx.Map{"value": []int32{ val }, "nothing": nil} - m := map[string]interface{}{"value": []int32{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Int32Slice()[0]) - assert.Equal(t, val, New(m).Get("value").MustInt32Slice()[0]) - assert.Equal(t, []int32(nil), New(m).Get("nothing").Int32Slice()) - assert.Equal(t, val, New(m).Get("nothing").Int32Slice([]int32{int32(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustInt32Slice() - }) + assert.Equal(t, val, m.Get("value").Int32Slice()[0]) + assert.Equal(t, val, m.Get("value").MustInt32Slice()[0]) + assert.Equal(t, []int32(nil), m.Get("nothing").Int32Slice()) + assert.Equal(t, val, m.Get("nothing").Int32Slice([]int32{int32(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustInt32Slice() + }) } func TestIsInt32(t *testing.T) { - v := &Value{data: int32(1)} - assert.True(t, v.IsInt32()) + m := objx.Map{"data": int32(1)} + assert.True(t, m.Get("data").IsInt32()) } func TestIsInt32Slice(t *testing.T) { - v := &Value{data: []int32{int32(1)}} - assert.True(t, v.IsInt32Slice()) + m := objx.Map{"data": []int32{int32(1)}} + + assert.True(t, m.Get("data").IsInt32Slice()) } func TestEachInt32(t *testing.T) { - v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1)}} - count := 0 - replacedVals := make([]int32, 0) - assert.Equal(t, v, v.EachInt32(func(i int, val int32) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []int32{int32(1), int32(1), int32(1), int32(1), int32(1)}} + count := 0 + replacedVals := make([]int32, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachInt32(func(i int, val int32) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustInt32Slice()[0]) - assert.Equal(t, replacedVals[1], v.MustInt32Slice()[1]) - assert.Equal(t, replacedVals[2], v.MustInt32Slice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustInt32Slice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustInt32Slice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustInt32Slice()[2]) } func TestWhereInt32(t *testing.T) { - v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}} + m := objx.Map{"data": []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}} + selected := m.Get("data").WhereInt32(func(i int, val int32) bool { + return i%2 == 0 + }).MustInt32Slice() - selected := v.WhereInt32(func(i int, val int32) bool { - return i%2 == 0 - }).MustInt32Slice() - - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupInt32(t *testing.T) { - v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}} - - grouped := v.GroupInt32(func(i int, val int32) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]int32) + m := objx.Map{"data": []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}} + grouped := m.Get("data").GroupInt32(func(i int, val int32) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]int32) - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceInt32(t *testing.T) { - v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}} - - rawArr := v.MustInt32Slice() - - replaced := v.ReplaceInt32(func(index int, val int32) int32 { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustInt32Slice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}} + rawArr := m.Get("data").MustInt32Slice() + replaced := m.Get("data").ReplaceInt32(func(index int, val int32) int32 { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustInt32Slice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectInt32(t *testing.T) { - v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}} - - collected := v.CollectInt32(func(index int, val int32) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}} + collected := m.Get("data").CollectInt32(func(index int, val int32) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Int64 (int64 and []int64) */ - func TestInt64(t *testing.T) { - val := int64(1) + val := int64(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Int64()) - assert.Equal(t, val, New(m).Get("value").MustInt64()) - assert.Equal(t, int64(0), New(m).Get("nothing").Int64()) - assert.Equal(t, val, New(m).Get("nothing").Int64(1)) - assert.Panics(t, func() { - New(m).Get("age").MustInt64() - }) + assert.Equal(t, val, m.Get("value").Int64()) + assert.Equal(t, val, m.Get("value").MustInt64()) + assert.Equal(t, int64(0), m.Get("nothing").Int64()) + assert.Equal(t, val, m.Get("nothing").Int64(1)) + assert.Panics(t, func() { + m.Get("age").MustInt64() + }) } func TestInt64Slice(t *testing.T) { - val := int64(1) + val := int64(1) + m := objx.Map{"value": []int64{ val }, "nothing": nil} - m := map[string]interface{}{"value": []int64{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Int64Slice()[0]) - assert.Equal(t, val, New(m).Get("value").MustInt64Slice()[0]) - assert.Equal(t, []int64(nil), New(m).Get("nothing").Int64Slice()) - assert.Equal(t, val, New(m).Get("nothing").Int64Slice([]int64{int64(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustInt64Slice() - }) + assert.Equal(t, val, m.Get("value").Int64Slice()[0]) + assert.Equal(t, val, m.Get("value").MustInt64Slice()[0]) + assert.Equal(t, []int64(nil), m.Get("nothing").Int64Slice()) + assert.Equal(t, val, m.Get("nothing").Int64Slice([]int64{int64(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustInt64Slice() + }) } func TestIsInt64(t *testing.T) { - v := &Value{data: int64(1)} - assert.True(t, v.IsInt64()) + m := objx.Map{"data": int64(1)} + assert.True(t, m.Get("data").IsInt64()) } func TestIsInt64Slice(t *testing.T) { - v := &Value{data: []int64{int64(1)}} - assert.True(t, v.IsInt64Slice()) + m := objx.Map{"data": []int64{int64(1)}} + + assert.True(t, m.Get("data").IsInt64Slice()) } func TestEachInt64(t *testing.T) { - v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1)}} - count := 0 - replacedVals := make([]int64, 0) - assert.Equal(t, v, v.EachInt64(func(i int, val int64) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []int64{int64(1), int64(1), int64(1), int64(1), int64(1)}} + count := 0 + replacedVals := make([]int64, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachInt64(func(i int, val int64) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustInt64Slice()[0]) - assert.Equal(t, replacedVals[1], v.MustInt64Slice()[1]) - assert.Equal(t, replacedVals[2], v.MustInt64Slice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustInt64Slice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustInt64Slice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustInt64Slice()[2]) } func TestWhereInt64(t *testing.T) { - v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}} - - selected := v.WhereInt64(func(i int, val int64) bool { - return i%2 == 0 - }).MustInt64Slice() + m := objx.Map{"data": []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}} + selected := m.Get("data").WhereInt64(func(i int, val int64) bool { + return i%2 == 0 + }).MustInt64Slice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupInt64(t *testing.T) { - v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}} - - grouped := v.GroupInt64(func(i int, val int64) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]int64) + m := objx.Map{"data": []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}} + grouped := m.Get("data").GroupInt64(func(i int, val int64) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]int64) - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceInt64(t *testing.T) { - v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}} - - rawArr := v.MustInt64Slice() - - replaced := v.ReplaceInt64(func(index int, val int64) int64 { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustInt64Slice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}} + rawArr := m.Get("data").MustInt64Slice() + replaced := m.Get("data").ReplaceInt64(func(index int, val int64) int64 { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustInt64Slice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectInt64(t *testing.T) { - v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}} - - collected := v.CollectInt64(func(index int, val int64) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}} + collected := m.Get("data").CollectInt64(func(index int, val int64) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Uint (uint and []uint) */ - func TestUint(t *testing.T) { - val := uint(1) + val := uint(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Uint()) - assert.Equal(t, val, New(m).Get("value").MustUint()) - assert.Equal(t, uint(0), New(m).Get("nothing").Uint()) - assert.Equal(t, val, New(m).Get("nothing").Uint(1)) - assert.Panics(t, func() { - New(m).Get("age").MustUint() - }) + assert.Equal(t, val, m.Get("value").Uint()) + assert.Equal(t, val, m.Get("value").MustUint()) + assert.Equal(t, uint(0), m.Get("nothing").Uint()) + assert.Equal(t, val, m.Get("nothing").Uint(1)) + assert.Panics(t, func() { + m.Get("age").MustUint() + }) } func TestUintSlice(t *testing.T) { - val := uint(1) + val := uint(1) + m := objx.Map{"value": []uint{ val }, "nothing": nil} - m := map[string]interface{}{"value": []uint{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").UintSlice()[0]) - assert.Equal(t, val, New(m).Get("value").MustUintSlice()[0]) - assert.Equal(t, []uint(nil), New(m).Get("nothing").UintSlice()) - assert.Equal(t, val, New(m).Get("nothing").UintSlice([]uint{uint(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustUintSlice() - }) + assert.Equal(t, val, m.Get("value").UintSlice()[0]) + assert.Equal(t, val, m.Get("value").MustUintSlice()[0]) + assert.Equal(t, []uint(nil), m.Get("nothing").UintSlice()) + assert.Equal(t, val, m.Get("nothing").UintSlice([]uint{uint(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustUintSlice() + }) } func TestIsUint(t *testing.T) { - v := &Value{data: uint(1)} - assert.True(t, v.IsUint()) + m := objx.Map{"data": uint(1)} + assert.True(t, m.Get("data").IsUint()) } func TestIsUintSlice(t *testing.T) { - v := &Value{data: []uint{uint(1)}} - assert.True(t, v.IsUintSlice()) + m := objx.Map{"data": []uint{uint(1)}} + + assert.True(t, m.Get("data").IsUintSlice()) } func TestEachUint(t *testing.T) { - v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1)}} - count := 0 - replacedVals := make([]uint, 0) - assert.Equal(t, v, v.EachUint(func(i int, val uint) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []uint{uint(1), uint(1), uint(1), uint(1), uint(1)}} + count := 0 + replacedVals := make([]uint, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachUint(func(i int, val uint) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustUintSlice()[0]) - assert.Equal(t, replacedVals[1], v.MustUintSlice()[1]) - assert.Equal(t, replacedVals[2], v.MustUintSlice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustUintSlice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustUintSlice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustUintSlice()[2]) } func TestWhereUint(t *testing.T) { - v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}} - - selected := v.WhereUint(func(i int, val uint) bool { - return i%2 == 0 - }).MustUintSlice() + m := objx.Map{"data": []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}} + selected := m.Get("data").WhereUint(func(i int, val uint) bool { + return i%2 == 0 + }).MustUintSlice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupUint(t *testing.T) { - v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}} + m := objx.Map{"data": []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}} + grouped := m.Get("data").GroupUint(func(i int, val uint) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]uint) - grouped := v.GroupUint(func(i int, val uint) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]uint) - - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceUint(t *testing.T) { - v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}} - - rawArr := v.MustUintSlice() - - replaced := v.ReplaceUint(func(index int, val uint) uint { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustUintSlice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}} + rawArr := m.Get("data").MustUintSlice() + replaced := m.Get("data").ReplaceUint(func(index int, val uint) uint { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustUintSlice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectUint(t *testing.T) { - v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}} - - collected := v.CollectUint(func(index int, val uint) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}} + collected := m.Get("data").CollectUint(func(index int, val uint) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Uint8 (uint8 and []uint8) */ - func TestUint8(t *testing.T) { - val := uint8(1) + val := uint8(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Uint8()) - assert.Equal(t, val, New(m).Get("value").MustUint8()) - assert.Equal(t, uint8(0), New(m).Get("nothing").Uint8()) - assert.Equal(t, val, New(m).Get("nothing").Uint8(1)) - assert.Panics(t, func() { - New(m).Get("age").MustUint8() - }) + assert.Equal(t, val, m.Get("value").Uint8()) + assert.Equal(t, val, m.Get("value").MustUint8()) + assert.Equal(t, uint8(0), m.Get("nothing").Uint8()) + assert.Equal(t, val, m.Get("nothing").Uint8(1)) + assert.Panics(t, func() { + m.Get("age").MustUint8() + }) } func TestUint8Slice(t *testing.T) { - val := uint8(1) + val := uint8(1) + m := objx.Map{"value": []uint8{ val }, "nothing": nil} - m := map[string]interface{}{"value": []uint8{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Uint8Slice()[0]) - assert.Equal(t, val, New(m).Get("value").MustUint8Slice()[0]) - assert.Equal(t, []uint8(nil), New(m).Get("nothing").Uint8Slice()) - assert.Equal(t, val, New(m).Get("nothing").Uint8Slice([]uint8{uint8(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustUint8Slice() - }) + assert.Equal(t, val, m.Get("value").Uint8Slice()[0]) + assert.Equal(t, val, m.Get("value").MustUint8Slice()[0]) + assert.Equal(t, []uint8(nil), m.Get("nothing").Uint8Slice()) + assert.Equal(t, val, m.Get("nothing").Uint8Slice([]uint8{uint8(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustUint8Slice() + }) } func TestIsUint8(t *testing.T) { - v := &Value{data: uint8(1)} - assert.True(t, v.IsUint8()) + m := objx.Map{"data": uint8(1)} + assert.True(t, m.Get("data").IsUint8()) } func TestIsUint8Slice(t *testing.T) { - v := &Value{data: []uint8{uint8(1)}} - assert.True(t, v.IsUint8Slice()) + m := objx.Map{"data": []uint8{uint8(1)}} + + assert.True(t, m.Get("data").IsUint8Slice()) } func TestEachUint8(t *testing.T) { - v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} - count := 0 - replacedVals := make([]uint8, 0) - assert.Equal(t, v, v.EachUint8(func(i int, val uint8) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} + count := 0 + replacedVals := make([]uint8, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachUint8(func(i int, val uint8) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustUint8Slice()[0]) - assert.Equal(t, replacedVals[1], v.MustUint8Slice()[1]) - assert.Equal(t, replacedVals[2], v.MustUint8Slice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustUint8Slice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustUint8Slice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustUint8Slice()[2]) } func TestWhereUint8(t *testing.T) { - v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} - - selected := v.WhereUint8(func(i int, val uint8) bool { - return i%2 == 0 - }).MustUint8Slice() + m := objx.Map{"data": []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} + selected := m.Get("data").WhereUint8(func(i int, val uint8) bool { + return i%2 == 0 + }).MustUint8Slice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupUint8(t *testing.T) { - v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} + m := objx.Map{"data": []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} + grouped := m.Get("data").GroupUint8(func(i int, val uint8) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]uint8) - grouped := v.GroupUint8(func(i int, val uint8) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]uint8) - - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceUint8(t *testing.T) { - v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} - - rawArr := v.MustUint8Slice() - - replaced := v.ReplaceUint8(func(index int, val uint8) uint8 { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustUint8Slice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} + rawArr := m.Get("data").MustUint8Slice() + replaced := m.Get("data").ReplaceUint8(func(index int, val uint8) uint8 { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustUint8Slice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectUint8(t *testing.T) { - v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} - - collected := v.CollectUint8(func(index int, val uint8) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}} + collected := m.Get("data").CollectUint8(func(index int, val uint8) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Uint16 (uint16 and []uint16) */ - func TestUint16(t *testing.T) { - val := uint16(1) + val := uint16(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Uint16()) - assert.Equal(t, val, New(m).Get("value").MustUint16()) - assert.Equal(t, uint16(0), New(m).Get("nothing").Uint16()) - assert.Equal(t, val, New(m).Get("nothing").Uint16(1)) - assert.Panics(t, func() { - New(m).Get("age").MustUint16() - }) + assert.Equal(t, val, m.Get("value").Uint16()) + assert.Equal(t, val, m.Get("value").MustUint16()) + assert.Equal(t, uint16(0), m.Get("nothing").Uint16()) + assert.Equal(t, val, m.Get("nothing").Uint16(1)) + assert.Panics(t, func() { + m.Get("age").MustUint16() + }) } func TestUint16Slice(t *testing.T) { - val := uint16(1) + val := uint16(1) + m := objx.Map{"value": []uint16{ val }, "nothing": nil} - m := map[string]interface{}{"value": []uint16{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Uint16Slice()[0]) - assert.Equal(t, val, New(m).Get("value").MustUint16Slice()[0]) - assert.Equal(t, []uint16(nil), New(m).Get("nothing").Uint16Slice()) - assert.Equal(t, val, New(m).Get("nothing").Uint16Slice([]uint16{uint16(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustUint16Slice() - }) + assert.Equal(t, val, m.Get("value").Uint16Slice()[0]) + assert.Equal(t, val, m.Get("value").MustUint16Slice()[0]) + assert.Equal(t, []uint16(nil), m.Get("nothing").Uint16Slice()) + assert.Equal(t, val, m.Get("nothing").Uint16Slice([]uint16{uint16(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustUint16Slice() + }) } func TestIsUint16(t *testing.T) { - v := &Value{data: uint16(1)} - assert.True(t, v.IsUint16()) + m := objx.Map{"data": uint16(1)} + assert.True(t, m.Get("data").IsUint16()) } func TestIsUint16Slice(t *testing.T) { - v := &Value{data: []uint16{uint16(1)}} - assert.True(t, v.IsUint16Slice()) + m := objx.Map{"data": []uint16{uint16(1)}} + + assert.True(t, m.Get("data").IsUint16Slice()) } func TestEachUint16(t *testing.T) { - v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} - count := 0 - replacedVals := make([]uint16, 0) - assert.Equal(t, v, v.EachUint16(func(i int, val uint16) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} + count := 0 + replacedVals := make([]uint16, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachUint16(func(i int, val uint16) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustUint16Slice()[0]) - assert.Equal(t, replacedVals[1], v.MustUint16Slice()[1]) - assert.Equal(t, replacedVals[2], v.MustUint16Slice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustUint16Slice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustUint16Slice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustUint16Slice()[2]) } func TestWhereUint16(t *testing.T) { - v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} - - selected := v.WhereUint16(func(i int, val uint16) bool { - return i%2 == 0 - }).MustUint16Slice() + m := objx.Map{"data": []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} + selected := m.Get("data").WhereUint16(func(i int, val uint16) bool { + return i%2 == 0 + }).MustUint16Slice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupUint16(t *testing.T) { - v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} + m := objx.Map{"data": []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} + grouped := m.Get("data").GroupUint16(func(i int, val uint16) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]uint16) - grouped := v.GroupUint16(func(i int, val uint16) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]uint16) - - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceUint16(t *testing.T) { - v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} - - rawArr := v.MustUint16Slice() - - replaced := v.ReplaceUint16(func(index int, val uint16) uint16 { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustUint16Slice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} + rawArr := m.Get("data").MustUint16Slice() + replaced := m.Get("data").ReplaceUint16(func(index int, val uint16) uint16 { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustUint16Slice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectUint16(t *testing.T) { - v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} - - collected := v.CollectUint16(func(index int, val uint16) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}} + collected := m.Get("data").CollectUint16(func(index int, val uint16) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Uint32 (uint32 and []uint32) */ - func TestUint32(t *testing.T) { - val := uint32(1) + val := uint32(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Uint32()) - assert.Equal(t, val, New(m).Get("value").MustUint32()) - assert.Equal(t, uint32(0), New(m).Get("nothing").Uint32()) - assert.Equal(t, val, New(m).Get("nothing").Uint32(1)) - assert.Panics(t, func() { - New(m).Get("age").MustUint32() - }) + assert.Equal(t, val, m.Get("value").Uint32()) + assert.Equal(t, val, m.Get("value").MustUint32()) + assert.Equal(t, uint32(0), m.Get("nothing").Uint32()) + assert.Equal(t, val, m.Get("nothing").Uint32(1)) + assert.Panics(t, func() { + m.Get("age").MustUint32() + }) } func TestUint32Slice(t *testing.T) { - val := uint32(1) + val := uint32(1) + m := objx.Map{"value": []uint32{ val }, "nothing": nil} - m := map[string]interface{}{"value": []uint32{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Uint32Slice()[0]) - assert.Equal(t, val, New(m).Get("value").MustUint32Slice()[0]) - assert.Equal(t, []uint32(nil), New(m).Get("nothing").Uint32Slice()) - assert.Equal(t, val, New(m).Get("nothing").Uint32Slice([]uint32{uint32(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustUint32Slice() - }) + assert.Equal(t, val, m.Get("value").Uint32Slice()[0]) + assert.Equal(t, val, m.Get("value").MustUint32Slice()[0]) + assert.Equal(t, []uint32(nil), m.Get("nothing").Uint32Slice()) + assert.Equal(t, val, m.Get("nothing").Uint32Slice([]uint32{uint32(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustUint32Slice() + }) } func TestIsUint32(t *testing.T) { - v := &Value{data: uint32(1)} - assert.True(t, v.IsUint32()) + m := objx.Map{"data": uint32(1)} + assert.True(t, m.Get("data").IsUint32()) } func TestIsUint32Slice(t *testing.T) { - v := &Value{data: []uint32{uint32(1)}} - assert.True(t, v.IsUint32Slice()) + m := objx.Map{"data": []uint32{uint32(1)}} + + assert.True(t, m.Get("data").IsUint32Slice()) } func TestEachUint32(t *testing.T) { - v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} - count := 0 - replacedVals := make([]uint32, 0) - assert.Equal(t, v, v.EachUint32(func(i int, val uint32) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} + count := 0 + replacedVals := make([]uint32, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachUint32(func(i int, val uint32) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustUint32Slice()[0]) - assert.Equal(t, replacedVals[1], v.MustUint32Slice()[1]) - assert.Equal(t, replacedVals[2], v.MustUint32Slice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustUint32Slice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustUint32Slice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustUint32Slice()[2]) } func TestWhereUint32(t *testing.T) { - v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} + m := objx.Map{"data": []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} + selected := m.Get("data").WhereUint32(func(i int, val uint32) bool { + return i%2 == 0 + }).MustUint32Slice() - selected := v.WhereUint32(func(i int, val uint32) bool { - return i%2 == 0 - }).MustUint32Slice() - - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupUint32(t *testing.T) { - v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} - - grouped := v.GroupUint32(func(i int, val uint32) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]uint32) + m := objx.Map{"data": []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} + grouped := m.Get("data").GroupUint32(func(i int, val uint32) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]uint32) - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceUint32(t *testing.T) { - v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} - - rawArr := v.MustUint32Slice() - - replaced := v.ReplaceUint32(func(index int, val uint32) uint32 { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustUint32Slice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} + rawArr := m.Get("data").MustUint32Slice() + replaced := m.Get("data").ReplaceUint32(func(index int, val uint32) uint32 { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustUint32Slice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectUint32(t *testing.T) { - v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} - - collected := v.CollectUint32(func(index int, val uint32) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}} + collected := m.Get("data").CollectUint32(func(index int, val uint32) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Uint64 (uint64 and []uint64) */ - func TestUint64(t *testing.T) { - val := uint64(1) + val := uint64(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Uint64()) - assert.Equal(t, val, New(m).Get("value").MustUint64()) - assert.Equal(t, uint64(0), New(m).Get("nothing").Uint64()) - assert.Equal(t, val, New(m).Get("nothing").Uint64(1)) - assert.Panics(t, func() { - New(m).Get("age").MustUint64() - }) + assert.Equal(t, val, m.Get("value").Uint64()) + assert.Equal(t, val, m.Get("value").MustUint64()) + assert.Equal(t, uint64(0), m.Get("nothing").Uint64()) + assert.Equal(t, val, m.Get("nothing").Uint64(1)) + assert.Panics(t, func() { + m.Get("age").MustUint64() + }) } func TestUint64Slice(t *testing.T) { - val := uint64(1) + val := uint64(1) + m := objx.Map{"value": []uint64{ val }, "nothing": nil} - m := map[string]interface{}{"value": []uint64{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Uint64Slice()[0]) - assert.Equal(t, val, New(m).Get("value").MustUint64Slice()[0]) - assert.Equal(t, []uint64(nil), New(m).Get("nothing").Uint64Slice()) - assert.Equal(t, val, New(m).Get("nothing").Uint64Slice([]uint64{uint64(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustUint64Slice() - }) + assert.Equal(t, val, m.Get("value").Uint64Slice()[0]) + assert.Equal(t, val, m.Get("value").MustUint64Slice()[0]) + assert.Equal(t, []uint64(nil), m.Get("nothing").Uint64Slice()) + assert.Equal(t, val, m.Get("nothing").Uint64Slice([]uint64{uint64(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustUint64Slice() + }) } func TestIsUint64(t *testing.T) { - v := &Value{data: uint64(1)} - assert.True(t, v.IsUint64()) + m := objx.Map{"data": uint64(1)} + assert.True(t, m.Get("data").IsUint64()) } func TestIsUint64Slice(t *testing.T) { - v := &Value{data: []uint64{uint64(1)}} - assert.True(t, v.IsUint64Slice()) + m := objx.Map{"data": []uint64{uint64(1)}} + + assert.True(t, m.Get("data").IsUint64Slice()) } func TestEachUint64(t *testing.T) { - v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} - count := 0 - replacedVals := make([]uint64, 0) - assert.Equal(t, v, v.EachUint64(func(i int, val uint64) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} + count := 0 + replacedVals := make([]uint64, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachUint64(func(i int, val uint64) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustUint64Slice()[0]) - assert.Equal(t, replacedVals[1], v.MustUint64Slice()[1]) - assert.Equal(t, replacedVals[2], v.MustUint64Slice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustUint64Slice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustUint64Slice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustUint64Slice()[2]) } func TestWhereUint64(t *testing.T) { - v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} - - selected := v.WhereUint64(func(i int, val uint64) bool { - return i%2 == 0 - }).MustUint64Slice() + m := objx.Map{"data": []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} + selected := m.Get("data").WhereUint64(func(i int, val uint64) bool { + return i%2 == 0 + }).MustUint64Slice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupUint64(t *testing.T) { - v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} - - grouped := v.GroupUint64(func(i int, val uint64) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]uint64) + m := objx.Map{"data": []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} + grouped := m.Get("data").GroupUint64(func(i int, val uint64) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]uint64) - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceUint64(t *testing.T) { - v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} - - rawArr := v.MustUint64Slice() - - replaced := v.ReplaceUint64(func(index int, val uint64) uint64 { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustUint64Slice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} + rawArr := m.Get("data").MustUint64Slice() + replaced := m.Get("data").ReplaceUint64(func(index int, val uint64) uint64 { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustUint64Slice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectUint64(t *testing.T) { - v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} - - collected := v.CollectUint64(func(index int, val uint64) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}} + collected := m.Get("data").CollectUint64(func(index int, val uint64) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Uintptr (uintptr and []uintptr) */ - func TestUintptr(t *testing.T) { - val := uintptr(1) + val := uintptr(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Uintptr()) - assert.Equal(t, val, New(m).Get("value").MustUintptr()) - assert.Equal(t, uintptr(0), New(m).Get("nothing").Uintptr()) - assert.Equal(t, val, New(m).Get("nothing").Uintptr(1)) - assert.Panics(t, func() { - New(m).Get("age").MustUintptr() - }) + assert.Equal(t, val, m.Get("value").Uintptr()) + assert.Equal(t, val, m.Get("value").MustUintptr()) + assert.Equal(t, uintptr(0), m.Get("nothing").Uintptr()) + assert.Equal(t, val, m.Get("nothing").Uintptr(1)) + assert.Panics(t, func() { + m.Get("age").MustUintptr() + }) } func TestUintptrSlice(t *testing.T) { - val := uintptr(1) + val := uintptr(1) + m := objx.Map{"value": []uintptr{ val }, "nothing": nil} - m := map[string]interface{}{"value": []uintptr{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").UintptrSlice()[0]) - assert.Equal(t, val, New(m).Get("value").MustUintptrSlice()[0]) - assert.Equal(t, []uintptr(nil), New(m).Get("nothing").UintptrSlice()) - assert.Equal(t, val, New(m).Get("nothing").UintptrSlice([]uintptr{uintptr(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustUintptrSlice() - }) + assert.Equal(t, val, m.Get("value").UintptrSlice()[0]) + assert.Equal(t, val, m.Get("value").MustUintptrSlice()[0]) + assert.Equal(t, []uintptr(nil), m.Get("nothing").UintptrSlice()) + assert.Equal(t, val, m.Get("nothing").UintptrSlice([]uintptr{uintptr(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustUintptrSlice() + }) } func TestIsUintptr(t *testing.T) { - v := &Value{data: uintptr(1)} - assert.True(t, v.IsUintptr()) + m := objx.Map{"data": uintptr(1)} + assert.True(t, m.Get("data").IsUintptr()) } func TestIsUintptrSlice(t *testing.T) { - v := &Value{data: []uintptr{uintptr(1)}} - assert.True(t, v.IsUintptrSlice()) + m := objx.Map{"data": []uintptr{uintptr(1)}} + + assert.True(t, m.Get("data").IsUintptrSlice()) } func TestEachUintptr(t *testing.T) { - v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} - count := 0 - replacedVals := make([]uintptr, 0) - assert.Equal(t, v, v.EachUintptr(func(i int, val uintptr) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} + count := 0 + replacedVals := make([]uintptr, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachUintptr(func(i int, val uintptr) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustUintptrSlice()[0]) - assert.Equal(t, replacedVals[1], v.MustUintptrSlice()[1]) - assert.Equal(t, replacedVals[2], v.MustUintptrSlice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustUintptrSlice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustUintptrSlice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustUintptrSlice()[2]) } func TestWhereUintptr(t *testing.T) { - v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} - - selected := v.WhereUintptr(func(i int, val uintptr) bool { - return i%2 == 0 - }).MustUintptrSlice() + m := objx.Map{"data": []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} + selected := m.Get("data").WhereUintptr(func(i int, val uintptr) bool { + return i%2 == 0 + }).MustUintptrSlice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupUintptr(t *testing.T) { - v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} + m := objx.Map{"data": []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} + grouped := m.Get("data").GroupUintptr(func(i int, val uintptr) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]uintptr) - grouped := v.GroupUintptr(func(i int, val uintptr) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]uintptr) - - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceUintptr(t *testing.T) { - v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} - - rawArr := v.MustUintptrSlice() - - replaced := v.ReplaceUintptr(func(index int, val uintptr) uintptr { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustUintptrSlice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} + rawArr := m.Get("data").MustUintptrSlice() + replaced := m.Get("data").ReplaceUintptr(func(index int, val uintptr) uintptr { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustUintptrSlice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectUintptr(t *testing.T) { - v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} - - collected := v.CollectUintptr(func(index int, val uintptr) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}} + collected := m.Get("data").CollectUintptr(func(index int, val uintptr) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Float32 (float32 and []float32) */ - func TestFloat32(t *testing.T) { - val := float32(1) + val := float32(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Float32()) - assert.Equal(t, val, New(m).Get("value").MustFloat32()) - assert.Equal(t, float32(0), New(m).Get("nothing").Float32()) - assert.Equal(t, val, New(m).Get("nothing").Float32(1)) - assert.Panics(t, func() { - New(m).Get("age").MustFloat32() - }) + assert.Equal(t, val, m.Get("value").Float32()) + assert.Equal(t, val, m.Get("value").MustFloat32()) + assert.Equal(t, float32(0), m.Get("nothing").Float32()) + assert.Equal(t, val, m.Get("nothing").Float32(1)) + assert.Panics(t, func() { + m.Get("age").MustFloat32() + }) } func TestFloat32Slice(t *testing.T) { - val := float32(1) + val := float32(1) + m := objx.Map{"value": []float32{ val }, "nothing": nil} - m := map[string]interface{}{"value": []float32{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Float32Slice()[0]) - assert.Equal(t, val, New(m).Get("value").MustFloat32Slice()[0]) - assert.Equal(t, []float32(nil), New(m).Get("nothing").Float32Slice()) - assert.Equal(t, val, New(m).Get("nothing").Float32Slice([]float32{float32(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustFloat32Slice() - }) + assert.Equal(t, val, m.Get("value").Float32Slice()[0]) + assert.Equal(t, val, m.Get("value").MustFloat32Slice()[0]) + assert.Equal(t, []float32(nil), m.Get("nothing").Float32Slice()) + assert.Equal(t, val, m.Get("nothing").Float32Slice([]float32{float32(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustFloat32Slice() + }) } func TestIsFloat32(t *testing.T) { - v := &Value{data: float32(1)} - assert.True(t, v.IsFloat32()) + m := objx.Map{"data": float32(1)} + assert.True(t, m.Get("data").IsFloat32()) } func TestIsFloat32Slice(t *testing.T) { - v := &Value{data: []float32{float32(1)}} - assert.True(t, v.IsFloat32Slice()) + m := objx.Map{"data": []float32{float32(1)}} + + assert.True(t, m.Get("data").IsFloat32Slice()) } func TestEachFloat32(t *testing.T) { - v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1)}} - count := 0 - replacedVals := make([]float32, 0) - assert.Equal(t, v, v.EachFloat32(func(i int, val float32) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []float32{float32(1), float32(1), float32(1), float32(1), float32(1)}} + count := 0 + replacedVals := make([]float32, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachFloat32(func(i int, val float32) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustFloat32Slice()[0]) - assert.Equal(t, replacedVals[1], v.MustFloat32Slice()[1]) - assert.Equal(t, replacedVals[2], v.MustFloat32Slice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustFloat32Slice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustFloat32Slice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustFloat32Slice()[2]) } func TestWhereFloat32(t *testing.T) { - v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}} + m := objx.Map{"data": []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}} + selected := m.Get("data").WhereFloat32(func(i int, val float32) bool { + return i%2 == 0 + }).MustFloat32Slice() - selected := v.WhereFloat32(func(i int, val float32) bool { - return i%2 == 0 - }).MustFloat32Slice() - - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupFloat32(t *testing.T) { - v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}} - - grouped := v.GroupFloat32(func(i int, val float32) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]float32) + m := objx.Map{"data": []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}} + grouped := m.Get("data").GroupFloat32(func(i int, val float32) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]float32) - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceFloat32(t *testing.T) { - v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}} - - rawArr := v.MustFloat32Slice() - - replaced := v.ReplaceFloat32(func(index int, val float32) float32 { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustFloat32Slice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}} + rawArr := m.Get("data").MustFloat32Slice() + replaced := m.Get("data").ReplaceFloat32(func(index int, val float32) float32 { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustFloat32Slice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectFloat32(t *testing.T) { - v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}} - - collected := v.CollectFloat32(func(index int, val float32) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}} + collected := m.Get("data").CollectFloat32(func(index int, val float32) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Float64 (float64 and []float64) */ - func TestFloat64(t *testing.T) { - val := float64(1) + val := float64(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Float64()) - assert.Equal(t, val, New(m).Get("value").MustFloat64()) - assert.Equal(t, float64(0), New(m).Get("nothing").Float64()) - assert.Equal(t, val, New(m).Get("nothing").Float64(1)) - assert.Panics(t, func() { - New(m).Get("age").MustFloat64() - }) + assert.Equal(t, val, m.Get("value").Float64()) + assert.Equal(t, val, m.Get("value").MustFloat64()) + assert.Equal(t, float64(0), m.Get("nothing").Float64()) + assert.Equal(t, val, m.Get("nothing").Float64(1)) + assert.Panics(t, func() { + m.Get("age").MustFloat64() + }) } func TestFloat64Slice(t *testing.T) { - val := float64(1) + val := float64(1) + m := objx.Map{"value": []float64{ val }, "nothing": nil} - m := map[string]interface{}{"value": []float64{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Float64Slice()[0]) - assert.Equal(t, val, New(m).Get("value").MustFloat64Slice()[0]) - assert.Equal(t, []float64(nil), New(m).Get("nothing").Float64Slice()) - assert.Equal(t, val, New(m).Get("nothing").Float64Slice([]float64{float64(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustFloat64Slice() - }) + assert.Equal(t, val, m.Get("value").Float64Slice()[0]) + assert.Equal(t, val, m.Get("value").MustFloat64Slice()[0]) + assert.Equal(t, []float64(nil), m.Get("nothing").Float64Slice()) + assert.Equal(t, val, m.Get("nothing").Float64Slice([]float64{float64(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustFloat64Slice() + }) } func TestIsFloat64(t *testing.T) { - v := &Value{data: float64(1)} - assert.True(t, v.IsFloat64()) + m := objx.Map{"data": float64(1)} + assert.True(t, m.Get("data").IsFloat64()) } func TestIsFloat64Slice(t *testing.T) { - v := &Value{data: []float64{float64(1)}} - assert.True(t, v.IsFloat64Slice()) + m := objx.Map{"data": []float64{float64(1)}} + + assert.True(t, m.Get("data").IsFloat64Slice()) } func TestEachFloat64(t *testing.T) { - v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1)}} - count := 0 - replacedVals := make([]float64, 0) - assert.Equal(t, v, v.EachFloat64(func(i int, val float64) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []float64{float64(1), float64(1), float64(1), float64(1), float64(1)}} + count := 0 + replacedVals := make([]float64, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachFloat64(func(i int, val float64) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustFloat64Slice()[0]) - assert.Equal(t, replacedVals[1], v.MustFloat64Slice()[1]) - assert.Equal(t, replacedVals[2], v.MustFloat64Slice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustFloat64Slice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustFloat64Slice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustFloat64Slice()[2]) } func TestWhereFloat64(t *testing.T) { - v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}} + m := objx.Map{"data": []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}} + selected := m.Get("data").WhereFloat64(func(i int, val float64) bool { + return i%2 == 0 + }).MustFloat64Slice() - selected := v.WhereFloat64(func(i int, val float64) bool { - return i%2 == 0 - }).MustFloat64Slice() - - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupFloat64(t *testing.T) { - v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}} - - grouped := v.GroupFloat64(func(i int, val float64) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]float64) + m := objx.Map{"data": []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}} + grouped := m.Get("data").GroupFloat64(func(i int, val float64) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]float64) - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceFloat64(t *testing.T) { - v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}} - - rawArr := v.MustFloat64Slice() - - replaced := v.ReplaceFloat64(func(index int, val float64) float64 { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustFloat64Slice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}} + rawArr := m.Get("data").MustFloat64Slice() + replaced := m.Get("data").ReplaceFloat64(func(index int, val float64) float64 { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustFloat64Slice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectFloat64(t *testing.T) { - v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}} - - collected := v.CollectFloat64(func(index int, val float64) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}} + collected := m.Get("data").CollectFloat64(func(index int, val float64) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Complex64 (complex64 and []complex64) */ - func TestComplex64(t *testing.T) { - val := complex64(1) + val := complex64(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Complex64()) - assert.Equal(t, val, New(m).Get("value").MustComplex64()) - assert.Equal(t, complex64(0), New(m).Get("nothing").Complex64()) - assert.Equal(t, val, New(m).Get("nothing").Complex64(1)) - assert.Panics(t, func() { - New(m).Get("age").MustComplex64() - }) + assert.Equal(t, val, m.Get("value").Complex64()) + assert.Equal(t, val, m.Get("value").MustComplex64()) + assert.Equal(t, complex64(0), m.Get("nothing").Complex64()) + assert.Equal(t, val, m.Get("nothing").Complex64(1)) + assert.Panics(t, func() { + m.Get("age").MustComplex64() + }) } func TestComplex64Slice(t *testing.T) { - val := complex64(1) + val := complex64(1) + m := objx.Map{"value": []complex64{ val }, "nothing": nil} - m := map[string]interface{}{"value": []complex64{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Complex64Slice()[0]) - assert.Equal(t, val, New(m).Get("value").MustComplex64Slice()[0]) - assert.Equal(t, []complex64(nil), New(m).Get("nothing").Complex64Slice()) - assert.Equal(t, val, New(m).Get("nothing").Complex64Slice([]complex64{complex64(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustComplex64Slice() - }) + assert.Equal(t, val, m.Get("value").Complex64Slice()[0]) + assert.Equal(t, val, m.Get("value").MustComplex64Slice()[0]) + assert.Equal(t, []complex64(nil), m.Get("nothing").Complex64Slice()) + assert.Equal(t, val, m.Get("nothing").Complex64Slice([]complex64{complex64(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustComplex64Slice() + }) } func TestIsComplex64(t *testing.T) { - v := &Value{data: complex64(1)} - assert.True(t, v.IsComplex64()) + m := objx.Map{"data": complex64(1)} + assert.True(t, m.Get("data").IsComplex64()) } func TestIsComplex64Slice(t *testing.T) { - v := &Value{data: []complex64{complex64(1)}} - assert.True(t, v.IsComplex64Slice()) + m := objx.Map{"data": []complex64{complex64(1)}} + + assert.True(t, m.Get("data").IsComplex64Slice()) } func TestEachComplex64(t *testing.T) { - v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} - count := 0 - replacedVals := make([]complex64, 0) - assert.Equal(t, v, v.EachComplex64(func(i int, val complex64) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} + count := 0 + replacedVals := make([]complex64, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachComplex64(func(i int, val complex64) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustComplex64Slice()[0]) - assert.Equal(t, replacedVals[1], v.MustComplex64Slice()[1]) - assert.Equal(t, replacedVals[2], v.MustComplex64Slice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustComplex64Slice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustComplex64Slice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustComplex64Slice()[2]) } func TestWhereComplex64(t *testing.T) { - v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} - - selected := v.WhereComplex64(func(i int, val complex64) bool { - return i%2 == 0 - }).MustComplex64Slice() + m := objx.Map{"data": []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} + selected := m.Get("data").WhereComplex64(func(i int, val complex64) bool { + return i%2 == 0 + }).MustComplex64Slice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupComplex64(t *testing.T) { - v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} - - grouped := v.GroupComplex64(func(i int, val complex64) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]complex64) + m := objx.Map{"data": []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} + grouped := m.Get("data").GroupComplex64(func(i int, val complex64) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]complex64) - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceComplex64(t *testing.T) { - v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} - - rawArr := v.MustComplex64Slice() - - replaced := v.ReplaceComplex64(func(index int, val complex64) complex64 { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustComplex64Slice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} + rawArr := m.Get("data").MustComplex64Slice() + replaced := m.Get("data").ReplaceComplex64(func(index int, val complex64) complex64 { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustComplex64Slice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectComplex64(t *testing.T) { - v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} - - collected := v.CollectComplex64(func(index int, val complex64) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}} + collected := m.Get("data").CollectComplex64(func(index int, val complex64) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } /* Tests for Complex128 (complex128 and []complex128) */ - func TestComplex128(t *testing.T) { - val := complex128(1) + val := complex128(1) + m := objx.Map{"value": val, "nothing": nil} - m := map[string]interface{}{"value": val, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Complex128()) - assert.Equal(t, val, New(m).Get("value").MustComplex128()) - assert.Equal(t, complex128(0), New(m).Get("nothing").Complex128()) - assert.Equal(t, val, New(m).Get("nothing").Complex128(1)) - assert.Panics(t, func() { - New(m).Get("age").MustComplex128() - }) + assert.Equal(t, val, m.Get("value").Complex128()) + assert.Equal(t, val, m.Get("value").MustComplex128()) + assert.Equal(t, complex128(0), m.Get("nothing").Complex128()) + assert.Equal(t, val, m.Get("nothing").Complex128(1)) + assert.Panics(t, func() { + m.Get("age").MustComplex128() + }) } func TestComplex128Slice(t *testing.T) { - val := complex128(1) + val := complex128(1) + m := objx.Map{"value": []complex128{ val }, "nothing": nil} - m := map[string]interface{}{"value": []complex128{val}, "nothing": nil} - assert.Equal(t, val, New(m).Get("value").Complex128Slice()[0]) - assert.Equal(t, val, New(m).Get("value").MustComplex128Slice()[0]) - assert.Equal(t, []complex128(nil), New(m).Get("nothing").Complex128Slice()) - assert.Equal(t, val, New(m).Get("nothing").Complex128Slice([]complex128{complex128(1)})[0]) - assert.Panics(t, func() { - New(m).Get("nothing").MustComplex128Slice() - }) + assert.Equal(t, val, m.Get("value").Complex128Slice()[0]) + assert.Equal(t, val, m.Get("value").MustComplex128Slice()[0]) + assert.Equal(t, []complex128(nil), m.Get("nothing").Complex128Slice()) + assert.Equal(t, val, m.Get("nothing").Complex128Slice([]complex128{complex128(1)})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustComplex128Slice() + }) } func TestIsComplex128(t *testing.T) { - v := &Value{data: complex128(1)} - assert.True(t, v.IsComplex128()) + m := objx.Map{"data": complex128(1)} + assert.True(t, m.Get("data").IsComplex128()) } func TestIsComplex128Slice(t *testing.T) { - v := &Value{data: []complex128{complex128(1)}} - assert.True(t, v.IsComplex128Slice()) + m := objx.Map{"data": []complex128{complex128(1)}} + + assert.True(t, m.Get("data").IsComplex128Slice()) } func TestEachComplex128(t *testing.T) { - v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} - count := 0 - replacedVals := make([]complex128, 0) - assert.Equal(t, v, v.EachComplex128(func(i int, val complex128) bool { - count++ - replacedVals = append(replacedVals, val) + m := objx.Map{"data": []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} + count := 0 + replacedVals := make([]complex128, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachComplex128(func(i int, val complex128) bool { + count++ + replacedVals = append(replacedVals, val) - // abort early - return i != 2 - })) + // abort early + return i != 2 + })) - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], v.MustComplex128Slice()[0]) - assert.Equal(t, replacedVals[1], v.MustComplex128Slice()[1]) - assert.Equal(t, replacedVals[2], v.MustComplex128Slice()[2]) + assert.Equal(t, count, 3) + assert.Equal(t, replacedVals[0], m.Get("data").MustComplex128Slice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustComplex128Slice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustComplex128Slice()[2]) } func TestWhereComplex128(t *testing.T) { - v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} - - selected := v.WhereComplex128(func(i int, val complex128) bool { - return i%2 == 0 - }).MustComplex128Slice() + m := objx.Map{"data": []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} + selected := m.Get("data").WhereComplex128(func(i int, val complex128) bool { + return i%2 == 0 + }).MustComplex128Slice() - assert.Equal(t, 3, len(selected)) + assert.Equal(t, 3, len(selected)) } func TestGroupComplex128(t *testing.T) { - v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} + m := objx.Map{"data": []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} + grouped := m.Get("data").GroupComplex128(func(i int, val complex128) string { + return fmt.Sprintf("%v", i%2==0) + }).Data().(map[string][]complex128) - grouped := v.GroupComplex128(func(i int, val complex128) string { - return fmt.Sprintf("%v", i%2 == 0) - }).data.(map[string][]complex128) - - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) } func TestReplaceComplex128(t *testing.T) { - v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} - - rawArr := v.MustComplex128Slice() - - replaced := v.ReplaceComplex128(func(index int, val complex128) complex128 { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - - replacedArr := replaced.MustComplex128Slice() - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } + m := objx.Map{"data": []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} + rawArr := m.Get("data").MustComplex128Slice() + replaced := m.Get("data").ReplaceComplex128(func(index int, val complex128) complex128 { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustComplex128Slice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } } func TestCollectComplex128(t *testing.T) { - v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} - - collected := v.CollectComplex128(func(index int, val complex128) interface{} { - return index - }) - - collectedArr := collected.MustInterSlice() - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } + m := objx.Map{"data": []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}} + collected := m.Get("data").CollectComplex128(func(index int, val complex128) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } } + |