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