github.com/goshafaq/sonic@v0.0.0-20231026082336-871835fb94c6/ast/iterator_test.go

/*
 * Copyright 2021 ByteDance Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package ast

import (
	"fmt"
	"strconv"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func getTestIteratorSample(loop int) (string, int) {
	var data []int
	var v1 = ""
	var v2 = ""
	for i := 0; i < loop; i++ {
		data = append(data, i*i)
		v1 += strconv.Itoa(i)
		v2 += `"k` + strconv.Itoa(i) + `":` + strconv.Itoa(i)
		if i != loop-1 {
			v1 += `,`
			v2 += `,`
		}
	}
	return `{"array":[` + v1 + `], "object":{` + v2 + `}}`, loop
}

func TestForEach(t *testing.T) {
	pathes := []Sequence{}
	values := []*Node{}
	sc := func(path Sequence, node *Node) bool {
		pathes = append(pathes, path)
		values = append(values, node)
		if path.Key != nil && *path.Key == "array" {
			node.ForEach(func(path Sequence, node *Node) bool {
				pathes = append(pathes, path)
				values = append(values, node)
				return true
			})
		}
		return true
	}

	str, _ := getTestIteratorSample(3)
	fmt.Println(str)
	root, err := NewSearcher(str).GetByPath()
	if err != nil {
		t.Fatal(err)
	}
	err = root.ForEach(sc)
	if err != nil {
		t.Fatal(err)
	}
	eObjKey := "object"
	eArrKey := "array"
	expPath := []Sequence{
		{0, &eArrKey},
		{0, nil},
		{1, nil},
		{2, nil},
		{1, &eObjKey},
	}
	expValue := []*Node{
		root.Get("array"),
		root.GetByPath("array", 0),
		root.GetByPath("array", 1),
		root.GetByPath("array", 2),
		root.Get("object"),
	}
	// fmt.Printf("pathes:%+v\n", pathes)
	// fmt.Printf("values:%+v\n", values)
	assert.Equal(t, expPath, pathes)
	assert.Equal(t, expValue, values)

}

func TestRawIterator(t *testing.T) {
	str, loop := getTestIteratorSample(_DEFAULT_NODE_CAP)
	fmt.Println(str)

	root, err := NewSearcher(str).GetByPath("array")
	if err != nil {
		t.Fatal(err)
	}
	ai, _ := root.Values()
	i := int64(0)
	for ai.HasNext() {
		v := &Node{}
		if !ai.Next(v) {
			t.Fatalf("no next")
		}
		x, _ := v.Int64()
		if i < int64(loop) && x != i {
			t.Fatalf("exp:%v, got:%v", i, v)
		}
		if i != int64(ai.Pos())-1 || i >= int64(ai.Len()) {
			t.Fatal(i)
		}
		i++
	}
	if i != int64(loop) {
		t.Fatal(i)
	}

	root, err = NewSearcher(str).GetByPath("object")
	if err != nil {
		t.Fatal(err)
	}
	mi, _ := root.Properties()
	i = int64(0)
	for mi.HasNext() {
		v := &Pair{}
		if !mi.Next(v) {
			t.Fatalf("no next")
		}
		x, _ := v.Value.Int64()
		if i < int64(loop) && (x != i || v.Key != fmt.Sprintf("k%d", i)) {
			vv, _ := v.Value.Interface()
			t.Fatalf("exp:%v, got:%v", i, vv)
		}
		if i != int64(mi.Pos())-1 || i >= int64(mi.Len()) {
			t.Fatal(i)
		}
		i++
	}
	if i != int64(loop) {
		t.Fatal(i)
	}
}

func TestIterator(t *testing.T) {
	str, loop := getTestIteratorSample(_DEFAULT_NODE_CAP)
	fmt.Println(str)

	root, err := NewParser(str).Parse()
	if err != 0 {
		t.Fatal(err)
	}
	ai, _ := root.Get("array").Values()
	i := int64(0)
	for ai.HasNext() {
		v := &Node{}
		if !ai.Next(v) {
			t.Fatalf("no next")
		}
		x, _ := v.Int64()
		if i < int64(loop) && x != i {
			t.Fatalf("exp:%v, got:%v", i, v)
		}
		if i != int64(ai.Pos())-1 || i >= int64(ai.Len()) {
			t.Fatal(i)
		}
		i++
	}
	if i != int64(loop) {
		t.Fatal(i)
	}

	root, err = NewParser(str).Parse()
	if err != 0 {
		t.Fatal(err)
	}
	mi, _ := root.Get("object").Properties()
	i = int64(0)
	for mi.HasNext() {
		v := &Pair{}
		if !mi.Next(v) {
			t.Fatalf("no next")
		}
		x, _ := v.Value.Int64()
		if i < int64(loop) && (x != i || v.Key != fmt.Sprintf("k%d", i)) {
			vv, _ := v.Value.Interface()
			t.Fatalf("exp:%v, got:%v", i, vv)
		}
		if i != int64(mi.Pos())-1 || i >= int64(mi.Len()) {
			t.Fatal(i)
		}
		i++
	}
	if i != int64(loop) {
		t.Fatal(i)
	}

	str, _ = getTestIteratorSample(0)
	root, err = NewParser(str).Parse()
	if err != 0 {
		t.Fatal(err)
	}
	mi, _ = root.Get("object").Properties()
	if mi.HasNext() {
		t.Fatalf("should not have next")
	}
}

func TestExist(t *testing.T) {
	n := NewRaw(`null`)
	if !n.Exists() {
		t.Fatal()
	}
	nn := n.Get("xx")
	if nn.Exists() {
		t.Fatal()
	}

	root := NewRaw(`{"a":1, "b":[1,2], "c":{"1":1, "2":2}}`)
	if !root.Exists() {
		t.Fatal()
	}
	exi, err := root.Unset("a")
	if !exi || err != nil {
		t.Fatal(exi, err)
	}

	root.ForEach(func(path Sequence, node *Node) bool {
		if path.Key != nil && *path.Key == "a" {
			t.Fatal()
		}
		if path.Index == 1 {
			if *path.Key != "b" {
				t.Fatal()
			}
			exi, err := node.UnsetByIndex(1)
			if !exi || err != nil {
				t.Fatal(exi, err)
			}
			node.ForEach(func(path Sequence, node *Node) bool {
				if path.Index == 1 {
					t.Fatal()
				}
				return true
			})
		}

		if path.Index == 2 {
			if *path.Key != "c" {
				t.Fatal()
			}
			exi, err := node.UnsetByIndex(1)
			if !exi || err != nil {
				t.Fatal(exi, err)
			}
			node.ForEach(func(path Sequence, node *Node) bool {
				if path.Index == 1 {
					t.Fatal()
				}
				return true
			})
		}
		return true
	})

	out, err := root.Raw()
	if err != nil {
		t.Fatal(err)
	}
	require.Equal(t, `{"b":[1],"c":{"1":1}}`, out)

}

func BenchmarkArrays(b *testing.B) {
	for i := 0; i < b.N; i++ {
		root, err := NewSearcher(_TwitterJson).GetByPath("statuses", 1, "entities", "hashtags")
		if err != nil {
			b.Fatal(err)
		}
		a, _ := root.Array()
		for _, v := range a {
			_ = v
		}
	}
}

func BenchmarkListIterator(b *testing.B) {
	for i := 0; i < b.N; i++ {
		root, err := NewSearcher(_TwitterJson).GetByPath("statuses", 1, "entities", "hashtags")
		if err != nil {
			b.Fatal(err)
		}
		it, _ := root.Values()
		for it.HasNext() {
			v := &Node{}
			if !it.Next(v) {
				b.Fatalf("no value")
			}
		}
	}
}

func BenchmarkMap(b *testing.B) {
	for i := 0; i < b.N; i++ {
		root, err := NewSearcher(_TwitterJson).GetByPath("statuses", 1, "user")
		if err != nil {
			b.Fatal(err)
		}
		m, _ := root.Map()
		for k, v := range m {
			_ = v
			_ = k
		}
	}
}

func BenchmarkObjectIterator(b *testing.B) {
	for i := 0; i < b.N; i++ {
		root, err := NewSearcher(_TwitterJson).GetByPath("statuses", 1, "user")
		if err != nil {
			b.Fatal(err)
		}
		it, _ := root.Properties()
		for it.HasNext() {
			v := &Pair{}
			if !it.Next(v) {
				b.Fatalf("no value")
			}
		}
	}
}