scanner_test.go

Documentation: encoding/json

		 1  // Copyright 2010 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package json
		 6  
		 7  import (
		 8  	"bytes"
		 9  	"math"
		10  	"math/rand"
		11  	"reflect"
		12  	"testing"
		13  )
		14  
		15  var validTests = []struct {
		16  	data string
		17  	ok	 bool
		18  }{
		19  	{`foo`, false},
		20  	{`}{`, false},
		21  	{`{]`, false},
		22  	{`{}`, true},
		23  	{`{"foo":"bar"}`, true},
		24  	{`{"foo":"bar","bar":{"baz":["qux"]}}`, true},
		25  }
		26  
		27  func TestValid(t *testing.T) {
		28  	for _, tt := range validTests {
		29  		if ok := Valid([]byte(tt.data)); ok != tt.ok {
		30  			t.Errorf("Valid(%#q) = %v, want %v", tt.data, ok, tt.ok)
		31  		}
		32  	}
		33  }
		34  
		35  // Tests of simple examples.
		36  
		37  type example struct {
		38  	compact string
		39  	indent	string
		40  }
		41  
		42  var examples = []example{
		43  	{`1`, `1`},
		44  	{`{}`, `{}`},
		45  	{`[]`, `[]`},
		46  	{`{"":2}`, "{\n\t\"\": 2\n}"},
		47  	{`[3]`, "[\n\t3\n]"},
		48  	{`[1,2,3]`, "[\n\t1,\n\t2,\n\t3\n]"},
		49  	{`{"x":1}`, "{\n\t\"x\": 1\n}"},
		50  	{ex1, ex1i},
		51  	{"{\"\":\"<>&\u2028\u2029\"}", "{\n\t\"\": \"<>&\u2028\u2029\"\n}"}, // See golang.org/issue/34070
		52  }
		53  
		54  var ex1 = `[true,false,null,"x",1,1.5,0,-5e+2]`
		55  
		56  var ex1i = `[
		57  	true,
		58  	false,
		59  	null,
		60  	"x",
		61  	1,
		62  	1.5,
		63  	0,
		64  	-5e+2
		65  ]`
		66  
		67  func TestCompact(t *testing.T) {
		68  	var buf bytes.Buffer
		69  	for _, tt := range examples {
		70  		buf.Reset()
		71  		if err := Compact(&buf, []byte(tt.compact)); err != nil {
		72  			t.Errorf("Compact(%#q): %v", tt.compact, err)
		73  		} else if s := buf.String(); s != tt.compact {
		74  			t.Errorf("Compact(%#q) = %#q, want original", tt.compact, s)
		75  		}
		76  
		77  		buf.Reset()
		78  		if err := Compact(&buf, []byte(tt.indent)); err != nil {
		79  			t.Errorf("Compact(%#q): %v", tt.indent, err)
		80  			continue
		81  		} else if s := buf.String(); s != tt.compact {
		82  			t.Errorf("Compact(%#q) = %#q, want %#q", tt.indent, s, tt.compact)
		83  		}
		84  	}
		85  }
		86  
		87  func TestCompactSeparators(t *testing.T) {
		88  	// U+2028 and U+2029 should be escaped inside strings.
		89  	// They should not appear outside strings.
		90  	tests := []struct {
		91  		in, compact string
		92  	}{
		93  		{"{\"\u2028\": 1}", "{\"\u2028\":1}"},
		94  		{"{\"\u2029\" :2}", "{\"\u2029\":2}"},
		95  	}
		96  	for _, tt := range tests {
		97  		var buf bytes.Buffer
		98  		if err := Compact(&buf, []byte(tt.in)); err != nil {
		99  			t.Errorf("Compact(%q): %v", tt.in, err)
	 100  		} else if s := buf.String(); s != tt.compact {
	 101  			t.Errorf("Compact(%q) = %q, want %q", tt.in, s, tt.compact)
	 102  		}
	 103  	}
	 104  }
	 105  
	 106  func TestIndent(t *testing.T) {
	 107  	var buf bytes.Buffer
	 108  	for _, tt := range examples {
	 109  		buf.Reset()
	 110  		if err := Indent(&buf, []byte(tt.indent), "", "\t"); err != nil {
	 111  			t.Errorf("Indent(%#q): %v", tt.indent, err)
	 112  		} else if s := buf.String(); s != tt.indent {
	 113  			t.Errorf("Indent(%#q) = %#q, want original", tt.indent, s)
	 114  		}
	 115  
	 116  		buf.Reset()
	 117  		if err := Indent(&buf, []byte(tt.compact), "", "\t"); err != nil {
	 118  			t.Errorf("Indent(%#q): %v", tt.compact, err)
	 119  			continue
	 120  		} else if s := buf.String(); s != tt.indent {
	 121  			t.Errorf("Indent(%#q) = %#q, want %#q", tt.compact, s, tt.indent)
	 122  		}
	 123  	}
	 124  }
	 125  
	 126  // Tests of a large random structure.
	 127  
	 128  func TestCompactBig(t *testing.T) {
	 129  	initBig()
	 130  	var buf bytes.Buffer
	 131  	if err := Compact(&buf, jsonBig); err != nil {
	 132  		t.Fatalf("Compact: %v", err)
	 133  	}
	 134  	b := buf.Bytes()
	 135  	if !bytes.Equal(b, jsonBig) {
	 136  		t.Error("Compact(jsonBig) != jsonBig")
	 137  		diff(t, b, jsonBig)
	 138  		return
	 139  	}
	 140  }
	 141  
	 142  func TestIndentBig(t *testing.T) {
	 143  	t.Parallel()
	 144  	initBig()
	 145  	var buf bytes.Buffer
	 146  	if err := Indent(&buf, jsonBig, "", "\t"); err != nil {
	 147  		t.Fatalf("Indent1: %v", err)
	 148  	}
	 149  	b := buf.Bytes()
	 150  	if len(b) == len(jsonBig) {
	 151  		// jsonBig is compact (no unnecessary spaces);
	 152  		// indenting should make it bigger
	 153  		t.Fatalf("Indent(jsonBig) did not get bigger")
	 154  	}
	 155  
	 156  	// should be idempotent
	 157  	var buf1 bytes.Buffer
	 158  	if err := Indent(&buf1, b, "", "\t"); err != nil {
	 159  		t.Fatalf("Indent2: %v", err)
	 160  	}
	 161  	b1 := buf1.Bytes()
	 162  	if !bytes.Equal(b1, b) {
	 163  		t.Error("Indent(Indent(jsonBig)) != Indent(jsonBig)")
	 164  		diff(t, b1, b)
	 165  		return
	 166  	}
	 167  
	 168  	// should get back to original
	 169  	buf1.Reset()
	 170  	if err := Compact(&buf1, b); err != nil {
	 171  		t.Fatalf("Compact: %v", err)
	 172  	}
	 173  	b1 = buf1.Bytes()
	 174  	if !bytes.Equal(b1, jsonBig) {
	 175  		t.Error("Compact(Indent(jsonBig)) != jsonBig")
	 176  		diff(t, b1, jsonBig)
	 177  		return
	 178  	}
	 179  }
	 180  
	 181  type indentErrorTest struct {
	 182  	in	string
	 183  	err error
	 184  }
	 185  
	 186  var indentErrorTests = []indentErrorTest{
	 187  	{`{"X": "foo", "Y"}`, &SyntaxError{"invalid character '}' after object key", 17}},
	 188  	{`{"X": "foo" "Y": "bar"}`, &SyntaxError{"invalid character '\"' after object key:value pair", 13}},
	 189  }
	 190  
	 191  func TestIndentErrors(t *testing.T) {
	 192  	for i, tt := range indentErrorTests {
	 193  		slice := make([]uint8, 0)
	 194  		buf := bytes.NewBuffer(slice)
	 195  		if err := Indent(buf, []uint8(tt.in), "", ""); err != nil {
	 196  			if !reflect.DeepEqual(err, tt.err) {
	 197  				t.Errorf("#%d: Indent: %#v", i, err)
	 198  				continue
	 199  			}
	 200  		}
	 201  	}
	 202  }
	 203  
	 204  func diff(t *testing.T, a, b []byte) {
	 205  	for i := 0; ; i++ {
	 206  		if i >= len(a) || i >= len(b) || a[i] != b[i] {
	 207  			j := i - 10
	 208  			if j < 0 {
	 209  				j = 0
	 210  			}
	 211  			t.Errorf("diverge at %d: «%s» vs «%s»", i, trim(a[j:]), trim(b[j:]))
	 212  			return
	 213  		}
	 214  	}
	 215  }
	 216  
	 217  func trim(b []byte) []byte {
	 218  	if len(b) > 20 {
	 219  		return b[0:20]
	 220  	}
	 221  	return b
	 222  }
	 223  
	 224  // Generate a random JSON object.
	 225  
	 226  var jsonBig []byte
	 227  
	 228  func initBig() {
	 229  	n := 10000
	 230  	if testing.Short() {
	 231  		n = 100
	 232  	}
	 233  	b, err := Marshal(genValue(n))
	 234  	if err != nil {
	 235  		panic(err)
	 236  	}
	 237  	jsonBig = b
	 238  }
	 239  
	 240  func genValue(n int) interface{} {
	 241  	if n > 1 {
	 242  		switch rand.Intn(2) {
	 243  		case 0:
	 244  			return genArray(n)
	 245  		case 1:
	 246  			return genMap(n)
	 247  		}
	 248  	}
	 249  	switch rand.Intn(3) {
	 250  	case 0:
	 251  		return rand.Intn(2) == 0
	 252  	case 1:
	 253  		return rand.NormFloat64()
	 254  	case 2:
	 255  		return genString(30)
	 256  	}
	 257  	panic("unreachable")
	 258  }
	 259  
	 260  func genString(stddev float64) string {
	 261  	n := int(math.Abs(rand.NormFloat64()*stddev + stddev/2))
	 262  	c := make([]rune, n)
	 263  	for i := range c {
	 264  		f := math.Abs(rand.NormFloat64()*64 + 32)
	 265  		if f > 0x10ffff {
	 266  			f = 0x10ffff
	 267  		}
	 268  		c[i] = rune(f)
	 269  	}
	 270  	return string(c)
	 271  }
	 272  
	 273  func genArray(n int) []interface{} {
	 274  	f := int(math.Abs(rand.NormFloat64()) * math.Min(10, float64(n/2)))
	 275  	if f > n {
	 276  		f = n
	 277  	}
	 278  	if f < 1 {
	 279  		f = 1
	 280  	}
	 281  	x := make([]interface{}, f)
	 282  	for i := range x {
	 283  		x[i] = genValue(((i+1)*n)/f - (i*n)/f)
	 284  	}
	 285  	return x
	 286  }
	 287  
	 288  func genMap(n int) map[string]interface{} {
	 289  	f := int(math.Abs(rand.NormFloat64()) * math.Min(10, float64(n/2)))
	 290  	if f > n {
	 291  		f = n
	 292  	}
	 293  	if n > 0 && f == 0 {
	 294  		f = 1
	 295  	}
	 296  	x := make(map[string]interface{})
	 297  	for i := 0; i < f; i++ {
	 298  		x[genString(10)] = genValue(((i+1)*n)/f - (i*n)/f)
	 299  	}
	 300  	return x
	 301  }
	 302
View as plain text