1
16
17 package ast
18
19 import (
20 `bytes`
21 `encoding/json`
22 `errors`
23 `fmt`
24 `reflect`
25 `strconv`
26 `testing`
27
28 `github.com/bytedance/sonic/internal/native/types`
29 `github.com/bytedance/sonic/internal/rt`
30 `github.com/stretchr/testify/assert`
31 `github.com/stretchr/testify/require`
32 )
33
34 func TestNodeSortKeys(t *testing.T) {
35 var src = `{"b":1,"a":2,"c":3}`
36 root, err := NewSearcher(src).GetByPath()
37 if err != nil {
38 t.Fatal(err)
39 }
40 obj, err := root.MapUseNumber()
41 if err != nil {
42 t.Fatal(err)
43 }
44 exp, err := json.Marshal(obj)
45 if err != nil {
46 t.Fatal(err)
47 }
48 if err := root.SortKeys(true); err != nil {
49 t.Fatal(err)
50 }
51 act, err := root.MarshalJSON()
52 if err != nil {
53 t.Fatal(err)
54 }
55 assert.Equal(t, len(exp), len(act))
56 assert.Equal(t, string(exp), string(act))
57
58 src = `[[1], {"b":1,"a":2,"c":3}, [], {}, [{"b":1,"a":2,"c":3,"d":[],"e":{}}]]`
59 root, err = NewSearcher(src).GetByPath()
60 if err != nil {
61 t.Fatal(err)
62 }
63 vv, err := root.Interface()
64 if err != nil {
65 t.Fatal(err)
66 }
67 exp, err = json.Marshal(vv)
68 if err != nil {
69 t.Fatal(err)
70 }
71 if err := root.SortKeys(true); err != nil {
72 t.Fatal(err)
73 }
74 act, err = root.MarshalJSON()
75 if err != nil {
76 t.Fatal(err)
77 }
78 assert.Equal(t, string(exp), string(act))
79
80 }
81
82 func BenchmarkNodeSortKeys(b *testing.B) {
83 root, err := NewSearcher(_TwitterJson).GetByPath()
84 if err != nil {
85 b.Fatal(err)
86 }
87
88
89
90
91 b.Run("single", func(b *testing.B) {
92 r := root.Get("statuses")
93 if r.Check() != nil {
94 b.Fatal(r.Error())
95 }
96 b.SetBytes(int64(len(_TwitterJson)))
97 b.ResetTimer()
98 for i := 0; i < b.N; i++ {
99 _ = root.SortKeys(false)
100 }
101 })
102 b.Run("recurse", func(b *testing.B) {
103 b.SetBytes(int64(len(_TwitterJson)))
104 b.ResetTimer()
105 for i := 0; i < b.N; i++ {
106 _ = root.SortKeys(true)
107 }
108 })
109 }
110
111 func TestNodeSortKeys2(t *testing.T) {
112 root, err := NewSearcher(_TwitterJson).GetByPath()
113 if err != nil {
114 t.Fatal(err)
115 }
116
117
118
119 t.Run("single", func(t *testing.T) {
120 r := root.Get("statuses")
121 if r.Check() != nil {
122 t.Fatal(r.Error())
123 }
124 require.NoError(t, root.SortKeys(false))
125 })
126 t.Run("recurse", func(t *testing.T) {
127 require.NoError(t, root.SortKeys(true))
128 })
129 }
130
131 func stackObj() interface{} {
132 var a int = 1
133 return rt.UnpackEface(a).Pack()
134 }
135
136 func TestLoadAll(t *testing.T) {
137 e := Node{}
138 err := e.Load()
139 if err != nil {
140 t.Fatal(err)
141 }
142 err = e.LoadAll()
143 if err != nil {
144 t.Fatal(err)
145 }
146
147 root, err := NewSearcher(`{"a":{"1":[1],"2":2},"b":[{"1":1},2],"c":[1,2]}`).GetByPath()
148 if err != nil {
149 t.Fatal(err)
150 }
151 if err = root.Load(); err != nil {
152 t.Fatal(err)
153 }
154 if root.len() != 3 {
155 t.Fatal(root.len())
156 }
157
158 c := root.Get("c")
159 if !c.IsRaw() {
160 t.Fatal(err)
161 }
162 err = c.LoadAll()
163 if err != nil {
164 t.Fatal(err)
165 }
166 if c.len() != 2 {
167 t.Fatal(c.len())
168 }
169 c1 := c.nodeAt(0)
170 if n, err := c1.Int64(); err != nil || n != 1 {
171 t.Fatal(n, err)
172 }
173
174 a := root.pairAt(0)
175 if a.Key != "a" {
176 t.Fatal(a.Key)
177 } else if !a.Value.IsRaw() {
178 t.Fatal(a.Value.itype())
179 } else if n, err := a.Value.Len(); n != 0 || err != nil {
180 t.Fatal(n, err)
181 }
182 if err := a.Value.Load(); err != nil {
183 t.Fatal(err)
184 }
185 if a.Value.len() != 2 {
186 t.Fatal(a.Value.len())
187 }
188 a1 := a.Value.Get("1")
189 if !a1.IsRaw() {
190 t.Fatal(a1)
191 }
192 a.Value.LoadAll()
193 if a1.t != types.V_ARRAY || a1.len() != 1 {
194 t.Fatal(a1.t, a1.len())
195 }
196
197 b := root.pairAt(1)
198 if b.Key != "b" {
199 t.Fatal(b.Key)
200 } else if !b.Value.IsRaw() {
201 t.Fatal(b.Value.itype())
202 } else if n, err := b.Value.Len(); n != 0 || err != nil {
203 t.Fatal(n, err)
204 }
205 if err := b.Value.Load(); err != nil {
206 t.Fatal(err)
207 }
208 if b.Value.len() != 2 {
209 t.Fatal(b.Value.len())
210 }
211 b1 := b.Value.Index(0)
212 if !b1.IsRaw() {
213 t.Fatal(b1)
214 }
215 b.Value.LoadAll()
216 if b1.t != types.V_OBJECT || b1.len() != 1 {
217 t.Fatal(a1.t, a1.len())
218 }
219 }
220
221 func TestIndexPair(t *testing.T) {
222 root, _ := NewParser(`{"a":1,"b":2}`).Parse()
223 a := root.IndexPair(0)
224 if a == nil || a.Key != "a" {
225 t.Fatal(a)
226 }
227 b := root.IndexPair(1)
228 if b == nil || b.Key != "b" {
229 t.Fatal(b)
230 }
231 c := root.IndexPair(2)
232 if c != nil {
233 t.Fatal(c)
234 }
235 }
236
237 func TestIndexOrGet(t *testing.T) {
238 root, _ := NewParser(`{"a":1,"b":2}`).Parse()
239 a := root.IndexOrGet(0, "a")
240 if v, err := a.Int64(); err != nil || v != int64(1) {
241 t.Fatal(a)
242 }
243 a = root.IndexOrGet(0, "b")
244 if v, err := a.Int64(); err != nil || v != int64(2) {
245 t.Fatal(a)
246 }
247 a = root.IndexOrGet(0, "c")
248 if a.Valid() {
249 t.Fatal(a)
250 }
251 }
252
253 func TestIndexOrGetWithIdx(t *testing.T) {
254 root, _ := NewParser(`{"a":1,"b":2}`).Parse()
255 b, idx := root.IndexOrGetWithIdx(0, "b")
256 if v, err := b.Int64(); err != nil || v != int64(2) {
257 t.Fatal(b, idx)
258 }
259 if idx != 1 {
260 t.Fatal(b, idx)
261 }
262 }
263
264 func TestTypeCast(t *testing.T) {
265 type tcase struct {
266 method string
267 node Node
268 exp interface{}
269 err error
270 }
271 var nonEmptyErr error = errors.New("")
272 a1 := NewAny(1)
273 lazyArray, _ := NewParser("[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]").Parse()
274 lazyObject, _ := NewParser(`{"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9,"10":10,"11":11,"12":12,"13":13,"14":14,"15":15,"16":16}`).Parse()
275 var cases = []tcase{
276 {"Interface", Node{}, interface{}(nil), ErrUnsupportType},
277 {"Interface", NewAny(NewNumber("1")), float64(1), nil},
278 {"Interface", NewAny(int64(1)), int64(1), nil},
279 {"Interface", NewNumber("1"), float64(1), nil},
280 {"InterfaceUseNode", Node{}, Node{}, nil},
281 {"InterfaceUseNode", a1, a1, nil},
282 {"InterfaceUseNode", NewNumber("1"), NewNumber("1"), nil},
283 {"InterfaceUseNumber", Node{}, interface{}(nil), ErrUnsupportType},
284 {"InterfaceUseNumber", NewAny(1), 1, nil},
285 {"InterfaceUseNumber", NewNumber("1"), json.Number("1"), nil},
286 {"Map", Node{}, map[string]interface{}(nil), ErrUnsupportType},
287 {"Map", NewAny(map[string]Node{"a": NewNumber("1")}), map[string]interface{}(nil), ErrUnsupportType},
288 {"Map", NewAny(map[string]interface{}{"a": 1}), map[string]interface{}{"a": 1}, nil},
289 {"Map", NewObject([]Pair{{"a", NewNumber("1")}}), map[string]interface{}{"a": float64(1.0)}, nil},
290 {"MapUseNode", Node{}, map[string]Node(nil), ErrUnsupportType},
291 {"MapUseNode", NewAny(map[string]interface{}{"a": 1}), map[string]Node(nil), ErrUnsupportType},
292 {"MapUseNode", NewAny(map[string]Node{"a": NewNumber("1")}), map[string]Node{"a": NewNumber("1")}, nil},
293 {"MapUseNode", NewObject([]Pair{{"a", NewNumber("1")}}), map[string]Node{"a": NewNumber("1")}, nil},
294 {"MapUseNumber", Node{}, map[string]interface{}(nil), ErrUnsupportType},
295 {"MapUseNumber", NewAny(map[string]interface{}{"a": 1}), map[string]interface{}{"a": 1}, nil},
296 {"MapUseNumber", NewObject([]Pair{{"a", NewNumber("1")}}), map[string]interface{}{"a": json.Number("1")}, nil},
297 {"Array", Node{}, []interface{}(nil), ErrUnsupportType},
298 {"Array", NewAny([]interface{}{1}), []interface{}{1}, nil},
299 {"Array", NewArray([]Node{NewNumber("1")}), []interface{}{float64(1.0)}, nil},
300 {"ArrayUseNode", Node{}, []Node(nil), ErrUnsupportType},
301 {"ArrayUseNode", NewAny([]interface{}{1}), []Node(nil), ErrUnsupportType},
302 {"ArrayUseNode", NewAny([]Node{NewNumber("1")}), []Node{NewNumber("1")}, nil},
303 {"ArrayUseNode", NewArray([]Node{NewNumber("1")}), []Node{NewNumber("1")}, nil},
304 {"ArrayUseNumber", Node{}, []interface{}(nil), ErrUnsupportType},
305 {"ArrayUseNumber", NewAny([]interface{}{1}), []interface{}{1}, nil},
306 {"ArrayUseNumber", NewAny([]Node{NewNumber("1")}), []interface{}(nil), ErrUnsupportType},
307 {"ArrayUseNumber", NewArray([]Node{NewNumber("1")}), []interface{}{json.Number("1")}, nil},
308 {"Raw", Node{}, "", ErrNotExist},
309 {"Raw", NewRaw(" "), "", nonEmptyErr},
310 {"Raw", NewRaw(" [ ] "), "[ ]", nil},
311 {"Raw", NewRaw("[ ]"), "[ ]", nil},
312 {"Raw", NewRaw(` { "a" : [ true, -1.2e34 ] } `), `{ "a" : [ true, -1.2e34 ] }`, nil},
313 {"Raw", NewRaw(` { "a" : [ true, -1.2e34 ] `), "", nonEmptyErr},
314 {"Raw", NewRaw(` { "a" : [ true, -1.2e34 }`), "", nonEmptyErr},
315 {"Raw", NewBool(true), "true", nil},
316 {"Raw", NewNumber("-0.0"), "-0.0", nil},
317 {"Raw", NewString(""), `""`, nil},
318 {"Raw", NewBytes([]byte("hello, world")), `"aGVsbG8sIHdvcmxk"`, nil},
319 {"Bool", Node{}, false, ErrUnsupportType},
320 {"Bool", NewAny(true), true, nil},
321 {"Bool", NewAny(false), false, nil},
322 {"Bool", NewAny(int(0)), false, nil},
323 {"Bool", NewAny(int8(1)), true, nil},
324 {"Bool", NewAny(int16(1)), true, nil},
325 {"Bool", NewAny(int32(1)), true, nil},
326 {"Bool", NewAny(int64(1)), true, nil},
327 {"Bool", NewAny(uint(1)), true, nil},
328 {"Bool", NewAny(uint16(1)), true, nil},
329 {"Bool", NewAny(uint32(1)), true, nil},
330 {"Bool", NewAny(uint64(1)), true, nil},
331 {"Bool", NewAny(float64(0)), false, nil},
332 {"Bool", NewAny(float32(1)), true, nil},
333 {"Bool", NewAny(float64(1)), true, nil},
334 {"Bool", NewAny(json.Number("0")), false, nil},
335 {"Bool", NewAny(json.Number("1")), true, nil},
336 {"Bool", NewAny(json.Number("1.1")), true, nil},
337 {"Bool", NewAny(json.Number("+x1.1")), false, nonEmptyErr},
338 {"Bool", NewAny(string("0")), false, nil},
339 {"Bool", NewAny(string("t")), true, nil},
340 {"Bool", NewAny([]byte{0}), false, nonEmptyErr},
341 {"Bool", NewRaw("true"), true, nil},
342 {"Bool", NewRaw("false"), false, nil},
343 {"Bool", NewRaw("null"), false, nil},
344 {"Bool", NewString(`true`), true, nil},
345 {"Bool", NewString(`false`), false, nil},
346 {"Bool", NewString(``), false, nonEmptyErr},
347 {"Bool", NewNumber("2"), true, nil},
348 {"Bool", NewNumber("-2.1"), true, nil},
349 {"Bool", NewNumber("-x-2.1"), false, nonEmptyErr},
350 {"Int64", NewRaw("true"), int64(1), nil},
351 {"Int64", NewRaw("false"), int64(0), nil},
352 {"Int64", NewRaw("\"1\""), int64(1), nil},
353 {"Int64", NewRaw("\"1.1\""), int64(1), nil},
354 {"Int64", NewRaw("\"1.0\""), int64(1), nil},
355 {"Int64", NewNumber("+x.0"), int64(0), nonEmptyErr},
356 {"Int64", NewAny(false), int64(0), nil},
357 {"Int64", NewAny(true), int64(1), nil},
358 {"Int64", NewAny(int(1)), int64(1), nil},
359 {"Int64", NewAny(int8(1)), int64(1), nil},
360 {"Int64", NewAny(int16(1)), int64(1), nil},
361 {"Int64", NewAny(int32(1)), int64(1), nil},
362 {"Int64", NewAny(int64(1)), int64(1), nil},
363 {"Int64", NewAny(uint(1)), int64(1), nil},
364 {"Int64", NewAny(uint8(1)), int64(1), nil},
365 {"Int64", NewAny(uint32(1)), int64(1), nil},
366 {"Int64", NewAny(uint64(1)), int64(1), nil},
367 {"Int64", NewAny(float32(1)), int64(1), nil},
368 {"Int64", NewAny(float64(1)), int64(1), nil},
369 {"Int64", NewAny("1"), int64(1), nil},
370 {"Int64", NewAny("1.1"), int64(1), nil},
371 {"Int64", NewAny("+1x.1"), int64(0), nonEmptyErr},
372 {"Int64", NewAny(json.Number("1")), int64(1), nil},
373 {"Int64", NewAny(json.Number("1.1")), int64(1), nil},
374 {"Int64", NewAny(json.Number("+1x.1")), int64(0), nonEmptyErr},
375 {"Int64", NewAny([]byte{0}), int64(0), ErrUnsupportType},
376 {"Int64", Node{}, int64(0), ErrUnsupportType},
377 {"Int64", NewRaw("0"), int64(0), nil},
378 {"Int64", NewRaw("null"), int64(0), nil},
379 {"StrictInt64", NewRaw("true"), int64(0), ErrUnsupportType},
380 {"StrictInt64", NewRaw("false"), int64(0), ErrUnsupportType},
381 {"StrictInt64", NewAny(int(0)), int64(0), nil},
382 {"StrictInt64", NewAny(int8(0)), int64(0), nil},
383 {"StrictInt64", NewAny(int16(0)), int64(0), nil},
384 {"StrictInt64", NewAny(int32(0)), int64(0), nil},
385 {"StrictInt64", NewAny(int64(0)), int64(0), nil},
386 {"StrictInt64", NewAny(uint(0)), int64(0), nil},
387 {"StrictInt64", NewAny(uint8(0)), int64(0), nil},
388 {"StrictInt64", NewAny(uint32(0)), int64(0), nil},
389 {"StrictInt64", NewAny(uint64(0)), int64(0), nil},
390 {"StrictInt64", Node{}, int64(0), ErrUnsupportType},
391 {"StrictInt64", NewRaw("0"), int64(0), nil},
392 {"StrictInt64", NewRaw("null"), int64(0), ErrUnsupportType},
393 {"Float64", NewRaw("true"), float64(1), nil},
394 {"Float64", NewRaw("false"), float64(0), nil},
395 {"Float64", NewRaw("\"1.0\""), float64(1.0), nil},
396 {"Float64", NewRaw("\"xx\""), float64(0), nonEmptyErr},
397 {"Float64", Node{}, float64(0), ErrUnsupportType},
398 {"Float64", NewAny(false), float64(0), nil},
399 {"Float64", NewAny(true), float64(1), nil},
400 {"Float64", NewAny(int(1)), float64(1), nil},
401 {"Float64", NewAny(int8(1)), float64(1), nil},
402 {"Float64", NewAny(int16(1)), float64(1), nil},
403 {"Float64", NewAny(int32(1)), float64(1), nil},
404 {"Float64", NewAny(int64(1)), float64(1), nil},
405 {"Float64", NewAny(uint(1)), float64(1), nil},
406 {"Float64", NewAny(uint8(1)), float64(1), nil},
407 {"Float64", NewAny(uint32(1)), float64(1), nil},
408 {"Float64", NewAny(uint64(1)), float64(1), nil},
409 {"Float64", NewAny(float32(1)), float64(1), nil},
410 {"Float64", NewAny(float64(1)), float64(1), nil},
411 {"Float64", NewAny("1.1"), float64(1.1), nil},
412 {"Float64", NewAny("+1x.1"), float64(0), nonEmptyErr},
413 {"Float64", NewAny(json.Number("0")), float64(0), nil},
414 {"Float64", NewAny(json.Number("x")), float64(0), nonEmptyErr},
415 {"Float64", NewAny([]byte{0}), float64(0), ErrUnsupportType},
416 {"Float64", NewRaw("0.0"), float64(0.0), nil},
417 {"Float64", NewRaw("1"), float64(1.0), nil},
418 {"Float64", NewRaw("null"), float64(0.0), nil},
419 {"StrictFloat64", NewRaw("true"), float64(0), ErrUnsupportType},
420 {"StrictFloat64", NewRaw("false"), float64(0), ErrUnsupportType},
421 {"StrictFloat64", Node{}, float64(0), ErrUnsupportType},
422 {"StrictFloat64", NewAny(float32(0)), float64(0), nil},
423 {"StrictFloat64", NewAny(float64(0)), float64(0), nil},
424 {"StrictFloat64", NewRaw("0.0"), float64(0.0), nil},
425 {"StrictFloat64", NewRaw("null"), float64(0.0), ErrUnsupportType},
426 {"Number", Node{}, json.Number(""), ErrUnsupportType},
427 {"Number", NewAny(false), json.Number("0"), nil},
428 {"Number", NewAny(true), json.Number("1"), nil},
429 {"Number", NewAny(int(1)), json.Number("1"), nil},
430 {"Number", NewAny(int8(1)), json.Number("1"), nil},
431 {"Number", NewAny(int16(1)), json.Number("1"), nil},
432 {"Number", NewAny(int32(1)), json.Number("1"), nil},
433 {"Number", NewAny(int64(1)), json.Number("1"), nil},
434 {"Number", NewAny(uint(1)), json.Number("1"), nil},
435 {"Number", NewAny(uint8(1)), json.Number("1"), nil},
436 {"Number", NewAny(uint32(1)), json.Number("1"), nil},
437 {"Number", NewAny(uint64(1)), json.Number("1"), nil},
438 {"Number", NewAny(float32(1)), json.Number("1"), nil},
439 {"Number", NewAny(float64(1)), json.Number("1"), nil},
440 {"Number", NewAny("1.1"), json.Number("1.1"), nil},
441 {"Number", NewAny("+1x.1"), json.Number(""), nonEmptyErr},
442 {"Number", NewAny(json.Number("0")), json.Number("0"), nil},
443 {"Number", NewAny(json.Number("x")), json.Number("x"), nil},
444 {"Number", NewAny(json.Number("+1x.1")), json.Number("+1x.1"), nil},
445 {"Number", NewAny([]byte{0}), json.Number(""), ErrUnsupportType},
446 {"Number", NewRaw("x"), json.Number(""), nonEmptyErr},
447 {"Number", NewRaw("0.0"), json.Number("0.0"), nil},
448 {"Number", NewRaw("\"1\""), json.Number("1"), nil},
449 {"Number", NewRaw("\"1.1\""), json.Number("1.1"), nil},
450 {"Number", NewRaw("\"0.x0\""), json.Number(""), nonEmptyErr},
451 {"Number", NewRaw("{]"), json.Number(""), nonEmptyErr},
452 {"Number", NewRaw("true"), json.Number("1"), nil},
453 {"Number", NewRaw("false"), json.Number("0"), nil},
454 {"Number", NewRaw("null"), json.Number("0"), nil},
455 {"StrictNumber", NewRaw("true"), json.Number(""), ErrUnsupportType},
456 {"StrictNumber", NewRaw("false"), json.Number(""), ErrUnsupportType},
457 {"StrictNumber", Node{}, json.Number(""), ErrUnsupportType},
458 {"StrictNumber", NewAny(json.Number("0")), json.Number("0"), nil},
459 {"StrictNumber", NewRaw("0.0"), json.Number("0.0"), nil},
460 {"StrictNumber", NewRaw("null"), json.Number(""), ErrUnsupportType},
461 {"String", Node{}, "", ErrUnsupportType},
462 {"String", NewAny(`\u263a`), `\u263a`, nil},
463 {"String", NewRaw(`"\u263a"`), `☺`, nil},
464 {"String", NewString(`\u263a`), `\u263a`, nil},
465 {"String", NewRaw(`0.0`), "0.0", nil},
466 {"String", NewRaw(`true`), "true", nil},
467 {"String", NewRaw(`false`), "false", nil},
468 {"String", NewRaw(`null`), "", nil},
469 {"String", NewAny(false), "false", nil},
470 {"String", NewAny(true), "true", nil},
471 {"String", NewAny(int(1)), "1", nil},
472 {"String", NewAny(int8(1)), "1", nil},
473 {"String", NewAny(int16(1)), "1", nil},
474 {"String", NewAny(int32(1)), "1", nil},
475 {"String", NewAny(int64(1)), "1", nil},
476 {"String", NewAny(uint(1)), "1", nil},
477 {"String", NewAny(uint8(1)), "1", nil},
478 {"String", NewAny(uint32(1)), "1", nil},
479 {"String", NewAny(uint64(1)), "1", nil},
480 {"String", NewAny(float32(1)), "1", nil},
481 {"String", NewAny(float64(1)), "1", nil},
482 {"String", NewAny("1.1"), "1.1", nil},
483 {"String", NewAny("+1x.1"), "+1x.1", nil},
484 {"String", NewAny(json.Number("0")), ("0"), nil},
485 {"String", NewAny(json.Number("x")), ("x"), nil},
486 {"String", NewAny([]byte{0}), (""), ErrUnsupportType},
487 {"StrictString", Node{}, "", ErrUnsupportType},
488 {"StrictString", NewAny(`\u263a`), `\u263a`, nil},
489 {"StrictString", NewRaw(`"\u263a"`), `☺`, nil},
490 {"StrictString", NewString(`\u263a`), `\u263a`, nil},
491 {"StrictString", NewRaw(`0.0`), "", ErrUnsupportType},
492 {"StrictString", NewRaw(`true`), "", ErrUnsupportType},
493 {"StrictString", NewRaw(`false`), "", ErrUnsupportType},
494 {"StrictString", NewRaw(`null`), "", ErrUnsupportType},
495 {"Len", Node{}, 0, nil},
496 {"Len", NewAny(0), 0, ErrUnsupportType},
497 {"Len", NewNull(), 0, nil},
498 {"Len", NewRaw(`"1"`), 1, nil},
499 {"Len", NewRaw(`[1]`), 0, nil},
500 {"Len", NewArray([]Node{NewNull()}), 1, nil},
501 {"Len", lazyArray, 0, nil},
502 {"Len", NewRaw(`{"a":1}`), 0, nil},
503 {"Len", lazyObject, 0, nil},
504 {"Cap", Node{}, 0, nil},
505 {"Cap", NewAny(0), 0, ErrUnsupportType},
506 {"Cap", NewNull(), 0, nil},
507 {"Cap", NewRaw(`[1]`), _DEFAULT_NODE_CAP, nil},
508 {"Cap", NewObject([]Pair{{"", NewNull()}}), _DEFAULT_NODE_CAP, nil},
509 {"Cap", NewRaw(`{"a":1}`), _DEFAULT_NODE_CAP, nil},
510 }
511 lazyArray.skipAllIndex()
512 lazyObject.skipAllKey()
513 cases = append(cases,
514 tcase{"Len", lazyArray, 17, nil},
515 tcase{"Len", lazyObject, 17, nil},
516 tcase{"Cap", lazyArray, _DEFAULT_NODE_CAP * 3, nil},
517 tcase{"Cap", lazyObject, _DEFAULT_NODE_CAP * 3, nil},
518 )
519
520 for i, c := range cases {
521 fmt.Println(i, c)
522 rt := reflect.ValueOf(&c.node)
523 m := rt.MethodByName(c.method)
524 rets := m.Call([]reflect.Value{})
525 if len(rets) != 2 {
526 t.Error(i, rets)
527 }
528 if !reflect.DeepEqual(rets[0].Interface(), c.exp) {
529 t.Error(i, rets[0].Interface(), c.exp)
530 }
531 v := rets[1].Interface()
532 if c.err == nonEmptyErr {
533 if reflect.ValueOf(v).IsNil() {
534 t.Error(i, v)
535 }
536 } else if v != c.err {
537 t.Error(i, v)
538 }
539 }
540 }
541
542 func TestCheckError_Nil(t *testing.T) {
543 nill := (*Node)(nil)
544 if nill.Valid() || nill.Check() == nil {
545 t.Fail()
546 }
547 if nill.Get("").Check() == nil {
548 t.Fatal()
549 }
550 if nill.GetByPath("").Check() == nil {
551 t.Fatal()
552 }
553 if nill.Index(1).Check() == nil {
554 t.Fatal()
555 }
556 if nill.IndexOrGet(1, "a").Check() == nil {
557 t.Fatal()
558 }
559 if nill.IndexPair(1) != nil {
560 t.Fatal()
561 }
562 if _, err := nill.Set("", Node{}); err == nil {
563 t.Fatal()
564 }
565 if _, err := nill.SetByIndex(1, Node{}); err == nil {
566 t.Fatal()
567 }
568 if _, err := nill.SetAny("", 1); err == nil {
569 t.Fatal()
570 }
571 if _, err := nill.SetAnyByIndex(1, 1); err == nil {
572 t.Fatal()
573 }
574 if _, err := nill.Unset(""); err == nil {
575 t.Fatal()
576 }
577 if _, err := nill.UnsetByIndex(1); err == nil {
578 t.Fatal()
579 }
580 if err := nill.Add(Node{}); err == nil {
581 t.Fatal()
582 }
583 if err := nill.AddAny(1); err == nil {
584 t.Fatal()
585 }
586 }
587
588 func TestCheckError_None(t *testing.T) {
589 nill := Node{}
590 if !nill.Valid() || nill.Check() != nil {
591 t.Fail()
592 }
593 if nill.Get("").Check() == nil {
594 t.Fatal()
595 }
596 if nill.GetByPath("").Check() == nil {
597 t.Fatal()
598 }
599 if nill.Index(1).Check() == nil {
600 t.Fatal()
601 }
602 if nill.IndexOrGet(1, "a").Check() == nil {
603 t.Fatal()
604 }
605 if nill.IndexPair(1) != nil {
606 t.Fatal()
607 }
608 nill = Node{}
609 if _, err := nill.Set("a", Node{}); err != nil {
610 t.Fatal()
611 }
612 nill = Node{}
613 if _, err := nill.SetByIndex(0, Node{}); err != nil {
614 t.Fatal()
615 }
616 nill = Node{}
617 if _, err := nill.SetByIndex(1, Node{}); err == nil {
618 t.Fatal()
619 }
620 nill = Node{}
621 if _, err := nill.SetAny("a", 1); err != nil {
622 t.Fatal()
623 }
624 nill = Node{}
625 if _, err := nill.SetAnyByIndex(0, 1); err != nil {
626 t.Fatal()
627 }
628 nill = Node{}
629 if _, err := nill.SetAnyByIndex(1, 1); err == nil {
630 t.Fatal()
631 }
632 nill = Node{}
633 if _, err := nill.Unset(""); err == nil {
634 t.Fatal()
635 }
636 nill = Node{}
637 if _, err := nill.UnsetByIndex(1); err == nil {
638 t.Fatal()
639 }
640 nill = Node{}
641 if err := nill.Add(Node{}); err != nil {
642 t.Fatal()
643 }
644 nill = Node{}
645 if err := nill.AddAny(1); err != nil {
646 t.Fatal()
647 }
648 }
649
650 func TestCheckError_Error(t *testing.T) {
651 nill := newError(types.ERR_EOF, "")
652 if nill.Valid() || nill.Check() == nil {
653 t.Fail()
654 }
655 if nill.Get("").Check() == nil {
656 t.Fatal()
657 }
658 if nill.GetByPath("").Check() == nil {
659 t.Fatal()
660 }
661 if nill.Index(1).Check() == nil {
662 t.Fatal()
663 }
664 if nill.IndexOrGet(1, "a").Check() == nil {
665 t.Fatal()
666 }
667 if nill.IndexPair(1) != nil {
668 t.Fatal()
669 }
670 if _, err := nill.Set("", Node{}); err == nil {
671 t.Fatal()
672 }
673 if _, err := nill.SetByIndex(1, Node{}); err == nil {
674 t.Fatal()
675 }
676 if _, err := nill.SetAny("", 1); err == nil {
677 t.Fatal()
678 }
679 if _, err := nill.SetAnyByIndex(1, 1); err == nil {
680 t.Fatal()
681 }
682 if _, err := nill.Unset(""); err == nil {
683 t.Fatal()
684 }
685 if _, err := nill.UnsetByIndex(1); err == nil {
686 t.Fatal()
687 }
688 if err := nill.Add(Node{}); err == nil {
689 t.Fatal()
690 }
691 if err := nill.AddAny(1); err == nil {
692 t.Fatal()
693 }
694 }
695
696 func TestCheckError_Empty(t *testing.T) {
697 empty := Node{}
698 if !empty.Valid() || empty.Check() != nil || empty.Error() != "" {
699 t.Fatal()
700 }
701
702 n := newRawNode("[hello]", types.V_ARRAY)
703 n.parseRaw(false)
704 if n.Check() != nil {
705 t.Fatal(n.Check())
706 }
707 n = newRawNode("[hello]", types.V_ARRAY)
708 n.parseRaw(true)
709 p := NewParser("[hello]")
710 p.noLazy = true
711 p.skipValue = false
712 _, x := p.Parse()
713 if n.Error() != newSyntaxError(p.syntaxError(x)).Error() {
714 t.Fatal(n.Check())
715 }
716
717 s, err := NewParser(`{"a":{}, "b":talse, "c":{}}`).Parse()
718 if err != 0 {
719 t.Fatal(err)
720 }
721
722 root := s.GetByPath()
723
724 a := root.Get("a")
725 if a.Check() != nil {
726 t.Fatal(a.Check())
727 }
728 c := root.Get("c")
729 if c.Check() == nil {
730 t.Fatal()
731 }
732 fmt.Println(c.Check())
733
734 _, e := a.Properties()
735 if e != nil {
736 t.Fatal(e)
737 }
738 exist, e := a.Set("d", newRawNode("x", types.V_OBJECT))
739 if exist || e != nil {
740 t.Fatal(err)
741 }
742 if a.len() != 1 {
743 t.Fail()
744 }
745 d := a.Get("d").Get("")
746 if d.Check() == nil {
747 t.Fatal(d)
748 }
749 exist, e = a.Set("e", newRawNode("[}", types.V_ARRAY))
750 if e != nil {
751 t.Fatal(e)
752 }
753 if a.len() != 2 {
754 t.Fail()
755 }
756 d = a.Index(1).Index(0)
757 if d.Check() == nil {
758 t.Fatal(d)
759 }
760
761 it, e := root.Interface()
762 if e == nil {
763 t.Fatal(it)
764 }
765 fmt.Println(e)
766 }
767
768 func TestIndex(t *testing.T) {
769 root, derr := NewParser(_TwitterJson).Parse()
770 if derr != 0 {
771 t.Fatalf("decode failed: %v", derr.Error())
772 }
773 status := root.GetByPath("statuses", 0)
774 x, _ := status.Index(4).String()
775 y, _ := status.Get("id_str").String()
776 if x != y {
777 t.Fail()
778 }
779 }
780
781 func TestUnset(t *testing.T) {
782 root, derr := NewParser(_TwitterJson).Parse()
783 if derr != 0 {
784 t.Fatalf("decode failed: %v", derr.Error())
785 }
786 entities := root.GetByPath("statuses", 0, "entities")
787 if !entities.Exists() || entities.Check() != nil {
788 t.Fatal(entities.Check().Error())
789 }
790 exist, err := entities.Unset("urls")
791 if !exist || err != nil {
792 t.Fatal()
793 }
794 e := entities.Get("urls")
795 if e.Exists() {
796 t.Fatal()
797 }
798 if entities.len() != 2 {
799 t.Fatal(entities.len())
800 }
801
802 es, err := entities.Interface()
803 require.NoError(t, err)
804 require.Equal(t, map[string]interface{}{
805 "hashtags": []interface{}{
806 map[string]interface{}{
807 "text": "freebandnames",
808 "indices": []interface{}{
809 float64(20), float64(34),
810 },
811 },
812 },
813 "user_mentions": []interface{}{},
814 }, es)
815
816 out, err := entities.MarshalJSON()
817 require.NoError(t, err)
818 println(string(out))
819 buf := bytes.NewBuffer(nil)
820 require.NoError(t, json.Compact(buf, out))
821 require.Equal(t,
822 `{"hashtags":[{"text":"freebandnames","indices":[20,34]}],"user_mentions":[]}`, buf.String())
823
824 entities.Set("urls", NewString("a"))
825 e = entities.Get("urls")
826 x, _ := e.String()
827 if !e.Exists() || x != "a" {
828 t.Fatal()
829 }
830
831 out, err = entities.MarshalJSON()
832 require.NoError(t, err)
833 buf = bytes.NewBuffer(nil)
834 json.Compact(buf, out)
835 require.Equal(t,
836 `{"hashtags":[{"text":"freebandnames","indices":[20,34]}],"user_mentions":[],"urls":"a"}`, buf.String())
837
838
839 *entities = NewRaw(string(out))
840
841 hashtags := entities.Get("hashtags").Index(0)
842 hashtags.Set("text2", newRawNode(`{}`, types.V_OBJECT))
843 exist, err = hashtags.Unset("indices")
844 if !exist || err != nil || hashtags.len() != 2 {
845 t.Fatal(hashtags.len())
846 }
847 y, _ := hashtags.Get("text").String()
848 if y != "freebandnames" {
849 t.Fatal()
850 }
851 if hashtags.Get("text2").Type() != V_OBJECT {
852 t.Fatal()
853 }
854
855 entities.Load()
856 exist, err = entities.UnsetByIndex(entities.len() - 1)
857 if !exist || err != nil {
858 t.Fatal()
859 }
860 if entities.len() != 2 {
861 t.Fatal(entities.len())
862 }
863 e = entities.Index(entities.len())
864 if e.Exists() {
865 t.Fatal()
866 }
867
868 ums := entities.Get("user_mentions")
869 ums.Add(NewNull())
870 ums.Add(NewBool(false))
871 ums.Add(NewBool(true))
872 if ums.len() != 3 {
873 t.Fatal()
874 }
875 exist, err = ums.UnsetByIndex(1)
876 if !exist || err != nil {
877 t.Fatal()
878 }
879 require.Equal(t, 2, ums.len())
880 umses, err := ums.Interface()
881 require.NoError(t, err)
882 require.Equal(t, []interface{}{interface{}(nil), true}, umses)
883
884 v1, _ := ums.Index(0).Interface()
885 v2, _ := ums.Index(1).Interface()
886 v3, _ := ums.Index(2).Interface()
887 if v1 != nil {
888 t.Fatal()
889 }
890 if v2 != true {
891 t.Fatal()
892 }
893 if v3 != nil {
894 t.Fatal()
895 }
896 out, err = entities.MarshalJSON()
897 require.NoError(t, err)
898 require.Equal(t,
899 `{"hashtags":[{"text":"freebandnames","text2":{}}],"user_mentions":[null,true]}`, string(out))
900
901 }
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942 func TestUseNode(t *testing.T) {
943 str, loop := getTestIteratorSample(_DEFAULT_NODE_CAP)
944 root, e := NewParser(str).Parse()
945 if e != 0 {
946 t.Fatal(e)
947 }
948 _, er := root.InterfaceUseNode()
949 if er != nil {
950 t.Fatal(er)
951 }
952
953 root, err := NewSearcher(str).GetByPath("array")
954 if err != nil {
955 t.Fatal(err)
956 }
957 a, _ := root.ArrayUseNode()
958 if len(a) != loop {
959 t.Fatalf("exp:%v, got:%v", loop, len(a))
960 }
961 for i := int64(0); i < int64(loop); i++ {
962 in := a[i]
963 a, _ := in.Int64()
964 if a != i {
965 t.Fatalf("exp:%v, got:%v", i, a)
966 }
967 }
968
969 root, err = NewSearcher(str).GetByPath("array")
970 if err != nil {
971 t.Fatal(err)
972 }
973 x, _ := root.InterfaceUseNode()
974 a = x.([]Node)
975 if len(a) != loop {
976 t.Fatalf("exp:%v, got:%v", loop, len(a))
977 }
978 for i := int64(0); i < int64(loop); i++ {
979 in := a[i]
980 a, _ := in.Int64()
981 if a != i {
982 t.Fatalf("exp:%v, got:%v", i, a)
983 }
984 }
985
986 root, err = NewSearcher(str).GetByPath("object")
987 if err != nil {
988 t.Fatal(err)
989 }
990 b, _ := root.MapUseNode()
991 if len(b) != loop {
992 t.Fatalf("exp:%v, got:%v", loop, len(b))
993 }
994 for i := int64(0); i < int64(loop); i++ {
995 k := `k` + strconv.Itoa(int(i))
996 xn, ok := b[k]
997 if !ok {
998 t.Fatalf("unexpected element: %#v", xn)
999 }
1000 a, _ := xn.Int64()
1001 if a != i {
1002 t.Fatalf("exp:%v, got:%v", i, a)
1003 }
1004 }
1005
1006 root, err = NewSearcher(str).GetByPath("object")
1007 if err != nil {
1008 t.Fatal(err)
1009 }
1010 x, _ = root.InterfaceUseNode()
1011 b = x.(map[string]Node)
1012 if len(b) != loop {
1013 t.Fatalf("exp:%v, got:%v", loop, len(b))
1014 }
1015 for i := int64(0); i < int64(loop); i++ {
1016 k := `k` + strconv.Itoa(int(i))
1017 xn, ok := b[k]
1018 if !ok {
1019 t.Fatalf("unexpected element: %#v", xn)
1020 }
1021 a, _ := xn.Int64()
1022 if a != i {
1023 t.Fatalf("exp:%v, got:%v", i, a)
1024 }
1025 }
1026 }
1027
1028 func TestUseNumber(t *testing.T) {
1029 str, _ := getTestIteratorSample(_DEFAULT_NODE_CAP)
1030 root, e := NewParser(str).Parse()
1031 if e != 0 {
1032 t.Fatal(e)
1033 }
1034 _, er := root.InterfaceUseNumber()
1035 if er != nil {
1036 t.Fatal(er)
1037 }
1038
1039 node, err := NewParser("1061346755812312312313").Parse()
1040 if err != 0 {
1041 t.Fatal(err)
1042 }
1043 if node.Type() != V_NUMBER {
1044 t.Fatalf("wrong type: %v", node.Type())
1045 }
1046 x, _ := node.InterfaceUseNumber()
1047 iv := x.(json.Number)
1048 if iv.String() != "1061346755812312312313" {
1049 t.Fatalf("exp:%#v, got:%#v", "1061346755812312312313", iv.String())
1050 }
1051 x, _ = node.Interface()
1052 ix := x.(float64)
1053 if ix != float64(1061346755812312312313) {
1054 t.Fatalf("exp:%#v, got:%#v", float64(1061346755812312312313), ix)
1055 }
1056 xj, _ := node.Number()
1057 ij, _ := xj.Int64()
1058 jj, _ := json.Number("1061346755812312312313").Int64()
1059 if ij != jj {
1060 t.Fatalf("exp:%#v, got:%#v", jj, ij)
1061 }
1062 }
1063
1064 func TestMap(t *testing.T) {
1065 node, err := NewParser(`{"a":-0, "b":1, "c":-1.2, "d":-1.2e-10}`).Parse()
1066 if err != 0 {
1067 t.Fatal(err)
1068 }
1069 m, _ := node.Map()
1070 assert.Equal(t, m, map[string]interface{}{
1071 "a": float64(0),
1072 "b": float64(1),
1073 "c": -1.2,
1074 "d": -1.2e-10,
1075 })
1076 m1, _ := node.MapUseNumber()
1077 assert.Equal(t, m1, map[string]interface{}{
1078 "a": json.Number("-0"),
1079 "b": json.Number("1"),
1080 "c": json.Number("-1.2"),
1081 "d": json.Number("-1.2e-10"),
1082 })
1083 }
1084
1085 func TestArray(t *testing.T) {
1086 node, err := NewParser(`[-0, 1, -1.2, -1.2e-10]`).Parse()
1087 if err != 0 {
1088 t.Fatal(err)
1089 }
1090 m, _ := node.Array()
1091 assert.Equal(t, m, []interface{}{
1092 float64(0),
1093 float64(1),
1094 -1.2,
1095 -1.2e-10,
1096 })
1097 m1, _ := node.ArrayUseNumber()
1098 assert.Equal(t, m1, []interface{}{
1099 json.Number("-0"),
1100 json.Number("1"),
1101 json.Number("-1.2"),
1102 json.Number("-1.2e-10"),
1103 })
1104 }
1105
1106 func TestNodeRaw(t *testing.T) {
1107 root, derr := NewSearcher(_TwitterJson).GetByPath("search_metadata")
1108 if derr != nil {
1109 t.Fatalf("decode failed: %v", derr.Error())
1110 }
1111 val, _ := root.Raw()
1112 var comp = `{
1113 "max_id": 250126199840518145,
1114 "since_id": 24012619984051000,
1115 "refresh_url": "?since_id=250126199840518145&q=%23freebandnames&result_type=mixed&include_entities=1",
1116 "next_results": "?max_id=249279667666817023&q=%23freebandnames&count=4&include_entities=1&result_type=mixed",
1117 "count": 4,
1118 "completed_in": 0.035,
1119 "since_id_str": "24012619984051000",
1120 "query": "%23freebandnames",
1121 "max_id_str": "250126199840518145"
1122 }`
1123 if val != comp {
1124 t.Fatalf("exp: %+v, got: %+v", comp, val)
1125 }
1126
1127 root, derr = NewSearcher(_TwitterJson).GetByPath("statuses", 0, "entities", "hashtags")
1128 if derr != nil {
1129 t.Fatalf("decode failed: %v", derr.Error())
1130 }
1131 val, _ = root.Raw()
1132 comp = `[
1133 {
1134 "text": "freebandnames",
1135 "indices": [
1136 20,
1137 34
1138 ]
1139 }
1140 ]`
1141 if val != comp {
1142 t.Fatalf("exp: \n%s\n, got: \n%s\n", comp, val)
1143 }
1144
1145 var data = `{"k1" : { "a" : "bc"} , "k2" : [1,2 ] , "k3":{} , "k4":[]}`
1146 root, derr = NewSearcher(data).GetByPath("k1")
1147 if derr != nil {
1148 t.Fatalf("decode failed: %v", derr.Error())
1149 }
1150 val, _ = root.Raw()
1151 comp = `{ "a" : "bc"}`
1152 if val != comp {
1153 t.Fatalf("exp: %+v, got: %+v", comp, val)
1154 }
1155
1156 root, derr = NewSearcher(data).GetByPath("k2")
1157 if derr != nil {
1158 t.Fatalf("decode failed: %v", derr.Error())
1159 }
1160 val, _ = root.Raw()
1161 comp = `[1,2 ]`
1162 if val != comp {
1163 t.Fatalf("exp: %+v, got: %+v", comp, val)
1164 }
1165
1166 root, derr = NewSearcher(data).GetByPath("k3")
1167 if derr != nil {
1168 t.Fatalf("decode failed: %v", derr.Error())
1169 }
1170 val, _ = root.Raw()
1171 comp = `{}`
1172 if val != comp {
1173 t.Fatalf("exp: %+v, got: %+v", comp, val)
1174 }
1175
1176 root, derr = NewSearcher(data).GetByPath("k4")
1177 if derr != nil {
1178 t.Fatalf("decode failed: %v", derr.Error())
1179 }
1180 val, _ = root.Raw()
1181 comp = `[]`
1182 if val != comp {
1183 t.Fatalf("exp: %+v, got: %+v", comp, val)
1184 }
1185 }
1186
1187 func TestNodeGet(t *testing.T) {
1188 root, derr := NewParser(_TwitterJson).Parse()
1189 if derr != 0 {
1190 t.Fatalf("decode failed: %v", derr.Error())
1191 }
1192 val, _ := root.Get("search_metadata").Get("max_id").Int64()
1193 if val != int64(250126199840518145) {
1194 t.Fatalf("exp: %+v, got: %+v", 250126199840518145, val)
1195 }
1196 }
1197
1198 func TestNodeIndex(t *testing.T) {
1199 root, derr := NewParser(_TwitterJson).Parse()
1200 if derr != 0 {
1201 t.Fatalf("decode failed: %v", derr.Error())
1202 }
1203 val, _ := root.Get("statuses").Index(3).Get("id_str").String()
1204 if val != "249279667666817024" {
1205 t.Fatalf("exp: %+v, got: %+v", "249279667666817024", val)
1206 }
1207 }
1208
1209 func TestNodeGetByPath(t *testing.T) {
1210 root, derr := NewParser(_TwitterJson).Parse()
1211 if derr != 0 {
1212 t.Fatalf("decode failed: %v", derr.Error())
1213 }
1214 val, _ := root.GetByPath("statuses", 3, "id_str").String()
1215 if val != "249279667666817024" {
1216 t.Fatalf("exp: %+v, got: %+v", "249279667666817024", val)
1217 }
1218 }
1219
1220 func TestNodeSet(t *testing.T) {
1221 arr := NewRaw(`[]`)
1222 ex, ee := arr.Set("a", NewNumber("-1"))
1223 if ex || ee == nil {
1224 t.Fatal()
1225 }
1226 empty := Node{}
1227 err := empty.Add(Node{})
1228 if err != nil {
1229 t.Fatal(err)
1230 }
1231 empty2 := empty.Index(0)
1232 if empty2.Check() != nil {
1233 t.Fatal(err)
1234 }
1235 exist, err := empty2.SetByIndex(1, Node{})
1236 if exist || err == nil {
1237 t.Fatal(exist, err)
1238 }
1239 empty3 := empty.Index(0)
1240 if empty3.Check() != nil {
1241 t.Fatal(err)
1242 }
1243 exist, err = empty3.Set("a", NewNumber("-1"))
1244 if exist || err != nil {
1245 t.Fatal(exist, err)
1246 }
1247 if n, e := empty.Index(0).Get("a").Int64(); e != nil || n != -1 {
1248 t.Fatal(n, e)
1249 }
1250
1251 empty = NewNull()
1252 err = empty.Add(NewNull())
1253 if err != nil {
1254 t.Fatal(err)
1255 }
1256 empty2 = empty.Index(0)
1257 if empty2.Check() != nil {
1258 t.Fatal(err)
1259 }
1260 exist, err = empty2.SetByIndex(1, NewNull())
1261 if exist || err == nil {
1262 t.Fatal(exist, err)
1263 }
1264 empty3 = empty.Index(0)
1265 if empty3.Check() != nil {
1266 t.Fatal(err)
1267 }
1268 exist, err = empty3.Set("a", NewNumber("-1"))
1269 if exist || err != nil {
1270 t.Fatal(exist, err)
1271 }
1272 if n, e := empty.Index(0).Get("a").Int64(); e != nil || n != -1 {
1273 t.Fatal(n, e)
1274 }
1275
1276 root, derr := NewParser(_TwitterJson).Parse()
1277 if derr != 0 {
1278 t.Fatalf("decode failed: %v", derr.Error())
1279 }
1280 app, _ := NewParser("111").Parse()
1281 root.GetByPath("statuses", 3).Set("id_str", app)
1282 val, _ := root.GetByPath("statuses", 3, "id_str").Int64()
1283 if val != 111 {
1284 t.Fatalf("exp: %+v, got: %+v", 111, val)
1285 }
1286 for i, _ := root.GetByPath("statuses", 3).Cap(); i >= 0; i-- {
1287 root.GetByPath("statuses", 3).Set("id_str"+strconv.Itoa(i), app)
1288 }
1289 val, _ = root.GetByPath("statuses", 3, "id_str0").Int64()
1290 if val != 111 {
1291 t.Fatalf("exp: %+v, got: %+v", 111, val)
1292 }
1293
1294 nroot, derr := NewParser(`{"a":[0.1,true,0,"name",{"b":"c"}]}`).Parse()
1295 if derr != 0 {
1296 t.Fatalf("decode failed: %v", derr.Error())
1297 }
1298 root.GetByPath("statuses", 3).Set("id_str2", nroot)
1299 val2, _ := root.GetByPath("statuses", 3, "id_str2", "a", 4, "b").String()
1300 if val2 != "c" {
1301 t.Fatalf("exp:%+v, got:%+v", "c", val2)
1302 }
1303 }
1304
1305 func TestNodeSetByIndex(t *testing.T) {
1306 root, derr := NewParser(_TwitterJson).Parse()
1307 if derr != 0 {
1308 t.Fatalf("decode failed: %v", derr.Error())
1309 }
1310 app, _ := NewParser("111").Parse()
1311 st := root.GetByPath("statuses")
1312 st.SetByIndex(0, app)
1313 st = root.GetByPath("statuses")
1314 val := st.Index(0)
1315 x, _ := val.Int64()
1316 if x != 111 {
1317 t.Fatalf("exp: %+v, got: %+v", 111, val)
1318 }
1319
1320 nroot, derr := NewParser(`{"a":[0.1,true,0,"name",{"b":"c"}]}`).Parse()
1321 if derr != 0 {
1322 t.Fatalf("decode failed: %v", derr.Error())
1323 }
1324 root.GetByPath("statuses").SetByIndex(0, nroot)
1325 val2, _ := root.GetByPath("statuses", 0, "a", 4, "b").String()
1326 if val2 != "c" {
1327 t.Fatalf("exp:%+v, got:%+v", "c", val2)
1328 }
1329 }
1330
1331 func TestNodeAdd(t *testing.T) {
1332 root, derr := NewParser(_TwitterJson).Parse()
1333 if derr != 0 {
1334 t.Fatalf("decode failed: %v", derr.Error())
1335 }
1336 app, _ := NewParser("111").Parse()
1337
1338 for i, _ := root.GetByPath("statuses").Cap(); i >= 0; i-- {
1339 root.GetByPath("statuses").Add(app)
1340 }
1341 val, _ := root.GetByPath("statuses", 4).Int64()
1342 if val != 111 {
1343 t.Fatalf("exp: %+v, got: %+v", 111, val)
1344 }
1345 val, _ = root.GetByPath("statuses", root.GetByPath("statuses").len()-1).Int64()
1346 if val != 111 {
1347 t.Fatalf("exp: %+v, got: %+v", 111, val)
1348 }
1349
1350 nroot, derr := NewParser(`{"a":[0.1,true,0,"name",{"b":"c"}]}`).Parse()
1351 if derr != 0 {
1352 t.Fatalf("decode failed: %v", derr.Error())
1353 }
1354 root.GetByPath("statuses").Add(nroot)
1355 val2, _ := root.GetByPath("statuses", root.GetByPath("statuses").len()-1, "a", 4, "b").String()
1356 if val2 != "c" {
1357 t.Fatalf("exp:%+v, got:%+v", "c", val2)
1358 }
1359 }
1360
1361 func BenchmarkLoadNode(b *testing.B) {
1362 b.Run("Interface()", func(b *testing.B) {
1363 b.SetBytes(int64(len(_TwitterJson)))
1364 b.ResetTimer()
1365 for i := 0; i < b.N; i++ {
1366 root, err := NewSearcher(_TwitterJson).GetByPath("statuses", 0)
1367 if err != nil {
1368 b.Fatal(err)
1369 }
1370 _, _ = root.Interface()
1371 }
1372 })
1373
1374 b.Run("LoadAll()", func(b *testing.B) {
1375 b.SetBytes(int64(len(_TwitterJson)))
1376 b.ResetTimer()
1377 for i := 0; i < b.N; i++ {
1378 root, err := NewSearcher(_TwitterJson).GetByPath("statuses", 0)
1379 if err != nil {
1380 b.Fatal(err)
1381 }
1382 _ = root.LoadAll()
1383 }
1384 })
1385
1386 b.Run("InterfaceUseNode()", func(b *testing.B) {
1387 b.SetBytes(int64(len(_TwitterJson)))
1388 b.ResetTimer()
1389 for i := 0; i < b.N; i++ {
1390 root, err := NewSearcher(_TwitterJson).GetByPath("statuses", 0)
1391 if err != nil {
1392 b.Fatal(err)
1393 }
1394 _, _ = root.InterfaceUseNode()
1395 }
1396 })
1397
1398 b.Run("Load()", func(b *testing.B) {
1399 b.SetBytes(int64(len(_TwitterJson)))
1400 b.ResetTimer()
1401 for i := 0; i < b.N; i++ {
1402 root, err := NewSearcher(_TwitterJson).GetByPath("statuses", 0)
1403 if err != nil {
1404 b.Fatal(err)
1405 }
1406 _ = root.Load()
1407 }
1408 })
1409 }
1410
1411 func BenchmarkLoadNode_Parallel(b *testing.B) {
1412 b.Run("Interface()", func(b *testing.B) {
1413 b.SetBytes(int64(len(_TwitterJson)))
1414 b.ResetTimer()
1415 b.RunParallel(func(pb *testing.PB) {
1416 for pb.Next() {
1417 root, err := NewSearcher(_TwitterJson).GetByPath("statuses", 0)
1418 if err != nil {
1419 b.Fatal(err)
1420 }
1421 _, _ = root.Interface()
1422 }
1423 })
1424 })
1425
1426 b.Run("LoadAll()", func(b *testing.B) {
1427 b.SetBytes(int64(len(_TwitterJson)))
1428 b.ResetTimer()
1429 b.RunParallel(func(pb *testing.PB) {
1430 for pb.Next() {
1431 root, err := NewSearcher(_TwitterJson).GetByPath("statuses", 0)
1432 if err != nil {
1433 b.Fatal(err)
1434 }
1435 _ = root.LoadAll()
1436 }
1437 })
1438 })
1439
1440 b.Run("InterfaceUseNode()", func(b *testing.B) {
1441 b.SetBytes(int64(len(_TwitterJson)))
1442 b.ResetTimer()
1443 b.RunParallel(func(pb *testing.PB) {
1444 for pb.Next() {
1445 root, err := NewSearcher(_TwitterJson).GetByPath("statuses", 0)
1446 if err != nil {
1447 b.Fatal(err)
1448 }
1449 _, _ = root.InterfaceUseNode()
1450 }
1451 })
1452 })
1453
1454 b.Run("Load()", func(b *testing.B) {
1455 b.SetBytes(int64(len(_TwitterJson)))
1456 b.ResetTimer()
1457 b.RunParallel(func(pb *testing.PB) {
1458 for pb.Next() {
1459 root, err := NewSearcher(_TwitterJson).GetByPath("statuses", 0)
1460 if err != nil {
1461 b.Fatal(err)
1462 }
1463 _ = root.Load()
1464 }
1465 })
1466 })
1467 }
1468
1469 func BenchmarkNodeGetByPath(b *testing.B) {
1470 root, derr := NewParser(_TwitterJson).Parse()
1471 if derr != 0 {
1472 b.Fatalf("decode failed: %v", derr.Error())
1473 }
1474 _, _ = root.GetByPath("statuses", 3, "entities", "hashtags", 0, "text").String()
1475 b.ResetTimer()
1476
1477 b.RunParallel(func(pb *testing.PB) {
1478 for pb.Next() {
1479 _, _ = root.GetByPath("statuses", 3, "entities", "hashtags", 0, "text").String()
1480 }
1481 })
1482 }
1483
1484 func BenchmarkStructGetByPath(b *testing.B) {
1485 var root = _TwitterStruct{}
1486 err := json.Unmarshal([]byte(_TwitterJson), &root)
1487 if err != nil {
1488 b.Fatalf("unmarshal failed: %v", err)
1489 }
1490
1491 b.ResetTimer()
1492
1493 b.RunParallel(func(pb *testing.PB) {
1494 for pb.Next() {
1495 _ = root.Statuses[3].Entities.Hashtags[0].Text
1496 }
1497 })
1498 }
1499
1500 func BenchmarkNodeIndex(b *testing.B) {
1501 root, derr := NewParser(_TwitterJson).Parse()
1502 if derr != 0 {
1503 b.Fatalf("decode failed: %v", derr.Error())
1504 }
1505 node := root.Get("statuses").Index(3).Get("entities").Get("hashtags").Index(0)
1506 node.Set("test1", NewNumber("1"))
1507 node.Set("test2", NewNumber("2"))
1508 node.Set("test3", NewNumber("3"))
1509 node.Set("test4", NewNumber("4"))
1510 node.Set("test5", NewNumber("5"))
1511 b.ResetTimer()
1512 for i := 0; i < b.N; i++ {
1513 node.Index(2)
1514 }
1515 }
1516
1517 func BenchmarkStructIndex(b *testing.B) {
1518 type T struct {
1519 A Node
1520 B Node
1521 C Node
1522 D Node
1523 E Node
1524 }
1525 var obj = new(T)
1526 b.ResetTimer()
1527 for i := 0; i < b.N; i++ {
1528 _ = obj.C
1529 }
1530 }
1531
1532 func BenchmarkSliceIndex(b *testing.B) {
1533 var obj = []Node{Node{}, Node{}, Node{}, Node{}, Node{}}
1534 b.ResetTimer()
1535 for i := 0; i < b.N; i++ {
1536 _ = obj[2]
1537 }
1538 }
1539
1540 func BenchmarkMapIndex(b *testing.B) {
1541 var obj = map[string]interface{}{"test1": Node{}, "test2": Node{}, "test3": Node{}, "test4": Node{}, "test5": Node{}}
1542 b.ResetTimer()
1543 for i := 0; i < b.N; i++ {
1544 for k := range obj {
1545 if k == "test3" {
1546 break
1547 }
1548 }
1549 }
1550 }
1551
1552 func BenchmarkNodeGet(b *testing.B) {
1553 var N = 5
1554 var half = "test" + strconv.Itoa(N/2+1)
1555 root, derr := NewParser(_TwitterJson).Parse()
1556 if derr != 0 {
1557 b.Fatalf("decode failed: %v", derr.Error())
1558 }
1559 node := root.Get("statuses").Index(3).Get("entities").Get("hashtags").Index(0)
1560 for i := 0; i < N; i++ {
1561 node.Set("test"+strconv.Itoa(i), NewNumber(strconv.Itoa(i)))
1562 }
1563
1564 b.ResetTimer()
1565 for i := 0; i < b.N; i++ {
1566 _ = node.Get(half)
1567 }
1568 }
1569
1570 func BenchmarkSliceGet(b *testing.B) {
1571 var obj = []string{"test1", "test2", "test3", "test4", "test5"}
1572 str := "test3"
1573 b.ResetTimer()
1574 for i := 0; i < b.N; i++ {
1575 for _, k := range obj {
1576 if k == str {
1577 break
1578 }
1579 }
1580 }
1581 }
1582
1583 func BenchmarkMapGet(b *testing.B) {
1584 root, derr := NewParser(_TwitterJson).Parse()
1585 if derr != 0 {
1586 b.Fatalf("decode failed: %v", derr.Error())
1587 }
1588 node := root.Get("statuses").Index(3).Get("entities").Get("hashtags").Index(0)
1589 node.Set("test1", NewNumber("1"))
1590 node.Set("test2", NewNumber("2"))
1591 node.Set("test3", NewNumber("3"))
1592 node.Set("test4", NewNumber("4"))
1593 node.Set("test5", NewNumber("5"))
1594 m, _ := node.Map()
1595 b.ResetTimer()
1596 for i := 0; i < b.N; i++ {
1597 _ = m["test3"]
1598 }
1599 }
1600
1601 func BenchmarkNodeSet(b *testing.B) {
1602 root, derr := NewParser(_TwitterJson).Parse()
1603 if derr != 0 {
1604 b.Fatalf("decode failed: %v", derr.Error())
1605 }
1606 node := root.Get("statuses").Index(3).Get("entities").Get("hashtags").Index(0)
1607 node.Set("test1", NewNumber("1"))
1608 node.Set("test2", NewNumber("2"))
1609 node.Set("test3", NewNumber("3"))
1610 node.Set("test4", NewNumber("4"))
1611 node.Set("test5", NewNumber("5"))
1612 n := NewNull()
1613 b.ResetTimer()
1614 for i := 0; i < b.N; i++ {
1615 node.Set("test3", n)
1616 }
1617 }
1618
1619 func BenchmarkMapSet(b *testing.B) {
1620 root, derr := NewParser(_TwitterJson).Parse()
1621 if derr != 0 {
1622 b.Fatalf("decode failed: %v", derr.Error())
1623 }
1624 node := root.Get("statuses").Index(3).Get("entities").Get("hashtags").Index(0)
1625 node.Set("test1", NewNumber("1"))
1626 node.Set("test2", NewNumber("2"))
1627 node.Set("test3", NewNumber("3"))
1628 node.Set("test4", NewNumber("4"))
1629 node.Set("test5", NewNumber("5"))
1630 m, _ := node.Map()
1631 n := NewNull()
1632 b.ResetTimer()
1633 for i := 0; i < b.N; i++ {
1634 m["test3"] = n
1635 }
1636 }
1637
1638 func BenchmarkNodeSetByIndex(b *testing.B) {
1639 root, derr := NewParser(_TwitterJson).Parse()
1640 if derr != 0 {
1641 b.Fatalf("decode failed: %v", derr.Error())
1642 }
1643 node := root.Get("statuses").Index(3).Get("entities").Get("hashtags")
1644 node.Add(NewNumber("1"))
1645 node.Add(NewNumber("2"))
1646 node.Add(NewNumber("3"))
1647 node.Add(NewNumber("4"))
1648 node.Add(NewNumber("5"))
1649 n := NewNull()
1650 b.ResetTimer()
1651 for i := 0; i < b.N; i++ {
1652 node.SetByIndex(2, n)
1653 }
1654 }
1655
1656 func BenchmarkSliceSetByIndex(b *testing.B) {
1657 root, derr := NewParser(_TwitterJson).Parse()
1658 if derr != 0 {
1659 b.Fatalf("decode failed: %v", derr.Error())
1660 }
1661 node := root.Get("statuses").Index(3).Get("entities").Get("hashtags")
1662 node.Add(NewNumber("1"))
1663 node.Add(NewNumber("2"))
1664 node.Add(NewNumber("3"))
1665 node.Add(NewNumber("4"))
1666 node.Add(NewNumber("5"))
1667 m, _ := node.Array()
1668 n := NewNull()
1669 b.ResetTimer()
1670 for i := 0; i < b.N; i++ {
1671 m[2] = n
1672 }
1673 }
1674
1675 func BenchmarkStructSetByIndex(b *testing.B) {
1676 type T struct {
1677 A Node
1678 B Node
1679 C Node
1680 D Node
1681 E Node
1682 }
1683 var obj = new(T)
1684 n := NewNull()
1685 b.ResetTimer()
1686 for i := 0; i < b.N; i++ {
1687 obj.C = n
1688 }
1689 }
1690
1691 func BenchmarkNodeUnset(b *testing.B) {
1692 root, derr := NewParser(_TwitterJson).Parse()
1693 if derr != 0 {
1694 b.Fatalf("decode failed: %v", derr.Error())
1695 }
1696 node := root.Get("statuses").Index(3).Get("entities").Get("hashtags").Index(0)
1697 node.Set("test1", NewNumber("1"))
1698 node.Set("test2", NewNumber("2"))
1699 node.Set("test3", NewNumber("3"))
1700 node.Set("test4", NewNumber("4"))
1701 node.Set("test5", NewNumber("5"))
1702 b.ResetTimer()
1703 for i := 0; i < b.N; i++ {
1704 node.Unset("test3")
1705 }
1706 }
1707
1708 func BenchmarkMapUnset(b *testing.B) {
1709 root, derr := NewParser(_TwitterJson).Parse()
1710 if derr != 0 {
1711 b.Fatalf("decode failed: %v", derr.Error())
1712 }
1713 node := root.Get("statuses").Index(3).Get("entities").Get("hashtags").Index(0)
1714 node.Set("test1", NewNumber("1"))
1715 node.Set("test2", NewNumber("2"))
1716 node.Set("test3", NewNumber("3"))
1717 node.Set("test4", NewNumber("4"))
1718 node.Set("test5", NewNumber("5"))
1719 m, _ := node.Map()
1720 b.ResetTimer()
1721 for i := 0; i < b.N; i++ {
1722 delete(m, "test3")
1723 }
1724 }
1725
1726 func BenchmarkNodUnsetByIndex(b *testing.B) {
1727 root, derr := NewParser(_TwitterJson).Parse()
1728 if derr != 0 {
1729 b.Fatalf("decode failed: %v", derr.Error())
1730 }
1731 node := root.Get("statuses").Index(3).Get("entities").Get("hashtags")
1732 node.Add(NewNumber("1"))
1733 node.Add(NewNumber("2"))
1734 node.Add(NewNumber("3"))
1735 node.Add(NewNumber("4"))
1736 node.Add(NewNumber("5"))
1737 b.ResetTimer()
1738 for i := 0; i < b.N; i++ {
1739 node.UnsetByIndex(2)
1740 }
1741 }
1742
1743 func BenchmarkSliceUnsetByIndex(b *testing.B) {
1744 root, derr := NewParser(_TwitterJson).Parse()
1745 if derr != 0 {
1746 b.Fatalf("decode failed: %v", derr.Error())
1747 }
1748 node := root.Get("statuses").Index(3).Get("entities").Get("hashtags")
1749 node.Add(NewNumber("1"))
1750 node.Add(NewNumber("2"))
1751 node.Add(NewNumber("3"))
1752 node.Add(NewNumber("4"))
1753 node.Add(NewNumber("5"))
1754 m, _ := node.Array()
1755 b.ResetTimer()
1756 for i := 0; i < b.N; i++ {
1757 for i := 3; i < 5; i++ {
1758 m[i-1] = m[i]
1759 }
1760 }
1761 }
1762
1763 func BenchmarkNodeAdd(b *testing.B) {
1764 n := NewObject([]Pair{{"test", NewNumber("1")}})
1765 b.ResetTimer()
1766 for i := 0; i < b.N; i++ {
1767 node := NewArray([]Node{})
1768 node.Add(n)
1769 }
1770 }
1771
1772 func BenchmarkSliceAdd(b *testing.B) {
1773 n := NewObject([]Pair{{"test", NewNumber("1")}})
1774 b.ResetTimer()
1775 for i := 0; i < b.N; i++ {
1776 node := []Node{}
1777 node = append(node, n)
1778 }
1779 }
1780
1781 func BenchmarkMapAdd(b *testing.B) {
1782 n := NewObject([]Pair{{"test", NewNumber("1")}})
1783 b.ResetTimer()
1784 for i := 0; i < b.N; i++ {
1785 node := map[string]Node{}
1786 node["test3"] = n
1787 }
1788 }
1789
1790 func TestNode_Move(t *testing.T) {
1791 var us = NewRaw(`["a","1","b","c"]`)
1792 if ex, e := us.UnsetByIndex(1); !ex || e != nil {
1793 t.Fail()
1794 }
1795 var us2 = NewRaw(`["a","b","c","1"]`)
1796 if ex, e := us2.UnsetByIndex(3); !ex || e != nil {
1797 t.Fail()
1798 }
1799 tests := []struct {
1800 name string
1801 in Node
1802 src int
1803 dst int
1804 out Node
1805 wantErr bool
1806 }{
1807 {
1808 name: "over index",
1809 in: NewArray([]Node{}),
1810 src: 0,
1811 dst: 1,
1812 out: NewArray([]Node{}),
1813 wantErr: false,
1814 },
1815 {
1816 name: "equal index",
1817 in: NewArray([]Node{NewBool(true)}),
1818 src: 0,
1819 dst: 0,
1820 out: NewArray([]Node{NewBool(true)}),
1821 wantErr: false,
1822 },
1823 {
1824 name: "forward",
1825 in: NewArray([]Node{NewString("a"), NewString("b"), NewString("c")}),
1826 src: 0,
1827 dst: 2,
1828 out: NewArray([]Node{NewString("b"), NewString("c"), NewString("a")}),
1829 wantErr: false,
1830 },
1831 {
1832 name: "backward",
1833 in: NewArray([]Node{NewString("a"), NewString("b"), NewString("c")}),
1834 src: 2,
1835 dst: 0,
1836 out: NewArray([]Node{NewString("c"), NewString("a"), NewString("b")}),
1837 wantErr: false,
1838 },
1839 {
1840 name: "lazy",
1841 in: NewRaw(`["a","b","c"]`),
1842 src: 2,
1843 dst: 0,
1844 out: NewArray([]Node{NewString("c"), NewString("a"), NewString("b")}),
1845 wantErr: false,
1846 },
1847 {
1848 name: "unset back",
1849 in: us,
1850 src: 2,
1851 dst: 0,
1852 out: NewArray([]Node{NewString("c"), NewString("a"), NewString("b")}),
1853 wantErr: false,
1854 },
1855 {
1856 name: "unset forward",
1857 in: us2,
1858 src: 0,
1859 dst: 2,
1860 out: NewArray([]Node{NewString("b"), NewString("c"), NewString("a")}),
1861 wantErr: false,
1862 },
1863 }
1864 for _, tt := range tests {
1865 t.Run(tt.name, func(t *testing.T) {
1866 err := tt.in.Move(tt.dst, tt.src)
1867 require.NoError(t, err)
1868 ej, _ := tt.out.MarshalJSON()
1869 aj, _ := tt.in.MarshalJSON()
1870 require.Equal(t, string(ej), string(aj))
1871 })
1872 }
1873
1874 }
1875
1876 func TestNode_Pop(t *testing.T) {
1877 var us = NewRaw(`[1,2,3]`)
1878 if ex, e := us.UnsetByIndex(0); !ex || e != nil {
1879 t.Fail()
1880 }
1881 var us2 = NewRaw(`[1,2,3]`)
1882 if ex, e := us2.UnsetByIndex(2); !ex || e != nil {
1883 t.Fail()
1884 }
1885 tests := []struct {
1886 name string
1887 in Node
1888 out Node
1889 wantErr bool
1890 }{
1891 {
1892 name: "empty",
1893 in: NewArray([]Node{}),
1894 out: NewArray([]Node{}),
1895 wantErr: false,
1896 },
1897 {
1898 name: "one",
1899 in: NewArray([]Node{NewString("a")}),
1900 out: NewArray([]Node{}),
1901 wantErr: false,
1902 },
1903 {
1904 name: "raw",
1905 in: NewRaw(`[1]`),
1906 out: NewArray([]Node{}),
1907 wantErr: false,
1908 },
1909 {
1910 name: "unset head",
1911 in: us,
1912 out: NewRaw(`[2]`),
1913 wantErr: false,
1914 },
1915 {
1916 name: "unset tail",
1917 in: us2,
1918 out: NewRaw(`[1]`),
1919 wantErr: false,
1920 },
1921 }
1922 for _, tt := range tests {
1923 t.Run(tt.name, func(t *testing.T) {
1924 if err := tt.in.Pop(); (err != nil) != tt.wantErr {
1925 t.Errorf("Node.Pop() error = %v, wantErr %v", err, tt.wantErr)
1926 }
1927 ej, _ := tt.out.MarshalJSON()
1928 aj, _ := tt.in.MarshalJSON()
1929 require.Equal(t, string(ej), string(aj))
1930 })
1931 }
1932 }
1933
View as plain text