libgo/go/encoding/json/scanner_test.go

   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 // Tests of simple examples.
  16
  17 type example struct {
  18         compact string
  19         indent  string
  20 }
  21
  22 var 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
  33 var ex1 = `[true,false,null,"x",1,1.5,0,-5e+2]`
  34
  35 var ex1i = `[
  36         true,
  37         false,
  38         null,
  39         "x",
  40         1,
  41         1.5,
  42         0,
  43         -5e+2
  44 ]`
  45
  46 func 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
  66 func 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
  85 func 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
 107 func 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
 121 func TestIndentBig(t *testing.T) {
 122         t.Parallel()
 123         initBig()
 124         var buf bytes.Buffer
 125         if err := Indent(&buf, jsonBig, "", "\t"); err != nil {
 126                 t.Fatalf("Indent1: %v", err)
 127         }
 128         b := buf.Bytes()
 129         if len(b) == len(jsonBig) {
 130                 // jsonBig is compact (no unnecessary spaces);
 131                 // indenting should make it bigger
 132                 t.Fatalf("Indent(jsonBig) did not get bigger")
 133         }
 134
 135         // should be idempotent
 136         var buf1 bytes.Buffer
 137         if err := Indent(&buf1, b, "", "\t"); err != nil {
 138                 t.Fatalf("Indent2: %v", err)
 139         }
 140         b1 := buf1.Bytes()
 141         if !bytes.Equal(b1, b) {
 142                 t.Error("Indent(Indent(jsonBig)) != Indent(jsonBig)")
 143                 diff(t, b1, b)
 144                 return
 145         }
 146
 147         // should get back to original
 148         buf1.Reset()
 149         if err := Compact(&buf1, b); err != nil {
 150                 t.Fatalf("Compact: %v", err)
 151         }
 152         b1 = buf1.Bytes()
 153         if !bytes.Equal(b1, jsonBig) {
 154                 t.Error("Compact(Indent(jsonBig)) != jsonBig")
 155                 diff(t, b1, jsonBig)
 156                 return
 157         }
 158 }
 159
 160 type indentErrorTest struct {
 161         in  string
 162         err error
 163 }
 164
 165 var indentErrorTests = []indentErrorTest{
 166         {`{"X": "foo", "Y"}`, &SyntaxError{"invalid character '}' after object key", 17}},
 167         {`{"X": "foo" "Y": "bar"}`, &SyntaxError{"invalid character '\"' after object key:value pair", 13}},
 168 }
 169
 170 func TestIndentErrors(t *testing.T) {
 171         for i, tt := range indentErrorTests {
 172                 slice := make([]uint8, 0)
 173                 buf := bytes.NewBuffer(slice)
 174                 if err := Indent(buf, []uint8(tt.in), "", ""); err != nil {
 175                         if !reflect.DeepEqual(err, tt.err) {
 176                                 t.Errorf("#%d: Indent: %#v", i, err)
 177                                 continue
 178                         }
 179                 }
 180         }
 181 }
 182
 183 func TestNextValueBig(t *testing.T) {
 184         initBig()
 185         var scan scanner
 186         item, rest, err := nextValue(jsonBig, &scan)
 187         if err != nil {
 188                 t.Fatalf("nextValue: %s", err)
 189         }
 190         if len(item) != len(jsonBig) || &item[0] != &jsonBig[0] {
 191                 t.Errorf("invalid item: %d %d", len(item), len(jsonBig))
 192         }
 193         if len(rest) != 0 {
 194                 t.Errorf("invalid rest: %d", len(rest))
 195         }
 196
 197         item, rest, err = nextValue(append(jsonBig, "HELLO WORLD"...), &scan)
 198         if err != nil {
 199                 t.Fatalf("nextValue extra: %s", err)
 200         }
 201         if len(item) != len(jsonBig) {
 202                 t.Errorf("invalid item: %d %d", len(item), len(jsonBig))
 203         }
 204         if string(rest) != "HELLO WORLD" {
 205                 t.Errorf("invalid rest: %d", len(rest))
 206         }
 207 }
 208
 209 var benchScan scanner
 210
 211 func BenchmarkSkipValue(b *testing.B) {
 212         initBig()
 213         b.ResetTimer()
 214         for i := 0; i < b.N; i++ {
 215                 nextValue(jsonBig, &benchScan)
 216         }
 217         b.SetBytes(int64(len(jsonBig)))
 218 }
 219
 220 func diff(t *testing.T, a, b []byte) {
 221         for i := 0; ; i++ {
 222                 if i >= len(a) || i >= len(b) || a[i] != b[i] {
 223                         j := i - 10
 224                         if j < 0 {
 225                                 j = 0
 226                         }
 227                         t.Errorf("diverge at %d: «%s» vs «%s»", i, trim(a[j:]), trim(b[j:]))
 228                         return
 229                 }
 230         }
 231 }
 232
 233 func trim(b []byte) []byte {
 234         if len(b) > 20 {
 235                 return b[0:20]
 236         }
 237         return b
 238 }
 239
 240 // Generate a random JSON object.
 241
 242 var jsonBig []byte
 243
 244 func initBig() {
 245         n := 10000
 246         if testing.Short() {
 247                 n = 100
 248         }
 249         b, err := Marshal(genValue(n))
 250         if err != nil {
 251                 panic(err)
 252         }
 253         jsonBig = b
 254 }
 255
 256 func genValue(n int) interface{} {
 257         if n > 1 {
 258                 switch rand.Intn(2) {
 259                 case 0:
 260                         return genArray(n)
 261                 case 1:
 262                         return genMap(n)
 263                 }
 264         }
 265         switch rand.Intn(3) {
 266         case 0:
 267                 return rand.Intn(2) == 0
 268         case 1:
 269                 return rand.NormFloat64()
 270         case 2:
 271                 return genString(30)
 272         }
 273         panic("unreachable")
 274 }
 275
 276 func genString(stddev float64) string {
 277         n := int(math.Abs(rand.NormFloat64()*stddev + stddev/2))
 278         c := make([]rune, n)
 279         for i := range c {
 280                 f := math.Abs(rand.NormFloat64()*64 + 32)
 281                 if f > 0x10ffff {
 282                         f = 0x10ffff
 283                 }
 284                 c[i] = rune(f)
 285         }
 286         return string(c)
 287 }
 288
 289 func genArray(n int) []interface{} {
 290         f := int(math.Abs(rand.NormFloat64()) * math.Min(10, float64(n/2)))
 291         if f > n {
 292                 f = n
 293         }
 294         if f < 1 {
 295                 f = 1
 296         }
 297         x := make([]interface{}, f)
 298         for i := range x {
 299                 x[i] = genValue(((i+1)*n)/f - (i*n)/f)
 300         }
 301         return x
 302 }
 303
 304 func genMap(n int) map[string]interface{} {
 305         f := int(math.Abs(rand.NormFloat64()) * math.Min(10, float64(n/2)))
 306         if f > n {
 307                 f = n
 308         }
 309         if n > 0 && f == 0 {
 310                 f = 1
 311         }
 312         x := make(map[string]interface{})
 313         for i := 0; i < f; i++ {
 314                 x[genString(10)] = genValue(((i+1)*n)/f - (i*n)/f)
 315         }
 316         return x
 317 }