add test to parse to randomly parse random values and make config for rand

Author: awalterschulze

json/parse/rand_test.go

@@ -21,7 +21,7 @@ import (
 	"github.com/katydid/parser-go-json/json/rand"
 )
 
-func TestRandomParse(t *testing.T) {
+func TestParseRandomValues(t *testing.T) {
 	r := rand.NewRand()
 	values := rand.Values(r, 100)
 	for _, value := range values {
@@ -34,3 +34,17 @@ func TestRandomParse(t *testing.T) {
 		})
 	}
 }
+
+func TestRandomlyParseRandomValues(t *testing.T) {
+	r := rand.NewRand()
+	values := rand.Values(r, 100)
+	for _, value := range values {
+		name := testrun.Name(value)
+		t.Run(name, func(t *testing.T) {
+			tokenizer := NewParser([]byte(value))
+			if err := randWalk(r, tokenizer); err != nil {
+				t.Fatalf("expected EOF, but got %v", err)
+			}
+		})
+	}
+}

json/parse/walk_test.go

@@ -17,6 +17,8 @@ package parse
 import (
 	"errors"
 	"io"
+
+	"github.com/katydid/parser-go-json/json/rand"
 )
 
 var errUnknownToken = errors.New("unknown token")
@@ -25,44 +27,72 @@ var errExpectedBool = errors.New("expected bool")
 
 var errExpectedString = errors.New("expected string")
 
