func testArray(t *testing.T, s string) {
parser := sjson.NewJsonParser()
if err := parser.Init([]byte(s)); err != nil {
t.Fatal(err)
}
jout := debug.Walk(parser)
t.Logf("%v", jout)
}
func newJsonParser(filename string) (parser.Interface, error) {
bytes, err := ioutil.ReadFile(filename)
if err != nil {
return nil, fmt.Errorf("err <%v> reading file <%s>", err, filename)
}
j := json.NewJsonParser()
if err := j.Init(bytes); err != nil {
return nil, fmt.Errorf("err <%v> parser.Init with bytes from filename <%s>", err, filename)
}
return j, nil
}
func TestMultiLineArray(t *testing.T) {
s := `{
"A":[1]
}`
parser := sjson.NewJsonParser()
if err := parser.Init([]byte(s)); err != nil {
t.Fatal(err)
}
jout := debug.Walk(parser)
t.Logf("%v", jout)
}
func TestDebug(t *testing.T) {
p := sjson.NewJsonParser()
data, err := json.Marshal(debug.Input)
if err != nil {
t.Fatal(err)
}
if err := p.Init(data); err != nil {
t.Fatal(err)
}
m := debug.Walk(p)
if !m.Equal(debug.Output) {
t.Fatalf("expected %s but got %s", debug.Output, m)
}
}
func TestRandomDebug(t *testing.T) {
p := sjson.NewJsonParser()
data, err := json.Marshal(debug.Input)
if err != nil {
t.Fatal(err)
}
for i := 0; i < 10; i++ {
if err := p.Init(data); err != nil {
t.Fatal(err)
}
//l := debug.NewLogger(p, debug.NewLineLogger())
debug.RandomWalk(p, debug.NewRand(), 10, 3)
//t.Logf("original %v vs random %v", debug.Output, m)
}
}
func testValue(t *testing.T, input, output string) {
parser := sjson.NewJsonParser()
if err := parser.Init([]byte(input)); err != nil {
t.Fatalf("init error: %v", err)
}
jout := debug.Walk(parser)
if len(jout) != 1 {
t.Fatalf("expected one node")
}
if len(jout[0].Children) != 0 {
t.Fatalf("did not expected any children")
}
if jout[0].Label != output {
t.Fatalf("expected %s got %s", output, jout[0].Label)
}
}
func TestEscapedChar(t *testing.T) {
j := map[string][]interface{}{
`a\"`: {1},
}
data, err := json.Marshal(j)
if err != nil {
t.Fatal(err)
}
t.Logf("%s", string(data))
parser := sjson.NewJsonParser()
if err := parser.Init(data); err != nil {
t.Fatal(err)
}
m := debug.Walk(parser)
name := m[0].Label
if name != `a\"` {
t.Fatalf("wrong escaped name %s", name)
}
}
func TestIntWithExponent(t *testing.T) {
s := `{"A":1e+08}`
parser := sjson.NewJsonParser()
if err := parser.Init([]byte(s)); err != nil {
t.Fatal(err)
}
if err := parser.Next(); err != nil {
t.Fatal(err)
}
parser.Down()
if err := parser.Next(); err != nil {
t.Fatal(err)
}
if !parser.IsLeaf() {
t.Fatal("incorrect walk, please adjust the path above")
}
if i, err := parser.Int(); err != nil {
t.Fatalf("did not expect error %v", err)
} else if i != 1e+08 {
t.Fatalf("got %d", i)
}
}
func testTranscode(t *testing.T, input interface{}) {
inputData, err := json.Marshal(input)
if err != nil {
panic(err)
}
t.Logf("testing transcoding: %s", string(inputData))
p := jsonparser.NewJsonParser()
if err := p.Init(inputData); err != nil {
t.Fatal(err)
}
outputData, err := Encode(p)
if err != nil {
t.Fatal(err)
}
output := reflect.New(reflect.TypeOf(input).Elem()).Interface()
if err := json.Unmarshal(outputData, output); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(input, output) {
t.Fatalf("expected equal, but got %s", string(outputData))
}
}