1package objx_test
2
3import (
4	"fmt"
5	"testing"
6
7	"github.com/stretchr/objx"
8	"github.com/stretchr/testify/assert"
9)
10
11/*
12   Tests for MSI (map[string]interface{} and []map[string]interface{})
13*/
14func 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
30func 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, 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
59func 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
66func 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
82func 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		// abort early
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		// abort early
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
112func 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
122func 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
132func 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
144func 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
156func 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
178func 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
199func 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
217func 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/*
235   Tests for ObjxMap ((objx.Map) and [](objx.Map))
236*/
237func 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
253func 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
286func 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
293func 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	//Valid json but not MSI slice
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
309func 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		// abort early
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		// abort early
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
339func 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
349func 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
359func 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
371func 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
383func 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
405func 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
426func 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
444func 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