Source file src/encoding/json/decode_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  	"encoding"
		10  	"errors"
		11  	"fmt"
		12  	"image"
		13  	"math"
		14  	"math/big"
		15  	"net"
		16  	"reflect"
		17  	"strconv"
		18  	"strings"
		19  	"testing"
		20  	"time"
		21  )
		22  
		23  type T struct {
		24  	X string
		25  	Y int
		26  	Z int `json:"-"`
		27  }
		28  
		29  type U struct {
		30  	Alphabet string `json:"alpha"`
		31  }
		32  
		33  type V struct {
		34  	F1 interface{}
		35  	F2 int32
		36  	F3 Number
		37  	F4 *VOuter
		38  }
		39  
		40  type VOuter struct {
		41  	V V
		42  }
		43  
		44  type W struct {
		45  	S SS
		46  }
		47  
		48  type P struct {
		49  	PP PP
		50  }
		51  
		52  type PP struct {
		53  	T	T
		54  	Ts []T
		55  }
		56  
		57  type SS string
		58  
		59  func (*SS) UnmarshalJSON(data []byte) error {
		60  	return &UnmarshalTypeError{Value: "number", Type: reflect.TypeOf(SS(""))}
		61  }
		62  
		63  // ifaceNumAsFloat64/ifaceNumAsNumber are used to test unmarshaling with and
		64  // without UseNumber
		65  var ifaceNumAsFloat64 = map[string]interface{}{
		66  	"k1": float64(1),
		67  	"k2": "s",
		68  	"k3": []interface{}{float64(1), float64(2.0), float64(3e-3)},
		69  	"k4": map[string]interface{}{"kk1": "s", "kk2": float64(2)},
		70  }
		71  
		72  var ifaceNumAsNumber = map[string]interface{}{
		73  	"k1": Number("1"),
		74  	"k2": "s",
		75  	"k3": []interface{}{Number("1"), Number("2.0"), Number("3e-3")},
		76  	"k4": map[string]interface{}{"kk1": "s", "kk2": Number("2")},
		77  }
		78  
		79  type tx struct {
		80  	x int
		81  }
		82  
		83  type u8 uint8
		84  
		85  // A type that can unmarshal itself.
		86  
		87  type unmarshaler struct {
		88  	T bool
		89  }
		90  
		91  func (u *unmarshaler) UnmarshalJSON(b []byte) error {
		92  	*u = unmarshaler{true} // All we need to see that UnmarshalJSON is called.
		93  	return nil
		94  }
		95  
		96  type ustruct struct {
		97  	M unmarshaler
		98  }
		99  
	 100  type unmarshalerText struct {
	 101  	A, B string
	 102  }
	 103  
	 104  // needed for re-marshaling tests
	 105  func (u unmarshalerText) MarshalText() ([]byte, error) {
	 106  	return []byte(u.A + ":" + u.B), nil
	 107  }
	 108  
	 109  func (u *unmarshalerText) UnmarshalText(b []byte) error {
	 110  	pos := bytes.IndexByte(b, ':')
	 111  	if pos == -1 {
	 112  		return errors.New("missing separator")
	 113  	}
	 114  	u.A, u.B = string(b[:pos]), string(b[pos+1:])
	 115  	return nil
	 116  }
	 117  
	 118  var _ encoding.TextUnmarshaler = (*unmarshalerText)(nil)
	 119  
	 120  type ustructText struct {
	 121  	M unmarshalerText
	 122  }
	 123  
	 124  // u8marshal is an integer type that can marshal/unmarshal itself.
	 125  type u8marshal uint8
	 126  
	 127  func (u8 u8marshal) MarshalText() ([]byte, error) {
	 128  	return []byte(fmt.Sprintf("u%d", u8)), nil
	 129  }
	 130  
	 131  var errMissingU8Prefix = errors.New("missing 'u' prefix")
	 132  
	 133  func (u8 *u8marshal) UnmarshalText(b []byte) error {
	 134  	if !bytes.HasPrefix(b, []byte{'u'}) {
	 135  		return errMissingU8Prefix
	 136  	}
	 137  	n, err := strconv.Atoi(string(b[1:]))
	 138  	if err != nil {
	 139  		return err
	 140  	}
	 141  	*u8 = u8marshal(n)
	 142  	return nil
	 143  }
	 144  
	 145  var _ encoding.TextUnmarshaler = (*u8marshal)(nil)
	 146  
	 147  var (
	 148  	umtrue	 = unmarshaler{true}
	 149  	umslice	= []unmarshaler{{true}}
	 150  	umstruct = ustruct{unmarshaler{true}}
	 151  
	 152  	umtrueXY	 = unmarshalerText{"x", "y"}
	 153  	umsliceXY	= []unmarshalerText{{"x", "y"}}
	 154  	umstructXY = ustructText{unmarshalerText{"x", "y"}}
	 155  
	 156  	ummapXY = map[unmarshalerText]bool{{"x", "y"}: true}
	 157  )
	 158  
	 159  // Test data structures for anonymous fields.
	 160  
	 161  type Point struct {
	 162  	Z int
	 163  }
	 164  
	 165  type Top struct {
	 166  	Level0 int
	 167  	Embed0
	 168  	*Embed0a
	 169  	*Embed0b `json:"e,omitempty"` // treated as named
	 170  	Embed0c	`json:"-"`					 // ignored
	 171  	Loop
	 172  	Embed0p // has Point with X, Y, used
	 173  	Embed0q // has Point with Z, used
	 174  	embed	 // contains exported field
	 175  }
	 176  
	 177  type Embed0 struct {
	 178  	Level1a int // overridden by Embed0a's Level1a with json tag
	 179  	Level1b int // used because Embed0a's Level1b is renamed
	 180  	Level1c int // used because Embed0a's Level1c is ignored
	 181  	Level1d int // annihilated by Embed0a's Level1d
	 182  	Level1e int `json:"x"` // annihilated by Embed0a.Level1e
	 183  }
	 184  
	 185  type Embed0a struct {
	 186  	Level1a int `json:"Level1a,omitempty"`
	 187  	Level1b int `json:"LEVEL1B,omitempty"`
	 188  	Level1c int `json:"-"`
	 189  	Level1d int // annihilated by Embed0's Level1d
	 190  	Level1f int `json:"x"` // annihilated by Embed0's Level1e
	 191  }
	 192  
	 193  type Embed0b Embed0
	 194  
	 195  type Embed0c Embed0
	 196  
	 197  type Embed0p struct {
	 198  	image.Point
	 199  }
	 200  
	 201  type Embed0q struct {
	 202  	Point
	 203  }
	 204  
	 205  type embed struct {
	 206  	Q int
	 207  }
	 208  
	 209  type Loop struct {
	 210  	Loop1 int `json:",omitempty"`
	 211  	Loop2 int `json:",omitempty"`
	 212  	*Loop
	 213  }
	 214  
	 215  // From reflect test:
	 216  // The X in S6 and S7 annihilate, but they also block the X in S8.S9.
	 217  type S5 struct {
	 218  	S6
	 219  	S7
	 220  	S8
	 221  }
	 222  
	 223  type S6 struct {
	 224  	X int
	 225  }
	 226  
	 227  type S7 S6
	 228  
	 229  type S8 struct {
	 230  	S9
	 231  }
	 232  
	 233  type S9 struct {
	 234  	X int
	 235  	Y int
	 236  }
	 237  
	 238  // From reflect test:
	 239  // The X in S11.S6 and S12.S6 annihilate, but they also block the X in S13.S8.S9.
	 240  type S10 struct {
	 241  	S11
	 242  	S12
	 243  	S13
	 244  }
	 245  
	 246  type S11 struct {
	 247  	S6
	 248  }
	 249  
	 250  type S12 struct {
	 251  	S6
	 252  }
	 253  
	 254  type S13 struct {
	 255  	S8
	 256  }
	 257  
	 258  type Ambig struct {
	 259  	// Given "hello", the first match should win.
	 260  	First	int `json:"HELLO"`
	 261  	Second int `json:"Hello"`
	 262  }
	 263  
	 264  type XYZ struct {
	 265  	X interface{}
	 266  	Y interface{}
	 267  	Z interface{}
	 268  }
	 269  
	 270  type unexportedWithMethods struct{}
	 271  
	 272  func (unexportedWithMethods) F() {}
	 273  
	 274  type byteWithMarshalJSON byte
	 275  
	 276  func (b byteWithMarshalJSON) MarshalJSON() ([]byte, error) {
	 277  	return []byte(fmt.Sprintf(`"Z%.2x"`, byte(b))), nil
	 278  }
	 279  
	 280  func (b *byteWithMarshalJSON) UnmarshalJSON(data []byte) error {
	 281  	if len(data) != 5 || data[0] != '"' || data[1] != 'Z' || data[4] != '"' {
	 282  		return fmt.Errorf("bad quoted string")
	 283  	}
	 284  	i, err := strconv.ParseInt(string(data[2:4]), 16, 8)
	 285  	if err != nil {
	 286  		return fmt.Errorf("bad hex")
	 287  	}
	 288  	*b = byteWithMarshalJSON(i)
	 289  	return nil
	 290  }
	 291  
	 292  type byteWithPtrMarshalJSON byte
	 293  
	 294  func (b *byteWithPtrMarshalJSON) MarshalJSON() ([]byte, error) {
	 295  	return byteWithMarshalJSON(*b).MarshalJSON()
	 296  }
	 297  
	 298  func (b *byteWithPtrMarshalJSON) UnmarshalJSON(data []byte) error {
	 299  	return (*byteWithMarshalJSON)(b).UnmarshalJSON(data)
	 300  }
	 301  
	 302  type byteWithMarshalText byte
	 303  
	 304  func (b byteWithMarshalText) MarshalText() ([]byte, error) {
	 305  	return []byte(fmt.Sprintf(`Z%.2x`, byte(b))), nil
	 306  }
	 307  
	 308  func (b *byteWithMarshalText) UnmarshalText(data []byte) error {
	 309  	if len(data) != 3 || data[0] != 'Z' {
	 310  		return fmt.Errorf("bad quoted string")
	 311  	}
	 312  	i, err := strconv.ParseInt(string(data[1:3]), 16, 8)
	 313  	if err != nil {
	 314  		return fmt.Errorf("bad hex")
	 315  	}
	 316  	*b = byteWithMarshalText(i)
	 317  	return nil
	 318  }
	 319  
	 320  type byteWithPtrMarshalText byte
	 321  
	 322  func (b *byteWithPtrMarshalText) MarshalText() ([]byte, error) {
	 323  	return byteWithMarshalText(*b).MarshalText()
	 324  }
	 325  
	 326  func (b *byteWithPtrMarshalText) UnmarshalText(data []byte) error {
	 327  	return (*byteWithMarshalText)(b).UnmarshalText(data)
	 328  }
	 329  
	 330  type intWithMarshalJSON int
	 331  
	 332  func (b intWithMarshalJSON) MarshalJSON() ([]byte, error) {
	 333  	return []byte(fmt.Sprintf(`"Z%.2x"`, int(b))), nil
	 334  }
	 335  
	 336  func (b *intWithMarshalJSON) UnmarshalJSON(data []byte) error {
	 337  	if len(data) != 5 || data[0] != '"' || data[1] != 'Z' || data[4] != '"' {
	 338  		return fmt.Errorf("bad quoted string")
	 339  	}
	 340  	i, err := strconv.ParseInt(string(data[2:4]), 16, 8)
	 341  	if err != nil {
	 342  		return fmt.Errorf("bad hex")
	 343  	}
	 344  	*b = intWithMarshalJSON(i)
	 345  	return nil
	 346  }
	 347  
	 348  type intWithPtrMarshalJSON int
	 349  
	 350  func (b *intWithPtrMarshalJSON) MarshalJSON() ([]byte, error) {
	 351  	return intWithMarshalJSON(*b).MarshalJSON()
	 352  }
	 353  
	 354  func (b *intWithPtrMarshalJSON) UnmarshalJSON(data []byte) error {
	 355  	return (*intWithMarshalJSON)(b).UnmarshalJSON(data)
	 356  }
	 357  
	 358  type intWithMarshalText int
	 359  
	 360  func (b intWithMarshalText) MarshalText() ([]byte, error) {
	 361  	return []byte(fmt.Sprintf(`Z%.2x`, int(b))), nil
	 362  }
	 363  
	 364  func (b *intWithMarshalText) UnmarshalText(data []byte) error {
	 365  	if len(data) != 3 || data[0] != 'Z' {
	 366  		return fmt.Errorf("bad quoted string")
	 367  	}
	 368  	i, err := strconv.ParseInt(string(data[1:3]), 16, 8)
	 369  	if err != nil {
	 370  		return fmt.Errorf("bad hex")
	 371  	}
	 372  	*b = intWithMarshalText(i)
	 373  	return nil
	 374  }
	 375  
	 376  type intWithPtrMarshalText int
	 377  
	 378  func (b *intWithPtrMarshalText) MarshalText() ([]byte, error) {
	 379  	return intWithMarshalText(*b).MarshalText()
	 380  }
	 381  
	 382  func (b *intWithPtrMarshalText) UnmarshalText(data []byte) error {
	 383  	return (*intWithMarshalText)(b).UnmarshalText(data)
	 384  }
	 385  
	 386  type mapStringToStringData struct {
	 387  	Data map[string]string `json:"data"`
	 388  }
	 389  
	 390  type unmarshalTest struct {
	 391  	in										string
	 392  	ptr									 interface{} // new(type)
	 393  	out									 interface{}
	 394  	err									 error
	 395  	useNumber						 bool
	 396  	golden								bool
	 397  	disallowUnknownFields bool
	 398  }
	 399  
	 400  type B struct {
	 401  	B bool `json:",string"`
	 402  }
	 403  
	 404  type DoublePtr struct {
	 405  	I **int
	 406  	J **int
	 407  }
	 408  
	 409  var unmarshalTests = []unmarshalTest{
	 410  	// basic types
	 411  	{in: `true`, ptr: new(bool), out: true},
	 412  	{in: `1`, ptr: new(int), out: 1},
	 413  	{in: `1.2`, ptr: new(float64), out: 1.2},
	 414  	{in: `-5`, ptr: new(int16), out: int16(-5)},
	 415  	{in: `2`, ptr: new(Number), out: Number("2"), useNumber: true},
	 416  	{in: `2`, ptr: new(Number), out: Number("2")},
	 417  	{in: `2`, ptr: new(interface{}), out: float64(2.0)},
	 418  	{in: `2`, ptr: new(interface{}), out: Number("2"), useNumber: true},
	 419  	{in: `"a\u1234"`, ptr: new(string), out: "a\u1234"},
	 420  	{in: `"http:\/\/"`, ptr: new(string), out: "http://"},
	 421  	{in: `"g-clef: \uD834\uDD1E"`, ptr: new(string), out: "g-clef: \U0001D11E"},
	 422  	{in: `"invalid: \uD834x\uDD1E"`, ptr: new(string), out: "invalid: \uFFFDx\uFFFD"},
	 423  	{in: "null", ptr: new(interface{}), out: nil},
	 424  	{in: `{"X": [1,2,3], "Y": 4}`, ptr: new(T), out: T{Y: 4}, err: &UnmarshalTypeError{"array", reflect.TypeOf(""), 7, "T", "X"}},
	 425  	{in: `{"X": 23}`, ptr: new(T), out: T{}, err: &UnmarshalTypeError{"number", reflect.TypeOf(""), 8, "T", "X"}}, {in: `{"x": 1}`, ptr: new(tx), out: tx{}},
	 426  	{in: `{"x": 1}`, ptr: new(tx), out: tx{}},
	 427  	{in: `{"x": 1}`, ptr: new(tx), err: fmt.Errorf("json: unknown field \"x\""), disallowUnknownFields: true},
	 428  	{in: `{"S": 23}`, ptr: new(W), out: W{}, err: &UnmarshalTypeError{"number", reflect.TypeOf(SS("")), 0, "W", "S"}},
	 429  	{in: `{"F1":1,"F2":2,"F3":3}`, ptr: new(V), out: V{F1: float64(1), F2: int32(2), F3: Number("3")}},
	 430  	{in: `{"F1":1,"F2":2,"F3":3}`, ptr: new(V), out: V{F1: Number("1"), F2: int32(2), F3: Number("3")}, useNumber: true},
	 431  	{in: `{"k1":1,"k2":"s","k3":[1,2.0,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(interface{}), out: ifaceNumAsFloat64},
	 432  	{in: `{"k1":1,"k2":"s","k3":[1,2.0,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(interface{}), out: ifaceNumAsNumber, useNumber: true},
	 433  
	 434  	// raw values with whitespace
	 435  	{in: "\n true ", ptr: new(bool), out: true},
	 436  	{in: "\t 1 ", ptr: new(int), out: 1},
	 437  	{in: "\r 1.2 ", ptr: new(float64), out: 1.2},
	 438  	{in: "\t -5 \n", ptr: new(int16), out: int16(-5)},
	 439  	{in: "\t \"a\\u1234\" \n", ptr: new(string), out: "a\u1234"},
	 440  
	 441  	// Z has a "-" tag.
	 442  	{in: `{"Y": 1, "Z": 2}`, ptr: new(T), out: T{Y: 1}},
	 443  	{in: `{"Y": 1, "Z": 2}`, ptr: new(T), err: fmt.Errorf("json: unknown field \"Z\""), disallowUnknownFields: true},
	 444  
	 445  	{in: `{"alpha": "abc", "alphabet": "xyz"}`, ptr: new(U), out: U{Alphabet: "abc"}},
	 446  	{in: `{"alpha": "abc", "alphabet": "xyz"}`, ptr: new(U), err: fmt.Errorf("json: unknown field \"alphabet\""), disallowUnknownFields: true},
	 447  	{in: `{"alpha": "abc"}`, ptr: new(U), out: U{Alphabet: "abc"}},
	 448  	{in: `{"alphabet": "xyz"}`, ptr: new(U), out: U{}},
	 449  	{in: `{"alphabet": "xyz"}`, ptr: new(U), err: fmt.Errorf("json: unknown field \"alphabet\""), disallowUnknownFields: true},
	 450  
	 451  	// syntax errors
	 452  	{in: `{"X": "foo", "Y"}`, err: &SyntaxError{"invalid character '}' after object key", 17}},
	 453  	{in: `[1, 2, 3+]`, err: &SyntaxError{"invalid character '+' after array element", 9}},
	 454  	{in: `{"X":12x}`, err: &SyntaxError{"invalid character 'x' after object key:value pair", 8}, useNumber: true},
	 455  	{in: `[2, 3`, err: &SyntaxError{msg: "unexpected end of JSON input", Offset: 5}},
	 456  	{in: `{"F3": -}`, ptr: new(V), out: V{F3: Number("-")}, err: &SyntaxError{msg: "invalid character '}' in numeric literal", Offset: 9}},
	 457  
	 458  	// raw value errors
	 459  	{in: "\x01 42", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},
	 460  	{in: " 42 \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 5}},
	 461  	{in: "\x01 true", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},
	 462  	{in: " false \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 8}},
	 463  	{in: "\x01 1.2", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},
	 464  	{in: " 3.4 \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 6}},
	 465  	{in: "\x01 \"string\"", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},
	 466  	{in: " \"string\" \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 11}},
	 467  
	 468  	// array tests
	 469  	{in: `[1, 2, 3]`, ptr: new([3]int), out: [3]int{1, 2, 3}},
	 470  	{in: `[1, 2, 3]`, ptr: new([1]int), out: [1]int{1}},
	 471  	{in: `[1, 2, 3]`, ptr: new([5]int), out: [5]int{1, 2, 3, 0, 0}},
	 472  	{in: `[1, 2, 3]`, ptr: new(MustNotUnmarshalJSON), err: errors.New("MustNotUnmarshalJSON was used")},
	 473  
	 474  	// empty array to interface test
	 475  	{in: `[]`, ptr: new([]interface{}), out: []interface{}{}},
	 476  	{in: `null`, ptr: new([]interface{}), out: []interface{}(nil)},
	 477  	{in: `{"T":[]}`, ptr: new(map[string]interface{}), out: map[string]interface{}{"T": []interface{}{}}},
	 478  	{in: `{"T":null}`, ptr: new(map[string]interface{}), out: map[string]interface{}{"T": interface{}(nil)}},
	 479  
	 480  	// composite tests
	 481  	{in: allValueIndent, ptr: new(All), out: allValue},
	 482  	{in: allValueCompact, ptr: new(All), out: allValue},
	 483  	{in: allValueIndent, ptr: new(*All), out: &allValue},
	 484  	{in: allValueCompact, ptr: new(*All), out: &allValue},
	 485  	{in: pallValueIndent, ptr: new(All), out: pallValue},
	 486  	{in: pallValueCompact, ptr: new(All), out: pallValue},
	 487  	{in: pallValueIndent, ptr: new(*All), out: &pallValue},
	 488  	{in: pallValueCompact, ptr: new(*All), out: &pallValue},
	 489  
	 490  	// unmarshal interface test
	 491  	{in: `{"T":false}`, ptr: new(unmarshaler), out: umtrue}, // use "false" so test will fail if custom unmarshaler is not called
	 492  	{in: `{"T":false}`, ptr: new(*unmarshaler), out: &umtrue},
	 493  	{in: `[{"T":false}]`, ptr: new([]unmarshaler), out: umslice},
	 494  	{in: `[{"T":false}]`, ptr: new(*[]unmarshaler), out: &umslice},
	 495  	{in: `{"M":{"T":"x:y"}}`, ptr: new(ustruct), out: umstruct},
	 496  
	 497  	// UnmarshalText interface test
	 498  	{in: `"x:y"`, ptr: new(unmarshalerText), out: umtrueXY},
	 499  	{in: `"x:y"`, ptr: new(*unmarshalerText), out: &umtrueXY},
	 500  	{in: `["x:y"]`, ptr: new([]unmarshalerText), out: umsliceXY},
	 501  	{in: `["x:y"]`, ptr: new(*[]unmarshalerText), out: &umsliceXY},
	 502  	{in: `{"M":"x:y"}`, ptr: new(ustructText), out: umstructXY},
	 503  
	 504  	// integer-keyed map test
	 505  	{
	 506  		in:	`{"-1":"a","0":"b","1":"c"}`,
	 507  		ptr: new(map[int]string),
	 508  		out: map[int]string{-1: "a", 0: "b", 1: "c"},
	 509  	},
	 510  	{
	 511  		in:	`{"0":"a","10":"c","9":"b"}`,
	 512  		ptr: new(map[u8]string),
	 513  		out: map[u8]string{0: "a", 9: "b", 10: "c"},
	 514  	},
	 515  	{
	 516  		in:	`{"-9223372036854775808":"min","9223372036854775807":"max"}`,
	 517  		ptr: new(map[int64]string),
	 518  		out: map[int64]string{math.MinInt64: "min", math.MaxInt64: "max"},
	 519  	},
	 520  	{
	 521  		in:	`{"18446744073709551615":"max"}`,
	 522  		ptr: new(map[uint64]string),
	 523  		out: map[uint64]string{math.MaxUint64: "max"},
	 524  	},
	 525  	{
	 526  		in:	`{"0":false,"10":true}`,
	 527  		ptr: new(map[uintptr]bool),
	 528  		out: map[uintptr]bool{0: false, 10: true},
	 529  	},
	 530  
	 531  	// Check that MarshalText and UnmarshalText take precedence
	 532  	// over default integer handling in map keys.
	 533  	{
	 534  		in:	`{"u2":4}`,
	 535  		ptr: new(map[u8marshal]int),
	 536  		out: map[u8marshal]int{2: 4},
	 537  	},
	 538  	{
	 539  		in:	`{"2":4}`,
	 540  		ptr: new(map[u8marshal]int),
	 541  		err: errMissingU8Prefix,
	 542  	},
	 543  
	 544  	// integer-keyed map errors
	 545  	{
	 546  		in:	`{"abc":"abc"}`,
	 547  		ptr: new(map[int]string),
	 548  		err: &UnmarshalTypeError{Value: "number abc", Type: reflect.TypeOf(0), Offset: 2},
	 549  	},
	 550  	{
	 551  		in:	`{"256":"abc"}`,
	 552  		ptr: new(map[uint8]string),
	 553  		err: &UnmarshalTypeError{Value: "number 256", Type: reflect.TypeOf(uint8(0)), Offset: 2},
	 554  	},
	 555  	{
	 556  		in:	`{"128":"abc"}`,
	 557  		ptr: new(map[int8]string),
	 558  		err: &UnmarshalTypeError{Value: "number 128", Type: reflect.TypeOf(int8(0)), Offset: 2},
	 559  	},
	 560  	{
	 561  		in:	`{"-1":"abc"}`,
	 562  		ptr: new(map[uint8]string),
	 563  		err: &UnmarshalTypeError{Value: "number -1", Type: reflect.TypeOf(uint8(0)), Offset: 2},
	 564  	},
	 565  	{
	 566  		in:	`{"F":{"a":2,"3":4}}`,
	 567  		ptr: new(map[string]map[int]int),
	 568  		err: &UnmarshalTypeError{Value: "number a", Type: reflect.TypeOf(int(0)), Offset: 7},
	 569  	},
	 570  	{
	 571  		in:	`{"F":{"a":2,"3":4}}`,
	 572  		ptr: new(map[string]map[uint]int),
	 573  		err: &UnmarshalTypeError{Value: "number a", Type: reflect.TypeOf(uint(0)), Offset: 7},
	 574  	},
	 575  
	 576  	// Map keys can be encoding.TextUnmarshalers.
	 577  	{in: `{"x:y":true}`, ptr: new(map[unmarshalerText]bool), out: ummapXY},
	 578  	// If multiple values for the same key exists, only the most recent value is used.
	 579  	{in: `{"x:y":false,"x:y":true}`, ptr: new(map[unmarshalerText]bool), out: ummapXY},
	 580  
	 581  	{
	 582  		in: `{
	 583  			"Level0": 1,
	 584  			"Level1b": 2,
	 585  			"Level1c": 3,
	 586  			"x": 4,
	 587  			"Level1a": 5,
	 588  			"LEVEL1B": 6,
	 589  			"e": {
	 590  				"Level1a": 8,
	 591  				"Level1b": 9,
	 592  				"Level1c": 10,
	 593  				"Level1d": 11,
	 594  				"x": 12
	 595  			},
	 596  			"Loop1": 13,
	 597  			"Loop2": 14,
	 598  			"X": 15,
	 599  			"Y": 16,
	 600  			"Z": 17,
	 601  			"Q": 18
	 602  		}`,
	 603  		ptr: new(Top),
	 604  		out: Top{
	 605  			Level0: 1,
	 606  			Embed0: Embed0{
	 607  				Level1b: 2,
	 608  				Level1c: 3,
	 609  			},
	 610  			Embed0a: &Embed0a{
	 611  				Level1a: 5,
	 612  				Level1b: 6,
	 613  			},
	 614  			Embed0b: &Embed0b{
	 615  				Level1a: 8,
	 616  				Level1b: 9,
	 617  				Level1c: 10,
	 618  				Level1d: 11,
	 619  				Level1e: 12,
	 620  			},
	 621  			Loop: Loop{
	 622  				Loop1: 13,
	 623  				Loop2: 14,
	 624  			},
	 625  			Embed0p: Embed0p{
	 626  				Point: image.Point{X: 15, Y: 16},
	 627  			},
	 628  			Embed0q: Embed0q{
	 629  				Point: Point{Z: 17},
	 630  			},
	 631  			embed: embed{
	 632  				Q: 18,
	 633  			},
	 634  		},
	 635  	},
	 636  	{
	 637  		in:	`{"hello": 1}`,
	 638  		ptr: new(Ambig),
	 639  		out: Ambig{First: 1},
	 640  	},
	 641  
	 642  	{
	 643  		in:	`{"X": 1,"Y":2}`,
	 644  		ptr: new(S5),
	 645  		out: S5{S8: S8{S9: S9{Y: 2}}},
	 646  	},
	 647  	{
	 648  		in:										`{"X": 1,"Y":2}`,
	 649  		ptr:									 new(S5),
	 650  		err:									 fmt.Errorf("json: unknown field \"X\""),
	 651  		disallowUnknownFields: true,
	 652  	},
	 653  	{
	 654  		in:	`{"X": 1,"Y":2}`,
	 655  		ptr: new(S10),
	 656  		out: S10{S13: S13{S8: S8{S9: S9{Y: 2}}}},
	 657  	},
	 658  	{
	 659  		in:										`{"X": 1,"Y":2}`,
	 660  		ptr:									 new(S10),
	 661  		err:									 fmt.Errorf("json: unknown field \"X\""),
	 662  		disallowUnknownFields: true,
	 663  	},
	 664  	{
	 665  		in:	`{"I": 0, "I": null, "J": null}`,
	 666  		ptr: new(DoublePtr),
	 667  		out: DoublePtr{I: nil, J: nil},
	 668  	},
	 669  
	 670  	// invalid UTF-8 is coerced to valid UTF-8.
	 671  	{
	 672  		in:	"\"hello\xffworld\"",
	 673  		ptr: new(string),
	 674  		out: "hello\ufffdworld",
	 675  	},
	 676  	{
	 677  		in:	"\"hello\xc2\xc2world\"",
	 678  		ptr: new(string),
	 679  		out: "hello\ufffd\ufffdworld",
	 680  	},
	 681  	{
	 682  		in:	"\"hello\xc2\xffworld\"",
	 683  		ptr: new(string),
	 684  		out: "hello\ufffd\ufffdworld",
	 685  	},
	 686  	{
	 687  		in:	"\"hello\\ud800world\"",
	 688  		ptr: new(string),
	 689  		out: "hello\ufffdworld",
	 690  	},
	 691  	{
	 692  		in:	"\"hello\\ud800\\ud800world\"",
	 693  		ptr: new(string),
	 694  		out: "hello\ufffd\ufffdworld",
	 695  	},
	 696  	{
	 697  		in:	"\"hello\\ud800\\ud800world\"",
	 698  		ptr: new(string),
	 699  		out: "hello\ufffd\ufffdworld",
	 700  	},
	 701  	{
	 702  		in:	"\"hello\xed\xa0\x80\xed\xb0\x80world\"",
	 703  		ptr: new(string),
	 704  		out: "hello\ufffd\ufffd\ufffd\ufffd\ufffd\ufffdworld",
	 705  	},
	 706  
	 707  	// Used to be issue 8305, but time.Time implements encoding.TextUnmarshaler so this works now.
	 708  	{
	 709  		in:	`{"2009-11-10T23:00:00Z": "hello world"}`,
	 710  		ptr: new(map[time.Time]string),
	 711  		out: map[time.Time]string{time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC): "hello world"},
	 712  	},
	 713  
	 714  	// issue 8305
	 715  	{
	 716  		in:	`{"2009-11-10T23:00:00Z": "hello world"}`,
	 717  		ptr: new(map[Point]string),
	 718  		err: &UnmarshalTypeError{Value: "object", Type: reflect.TypeOf(map[Point]string{}), Offset: 1},
	 719  	},
	 720  	{
	 721  		in:	`{"asdf": "hello world"}`,
	 722  		ptr: new(map[unmarshaler]string),
	 723  		err: &UnmarshalTypeError{Value: "object", Type: reflect.TypeOf(map[unmarshaler]string{}), Offset: 1},
	 724  	},
	 725  
	 726  	// related to issue 13783.
	 727  	// Go 1.7 changed marshaling a slice of typed byte to use the methods on the byte type,
	 728  	// similar to marshaling a slice of typed int.
	 729  	// These tests check that, assuming the byte type also has valid decoding methods,
	 730  	// either the old base64 string encoding or the new per-element encoding can be
	 731  	// successfully unmarshaled. The custom unmarshalers were accessible in earlier
	 732  	// versions of Go, even though the custom marshaler was not.
	 733  	{
	 734  		in:	`"AQID"`,
	 735  		ptr: new([]byteWithMarshalJSON),
	 736  		out: []byteWithMarshalJSON{1, 2, 3},
	 737  	},
	 738  	{
	 739  		in:		 `["Z01","Z02","Z03"]`,
	 740  		ptr:		new([]byteWithMarshalJSON),
	 741  		out:		[]byteWithMarshalJSON{1, 2, 3},
	 742  		golden: true,
	 743  	},
	 744  	{
	 745  		in:	`"AQID"`,
	 746  		ptr: new([]byteWithMarshalText),
	 747  		out: []byteWithMarshalText{1, 2, 3},
	 748  	},
	 749  	{
	 750  		in:		 `["Z01","Z02","Z03"]`,
	 751  		ptr:		new([]byteWithMarshalText),
	 752  		out:		[]byteWithMarshalText{1, 2, 3},
	 753  		golden: true,
	 754  	},
	 755  	{
	 756  		in:	`"AQID"`,
	 757  		ptr: new([]byteWithPtrMarshalJSON),
	 758  		out: []byteWithPtrMarshalJSON{1, 2, 3},
	 759  	},
	 760  	{
	 761  		in:		 `["Z01","Z02","Z03"]`,
	 762  		ptr:		new([]byteWithPtrMarshalJSON),
	 763  		out:		[]byteWithPtrMarshalJSON{1, 2, 3},
	 764  		golden: true,
	 765  	},
	 766  	{
	 767  		in:	`"AQID"`,
	 768  		ptr: new([]byteWithPtrMarshalText),
	 769  		out: []byteWithPtrMarshalText{1, 2, 3},
	 770  	},
	 771  	{
	 772  		in:		 `["Z01","Z02","Z03"]`,
	 773  		ptr:		new([]byteWithPtrMarshalText),
	 774  		out:		[]byteWithPtrMarshalText{1, 2, 3},
	 775  		golden: true,
	 776  	},
	 777  
	 778  	// ints work with the marshaler but not the base64 []byte case
	 779  	{
	 780  		in:		 `["Z01","Z02","Z03"]`,
	 781  		ptr:		new([]intWithMarshalJSON),
	 782  		out:		[]intWithMarshalJSON{1, 2, 3},
	 783  		golden: true,
	 784  	},
	 785  	{
	 786  		in:		 `["Z01","Z02","Z03"]`,
	 787  		ptr:		new([]intWithMarshalText),
	 788  		out:		[]intWithMarshalText{1, 2, 3},
	 789  		golden: true,
	 790  	},
	 791  	{
	 792  		in:		 `["Z01","Z02","Z03"]`,
	 793  		ptr:		new([]intWithPtrMarshalJSON),
	 794  		out:		[]intWithPtrMarshalJSON{1, 2, 3},
	 795  		golden: true,
	 796  	},
	 797  	{
	 798  		in:		 `["Z01","Z02","Z03"]`,
	 799  		ptr:		new([]intWithPtrMarshalText),
	 800  		out:		[]intWithPtrMarshalText{1, 2, 3},
	 801  		golden: true,
	 802  	},
	 803  
	 804  	{in: `0.000001`, ptr: new(float64), out: 0.000001, golden: true},
	 805  	{in: `1e-7`, ptr: new(float64), out: 1e-7, golden: true},
	 806  	{in: `100000000000000000000`, ptr: new(float64), out: 100000000000000000000.0, golden: true},
	 807  	{in: `1e+21`, ptr: new(float64), out: 1e21, golden: true},
	 808  	{in: `-0.000001`, ptr: new(float64), out: -0.000001, golden: true},
	 809  	{in: `-1e-7`, ptr: new(float64), out: -1e-7, golden: true},
	 810  	{in: `-100000000000000000000`, ptr: new(float64), out: -100000000000000000000.0, golden: true},
	 811  	{in: `-1e+21`, ptr: new(float64), out: -1e21, golden: true},
	 812  	{in: `999999999999999900000`, ptr: new(float64), out: 999999999999999900000.0, golden: true},
	 813  	{in: `9007199254740992`, ptr: new(float64), out: 9007199254740992.0, golden: true},
	 814  	{in: `9007199254740993`, ptr: new(float64), out: 9007199254740992.0, golden: false},
	 815  
	 816  	{
	 817  		in:	`{"V": {"F2": "hello"}}`,
	 818  		ptr: new(VOuter),
	 819  		err: &UnmarshalTypeError{
	 820  			Value:	"string",
	 821  			Struct: "V",
	 822  			Field:	"V.F2",
	 823  			Type:	 reflect.TypeOf(int32(0)),
	 824  			Offset: 20,
	 825  		},
	 826  	},
	 827  	{
	 828  		in:	`{"V": {"F4": {}, "F2": "hello"}}`,
	 829  		ptr: new(VOuter),
	 830  		err: &UnmarshalTypeError{
	 831  			Value:	"string",
	 832  			Struct: "V",
	 833  			Field:	"V.F2",
	 834  			Type:	 reflect.TypeOf(int32(0)),
	 835  			Offset: 30,
	 836  		},
	 837  	},
	 838  
	 839  	// issue 15146.
	 840  	// invalid inputs in wrongStringTests below.
	 841  	{in: `{"B":"true"}`, ptr: new(B), out: B{true}, golden: true},
	 842  	{in: `{"B":"false"}`, ptr: new(B), out: B{false}, golden: true},
	 843  	{in: `{"B": "maybe"}`, ptr: new(B), err: errors.New(`json: invalid use of ,string struct tag, trying to unmarshal "maybe" into bool`)},
	 844  	{in: `{"B": "tru"}`, ptr: new(B), err: errors.New(`json: invalid use of ,string struct tag, trying to unmarshal "tru" into bool`)},
	 845  	{in: `{"B": "False"}`, ptr: new(B), err: errors.New(`json: invalid use of ,string struct tag, trying to unmarshal "False" into bool`)},
	 846  	{in: `{"B": "null"}`, ptr: new(B), out: B{false}},
	 847  	{in: `{"B": "nul"}`, ptr: new(B), err: errors.New(`json: invalid use of ,string struct tag, trying to unmarshal "nul" into bool`)},
	 848  	{in: `{"B": [2, 3]}`, ptr: new(B), err: errors.New(`json: invalid use of ,string struct tag, trying to unmarshal unquoted value into bool`)},
	 849  
	 850  	// additional tests for disallowUnknownFields
	 851  	{
	 852  		in: `{
	 853  			"Level0": 1,
	 854  			"Level1b": 2,
	 855  			"Level1c": 3,
	 856  			"x": 4,
	 857  			"Level1a": 5,
	 858  			"LEVEL1B": 6,
	 859  			"e": {
	 860  				"Level1a": 8,
	 861  				"Level1b": 9,
	 862  				"Level1c": 10,
	 863  				"Level1d": 11,
	 864  				"x": 12
	 865  			},
	 866  			"Loop1": 13,
	 867  			"Loop2": 14,
	 868  			"X": 15,
	 869  			"Y": 16,
	 870  			"Z": 17,
	 871  			"Q": 18,
	 872  			"extra": true
	 873  		}`,
	 874  		ptr:									 new(Top),
	 875  		err:									 fmt.Errorf("json: unknown field \"extra\""),
	 876  		disallowUnknownFields: true,
	 877  	},
	 878  	{
	 879  		in: `{
	 880  			"Level0": 1,
	 881  			"Level1b": 2,
	 882  			"Level1c": 3,
	 883  			"x": 4,
	 884  			"Level1a": 5,
	 885  			"LEVEL1B": 6,
	 886  			"e": {
	 887  				"Level1a": 8,
	 888  				"Level1b": 9,
	 889  				"Level1c": 10,
	 890  				"Level1d": 11,
	 891  				"x": 12,
	 892  				"extra": null
	 893  			},
	 894  			"Loop1": 13,
	 895  			"Loop2": 14,
	 896  			"X": 15,
	 897  			"Y": 16,
	 898  			"Z": 17,
	 899  			"Q": 18
	 900  		}`,
	 901  		ptr:									 new(Top),
	 902  		err:									 fmt.Errorf("json: unknown field \"extra\""),
	 903  		disallowUnknownFields: true,
	 904  	},
	 905  	// issue 26444
	 906  	// UnmarshalTypeError without field & struct values
	 907  	{
	 908  		in:	`{"data":{"test1": "bob", "test2": 123}}`,
	 909  		ptr: new(mapStringToStringData),
	 910  		err: &UnmarshalTypeError{Value: "number", Type: reflect.TypeOf(""), Offset: 37, Struct: "mapStringToStringData", Field: "data"},
	 911  	},
	 912  	{
	 913  		in:	`{"data":{"test1": 123, "test2": "bob"}}`,
	 914  		ptr: new(mapStringToStringData),
	 915  		err: &UnmarshalTypeError{Value: "number", Type: reflect.TypeOf(""), Offset: 21, Struct: "mapStringToStringData", Field: "data"},
	 916  	},
	 917  
	 918  	// trying to decode JSON arrays or objects via TextUnmarshaler
	 919  	{
	 920  		in:	`[1, 2, 3]`,
	 921  		ptr: new(MustNotUnmarshalText),
	 922  		err: &UnmarshalTypeError{Value: "array", Type: reflect.TypeOf(&MustNotUnmarshalText{}), Offset: 1},
	 923  	},
	 924  	{
	 925  		in:	`{"foo": "bar"}`,
	 926  		ptr: new(MustNotUnmarshalText),
	 927  		err: &UnmarshalTypeError{Value: "object", Type: reflect.TypeOf(&MustNotUnmarshalText{}), Offset: 1},
	 928  	},
	 929  	// #22369
	 930  	{
	 931  		in:	`{"PP": {"T": {"Y": "bad-type"}}}`,
	 932  		ptr: new(P),
	 933  		err: &UnmarshalTypeError{
	 934  			Value:	"string",
	 935  			Struct: "T",
	 936  			Field:	"PP.T.Y",
	 937  			Type:	 reflect.TypeOf(int(0)),
	 938  			Offset: 29,
	 939  		},
	 940  	},
	 941  	{
	 942  		in:	`{"Ts": [{"Y": 1}, {"Y": 2}, {"Y": "bad-type"}]}`,
	 943  		ptr: new(PP),
	 944  		err: &UnmarshalTypeError{
	 945  			Value:	"string",
	 946  			Struct: "T",
	 947  			Field:	"Ts.Y",
	 948  			Type:	 reflect.TypeOf(int(0)),
	 949  			Offset: 29,
	 950  		},
	 951  	},
	 952  	// #14702
	 953  	{
	 954  		in:	`invalid`,
	 955  		ptr: new(Number),
	 956  		err: &SyntaxError{
	 957  			msg:		"invalid character 'i' looking for beginning of value",
	 958  			Offset: 1,
	 959  		},
	 960  	},
	 961  	{
	 962  		in:	`"invalid"`,
	 963  		ptr: new(Number),
	 964  		err: fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", `"invalid"`),
	 965  	},
	 966  	{
	 967  		in:	`{"A":"invalid"}`,
	 968  		ptr: new(struct{ A Number }),
	 969  		err: fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", `"invalid"`),
	 970  	},
	 971  	{
	 972  		in: `{"A":"invalid"}`,
	 973  		ptr: new(struct {
	 974  			A Number `json:",string"`
	 975  		}),
	 976  		err: fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into json.Number", `invalid`),
	 977  	},
	 978  	{
	 979  		in:	`{"A":"invalid"}`,
	 980  		ptr: new(map[string]Number),
	 981  		err: fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", `"invalid"`),
	 982  	},
	 983  }
	 984  
	 985  func TestMarshal(t *testing.T) {
	 986  	b, err := Marshal(allValue)
	 987  	if err != nil {
	 988  		t.Fatalf("Marshal allValue: %v", err)
	 989  	}
	 990  	if string(b) != allValueCompact {
	 991  		t.Errorf("Marshal allValueCompact")
	 992  		diff(t, b, []byte(allValueCompact))
	 993  		return
	 994  	}
	 995  
	 996  	b, err = Marshal(pallValue)
	 997  	if err != nil {
	 998  		t.Fatalf("Marshal pallValue: %v", err)
	 999  	}
	1000  	if string(b) != pallValueCompact {
	1001  		t.Errorf("Marshal pallValueCompact")
	1002  		diff(t, b, []byte(pallValueCompact))
	1003  		return
	1004  	}
	1005  }
	1006  
	1007  var badUTF8 = []struct {
	1008  	in, out string
	1009  }{
	1010  	{"hello\xffworld", `"hello\ufffdworld"`},
	1011  	{"", `""`},
	1012  	{"\xff", `"\ufffd"`},
	1013  	{"\xff\xff", `"\ufffd\ufffd"`},
	1014  	{"a\xffb", `"a\ufffdb"`},
	1015  	{"\xe6\x97\xa5\xe6\x9c\xac\xff\xaa\x9e", `"日本\ufffd\ufffd\ufffd"`},
	1016  }
	1017  
	1018  func TestMarshalBadUTF8(t *testing.T) {
	1019  	for _, tt := range badUTF8 {
	1020  		b, err := Marshal(tt.in)
	1021  		if string(b) != tt.out || err != nil {
	1022  			t.Errorf("Marshal(%q) = %#q, %v, want %#q, nil", tt.in, b, err, tt.out)
	1023  		}
	1024  	}
	1025  }
	1026  
	1027  func TestMarshalNumberZeroVal(t *testing.T) {
	1028  	var n Number
	1029  	out, err := Marshal(n)
	1030  	if err != nil {
	1031  		t.Fatal(err)
	1032  	}
	1033  	outStr := string(out)
	1034  	if outStr != "0" {
	1035  		t.Fatalf("Invalid zero val for Number: %q", outStr)
	1036  	}
	1037  }
	1038  
	1039  func TestMarshalEmbeds(t *testing.T) {
	1040  	top := &Top{
	1041  		Level0: 1,
	1042  		Embed0: Embed0{
	1043  			Level1b: 2,
	1044  			Level1c: 3,
	1045  		},
	1046  		Embed0a: &Embed0a{
	1047  			Level1a: 5,
	1048  			Level1b: 6,
	1049  		},
	1050  		Embed0b: &Embed0b{
	1051  			Level1a: 8,
	1052  			Level1b: 9,
	1053  			Level1c: 10,
	1054  			Level1d: 11,
	1055  			Level1e: 12,
	1056  		},
	1057  		Loop: Loop{
	1058  			Loop1: 13,
	1059  			Loop2: 14,
	1060  		},
	1061  		Embed0p: Embed0p{
	1062  			Point: image.Point{X: 15, Y: 16},
	1063  		},
	1064  		Embed0q: Embed0q{
	1065  			Point: Point{Z: 17},
	1066  		},
	1067  		embed: embed{
	1068  			Q: 18,
	1069  		},
	1070  	}
	1071  	b, err := Marshal(top)
	1072  	if err != nil {
	1073  		t.Fatal(err)
	1074  	}
	1075  	want := "{\"Level0\":1,\"Level1b\":2,\"Level1c\":3,\"Level1a\":5,\"LEVEL1B\":6,\"e\":{\"Level1a\":8,\"Level1b\":9,\"Level1c\":10,\"Level1d\":11,\"x\":12},\"Loop1\":13,\"Loop2\":14,\"X\":15,\"Y\":16,\"Z\":17,\"Q\":18}"
	1076  	if string(b) != want {
	1077  		t.Errorf("Wrong marshal result.\n got: %q\nwant: %q", b, want)
	1078  	}
	1079  }
	1080  
	1081  func equalError(a, b error) bool {
	1082  	if a == nil {
	1083  		return b == nil
	1084  	}
	1085  	if b == nil {
	1086  		return a == nil
	1087  	}
	1088  	return a.Error() == b.Error()
	1089  }
	1090  
	1091  func TestUnmarshal(t *testing.T) {
	1092  	for i, tt := range unmarshalTests {
	1093  		var scan scanner
	1094  		in := []byte(tt.in)
	1095  		if err := checkValid(in, &scan); err != nil {
	1096  			if !equalError(err, tt.err) {
	1097  				t.Errorf("#%d: checkValid: %#v", i, err)
	1098  				continue
	1099  			}
	1100  		}
	1101  		if tt.ptr == nil {
	1102  			continue
	1103  		}
	1104  
	1105  		typ := reflect.TypeOf(tt.ptr)
	1106  		if typ.Kind() != reflect.Ptr {
	1107  			t.Errorf("#%d: unmarshalTest.ptr %T is not a pointer type", i, tt.ptr)
	1108  			continue
	1109  		}
	1110  		typ = typ.Elem()
	1111  
	1112  		// v = new(right-type)
	1113  		v := reflect.New(typ)
	1114  
	1115  		if !reflect.DeepEqual(tt.ptr, v.Interface()) {
	1116  			// There's no reason for ptr to point to non-zero data,
	1117  			// as we decode into new(right-type), so the data is
	1118  			// discarded.
	1119  			// This can easily mean tests that silently don't test
	1120  			// what they should. To test decoding into existing
	1121  			// data, see TestPrefilled.
	1122  			t.Errorf("#%d: unmarshalTest.ptr %#v is not a pointer to a zero value", i, tt.ptr)
	1123  			continue
	1124  		}
	1125  
	1126  		dec := NewDecoder(bytes.NewReader(in))
	1127  		if tt.useNumber {
	1128  			dec.UseNumber()
	1129  		}
	1130  		if tt.disallowUnknownFields {
	1131  			dec.DisallowUnknownFields()
	1132  		}
	1133  		if err := dec.Decode(v.Interface()); !equalError(err, tt.err) {
	1134  			t.Errorf("#%d: %v, want %v", i, err, tt.err)
	1135  			continue
	1136  		} else if err != nil {
	1137  			continue
	1138  		}
	1139  		if !reflect.DeepEqual(v.Elem().Interface(), tt.out) {
	1140  			t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), tt.out)
	1141  			data, _ := Marshal(v.Elem().Interface())
	1142  			println(string(data))
	1143  			data, _ = Marshal(tt.out)
	1144  			println(string(data))
	1145  			continue
	1146  		}
	1147  
	1148  		// Check round trip also decodes correctly.
	1149  		if tt.err == nil {
	1150  			enc, err := Marshal(v.Interface())
	1151  			if err != nil {
	1152  				t.Errorf("#%d: error re-marshaling: %v", i, err)
	1153  				continue
	1154  			}
	1155  			if tt.golden && !bytes.Equal(enc, in) {
	1156  				t.Errorf("#%d: remarshal mismatch:\nhave: %s\nwant: %s", i, enc, in)
	1157  			}
	1158  			vv := reflect.New(reflect.TypeOf(tt.ptr).Elem())
	1159  			dec = NewDecoder(bytes.NewReader(enc))
	1160  			if tt.useNumber {
	1161  				dec.UseNumber()
	1162  			}
	1163  			if err := dec.Decode(vv.Interface()); err != nil {
	1164  				t.Errorf("#%d: error re-unmarshaling %#q: %v", i, enc, err)
	1165  				continue
	1166  			}
	1167  			if !reflect.DeepEqual(v.Elem().Interface(), vv.Elem().Interface()) {
	1168  				t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), vv.Elem().Interface())
	1169  				t.Errorf("		 In: %q", strings.Map(noSpace, string(in)))
	1170  				t.Errorf("Marshal: %q", strings.Map(noSpace, string(enc)))
	1171  				continue
	1172  			}
	1173  		}
	1174  	}
	1175  }
	1176  
	1177  func TestUnmarshalMarshal(t *testing.T) {
	1178  	initBig()
	1179  	var v interface{}
	1180  	if err := Unmarshal(jsonBig, &v); err != nil {
	1181  		t.Fatalf("Unmarshal: %v", err)
	1182  	}
	1183  	b, err := Marshal(v)
	1184  	if err != nil {
	1185  		t.Fatalf("Marshal: %v", err)
	1186  	}
	1187  	if !bytes.Equal(jsonBig, b) {
	1188  		t.Errorf("Marshal jsonBig")
	1189  		diff(t, b, jsonBig)
	1190  		return
	1191  	}
	1192  }
	1193  
	1194  var numberTests = []struct {
	1195  	in			 string
	1196  	i				int64
	1197  	intErr	 string
	1198  	f				float64
	1199  	floatErr string
	1200  }{
	1201  	{in: "-1.23e1", intErr: "strconv.ParseInt: parsing \"-1.23e1\": invalid syntax", f: -1.23e1},
	1202  	{in: "-12", i: -12, f: -12.0},
	1203  	{in: "1e1000", intErr: "strconv.ParseInt: parsing \"1e1000\": invalid syntax", floatErr: "strconv.ParseFloat: parsing \"1e1000\": value out of range"},
	1204  }
	1205  
	1206  // Independent of Decode, basic coverage of the accessors in Number
	1207  func TestNumberAccessors(t *testing.T) {
	1208  	for _, tt := range numberTests {
	1209  		n := Number(tt.in)
	1210  		if s := n.String(); s != tt.in {
	1211  			t.Errorf("Number(%q).String() is %q", tt.in, s)
	1212  		}
	1213  		if i, err := n.Int64(); err == nil && tt.intErr == "" && i != tt.i {
	1214  			t.Errorf("Number(%q).Int64() is %d", tt.in, i)
	1215  		} else if (err == nil && tt.intErr != "") || (err != nil && err.Error() != tt.intErr) {
	1216  			t.Errorf("Number(%q).Int64() wanted error %q but got: %v", tt.in, tt.intErr, err)
	1217  		}
	1218  		if f, err := n.Float64(); err == nil && tt.floatErr == "" && f != tt.f {
	1219  			t.Errorf("Number(%q).Float64() is %g", tt.in, f)
	1220  		} else if (err == nil && tt.floatErr != "") || (err != nil && err.Error() != tt.floatErr) {
	1221  			t.Errorf("Number(%q).Float64() wanted error %q but got: %v", tt.in, tt.floatErr, err)
	1222  		}
	1223  	}
	1224  }
	1225  
	1226  func TestLargeByteSlice(t *testing.T) {
	1227  	s0 := make([]byte, 2000)
	1228  	for i := range s0 {
	1229  		s0[i] = byte(i)
	1230  	}
	1231  	b, err := Marshal(s0)
	1232  	if err != nil {
	1233  		t.Fatalf("Marshal: %v", err)
	1234  	}
	1235  	var s1 []byte
	1236  	if err := Unmarshal(b, &s1); err != nil {
	1237  		t.Fatalf("Unmarshal: %v", err)
	1238  	}
	1239  	if !bytes.Equal(s0, s1) {
	1240  		t.Errorf("Marshal large byte slice")
	1241  		diff(t, s0, s1)
	1242  	}
	1243  }
	1244  
	1245  type Xint struct {
	1246  	X int
	1247  }
	1248  
	1249  func TestUnmarshalInterface(t *testing.T) {
	1250  	var xint Xint
	1251  	var i interface{} = &xint
	1252  	if err := Unmarshal([]byte(`{"X":1}`), &i); err != nil {
	1253  		t.Fatalf("Unmarshal: %v", err)
	1254  	}
	1255  	if xint.X != 1 {
	1256  		t.Fatalf("Did not write to xint")
	1257  	}
	1258  }
	1259  
	1260  func TestUnmarshalPtrPtr(t *testing.T) {
	1261  	var xint Xint
	1262  	pxint := &xint
	1263  	if err := Unmarshal([]byte(`{"X":1}`), &pxint); err != nil {
	1264  		t.Fatalf("Unmarshal: %v", err)
	1265  	}
	1266  	if xint.X != 1 {
	1267  		t.Fatalf("Did not write to xint")
	1268  	}
	1269  }
	1270  
	1271  func TestEscape(t *testing.T) {
	1272  	const input = `"foobar"<html>` + " [\u2028 \u2029]"
	1273  	const expected = `"\"foobar\"\u003chtml\u003e [\u2028 \u2029]"`
	1274  	b, err := Marshal(input)
	1275  	if err != nil {
	1276  		t.Fatalf("Marshal error: %v", err)
	1277  	}
	1278  	if s := string(b); s != expected {
	1279  		t.Errorf("Encoding of [%s]:\n got [%s]\nwant [%s]", input, s, expected)
	1280  	}
	1281  }
	1282  
	1283  // WrongString is a struct that's misusing the ,string modifier.
	1284  type WrongString struct {
	1285  	Message string `json:"result,string"`
	1286  }
	1287  
	1288  type wrongStringTest struct {
	1289  	in, err string
	1290  }
	1291  
	1292  var wrongStringTests = []wrongStringTest{
	1293  	{`{"result":"x"}`, `json: invalid use of ,string struct tag, trying to unmarshal "x" into string`},
	1294  	{`{"result":"foo"}`, `json: invalid use of ,string struct tag, trying to unmarshal "foo" into string`},
	1295  	{`{"result":"123"}`, `json: invalid use of ,string struct tag, trying to unmarshal "123" into string`},
	1296  	{`{"result":123}`, `json: invalid use of ,string struct tag, trying to unmarshal unquoted value into string`},
	1297  	{`{"result":"\""}`, `json: invalid use of ,string struct tag, trying to unmarshal "\"" into string`},
	1298  	{`{"result":"\"foo"}`, `json: invalid use of ,string struct tag, trying to unmarshal "\"foo" into string`},
	1299  }
	1300  
	1301  // If people misuse the ,string modifier, the error message should be
	1302  // helpful, telling the user that they're doing it wrong.
	1303  func TestErrorMessageFromMisusedString(t *testing.T) {
	1304  	for n, tt := range wrongStringTests {
	1305  		r := strings.NewReader(tt.in)
	1306  		var s WrongString
	1307  		err := NewDecoder(r).Decode(&s)
	1308  		got := fmt.Sprintf("%v", err)
	1309  		if got != tt.err {
	1310  			t.Errorf("%d. got err = %q, want %q", n, got, tt.err)
	1311  		}
	1312  	}
	1313  }
	1314  
	1315  func noSpace(c rune) rune {
	1316  	if isSpace(byte(c)) { //only used for ascii
	1317  		return -1
	1318  	}
	1319  	return c
	1320  }
	1321  
	1322  type All struct {
	1323  	Bool		bool
	1324  	Int		 int
	1325  	Int8		int8
	1326  	Int16	 int16
	1327  	Int32	 int32
	1328  	Int64	 int64
	1329  	Uint		uint
	1330  	Uint8	 uint8
	1331  	Uint16	uint16
	1332  	Uint32	uint32
	1333  	Uint64	uint64
	1334  	Uintptr uintptr
	1335  	Float32 float32
	1336  	Float64 float64
	1337  
	1338  	Foo	string `json:"bar"`
	1339  	Foo2 string `json:"bar2,dummyopt"`
	1340  
	1341  	IntStr		 int64	 `json:",string"`
	1342  	UintptrStr uintptr `json:",string"`
	1343  
	1344  	PBool		*bool
	1345  	PInt		 *int
	1346  	PInt8		*int8
	1347  	PInt16	 *int16
	1348  	PInt32	 *int32
	1349  	PInt64	 *int64
	1350  	PUint		*uint
	1351  	PUint8	 *uint8
	1352  	PUint16	*uint16
	1353  	PUint32	*uint32
	1354  	PUint64	*uint64
	1355  	PUintptr *uintptr
	1356  	PFloat32 *float32
	1357  	PFloat64 *float64
	1358  
	1359  	String	string
	1360  	PString *string
	1361  
	1362  	Map	 map[string]Small
	1363  	MapP	map[string]*Small
	1364  	PMap	*map[string]Small
	1365  	PMapP *map[string]*Small
	1366  
	1367  	EmptyMap map[string]Small
	1368  	NilMap	 map[string]Small
	1369  
	1370  	Slice	 []Small
	1371  	SliceP	[]*Small
	1372  	PSlice	*[]Small
	1373  	PSliceP *[]*Small
	1374  
	1375  	EmptySlice []Small
	1376  	NilSlice	 []Small
	1377  
	1378  	StringSlice []string
	1379  	ByteSlice	 []byte
	1380  
	1381  	Small	 Small
	1382  	PSmall	*Small
	1383  	PPSmall **Small
	1384  
	1385  	Interface	interface{}
	1386  	PInterface *interface{}
	1387  
	1388  	unexported int
	1389  }
	1390  
	1391  type Small struct {
	1392  	Tag string
	1393  }
	1394  
	1395  var allValue = All{
	1396  	Bool:			 true,
	1397  	Int:				2,
	1398  	Int8:			 3,
	1399  	Int16:			4,
	1400  	Int32:			5,
	1401  	Int64:			6,
	1402  	Uint:			 7,
	1403  	Uint8:			8,
	1404  	Uint16:		 9,
	1405  	Uint32:		 10,
	1406  	Uint64:		 11,
	1407  	Uintptr:		12,
	1408  	Float32:		14.1,
	1409  	Float64:		15.1,
	1410  	Foo:				"foo",
	1411  	Foo2:			 "foo2",
	1412  	IntStr:		 42,
	1413  	UintptrStr: 44,
	1414  	String:		 "16",
	1415  	Map: map[string]Small{
	1416  		"17": {Tag: "tag17"},
	1417  		"18": {Tag: "tag18"},
	1418  	},
	1419  	MapP: map[string]*Small{
	1420  		"19": {Tag: "tag19"},
	1421  		"20": nil,
	1422  	},
	1423  	EmptyMap:		map[string]Small{},
	1424  	Slice:			 []Small{{Tag: "tag20"}, {Tag: "tag21"}},
	1425  	SliceP:			[]*Small{{Tag: "tag22"}, nil, {Tag: "tag23"}},
	1426  	EmptySlice:	[]Small{},
	1427  	StringSlice: []string{"str24", "str25", "str26"},
	1428  	ByteSlice:	 []byte{27, 28, 29},
	1429  	Small:			 Small{Tag: "tag30"},
	1430  	PSmall:			&Small{Tag: "tag31"},
	1431  	Interface:	 5.2,
	1432  }
	1433  
	1434  var pallValue = All{
	1435  	PBool:			&allValue.Bool,
	1436  	PInt:			 &allValue.Int,
	1437  	PInt8:			&allValue.Int8,
	1438  	PInt16:		 &allValue.Int16,
	1439  	PInt32:		 &allValue.Int32,
	1440  	PInt64:		 &allValue.Int64,
	1441  	PUint:			&allValue.Uint,
	1442  	PUint8:		 &allValue.Uint8,
	1443  	PUint16:		&allValue.Uint16,
	1444  	PUint32:		&allValue.Uint32,
	1445  	PUint64:		&allValue.Uint64,
	1446  	PUintptr:	 &allValue.Uintptr,
	1447  	PFloat32:	 &allValue.Float32,
	1448  	PFloat64:	 &allValue.Float64,
	1449  	PString:		&allValue.String,
	1450  	PMap:			 &allValue.Map,
	1451  	PMapP:			&allValue.MapP,
	1452  	PSlice:		 &allValue.Slice,
	1453  	PSliceP:		&allValue.SliceP,
	1454  	PPSmall:		&allValue.PSmall,
	1455  	PInterface: &allValue.Interface,
	1456  }
	1457  
	1458  var allValueIndent = `{
	1459  	"Bool": true,
	1460  	"Int": 2,
	1461  	"Int8": 3,
	1462  	"Int16": 4,
	1463  	"Int32": 5,
	1464  	"Int64": 6,
	1465  	"Uint": 7,
	1466  	"Uint8": 8,
	1467  	"Uint16": 9,
	1468  	"Uint32": 10,
	1469  	"Uint64": 11,
	1470  	"Uintptr": 12,
	1471  	"Float32": 14.1,
	1472  	"Float64": 15.1,
	1473  	"bar": "foo",
	1474  	"bar2": "foo2",
	1475  	"IntStr": "42",
	1476  	"UintptrStr": "44",
	1477  	"PBool": null,
	1478  	"PInt": null,
	1479  	"PInt8": null,
	1480  	"PInt16": null,
	1481  	"PInt32": null,
	1482  	"PInt64": null,
	1483  	"PUint": null,
	1484  	"PUint8": null,
	1485  	"PUint16": null,
	1486  	"PUint32": null,
	1487  	"PUint64": null,
	1488  	"PUintptr": null,
	1489  	"PFloat32": null,
	1490  	"PFloat64": null,
	1491  	"String": "16",
	1492  	"PString": null,
	1493  	"Map": {
	1494  		"17": {
	1495  			"Tag": "tag17"
	1496  		},
	1497  		"18": {
	1498  			"Tag": "tag18"
	1499  		}
	1500  	},
	1501  	"MapP": {
	1502  		"19": {
	1503  			"Tag": "tag19"
	1504  		},
	1505  		"20": null
	1506  	},
	1507  	"PMap": null,
	1508  	"PMapP": null,
	1509  	"EmptyMap": {},
	1510  	"NilMap": null,
	1511  	"Slice": [
	1512  		{
	1513  			"Tag": "tag20"
	1514  		},
	1515  		{
	1516  			"Tag": "tag21"
	1517  		}
	1518  	],
	1519  	"SliceP": [
	1520  		{
	1521  			"Tag": "tag22"
	1522  		},
	1523  		null,
	1524  		{
	1525  			"Tag": "tag23"
	1526  		}
	1527  	],
	1528  	"PSlice": null,
	1529  	"PSliceP": null,
	1530  	"EmptySlice": [],
	1531  	"NilSlice": null,
	1532  	"StringSlice": [
	1533  		"str24",
	1534  		"str25",
	1535  		"str26"
	1536  	],
	1537  	"ByteSlice": "Gxwd",
	1538  	"Small": {
	1539  		"Tag": "tag30"
	1540  	},
	1541  	"PSmall": {
	1542  		"Tag": "tag31"
	1543  	},
	1544  	"PPSmall": null,
	1545  	"Interface": 5.2,
	1546  	"PInterface": null
	1547  }`
	1548  
	1549  var allValueCompact = strings.Map(noSpace, allValueIndent)
	1550  
	1551  var pallValueIndent = `{
	1552  	"Bool": false,
	1553  	"Int": 0,
	1554  	"Int8": 0,
	1555  	"Int16": 0,
	1556  	"Int32": 0,
	1557  	"Int64": 0,
	1558  	"Uint": 0,
	1559  	"Uint8": 0,
	1560  	"Uint16": 0,
	1561  	"Uint32": 0,
	1562  	"Uint64": 0,
	1563  	"Uintptr": 0,
	1564  	"Float32": 0,
	1565  	"Float64": 0,
	1566  	"bar": "",
	1567  	"bar2": "",
	1568  				"IntStr": "0",
	1569  	"UintptrStr": "0",
	1570  	"PBool": true,
	1571  	"PInt": 2,
	1572  	"PInt8": 3,
	1573  	"PInt16": 4,
	1574  	"PInt32": 5,
	1575  	"PInt64": 6,
	1576  	"PUint": 7,
	1577  	"PUint8": 8,
	1578  	"PUint16": 9,
	1579  	"PUint32": 10,
	1580  	"PUint64": 11,
	1581  	"PUintptr": 12,
	1582  	"PFloat32": 14.1,
	1583  	"PFloat64": 15.1,
	1584  	"String": "",
	1585  	"PString": "16",
	1586  	"Map": null,
	1587  	"MapP": null,
	1588  	"PMap": {
	1589  		"17": {
	1590  			"Tag": "tag17"
	1591  		},
	1592  		"18": {
	1593  			"Tag": "tag18"
	1594  		}
	1595  	},
	1596  	"PMapP": {
	1597  		"19": {
	1598  			"Tag": "tag19"
	1599  		},
	1600  		"20": null
	1601  	},
	1602  	"EmptyMap": null,
	1603  	"NilMap": null,
	1604  	"Slice": null,
	1605  	"SliceP": null,
	1606  	"PSlice": [
	1607  		{
	1608  			"Tag": "tag20"
	1609  		},
	1610  		{
	1611  			"Tag": "tag21"
	1612  		}
	1613  	],
	1614  	"PSliceP": [
	1615  		{
	1616  			"Tag": "tag22"
	1617  		},
	1618  		null,
	1619  		{
	1620  			"Tag": "tag23"
	1621  		}
	1622  	],
	1623  	"EmptySlice": null,
	1624  	"NilSlice": null,
	1625  	"StringSlice": null,
	1626  	"ByteSlice": null,
	1627  	"Small": {
	1628  		"Tag": ""
	1629  	},
	1630  	"PSmall": null,
	1631  	"PPSmall": {
	1632  		"Tag": "tag31"
	1633  	},
	1634  	"Interface": null,
	1635  	"PInterface": 5.2
	1636  }`
	1637  
	1638  var pallValueCompact = strings.Map(noSpace, pallValueIndent)
	1639  
	1640  func TestRefUnmarshal(t *testing.T) {
	1641  	type S struct {
	1642  		// Ref is defined in encode_test.go.
	1643  		R0 Ref
	1644  		R1 *Ref
	1645  		R2 RefText
	1646  		R3 *RefText
	1647  	}
	1648  	want := S{
	1649  		R0: 12,
	1650  		R1: new(Ref),
	1651  		R2: 13,
	1652  		R3: new(RefText),
	1653  	}
	1654  	*want.R1 = 12
	1655  	*want.R3 = 13
	1656  
	1657  	var got S
	1658  	if err := Unmarshal([]byte(`{"R0":"ref","R1":"ref","R2":"ref","R3":"ref"}`), &got); err != nil {
	1659  		t.Fatalf("Unmarshal: %v", err)
	1660  	}
	1661  	if !reflect.DeepEqual(got, want) {
	1662  		t.Errorf("got %+v, want %+v", got, want)
	1663  	}
	1664  }
	1665  
	1666  // Test that the empty string doesn't panic decoding when ,string is specified
	1667  // Issue 3450
	1668  func TestEmptyString(t *testing.T) {
	1669  	type T2 struct {
	1670  		Number1 int `json:",string"`
	1671  		Number2 int `json:",string"`
	1672  	}
	1673  	data := `{"Number1":"1", "Number2":""}`
	1674  	dec := NewDecoder(strings.NewReader(data))
	1675  	var t2 T2
	1676  	err := dec.Decode(&t2)
	1677  	if err == nil {
	1678  		t.Fatal("Decode: did not return error")
	1679  	}
	1680  	if t2.Number1 != 1 {
	1681  		t.Fatal("Decode: did not set Number1")
	1682  	}
	1683  }
	1684  
	1685  // Test that a null for ,string is not replaced with the previous quoted string (issue 7046).
	1686  // It should also not be an error (issue 2540, issue 8587).
	1687  func TestNullString(t *testing.T) {
	1688  	type T struct {
	1689  		A int	`json:",string"`
	1690  		B int	`json:",string"`
	1691  		C *int `json:",string"`
	1692  	}
	1693  	data := []byte(`{"A": "1", "B": null, "C": null}`)
	1694  	var s T
	1695  	s.B = 1
	1696  	s.C = new(int)
	1697  	*s.C = 2
	1698  	err := Unmarshal(data, &s)
	1699  	if err != nil {
	1700  		t.Fatalf("Unmarshal: %v", err)
	1701  	}
	1702  	if s.B != 1 || s.C != nil {
	1703  		t.Fatalf("after Unmarshal, s.B=%d, s.C=%p, want 1, nil", s.B, s.C)
	1704  	}
	1705  }
	1706  
	1707  func intp(x int) *int {
	1708  	p := new(int)
	1709  	*p = x
	1710  	return p
	1711  }
	1712  
	1713  func intpp(x *int) **int {
	1714  	pp := new(*int)
	1715  	*pp = x
	1716  	return pp
	1717  }
	1718  
	1719  var interfaceSetTests = []struct {
	1720  	pre	interface{}
	1721  	json string
	1722  	post interface{}
	1723  }{
	1724  	{"foo", `"bar"`, "bar"},
	1725  	{"foo", `2`, 2.0},
	1726  	{"foo", `true`, true},
	1727  	{"foo", `null`, nil},
	1728  
	1729  	{nil, `null`, nil},
	1730  	{new(int), `null`, nil},
	1731  	{(*int)(nil), `null`, nil},
	1732  	{new(*int), `null`, new(*int)},
	1733  	{(**int)(nil), `null`, nil},
	1734  	{intp(1), `null`, nil},
	1735  	{intpp(nil), `null`, intpp(nil)},
	1736  	{intpp(intp(1)), `null`, intpp(nil)},
	1737  }
	1738  
	1739  func TestInterfaceSet(t *testing.T) {
	1740  	for _, tt := range interfaceSetTests {
	1741  		b := struct{ X interface{} }{tt.pre}
	1742  		blob := `{"X":` + tt.json + `}`
	1743  		if err := Unmarshal([]byte(blob), &b); err != nil {
	1744  			t.Errorf("Unmarshal %#q: %v", blob, err)
	1745  			continue
	1746  		}
	1747  		if !reflect.DeepEqual(b.X, tt.post) {
	1748  			t.Errorf("Unmarshal %#q into %#v: X=%#v, want %#v", blob, tt.pre, b.X, tt.post)
	1749  		}
	1750  	}
	1751  }
	1752  
	1753  type NullTest struct {
	1754  	Bool			bool
	1755  	Int			 int
	1756  	Int8			int8
	1757  	Int16		 int16
	1758  	Int32		 int32
	1759  	Int64		 int64
	1760  	Uint			uint
	1761  	Uint8		 uint8
	1762  	Uint16		uint16
	1763  	Uint32		uint32
	1764  	Uint64		uint64
	1765  	Float32	 float32
	1766  	Float64	 float64
	1767  	String		string
	1768  	PBool		 *bool
	1769  	Map			 map[string]string
	1770  	Slice		 []string
	1771  	Interface interface{}
	1772  
	1773  	PRaw		*RawMessage
	1774  	PTime	 *time.Time
	1775  	PBigInt *big.Int
	1776  	PText	 *MustNotUnmarshalText
	1777  	PBuffer *bytes.Buffer // has methods, just not relevant ones
	1778  	PStruct *struct{}
	1779  
	1780  	Raw		RawMessage
	1781  	Time	 time.Time
	1782  	BigInt big.Int
	1783  	Text	 MustNotUnmarshalText
	1784  	Buffer bytes.Buffer
	1785  	Struct struct{}
	1786  }
	1787  
	1788  // JSON null values should be ignored for primitives and string values instead of resulting in an error.
	1789  // Issue 2540
	1790  func TestUnmarshalNulls(t *testing.T) {
	1791  	// Unmarshal docs:
	1792  	// The JSON null value unmarshals into an interface, map, pointer, or slice
	1793  	// by setting that Go value to nil. Because null is often used in JSON to mean
	1794  	// ``not present,'' unmarshaling a JSON null into any other Go type has no effect
	1795  	// on the value and produces no error.
	1796  
	1797  	jsonData := []byte(`{
	1798  				"Bool"		: null,
	1799  				"Int"		 : null,
	1800  				"Int8"		: null,
	1801  				"Int16"	 : null,
	1802  				"Int32"	 : null,
	1803  				"Int64"	 : null,
	1804  				"Uint"		: null,
	1805  				"Uint8"	 : null,
	1806  				"Uint16"	: null,
	1807  				"Uint32"	: null,
	1808  				"Uint64"	: null,
	1809  				"Float32" : null,
	1810  				"Float64" : null,
	1811  				"String"	: null,
	1812  				"PBool": null,
	1813  				"Map": null,
	1814  				"Slice": null,
	1815  				"Interface": null,
	1816  				"PRaw": null,
	1817  				"PTime": null,
	1818  				"PBigInt": null,
	1819  				"PText": null,
	1820  				"PBuffer": null,
	1821  				"PStruct": null,
	1822  				"Raw": null,
	1823  				"Time": null,
	1824  				"BigInt": null,
	1825  				"Text": null,
	1826  				"Buffer": null,
	1827  				"Struct": null
	1828  			}`)
	1829  	nulls := NullTest{
	1830  		Bool:			true,
	1831  		Int:			 2,
	1832  		Int8:			3,
	1833  		Int16:		 4,
	1834  		Int32:		 5,
	1835  		Int64:		 6,
	1836  		Uint:			7,
	1837  		Uint8:		 8,
	1838  		Uint16:		9,
	1839  		Uint32:		10,
	1840  		Uint64:		11,
	1841  		Float32:	 12.1,
	1842  		Float64:	 13.1,
	1843  		String:		"14",
	1844  		PBool:		 new(bool),
	1845  		Map:			 map[string]string{},
	1846  		Slice:		 []string{},
	1847  		Interface: new(MustNotUnmarshalJSON),
	1848  		PRaw:			new(RawMessage),
	1849  		PTime:		 new(time.Time),
	1850  		PBigInt:	 new(big.Int),
	1851  		PText:		 new(MustNotUnmarshalText),
	1852  		PStruct:	 new(struct{}),
	1853  		PBuffer:	 new(bytes.Buffer),
	1854  		Raw:			 RawMessage("123"),
	1855  		Time:			time.Unix(123456789, 0),
	1856  		BigInt:		*big.NewInt(123),
	1857  	}
	1858  
	1859  	before := nulls.Time.String()
	1860  
	1861  	err := Unmarshal(jsonData, &nulls)
	1862  	if err != nil {
	1863  		t.Errorf("Unmarshal of null values failed: %v", err)
	1864  	}
	1865  	if !nulls.Bool || nulls.Int != 2 || nulls.Int8 != 3 || nulls.Int16 != 4 || nulls.Int32 != 5 || nulls.Int64 != 6 ||
	1866  		nulls.Uint != 7 || nulls.Uint8 != 8 || nulls.Uint16 != 9 || nulls.Uint32 != 10 || nulls.Uint64 != 11 ||
	1867  		nulls.Float32 != 12.1 || nulls.Float64 != 13.1 || nulls.String != "14" {
	1868  		t.Errorf("Unmarshal of null values affected primitives")
	1869  	}
	1870  
	1871  	if nulls.PBool != nil {
	1872  		t.Errorf("Unmarshal of null did not clear nulls.PBool")
	1873  	}
	1874  	if nulls.Map != nil {
	1875  		t.Errorf("Unmarshal of null did not clear nulls.Map")
	1876  	}
	1877  	if nulls.Slice != nil {
	1878  		t.Errorf("Unmarshal of null did not clear nulls.Slice")
	1879  	}
	1880  	if nulls.Interface != nil {
	1881  		t.Errorf("Unmarshal of null did not clear nulls.Interface")
	1882  	}
	1883  	if nulls.PRaw != nil {
	1884  		t.Errorf("Unmarshal of null did not clear nulls.PRaw")
	1885  	}
	1886  	if nulls.PTime != nil {
	1887  		t.Errorf("Unmarshal of null did not clear nulls.PTime")
	1888  	}
	1889  	if nulls.PBigInt != nil {
	1890  		t.Errorf("Unmarshal of null did not clear nulls.PBigInt")
	1891  	}
	1892  	if nulls.PText != nil {
	1893  		t.Errorf("Unmarshal of null did not clear nulls.PText")
	1894  	}
	1895  	if nulls.PBuffer != nil {
	1896  		t.Errorf("Unmarshal of null did not clear nulls.PBuffer")
	1897  	}
	1898  	if nulls.PStruct != nil {
	1899  		t.Errorf("Unmarshal of null did not clear nulls.PStruct")
	1900  	}
	1901  
	1902  	if string(nulls.Raw) != "null" {
	1903  		t.Errorf("Unmarshal of RawMessage null did not record null: %v", string(nulls.Raw))
	1904  	}
	1905  	if nulls.Time.String() != before {
	1906  		t.Errorf("Unmarshal of time.Time null set time to %v", nulls.Time.String())
	1907  	}
	1908  	if nulls.BigInt.String() != "123" {
	1909  		t.Errorf("Unmarshal of big.Int null set int to %v", nulls.BigInt.String())
	1910  	}
	1911  }
	1912  
	1913  type MustNotUnmarshalJSON struct{}
	1914  
	1915  func (x MustNotUnmarshalJSON) UnmarshalJSON(data []byte) error {
	1916  	return errors.New("MustNotUnmarshalJSON was used")
	1917  }
	1918  
	1919  type MustNotUnmarshalText struct{}
	1920  
	1921  func (x MustNotUnmarshalText) UnmarshalText(text []byte) error {
	1922  	return errors.New("MustNotUnmarshalText was used")
	1923  }
	1924  
	1925  func TestStringKind(t *testing.T) {
	1926  	type stringKind string
	1927  
	1928  	var m1, m2 map[stringKind]int
	1929  	m1 = map[stringKind]int{
	1930  		"foo": 42,
	1931  	}
	1932  
	1933  	data, err := Marshal(m1)
	1934  	if err != nil {
	1935  		t.Errorf("Unexpected error marshaling: %v", err)
	1936  	}
	1937  
	1938  	err = Unmarshal(data, &m2)
	1939  	if err != nil {
	1940  		t.Errorf("Unexpected error unmarshaling: %v", err)
	1941  	}
	1942  
	1943  	if !reflect.DeepEqual(m1, m2) {
	1944  		t.Error("Items should be equal after encoding and then decoding")
	1945  	}
	1946  }
	1947  
	1948  // Custom types with []byte as underlying type could not be marshaled
	1949  // and then unmarshaled.
	1950  // Issue 8962.
	1951  func TestByteKind(t *testing.T) {
	1952  	type byteKind []byte
	1953  
	1954  	a := byteKind("hello")
	1955  
	1956  	data, err := Marshal(a)
	1957  	if err != nil {
	1958  		t.Error(err)
	1959  	}
	1960  	var b byteKind
	1961  	err = Unmarshal(data, &b)
	1962  	if err != nil {
	1963  		t.Fatal(err)
	1964  	}
	1965  	if !reflect.DeepEqual(a, b) {
	1966  		t.Errorf("expected %v == %v", a, b)
	1967  	}
	1968  }
	1969  
	1970  // The fix for issue 8962 introduced a regression.
	1971  // Issue 12921.
	1972  func TestSliceOfCustomByte(t *testing.T) {
	1973  	type Uint8 uint8
	1974  
	1975  	a := []Uint8("hello")
	1976  
	1977  	data, err := Marshal(a)
	1978  	if err != nil {
	1979  		t.Fatal(err)
	1980  	}
	1981  	var b []Uint8
	1982  	err = Unmarshal(data, &b)
	1983  	if err != nil {
	1984  		t.Fatal(err)
	1985  	}
	1986  	if !reflect.DeepEqual(a, b) {
	1987  		t.Fatalf("expected %v == %v", a, b)
	1988  	}
	1989  }
	1990  
	1991  var decodeTypeErrorTests = []struct {
	1992  	dest interface{}
	1993  	src	string
	1994  }{
	1995  	{new(string), `{"user": "name"}`}, // issue 4628.
	1996  	{new(error), `{}`},								// issue 4222
	1997  	{new(error), `[]`},
	1998  	{new(error), `""`},
	1999  	{new(error), `123`},
	2000  	{new(error), `true`},
	2001  }
	2002  
	2003  func TestUnmarshalTypeError(t *testing.T) {
	2004  	for _, item := range decodeTypeErrorTests {
	2005  		err := Unmarshal([]byte(item.src), item.dest)
	2006  		if _, ok := err.(*UnmarshalTypeError); !ok {
	2007  			t.Errorf("expected type error for Unmarshal(%q, type %T): got %T",
	2008  				item.src, item.dest, err)
	2009  		}
	2010  	}
	2011  }
	2012  
	2013  var unmarshalSyntaxTests = []string{
	2014  	"tru",
	2015  	"fals",
	2016  	"nul",
	2017  	"123e",
	2018  	`"hello`,
	2019  	`[1,2,3`,
	2020  	`{"key":1`,
	2021  	`{"key":1,`,
	2022  }
	2023  
	2024  func TestUnmarshalSyntax(t *testing.T) {
	2025  	var x interface{}
	2026  	for _, src := range unmarshalSyntaxTests {
	2027  		err := Unmarshal([]byte(src), &x)
	2028  		if _, ok := err.(*SyntaxError); !ok {
	2029  			t.Errorf("expected syntax error for Unmarshal(%q): got %T", src, err)
	2030  		}
	2031  	}
	2032  }
	2033  
	2034  // Test handling of unexported fields that should be ignored.
	2035  // Issue 4660
	2036  type unexportedFields struct {
	2037  	Name string
	2038  	m		map[string]interface{} `json:"-"`
	2039  	m2	 map[string]interface{} `json:"abcd"`
	2040  
	2041  	s []int `json:"-"`
	2042  }
	2043  
	2044  func TestUnmarshalUnexported(t *testing.T) {
	2045  	input := `{"Name": "Bob", "m": {"x": 123}, "m2": {"y": 456}, "abcd": {"z": 789}, "s": [2, 3]}`
	2046  	want := &unexportedFields{Name: "Bob"}
	2047  
	2048  	out := &unexportedFields{}
	2049  	err := Unmarshal([]byte(input), out)
	2050  	if err != nil {
	2051  		t.Errorf("got error %v, expected nil", err)
	2052  	}
	2053  	if !reflect.DeepEqual(out, want) {
	2054  		t.Errorf("got %q, want %q", out, want)
	2055  	}
	2056  }
	2057  
	2058  // Time3339 is a time.Time which encodes to and from JSON
	2059  // as an RFC 3339 time in UTC.
	2060  type Time3339 time.Time
	2061  
	2062  func (t *Time3339) UnmarshalJSON(b []byte) error {
	2063  	if len(b) < 2 || b[0] != '"' || b[len(b)-1] != '"' {
	2064  		return fmt.Errorf("types: failed to unmarshal non-string value %q as an RFC 3339 time", b)
	2065  	}
	2066  	tm, err := time.Parse(time.RFC3339, string(b[1:len(b)-1]))
	2067  	if err != nil {
	2068  		return err
	2069  	}
	2070  	*t = Time3339(tm)
	2071  	return nil
	2072  }
	2073  
	2074  func TestUnmarshalJSONLiteralError(t *testing.T) {
	2075  	var t3 Time3339
	2076  	err := Unmarshal([]byte(`"0000-00-00T00:00:00Z"`), &t3)
	2077  	if err == nil {
	2078  		t.Fatalf("expected error; got time %v", time.Time(t3))
	2079  	}
	2080  	if !strings.Contains(err.Error(), "range") {
	2081  		t.Errorf("got err = %v; want out of range error", err)
	2082  	}
	2083  }
	2084  
	2085  // Test that extra object elements in an array do not result in a
	2086  // "data changing underfoot" error.
	2087  // Issue 3717
	2088  func TestSkipArrayObjects(t *testing.T) {
	2089  	json := `[{}]`
	2090  	var dest [0]interface{}
	2091  
	2092  	err := Unmarshal([]byte(json), &dest)
	2093  	if err != nil {
	2094  		t.Errorf("got error %q, want nil", err)
	2095  	}
	2096  }
	2097  
	2098  // Test semantics of pre-filled data, such as struct fields, map elements,
	2099  // slices, and arrays.
	2100  // Issues 4900 and 8837, among others.
	2101  func TestPrefilled(t *testing.T) {
	2102  	// Values here change, cannot reuse table across runs.
	2103  	var prefillTests = []struct {
	2104  		in	string
	2105  		ptr interface{}
	2106  		out interface{}
	2107  	}{
	2108  		{
	2109  			in:	`{"X": 1, "Y": 2}`,
	2110  			ptr: &XYZ{X: float32(3), Y: int16(4), Z: 1.5},
	2111  			out: &XYZ{X: float64(1), Y: float64(2), Z: 1.5},
	2112  		},
	2113  		{
	2114  			in:	`{"X": 1, "Y": 2}`,
	2115  			ptr: &map[string]interface{}{"X": float32(3), "Y": int16(4), "Z": 1.5},
	2116  			out: &map[string]interface{}{"X": float64(1), "Y": float64(2), "Z": 1.5},
	2117  		},
	2118  		{
	2119  			in:	`[2]`,
	2120  			ptr: &[]int{1},
	2121  			out: &[]int{2},
	2122  		},
	2123  		{
	2124  			in:	`[2, 3]`,
	2125  			ptr: &[]int{1},
	2126  			out: &[]int{2, 3},
	2127  		},
	2128  		{
	2129  			in:	`[2, 3]`,
	2130  			ptr: &[...]int{1},
	2131  			out: &[...]int{2},
	2132  		},
	2133  		{
	2134  			in:	`[3]`,
	2135  			ptr: &[...]int{1, 2},
	2136  			out: &[...]int{3, 0},
	2137  		},
	2138  	}
	2139  
	2140  	for _, tt := range prefillTests {
	2141  		ptrstr := fmt.Sprintf("%v", tt.ptr)
	2142  		err := Unmarshal([]byte(tt.in), tt.ptr) // tt.ptr edited here
	2143  		if err != nil {
	2144  			t.Errorf("Unmarshal: %v", err)
	2145  		}
	2146  		if !reflect.DeepEqual(tt.ptr, tt.out) {
	2147  			t.Errorf("Unmarshal(%#q, %s): have %v, want %v", tt.in, ptrstr, tt.ptr, tt.out)
	2148  		}
	2149  	}
	2150  }
	2151  
	2152  var invalidUnmarshalTests = []struct {
	2153  	v		interface{}
	2154  	want string
	2155  }{
	2156  	{nil, "json: Unmarshal(nil)"},
	2157  	{struct{}{}, "json: Unmarshal(non-pointer struct {})"},
	2158  	{(*int)(nil), "json: Unmarshal(nil *int)"},
	2159  }
	2160  
	2161  func TestInvalidUnmarshal(t *testing.T) {
	2162  	buf := []byte(`{"a":"1"}`)
	2163  	for _, tt := range invalidUnmarshalTests {
	2164  		err := Unmarshal(buf, tt.v)
	2165  		if err == nil {
	2166  			t.Errorf("Unmarshal expecting error, got nil")
	2167  			continue
	2168  		}
	2169  		if got := err.Error(); got != tt.want {
	2170  			t.Errorf("Unmarshal = %q; want %q", got, tt.want)
	2171  		}
	2172  	}
	2173  }
	2174  
	2175  var invalidUnmarshalTextTests = []struct {
	2176  	v		interface{}
	2177  	want string
	2178  }{
	2179  	{nil, "json: Unmarshal(nil)"},
	2180  	{struct{}{}, "json: Unmarshal(non-pointer struct {})"},
	2181  	{(*int)(nil), "json: Unmarshal(nil *int)"},
	2182  	{new(net.IP), "json: cannot unmarshal number into Go value of type *net.IP"},
	2183  }
	2184  
	2185  func TestInvalidUnmarshalText(t *testing.T) {
	2186  	buf := []byte(`123`)
	2187  	for _, tt := range invalidUnmarshalTextTests {
	2188  		err := Unmarshal(buf, tt.v)
	2189  		if err == nil {
	2190  			t.Errorf("Unmarshal expecting error, got nil")
	2191  			continue
	2192  		}
	2193  		if got := err.Error(); got != tt.want {
	2194  			t.Errorf("Unmarshal = %q; want %q", got, tt.want)
	2195  		}
	2196  	}
	2197  }
	2198  
	2199  // Test that string option is ignored for invalid types.
	2200  // Issue 9812.
	2201  func TestInvalidStringOption(t *testing.T) {
	2202  	num := 0
	2203  	item := struct {
	2204  		T time.Time				 `json:",string"`
	2205  		M map[string]string `json:",string"`
	2206  		S []string					`json:",string"`
	2207  		A [1]string				 `json:",string"`
	2208  		I interface{}			 `json:",string"`
	2209  		P *int							`json:",string"`
	2210  	}{M: make(map[string]string), S: make([]string, 0), I: num, P: &num}
	2211  
	2212  	data, err := Marshal(item)
	2213  	if err != nil {
	2214  		t.Fatalf("Marshal: %v", err)
	2215  	}
	2216  
	2217  	err = Unmarshal(data, &item)
	2218  	if err != nil {
	2219  		t.Fatalf("Unmarshal: %v", err)
	2220  	}
	2221  }
	2222  
	2223  // Test unmarshal behavior with regards to embedded unexported structs.
	2224  //
	2225  // (Issue 21357) If the embedded struct is a pointer and is unallocated,
	2226  // this returns an error because unmarshal cannot set the field.
	2227  //
	2228  // (Issue 24152) If the embedded struct is given an explicit name,
	2229  // ensure that the normal unmarshal logic does not panic in reflect.
	2230  //
	2231  // (Issue 28145) If the embedded struct is given an explicit name and has
	2232  // exported methods, don't cause a panic trying to get its value.
	2233  func TestUnmarshalEmbeddedUnexported(t *testing.T) {
	2234  	type (
	2235  		embed1 struct{ Q int }
	2236  		embed2 struct{ Q int }
	2237  		embed3 struct {
	2238  			Q int64 `json:",string"`
	2239  		}
	2240  		S1 struct {
	2241  			*embed1
	2242  			R int
	2243  		}
	2244  		S2 struct {
	2245  			*embed1
	2246  			Q int
	2247  		}
	2248  		S3 struct {
	2249  			embed1
	2250  			R int
	2251  		}
	2252  		S4 struct {
	2253  			*embed1
	2254  			embed2
	2255  		}
	2256  		S5 struct {
	2257  			*embed3
	2258  			R int
	2259  		}
	2260  		S6 struct {
	2261  			embed1 `json:"embed1"`
	2262  		}
	2263  		S7 struct {
	2264  			embed1 `json:"embed1"`
	2265  			embed2
	2266  		}
	2267  		S8 struct {
	2268  			embed1 `json:"embed1"`
	2269  			embed2 `json:"embed2"`
	2270  			Q			int
	2271  		}
	2272  		S9 struct {
	2273  			unexportedWithMethods `json:"embed"`
	2274  		}
	2275  	)
	2276  
	2277  	tests := []struct {
	2278  		in	string
	2279  		ptr interface{}
	2280  		out interface{}
	2281  		err error
	2282  	}{{
	2283  		// Error since we cannot set S1.embed1, but still able to set S1.R.
	2284  		in:	`{"R":2,"Q":1}`,
	2285  		ptr: new(S1),
	2286  		out: &S1{R: 2},
	2287  		err: fmt.Errorf("json: cannot set embedded pointer to unexported struct: json.embed1"),
	2288  	}, {
	2289  		// The top level Q field takes precedence.
	2290  		in:	`{"Q":1}`,
	2291  		ptr: new(S2),
	2292  		out: &S2{Q: 1},
	2293  	}, {
	2294  		// No issue with non-pointer variant.
	2295  		in:	`{"R":2,"Q":1}`,
	2296  		ptr: new(S3),
	2297  		out: &S3{embed1: embed1{Q: 1}, R: 2},
	2298  	}, {
	2299  		// No error since both embedded structs have field R, which annihilate each other.
	2300  		// Thus, no attempt is made at setting S4.embed1.
	2301  		in:	`{"R":2}`,
	2302  		ptr: new(S4),
	2303  		out: new(S4),
	2304  	}, {
	2305  		// Error since we cannot set S5.embed1, but still able to set S5.R.
	2306  		in:	`{"R":2,"Q":1}`,
	2307  		ptr: new(S5),
	2308  		out: &S5{R: 2},
	2309  		err: fmt.Errorf("json: cannot set embedded pointer to unexported struct: json.embed3"),
	2310  	}, {
	2311  		// Issue 24152, ensure decodeState.indirect does not panic.
	2312  		in:	`{"embed1": {"Q": 1}}`,
	2313  		ptr: new(S6),
	2314  		out: &S6{embed1{1}},
	2315  	}, {
	2316  		// Issue 24153, check that we can still set forwarded fields even in
	2317  		// the presence of a name conflict.
	2318  		//
	2319  		// This relies on obscure behavior of reflect where it is possible
	2320  		// to set a forwarded exported field on an unexported embedded struct
	2321  		// even though there is a name conflict, even when it would have been
	2322  		// impossible to do so according to Go visibility rules.
	2323  		// Go forbids this because it is ambiguous whether S7.Q refers to
	2324  		// S7.embed1.Q or S7.embed2.Q. Since embed1 and embed2 are unexported,
	2325  		// it should be impossible for an external package to set either Q.
	2326  		//
	2327  		// It is probably okay for a future reflect change to break this.
	2328  		in:	`{"embed1": {"Q": 1}, "Q": 2}`,
	2329  		ptr: new(S7),
	2330  		out: &S7{embed1{1}, embed2{2}},
	2331  	}, {
	2332  		// Issue 24153, similar to the S7 case.
	2333  		in:	`{"embed1": {"Q": 1}, "embed2": {"Q": 2}, "Q": 3}`,
	2334  		ptr: new(S8),
	2335  		out: &S8{embed1{1}, embed2{2}, 3},
	2336  	}, {
	2337  		// Issue 228145, similar to the cases above.
	2338  		in:	`{"embed": {}}`,
	2339  		ptr: new(S9),
	2340  		out: &S9{},
	2341  	}}
	2342  
	2343  	for i, tt := range tests {
	2344  		err := Unmarshal([]byte(tt.in), tt.ptr)
	2345  		if !equalError(err, tt.err) {
	2346  			t.Errorf("#%d: %v, want %v", i, err, tt.err)
	2347  		}
	2348  		if !reflect.DeepEqual(tt.ptr, tt.out) {
	2349  			t.Errorf("#%d: mismatch\ngot:	%#+v\nwant: %#+v", i, tt.ptr, tt.out)
	2350  		}
	2351  	}
	2352  }
	2353  
	2354  func TestUnmarshalErrorAfterMultipleJSON(t *testing.T) {
	2355  	tests := []struct {
	2356  		in	string
	2357  		err error
	2358  	}{{
	2359  		in:	`1 false null :`,
	2360  		err: &SyntaxError{"invalid character ':' looking for beginning of value", 14},
	2361  	}, {
	2362  		in:	`1 [] [,]`,
	2363  		err: &SyntaxError{"invalid character ',' looking for beginning of value", 7},
	2364  	}, {
	2365  		in:	`1 [] [true:]`,
	2366  		err: &SyntaxError{"invalid character ':' after array element", 11},
	2367  	}, {
	2368  		in:	`1	{}		{"x"=}`,
	2369  		err: &SyntaxError{"invalid character '=' after object key", 14},
	2370  	}, {
	2371  		in:	`falsetruenul#`,
	2372  		err: &SyntaxError{"invalid character '#' in literal null (expecting 'l')", 13},
	2373  	}}
	2374  	for i, tt := range tests {
	2375  		dec := NewDecoder(strings.NewReader(tt.in))
	2376  		var err error
	2377  		for {
	2378  			var v interface{}
	2379  			if err = dec.Decode(&v); err != nil {
	2380  				break
	2381  			}
	2382  		}
	2383  		if !reflect.DeepEqual(err, tt.err) {
	2384  			t.Errorf("#%d: got %#v, want %#v", i, err, tt.err)
	2385  		}
	2386  	}
	2387  }
	2388  
	2389  type unmarshalPanic struct{}
	2390  
	2391  func (unmarshalPanic) UnmarshalJSON([]byte) error { panic(0xdead) }
	2392  
	2393  func TestUnmarshalPanic(t *testing.T) {
	2394  	defer func() {
	2395  		if got := recover(); !reflect.DeepEqual(got, 0xdead) {
	2396  			t.Errorf("panic() = (%T)(%v), want 0xdead", got, got)
	2397  		}
	2398  	}()
	2399  	Unmarshal([]byte("{}"), &unmarshalPanic{})
	2400  	t.Fatalf("Unmarshal should have panicked")
	2401  }
	2402  
	2403  // The decoder used to hang if decoding into an interface pointing to its own address.
	2404  // See golang.org/issues/31740.
	2405  func TestUnmarshalRecursivePointer(t *testing.T) {
	2406  	var v interface{}
	2407  	v = &v
	2408  	data := []byte(`{"a": "b"}`)
	2409  
	2410  	if err := Unmarshal(data, v); err != nil {
	2411  		t.Fatal(err)
	2412  	}
	2413  }
	2414  
	2415  type textUnmarshalerString string
	2416  
	2417  func (m *textUnmarshalerString) UnmarshalText(text []byte) error {
	2418  	*m = textUnmarshalerString(strings.ToLower(string(text)))
	2419  	return nil
	2420  }
	2421  
	2422  // Test unmarshal to a map, where the map key is a user defined type.
	2423  // See golang.org/issues/34437.
	2424  func TestUnmarshalMapWithTextUnmarshalerStringKey(t *testing.T) {
	2425  	var p map[textUnmarshalerString]string
	2426  	if err := Unmarshal([]byte(`{"FOO": "1"}`), &p); err != nil {
	2427  		t.Fatalf("Unmarshal unexpected error: %v", err)
	2428  	}
	2429  
	2430  	if _, ok := p["foo"]; !ok {
	2431  		t.Errorf(`Key "foo" does not exist in map: %v`, p)
	2432  	}
	2433  }
	2434  
	2435  func TestUnmarshalRescanLiteralMangledUnquote(t *testing.T) {
	2436  	// See golang.org/issues/38105.
	2437  	var p map[textUnmarshalerString]string
	2438  	if err := Unmarshal([]byte(`{"开源":"12345开源"}`), &p); err != nil {
	2439  		t.Fatalf("Unmarshal unexpected error: %v", err)
	2440  	}
	2441  	if _, ok := p["开源"]; !ok {
	2442  		t.Errorf(`Key "开源" does not exist in map: %v`, p)
	2443  	}
	2444  
	2445  	// See golang.org/issues/38126.
	2446  	type T struct {
	2447  		F1 string `json:"F1,string"`
	2448  	}
	2449  	t1 := T{"aaa\tbbb"}
	2450  
	2451  	b, err := Marshal(t1)
	2452  	if err != nil {
	2453  		t.Fatalf("Marshal unexpected error: %v", err)
	2454  	}
	2455  	var t2 T
	2456  	if err := Unmarshal(b, &t2); err != nil {
	2457  		t.Fatalf("Unmarshal unexpected error: %v", err)
	2458  	}
	2459  	if t1 != t2 {
	2460  		t.Errorf("Marshal and Unmarshal roundtrip mismatch: want %q got %q", t1, t2)
	2461  	}
	2462  
	2463  	// See golang.org/issues/39555.
	2464  	input := map[textUnmarshalerString]string{"FOO": "", `"`: ""}
	2465  
	2466  	encoded, err := Marshal(input)
	2467  	if err != nil {
	2468  		t.Fatalf("Marshal unexpected error: %v", err)
	2469  	}
	2470  	var got map[textUnmarshalerString]string
	2471  	if err := Unmarshal(encoded, &got); err != nil {
	2472  		t.Fatalf("Unmarshal unexpected error: %v", err)
	2473  	}
	2474  	want := map[textUnmarshalerString]string{"foo": "", `"`: ""}
	2475  	if !reflect.DeepEqual(want, got) {
	2476  		t.Fatalf("Unexpected roundtrip result:\nwant: %q\ngot:	%q", want, got)
	2477  	}
	2478  }
	2479  
	2480  func TestUnmarshalMaxDepth(t *testing.T) {
	2481  	testcases := []struct {
	2482  		name				string
	2483  		data				string
	2484  		errMaxDepth bool
	2485  	}{
	2486  		{
	2487  			name:				"ArrayUnderMaxNestingDepth",
	2488  			data:				`{"a":` + strings.Repeat(`[`, 10000-1) + strings.Repeat(`]`, 10000-1) + `}`,
	2489  			errMaxDepth: false,
	2490  		},
	2491  		{
	2492  			name:				"ArrayOverMaxNestingDepth",
	2493  			data:				`{"a":` + strings.Repeat(`[`, 10000) + strings.Repeat(`]`, 10000) + `}`,
	2494  			errMaxDepth: true,
	2495  		},
	2496  		{
	2497  			name:				"ArrayOverStackDepth",
	2498  			data:				`{"a":` + strings.Repeat(`[`, 3000000) + strings.Repeat(`]`, 3000000) + `}`,
	2499  			errMaxDepth: true,
	2500  		},
	2501  		{
	2502  			name:				"ObjectUnderMaxNestingDepth",
	2503  			data:				`{"a":` + strings.Repeat(`{"a":`, 10000-1) + `0` + strings.Repeat(`}`, 10000-1) + `}`,
	2504  			errMaxDepth: false,
	2505  		},
	2506  		{
	2507  			name:				"ObjectOverMaxNestingDepth",
	2508  			data:				`{"a":` + strings.Repeat(`{"a":`, 10000) + `0` + strings.Repeat(`}`, 10000) + `}`,
	2509  			errMaxDepth: true,
	2510  		},
	2511  		{
	2512  			name:				"ObjectOverStackDepth",
	2513  			data:				`{"a":` + strings.Repeat(`{"a":`, 3000000) + `0` + strings.Repeat(`}`, 3000000) + `}`,
	2514  			errMaxDepth: true,
	2515  		},
	2516  	}
	2517  
	2518  	targets := []struct {
	2519  		name		 string
	2520  		newValue func() interface{}
	2521  	}{
	2522  		{
	2523  			name: "unstructured",
	2524  			newValue: func() interface{} {
	2525  				var v interface{}
	2526  				return &v
	2527  			},
	2528  		},
	2529  		{
	2530  			name: "typed named field",
	2531  			newValue: func() interface{} {
	2532  				v := struct {
	2533  					A interface{} `json:"a"`
	2534  				}{}
	2535  				return &v
	2536  			},
	2537  		},
	2538  		{
	2539  			name: "typed missing field",
	2540  			newValue: func() interface{} {
	2541  				v := struct {
	2542  					B interface{} `json:"b"`
	2543  				}{}
	2544  				return &v
	2545  			},
	2546  		},
	2547  		{
	2548  			name: "custom unmarshaler",
	2549  			newValue: func() interface{} {
	2550  				v := unmarshaler{}
	2551  				return &v
	2552  			},
	2553  		},
	2554  	}
	2555  
	2556  	for _, tc := range testcases {
	2557  		for _, target := range targets {
	2558  			t.Run(target.name+"-"+tc.name, func(t *testing.T) {
	2559  				err := Unmarshal([]byte(tc.data), target.newValue())
	2560  				if !tc.errMaxDepth {
	2561  					if err != nil {
	2562  						t.Errorf("unexpected error: %v", err)
	2563  					}
	2564  				} else {
	2565  					if err == nil {
	2566  						t.Errorf("expected error containing 'exceeded max depth', got none")
	2567  					} else if !strings.Contains(err.Error(), "exceeded max depth") {
	2568  						t.Errorf("expected error containing 'exceeded max depth', got: %v", err)
	2569  					}
	2570  				}
	2571  			})
	2572  		}
	2573  	}
	2574  }
	2575  

View as plain text