rewrite the json parser

json/debug_test.go

@@ -15,8 +15,10 @@
 package json
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
+	"testing"
 
 	"github.com/katydid/parser-go/parser"
 	"github.com/katydid/parser-go/parser/debug"
@@ -55,23 +57,29 @@ func getValue(p parser.Interface) interface{} {
 func parse(p parser.Interface) (debug.Nodes, error) {
 	a := make(debug.Nodes, 0)
 	for {
+		fmt.Printf("Next\n")
 		if err := p.Next(); err != nil {
 			if err == io.EOF {
+				fmt.Printf("EOF\n")
 				break
 			} else {
+				fmt.Printf("err = %v\n", err)
 				return nil, err
 			}
 		}
 		value := getValue(p)
 		if p.IsLeaf() {
+			fmt.Printf("IsLeaf\n")
 			a = append(a, debug.Node{Label: fmt.Sprintf("%v", value), Children: nil})
 		} else {
 			name := fmt.Sprintf("%v", value)
+			fmt.Printf("Down\n")
 			p.Down()
 			v, err := parse(p)
 			if err != nil {
 				return nil, err
 			}
+			fmt.Printf("Up\n")
 			p.Up()
 			a = append(a, debug.Node{Label: name, Children: v})
 		}
@@ -121,3 +129,34 @@ func walk(p parser.Interface) error {
 	}
 	return nil
 }
+
+func TestDebug(t *testing.T) {
+	p := 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 := 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)
+	}
+}

json/errors.go

@@ -42,3 +42,9 @@ var errExpectedNull = errors.New("expected null")
 var errExpectedFalse = errors.New("expected false")
 
 var errExpectedTrue = errors.New("expected true")
+
+var errExpectedCommaOrCloseCurly = errors.New("expected ',' or '}'")
+
+var errExpectedCommaOrCloseBracket = errors.New("expected ',' or ']'")
+
+var errNotLeaf = errors.New("not leaf")

json/helper_test.go

@@ -16,49 +16,58 @@ package json
 
 import (
 	"testing"
+
+	"github.com/katydid/parser-go/parser/debug"
 )
 
-func testValue(t *testing.T, input, output string) {
-	t.Helper()
+func parseJSON(s string) (debug.Nodes, error) {
 	parser := NewJsonParser()
-	if err := parser.Init([]byte(input)); err != nil {
-		t.Errorf("init error: %v", err)
-		return
-	}
-	jout, err := parse(parser)
-	if err != nil {
-		t.Errorf("walk error: %v", err)
-		return
-	}
-	if len(jout) != 1 {
-		t.Errorf("expected one node")
-		return
-	}
-	if len(jout[0].Children) != 0 {
-		t.Errorf("did not expected any children")
-		return
-	}
-	if jout[0].Label != output {
-		t.Errorf("expected %q got %q", output, jout[0].Label)
+	if err := parser.Init([]byte(s)); err != nil {
+		return nil, err
 	}
+	return parse(parser)
+}
+
+func testWalk(t *testing.T, s string) {
+	t.Run(s, func(t *testing.T) {
+		m, err := parseJSON(s)
+		if err != nil {
+			t.Fatal(err)
+			return
+		}
+		t.Logf("%v", m)
+	})
+}
+
+func testValue(t *testing.T, input, output string) {
+	t.Run(input, func(t *testing.T) {
+		jout, err := parseJSON(input)
+		if err != nil {
+			t.Fatalf("walk error: %v", err)
+		}
+		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 %q got %q", output, jout[0].Label)
+		}
+	})
 }
 
 func testSame(t *testing.T, input string) {
-	t.Helper()
 	testValue(t, input, input)
 }
 
 func testError(t *testing.T, s string) {
-	t.Helper()
-	parser := NewJsonParser()
-	if err := parser.Init([]byte(s)); err != nil {
-		t.Logf("PASS: given <%s> error: %v", s, err)
-		return
-	}
-	parsed, err := parse(parser)
-	if err != nil {
-		t.Logf("PASS: given <%s> error: %v", s, err)
-		return
-	}
-	t.Errorf("FAIL: expected error given: <%v> got: %v", s, parsed)
+	t.Run("ExpectError"+s, func(t *testing.T) {
+		parsed, err := parseJSON(s)
+		if err != nil {
+			t.Logf("PASS: given <%s> error: %v", s, err)
+			return
+		}
+		t.Fatalf("FAIL: expected error given: <%v> got: %v", s, parsed)
+	})
 }