1 package objx_test
2
3 import (
4 "fmt"
5 "testing"
6
7 "github.com/stretchr/objx"
8 "github.com/stretchr/testify/assert"
9 )
10
11
14 func TestMSI(t *testing.T) {
15 val := map[string]interface{}(map[string]interface{}{"name": "Tyler"})
16 m := objx.Map{"value": val, "nothing": nil}
17 mVal := map[string]interface{}{"value": val, "nothing": nil}
18
19 assert.Equal(t, mVal, m.Value().MSI())
20 assert.Equal(t, val, m.Get("value").MSI())
21 assert.Equal(t, mVal, m.Value().MustMSI())
22 assert.Equal(t, val, m.Get("value").MustMSI())
23 assert.Equal(t, map[string]interface{}(nil), m.Get("nothing").MSI())
24 assert.Equal(t, val, m.Get("nothing").MSI(map[string]interface{}{"name": "Tyler"}))
25 assert.Panics(t, func() {
26 m.Get("age").MustMSI()
27 })
28 }
29
30 func TestMSISlice(t *testing.T) {
31 val := map[string]interface{}(map[string]interface{}{"name": "Tyler"})
32 m := objx.Map{
33 "value": []map[string]interface{}{val},
34 "value2": []objx.Map{val},
35 "value3": []interface{}{val},
36 "nothing": nil,
37 }
38
39 assert.Equal(t, val, m.Get("value").MSISlice()[0])
40 assert.Equal(t, val, m.Get("value2").MSISlice()[0])
41 assert.Equal(t, val, m.Get("value3").MSISlice()[0])
42 assert.Equal(t, val, m.Get("value").MustMSISlice()[0])
43 assert.Equal(t, val, m.Get("value2").MustMSISlice()[0])
44 assert.Equal(t, val, m.Get("value3").MustMSISlice()[0])
45 assert.Equal(t, []map[string]interface{}(nil), m.Get("nothing").MSISlice())
46 assert.Equal(t, val, m.Get("nothing").MSISlice([]map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"})})[0])
47 assert.Panics(t, func() {
48 m.Get("nothing").MustMSISlice()
49 })
50
51 o := objx.MustFromJSON(`{"d":[{"author":{"displayName":"DemoUser3","id":2},"classes":null,"id":9879,"v":{"code":"","created":"2013-09-19T09:38:50+02:00","published":"0001-01-01T00:00:00Z","updated":"2013-09-19T09:38:50+02:00"}}],"s":200}`)
52 assert.Equal(t, float64(9879), o.Get("d").MustMSISlice()[0]["id"])
53 assert.Equal(t, 1, len(o.Get("d").MSISlice()))
54
55 i := objx.MustFromJSON(`{"d":[{"author":"abc"},[1]]}`)
56 assert.Nil(t, i.Get("d").MSISlice())
57 }
58
59 func TestIsMSI(t *testing.T) {
60 m := objx.Map{"data": map[string]interface{}(map[string]interface{}{"name": "Tyler"})}
61
62 assert.True(t, m.Get("data").IsMSI())
63 assert.True(t, m.Value().IsMSI())
64 }
65
66 func TestIsMSISlice(t *testing.T) {
67 val := map[string]interface{}(map[string]interface{}{"name": "Tyler"})
68 m := objx.Map{"data": []map[string]interface{}{val}, "data2": []objx.Map{val}}
69
70 assert.True(t, m.Get("data").IsMSISlice())
71 assert.True(t, m.Get("data2").IsMSISlice())
72
73 o := objx.MustFromJSON(`{"d":[{"author":{"displayName":"DemoUser3","id":2},"classes":null,"id":9879,"v":{"code":"","created":"2013-09-19T09:38:50+02:00","published":"0001-01-01T00:00:00Z","updated":"2013-09-19T09:38:50+02:00"}}],"s":200}`)
74 assert.True(t, o.Has("d"))
75 assert.True(t, o.Get("d").IsMSISlice())
76
77 o = objx.MustFromJSON(`{"d":[{"author":"abc"},[1]]}`)
78 assert.True(t, o.Has("d"))
79 assert.False(t, o.Get("d").IsMSISlice())
80 }
81
82 func TestEachMSI(t *testing.T) {
83 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"})}}
84 count := 0
85 replacedVals := make([]map[string]interface{}, 0)
86 assert.Equal(t, m.Get("data"), m.Get("data").EachMSI(func(i int, val map[string]interface{}) bool {
87 count++
88 replacedVals = append(replacedVals, val)
89
90
91 return i != 2
92 }))
93
94 m2 := objx.Map{"data": []objx.Map{{"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}}}
95 assert.Equal(t, m2.Get("data"), m2.Get("data").EachMSI(func(i int, val map[string]interface{}) bool {
96 count++
97 replacedVals = append(replacedVals, val)
98
99
100 return i != 2
101 }))
102
103 assert.Equal(t, count, 6)
104 assert.Equal(t, replacedVals[0], m.Get("data").MustMSISlice()[0])
105 assert.Equal(t, replacedVals[1], m.Get("data").MustMSISlice()[1])
106 assert.Equal(t, replacedVals[2], m.Get("data").MustMSISlice()[2])
107 assert.Equal(t, replacedVals[3], m2.Get("data").MustMSISlice()[0])
108 assert.Equal(t, replacedVals[4], m2.Get("data").MustMSISlice()[1])
109 assert.Equal(t, replacedVals[5], m2.Get("data").MustMSISlice()[2])
110 }
111
112 func TestWhereMSI(t *testing.T) {
113 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"})}}
114
115 selected := m.Get("data").WhereMSI(func(i int, val map[string]interface{}) bool {
116 return i%2 == 0
117 }).MustMSISlice()
118
119 assert.Equal(t, 3, len(selected))
120 }
121
122 func TestWhereMSI2(t *testing.T) {
123 m := objx.Map{"data": []objx.Map{{"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}}}
124
125 selected := m.Get("data").WhereMSI(func(i int, val map[string]interface{}) bool {
126 return i%2 == 0
127 }).MustMSISlice()
128
129 assert.Equal(t, 2, len(selected))
130 }
131
132 func TestGroupMSI(t *testing.T) {
133 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"})}}
134
135 grouped := m.Get("data").GroupMSI(func(i int, val map[string]interface{}) string {
136 return fmt.Sprintf("%v", i%2 == 0)
137 }).Data().(map[string][]map[string]interface{})
138
139 assert.Equal(t, 2, len(grouped))
140 assert.Equal(t, 3, len(grouped["true"]))
141 assert.Equal(t, 3, len(grouped["false"]))
142 }
143
144 func TestGroupMSI2(t *testing.T) {
145 m := objx.Map{"data": []objx.Map{{"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}}}
146
147 grouped := m.Get("data").GroupMSI(func(i int, val map[string]interface{}) string {
148 return fmt.Sprintf("%v", i%2 == 0)
149 }).Data().(map[string][]map[string]interface{})
150
151 assert.Equal(t, 2, len(grouped))
152 assert.Equal(t, 3, len(grouped["true"]))
153 assert.Equal(t, 2, len(grouped["false"]))
154 }
155
156 func TestReplaceMSI(t *testing.T) {
157 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"})}}
158 rawArr := m.Get("data").MustMSISlice()
159
160 replaced := m.Get("data").ReplaceMSI(func(index int, val map[string]interface{}) map[string]interface{} {
161 if index < len(rawArr)-1 {
162 return rawArr[index+1]
163 }
164 return rawArr[0]
165 })
166 replacedArr := replaced.MustMSISlice()
167
168 if assert.Equal(t, 6, len(replacedArr)) {
169 assert.Equal(t, replacedArr[0], rawArr[1])
170 assert.Equal(t, replacedArr[1], rawArr[2])
171 assert.Equal(t, replacedArr[2], rawArr[3])
172 assert.Equal(t, replacedArr[3], rawArr[4])
173 assert.Equal(t, replacedArr[4], rawArr[5])
174 assert.Equal(t, replacedArr[5], rawArr[0])
175 }
176 }
177
178 func TestReplaceMSI2(t *testing.T) {
179 m := objx.Map{"data": []objx.Map{{"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}}}
180 rawArr := m.Get("data").MustMSISlice()
181
182 replaced := m.Get("data").ReplaceMSI(func(index int, val map[string]interface{}) map[string]interface{} {
183 if index < len(rawArr)-1 {
184 return rawArr[index+1]
185 }
186 return rawArr[0]
187 })
188 replacedArr := replaced.MustMSISlice()
189
190 if assert.Equal(t, 5, len(replacedArr)) {
191 assert.Equal(t, replacedArr[0], rawArr[1])
192 assert.Equal(t, replacedArr[1], rawArr[2])
193 assert.Equal(t, replacedArr[2], rawArr[3])
194 assert.Equal(t, replacedArr[3], rawArr[4])
195 assert.Equal(t, replacedArr[4], rawArr[0])
196 }
197 }
198
199 func TestCollectMSI(t *testing.T) {
200 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"})}}
201
202 collected := m.Get("data").CollectMSI(func(index int, val map[string]interface{}) interface{} {
203 return index
204 })
205 collectedArr := collected.MustInterSlice()
206
207 if assert.Equal(t, 6, len(collectedArr)) {
208 assert.Equal(t, collectedArr[0], 0)
209 assert.Equal(t, collectedArr[1], 1)
210 assert.Equal(t, collectedArr[2], 2)
211 assert.Equal(t, collectedArr[3], 3)
212 assert.Equal(t, collectedArr[4], 4)
213 assert.Equal(t, collectedArr[5], 5)
214 }
215 }
216
217 func TestCollectMSI2(t *testing.T) {
218 m := objx.Map{"data": []objx.Map{{"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}, {"name": "Taylor"}}}
219
220 collected := m.Get("data").CollectMSI(func(index int, val map[string]interface{}) interface{} {
221 return index
222 })
223 collectedArr := collected.MustInterSlice()
224
225 if assert.Equal(t, 5, len(collectedArr)) {
226 assert.Equal(t, collectedArr[0], 0)
227 assert.Equal(t, collectedArr[1], 1)
228 assert.Equal(t, collectedArr[2], 2)
229 assert.Equal(t, collectedArr[3], 3)
230 assert.Equal(t, collectedArr[4], 4)
231 }
232 }
233
234
237 func TestObjxMap(t *testing.T) {
238 val := (objx.Map)(objx.New(1))
239 m := objx.Map{"value": val, "value2": map[string]interface{}{"name": "Taylor"}, "nothing": nil}
240 valMSI := objx.Map{"name": "Taylor"}
241
242 assert.Equal(t, val, m.Get("value").ObjxMap())
243 assert.Equal(t, valMSI, m.Get("value2").ObjxMap())
244 assert.Equal(t, val, m.Get("value").MustObjxMap())
245 assert.Equal(t, valMSI, m.Get("value2").MustObjxMap())
246 assert.Equal(t, (objx.Map)(objx.New(nil)), m.Get("nothing").ObjxMap())
247 assert.Equal(t, val, m.Get("nothing").ObjxMap(objx.New(1)))
248 assert.Panics(t, func() {
249 m.Get("age").MustObjxMap()
250 })
251 }
252
253 func TestObjxMapSlice(t *testing.T) {
254 val := (objx.Map)(objx.New(1))
255 m := objx.Map{
256 "value": [](objx.Map){val},
257 "value2": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Taylor"})},
258 "value3": []interface{}{val},
259 "value4": []interface{}{map[string]interface{}(map[string]interface{}{"name": "Taylor"})},
260 "nothing": nil,
261 }
262 valMSI := objx.Map{"name": "Taylor"}
263
264 assert.Equal(t, val, m.Get("value").ObjxMapSlice()[0])
265 assert.Equal(t, valMSI, m.Get("value2").ObjxMapSlice()[0])
266 assert.Equal(t, val, m.Get("value3").ObjxMapSlice()[0])
267 assert.Equal(t, valMSI, m.Get("value4").ObjxMapSlice()[0])
268 assert.Equal(t, val, m.Get("value").MustObjxMapSlice()[0])
269 assert.Equal(t, valMSI, m.Get("value2").MustObjxMapSlice()[0])
270 assert.Equal(t, val, m.Get("value3").MustObjxMapSlice()[0])
271 assert.Equal(t, valMSI, m.Get("value4").MustObjxMapSlice()[0])
272 assert.Equal(t, [](objx.Map)(nil), m.Get("nothing").ObjxMapSlice())
273 assert.Equal(t, val, m.Get("nothing").ObjxMapSlice([](objx.Map){(objx.Map)(objx.New(1))})[0])
274 assert.Panics(t, func() {
275 m.Get("nothing").MustObjxMapSlice()
276 })
277
278 o := objx.MustFromJSON(`{"d":[{"author":{"displayName":"DemoUser3","id":2},"classes":null,"id":9879,"v":{"code":"","created":"2013-09-19T09:38:50+02:00","published":"0001-01-01T00:00:00Z","updated":"2013-09-19T09:38:50+02:00"}}],"s":200}`)
279 assert.Equal(t, 9879, o.Get("d").MustObjxMapSlice()[0].Get("id").Int())
280 assert.Equal(t, 1, len(o.Get("d").ObjxMapSlice()))
281
282 i := objx.MustFromJSON(`{"d":[{"author":"abc"},[1]]}`)
283 assert.Nil(t, i.Get("d").ObjxMapSlice())
284 }
285
286 func TestIsObjxMap(t *testing.T) {
287 m := objx.Map{"data": (objx.Map)(objx.New(1)), "data2": map[string]interface{}{"name": "Taylor"}}
288
289 assert.True(t, m.Get("data").IsObjxMap())
290 assert.True(t, m.Get("data2").IsObjxMap())
291 }
292
293 func TestIsObjxMapSlice(t *testing.T) {
294 m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1))}, "data2": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Taylor"})}}
295
296 assert.True(t, m.Get("data").IsObjxMapSlice())
297 assert.True(t, m.Get("data2").IsObjxMapSlice())
298
299 o := objx.MustFromJSON(`{"d":[{"author":{"displayName":"DemoUser3","id":2},"classes":null,"id":9879,"v":{"code":"","created":"2013-09-19T09:38:50+02:00","published":"0001-01-01T00:00:00Z","updated":"2013-09-19T09:38:50+02:00"}}],"s":200}`)
300 assert.True(t, o.Has("d"))
301 assert.True(t, o.Get("d").IsObjxMapSlice())
302
303
304 o = objx.MustFromJSON(`{"d":[{"author":"abc"},[1]]}`)
305 assert.True(t, o.Has("d"))
306 assert.False(t, o.Get("d").IsObjxMapSlice())
307 }
308
309 func TestEachObjxMap(t *testing.T) {
310 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))}}
311 count := 0
312 replacedVals := make([](objx.Map), 0)
313 assert.Equal(t, m.Get("data"), m.Get("data").EachObjxMap(func(i int, val objx.Map) bool {
314 count++
315 replacedVals = append(replacedVals, val)
316
317
318 return i != 2
319 }))
320
321 m2 := 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"})}}
322 assert.Equal(t, m2.Get("data"), m2.Get("data").EachObjxMap(func(i int, val objx.Map) bool {
323 count++
324 replacedVals = append(replacedVals, val)
325
326
327 return i != 2
328 }))
329
330 assert.Equal(t, count, 6)
331 assert.Equal(t, replacedVals[0], m.Get("data").MustObjxMapSlice()[0])
332 assert.Equal(t, replacedVals[1], m.Get("data").MustObjxMapSlice()[1])
333 assert.Equal(t, replacedVals[2], m.Get("data").MustObjxMapSlice()[2])
334 assert.Equal(t, replacedVals[3], m2.Get("data").MustObjxMapSlice()[0])
335 assert.Equal(t, replacedVals[4], m2.Get("data").MustObjxMapSlice()[1])
336 assert.Equal(t, replacedVals[5], m2.Get("data").MustObjxMapSlice()[2])
337 }
338
339 func TestWhereObjxMap(t *testing.T) {
340 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))}}
341
342 selected := m.Get("data").WhereObjxMap(func(i int, val objx.Map) bool {
343 return i%2 == 0
344 }).MustObjxMapSlice()
345
346 assert.Equal(t, 3, len(selected))
347 }
348
349 func TestWhereObjxMap2(t *testing.T) {
350 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"})}}
351
352 selected := m.Get("data").WhereObjxMap(func(i int, val objx.Map) bool {
353 return i%2 == 0
354 }).MustObjxMapSlice()
355
356 assert.Equal(t, 2, len(selected))
357 }
358
359 func TestGroupObjxMap(t *testing.T) {
360 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))}}
361
362 grouped := m.Get("data").GroupObjxMap(func(i int, val objx.Map) string {
363 return fmt.Sprintf("%v", i%2 == 0)
364 }).Data().(map[string][](objx.Map))
365
366 assert.Equal(t, 2, len(grouped))
367 assert.Equal(t, 3, len(grouped["true"]))
368 assert.Equal(t, 3, len(grouped["false"]))
369 }
370
371 func TestGroupObjxMap2(t *testing.T) {
372 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"})}}
373
374 grouped := m.Get("data").GroupObjxMap(func(i int, val objx.Map) string {
375 return fmt.Sprintf("%v", i%2 == 0)
376 }).Data().(map[string][](objx.Map))
377
378 assert.Equal(t, 2, len(grouped))
379 assert.Equal(t, 3, len(grouped["true"]))
380 assert.Equal(t, 2, len(grouped["false"]))
381 }
382
383 func TestReplaceObjxMap(t *testing.T) {
384 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))}}
385 rawArr := m.Get("data").MustObjxMapSlice()
386
387 replaced := m.Get("data").ReplaceObjxMap(func(index int, val objx.Map) objx.Map {
388 if index < len(rawArr)-1 {
389 return rawArr[index+1]
390 }
391 return rawArr[0]
392 })
393 replacedArr := replaced.MustObjxMapSlice()
394
395 if assert.Equal(t, 6, len(replacedArr)) {
396 assert.Equal(t, replacedArr[0], rawArr[1])
397 assert.Equal(t, replacedArr[1], rawArr[2])
398 assert.Equal(t, replacedArr[2], rawArr[3])
399 assert.Equal(t, replacedArr[3], rawArr[4])
400 assert.Equal(t, replacedArr[4], rawArr[5])
401 assert.Equal(t, replacedArr[5], rawArr[0])
402 }
403 }
404
405 func TestReplaceObjxMap2(t *testing.T) {
406 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"})}}
407 rawArr := m.Get("data").MustObjxMapSlice()
408
409 replaced := m.Get("data").ReplaceObjxMap(func(index int, val objx.Map) objx.Map {
410 if index < len(rawArr)-1 {
411 return rawArr[index+1]
412 }
413 return rawArr[0]
414 })
415 replacedArr := replaced.MustObjxMapSlice()
416
417 if assert.Equal(t, 5, len(replacedArr)) {
418 assert.Equal(t, replacedArr[0], rawArr[1])
419 assert.Equal(t, replacedArr[1], rawArr[2])
420 assert.Equal(t, replacedArr[2], rawArr[3])
421 assert.Equal(t, replacedArr[3], rawArr[4])
422 assert.Equal(t, replacedArr[4], rawArr[0])
423 }
424 }
425
426 func TestCollectObjxMap(t *testing.T) {
427 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))}}
428
429 collected := m.Get("data").CollectObjxMap(func(index int, val objx.Map) interface{} {
430 return index
431 })
432 collectedArr := collected.MustInterSlice()
433
434 if assert.Equal(t, 6, len(collectedArr)) {
435 assert.Equal(t, collectedArr[0], 0)
436 assert.Equal(t, collectedArr[1], 1)
437 assert.Equal(t, collectedArr[2], 2)
438 assert.Equal(t, collectedArr[3], 3)
439 assert.Equal(t, collectedArr[4], 4)
440 assert.Equal(t, collectedArr[5], 5)
441 }
442 }
443
444 func TestCollectObjxMap2(t *testing.T) {
445 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"})}}
446
447 collected := m.Get("data").CollectObjxMap(func(index int, val objx.Map) interface{} {
448 return index
449 })
450 collectedArr := collected.MustInterSlice()
451
452 if assert.Equal(t, 5, len(collectedArr)) {
453 assert.Equal(t, collectedArr[0], 0)
454 assert.Equal(t, collectedArr[1], 1)
455 assert.Equal(t, collectedArr[2], 2)
456 assert.Equal(t, collectedArr[3], 3)
457 assert.Equal(t, collectedArr[4], 4)
458 }
459 }
460
View as plain text