-func walkValue(t Parser, kind Kind) error {
-	if _, err := t.Bool(); err == nil {
+func walkValue(p Parser, kind Kind) error {
+	if _, err := p.Bool(); err == nil {
 		return nil
 	}
 	if kind == BoolKind {
 		return errExpectedBool
 	}
-	if _, err := t.Int(); err == nil {
+	if _, err := p.Int(); err == nil {
 		return nil
 	}
-	if _, err := t.Uint(); err == nil {
+	if _, err := p.Uint(); err == nil {
 		return nil
 	}
-	if _, err := t.Double(); err == nil {
+	if _, err := p.Double(); err == nil {
 		return nil
 	}
-	if _, err := t.String(); err == nil {
+	if _, err := p.String(); err == nil {
 		return nil
 	}
 	if kind == StringKind {
 		return errExpectedString
 	}
-	if _, err := t.Bytes(); err == nil {
+	if _, err := p.Bytes(); err == nil {
 		return nil
 	}
 	return errUnknownToken
 }
 
-func walk(t Parser) error {
-	kind, err := t.Next()
+func walk(p Parser) error {
+	kind, err := p.Next()
+	for err == nil {
+		switch kind {
+		case NullKind, BoolKind, NumberKind, StringKind:
+			if err := walkValue(p, kind); err != nil {
+				return err
+			}
+		}
+		kind, err = p.Next()
+	}
+	if err != io.EOF {
+		return err
+	}
+	return nil
+}
+
+func randNext(r rand.Rand, p Parser) (Kind, error) {
+	skip := r.Intn(2) == 0
+	for skip {
+		if err := p.Skip(); err != nil {
+			return UnknownKind, err
+		}
+		skip = r.Intn(2) == 0
+	}
+	return p.Next()
+}
+
+func randWalk(r rand.Rand, p Parser) error {
+	kind, err := p.Next()
 	for err == nil {
 		switch kind {
 		case NullKind, BoolKind, NumberKind, StringKind:
-			if err := walkValue(t, kind); err != nil {
+			if err := walkValue(p, kind); err != nil {
 				return err
 			}
 		}
-		kind, err = t.Next()
+		kind, err = randNext(r, p)
 	}
 	if err != io.EOF {
 		return err

json/rand/config.go

@@ -0,0 +1,40 @@
+//  Copyright 2025 Walter Schulze
+//
+//  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 rand
+
+type config struct {
+	// MaxLevels is the maximum number of objects/arrays to generate down. It makes sure the algorithm terminates.
+	maxLevels int
+}
+
+type Option func(*config)
+
+func newConfig(opts ...Option) *config {
+	// default Config
+	c := &config{
+		maxLevels: 5,
+	}
+	// apply options
+	for _, o := range opts {
+		o(c)
+	}
+	return c
+}
+
+func WithMaxLevel(maxLevel int) Option {
+	return func(c *config) {
+		c.maxLevels = maxLevel
+	}
+}

json/rand/many.go

@@ -31,7 +31,7 @@ func values(r Rand, atleast int) (map[byte]int, []string) {
 	kinds := allKinds()
 	ss := []string{}
 	for !(eachKindHasNonZero(kinds) && len(ss) >= atleast) {
-		s := Value(r, 5)
+		s := Value(r)
 		ss = append(ss, s)
 		kinds[whichKind(s)] += 1
 	}

json/rand/rand.go

@@ -20,11 +20,16 @@ import (
 )
 
 // Value returns a string representing random json value.
+func Value(r Rand, opts ...Option) string {
+	c := newConfig(opts...)
+	return randValue(r, c)
+}
+
 // value BNF:
 // value := object | array | string | number | "true" | "false" | "null"
-func Value(r Rand, level int) string {
+func randValue(r Rand, c *config) string {
 	maxN := 7
-	if level <= 0 {
+	if c.maxLevels <= 0 {
 		// do not generate arrays or objects,
 		// since we have generated a deep enough structure and
 		// we do not want to endlessly recurse.
@@ -38,59 +43,75 @@ func Value(r Rand, level int) string {
 	case 2:
 		return "true"
 	case 3:
-		return Number(r)
+		return randNumber(r, c)
 	case 4:
-		return String(r)
+		return randString(r, c)
 	case 5:
-		return Array(r, level-1)
+		c.maxLevels = c.maxLevels - 1
+		return randArray(r, c)
 	case 6:
-		return Object(r, level-1)
+		return randObject(r, c)
 	}
 	panic("unreachable")
 }
 
 // Object returns a string that represents a random JSON object.
+func Object(r Rand, opts ...Option) string {
+	c := newConfig(opts...)
+	return randObject(r, c)
+}
+
 // object BNF:
 // object := '{' ws '}' | '{' members '}'
 // members := member | member ',' members
 // member := ws string ws ':' element
-func Object(r Rand, level int) string {
+func randObject(r Rand, c *config) string {
 	l := r.Intn(10)
 	if l == 0 {
 		return "{" + randWs(r) + "}"
 	}
 	ss := make([]string, l)
 	for i := 0; i < l; i++ {
-		ss[i] = randWs(r) + String(r) + randWs(r) + ":" + randElement(r, level)
+		ss[i] = randWs(r) + String(r) + randWs(r) + ":" + randElement(r, c)
 	}
 	return "{" + strings.Join(ss, ",") + "}"
 }
 
 // Array returns a string that represents a random JSON array.
+func Array(r Rand, opts ...Option) string {
+	c := newConfig(opts...)
+	return randArray(r, c)
+}
+
 // array := '[' ws ']' | '[' elements ']'
 // elements := element | element ',' elements
-func Array(r Rand, level int) string {
+func randArray(r Rand, c *config) string {
 	l := r.Intn(10)
 	if l == 0 {
 		return "[" + randWs(r) + "]"
 	}
 	ss := make([]string, l)
 	for i := 0; i < l; i++ {
-		ss[i] = randElement(r, level)
+		ss[i] = randElement(r, c)
 	}
 	return "[" + strings.Join(ss, ",") + "]"
 }
 
 // element := ws value ws
-func randElement(r Rand, level int) string {
-	return randWs(r) + Value(r, level) + randWs(r)
+func randElement(r Rand, c *config) string {
+	return randWs(r) + randValue(r, c) + randWs(r)
 }
 
 // String returns a string that represents a random JSON string.
+func String(r Rand, opts ...Option) string {
+	c := newConfig(opts...)
+	return randString(r, c)
+}
+
 // String BNF:
 // string := '"' characters '"'
 // characters := "" | character characters
-func String(r Rand) string {
+func randString(r Rand, c *config) string {
 	ss := make([]string, int(r.Intn(100)))
 	for i := range ss {
 		ss[i] = randChar(r)
@@ -143,9 +164,14 @@ func randEscape(r Rand) string {
 }
 
 // Number returns a string that represents a random JSON number.
+func Number(r Rand, opts ...Option) string {
+	c := newConfig(opts...)
+	return randNumber(r, c)
+}
+
 // number BNF:
 // number := integer fraction exponent
-func Number(r Rand) string {
+func randNumber(r Rand, c *config) string {
 	// Sometimes generate an edge case
 	if r.Intn(100) == 0 {
 		switch r.Intn(9) {