Source file src/encoding/json/encode_test.go

Documentation: encoding/json

     1  // Copyright 2011 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  	"fmt"
    11  	"log"
    12  	"math"
    13  	"reflect"
    14  	"regexp"
    15  	"strconv"
    16  	"testing"
    17  	"unicode"
    18  )
    19  
    20  type Optionals struct {
    21  	Sr string `json:"sr"`
    22  	So string `json:"so,omitempty"`
    23  	Sw string `json:"-"`
    24  
    25  	Ir int `json:"omitempty"` // actually named omitempty, not an option
    26  	Io int `json:"io,omitempty"`
    27  
    28  	Slr []string `json:"slr,random"`
    29  	Slo []string `json:"slo,omitempty"`
    30  
    31  	Mr map[string]interface{} `json:"mr"`
    32  	Mo map[string]interface{} `json:",omitempty"`
    33  
    34  	Fr float64 `json:"fr"`
    35  	Fo float64 `json:"fo,omitempty"`
    36  
    37  	Br bool `json:"br"`
    38  	Bo bool `json:"bo,omitempty"`
    39  
    40  	Ur uint `json:"ur"`
    41  	Uo uint `json:"uo,omitempty"`
    42  
    43  	Str struct{} `json:"str"`
    44  	Sto struct{} `json:"sto,omitempty"`
    45  }
    46  
    47  var optionalsExpected = `{
    48   "sr": "",
    49   "omitempty": 0,
    50   "slr": null,
    51   "mr": {},
    52   "fr": 0,
    53   "br": false,
    54   "ur": 0,
    55   "str": {},
    56   "sto": {}
    57  }`
    58  
    59  func TestOmitEmpty(t *testing.T) {
    60  	var o Optionals
    61  	o.Sw = "something"
    62  	o.Mr = map[string]interface{}{}
    63  	o.Mo = map[string]interface{}{}
    64  
    65  	got, err := MarshalIndent(&o, "", " ")
    66  	if err != nil {
    67  		t.Fatal(err)
    68  	}
    69  	if got := string(got); got != optionalsExpected {
    70  		t.Errorf(" got: %s\nwant: %s\n", got, optionalsExpected)
    71  	}
    72  }
    73  
    74  type StringTag struct {
    75  	BoolStr    bool    `json:",string"`
    76  	IntStr     int64   `json:",string"`
    77  	UintptrStr uintptr `json:",string"`
    78  	StrStr     string  `json:",string"`
    79  	NumberStr  Number  `json:",string"`
    80  }
    81  
    82  func TestRoundtripStringTag(t *testing.T) {
    83  	tests := []struct {
    84  		name string
    85  		in   StringTag
    86  		want string // empty to just test that we roundtrip
    87  	}{
    88  		{
    89  			name: "AllTypes",
    90  			in: StringTag{
    91  				BoolStr:    true,
    92  				IntStr:     42,
    93  				UintptrStr: 44,
    94  				StrStr:     "xzbit",
    95  				NumberStr:  "46",
    96  			},
    97  			want: `{
    98  				"BoolStr": "true",
    99  				"IntStr": "42",
   100  				"UintptrStr": "44",
   101  				"StrStr": "\"xzbit\"",
   102  				"NumberStr": "46"
   103  			}`,
   104  		},
   105  		{
   106  			// See golang.org/issues/38173.
   107  			name: "StringDoubleEscapes",
   108  			in: StringTag{
   109  				StrStr:    "\b\f\n\r\t\"\\",
   110  				NumberStr: "0", // just to satisfy the roundtrip
   111  			},
   112  			want: `{
   113  				"BoolStr": "false",
   114  				"IntStr": "0",
   115  				"UintptrStr": "0",
   116  				"StrStr": "\"\\u0008\\u000c\\n\\r\\t\\\"\\\\\"",
   117  				"NumberStr": "0"
   118  			}`,
   119  		},
   120  	}
   121  	for _, test := range tests {
   122  		t.Run(test.name, func(t *testing.T) {
   123  			// Indent with a tab prefix to make the multi-line string
   124  			// literals in the table nicer to read.
   125  			got, err := MarshalIndent(&test.in, "\t\t\t", "\t")
   126  			if err != nil {
   127  				t.Fatal(err)
   128  			}
   129  			if got := string(got); got != test.want {
   130  				t.Fatalf(" got: %s\nwant: %s\n", got, test.want)
   131  			}
   132  
   133  			// Verify that it round-trips.
   134  			var s2 StringTag
   135  			if err := Unmarshal(got, &s2); err != nil {
   136  				t.Fatalf("Decode: %v", err)
   137  			}
   138  			if !reflect.DeepEqual(test.in, s2) {
   139  				t.Fatalf("decode didn't match.\nsource: %#v\nEncoded as:\n%s\ndecode: %#v", test.in, string(got), s2)
   140  			}
   141  		})
   142  	}
   143  }
   144  
   145  // byte slices are special even if they're renamed types.
   146  type renamedByte byte
   147  type renamedByteSlice []byte
   148  type renamedRenamedByteSlice []renamedByte
   149  
   150  func TestEncodeRenamedByteSlice(t *testing.T) {
   151  	s := renamedByteSlice("abc")
   152  	result, err := Marshal(s)
   153  	if err != nil {
   154  		t.Fatal(err)
   155  	}
   156  	expect := `"YWJj"`
   157  	if string(result) != expect {
   158  		t.Errorf(" got %s want %s", result, expect)
   159  	}
   160  	r := renamedRenamedByteSlice("abc")
   161  	result, err = Marshal(r)
   162  	if err != nil {
   163  		t.Fatal(err)
   164  	}
   165  	if string(result) != expect {
   166  		t.Errorf(" got %s want %s", result, expect)
   167  	}
   168  }
   169  
   170  type SamePointerNoCycle struct {
   171  	Ptr1, Ptr2 *SamePointerNoCycle
   172  }
   173  
   174  var samePointerNoCycle = &SamePointerNoCycle{}
   175  
   176  type PointerCycle struct {
   177  	Ptr *PointerCycle
   178  }
   179  
   180  var pointerCycle = &PointerCycle{}
   181  
   182  type PointerCycleIndirect struct {
   183  	Ptrs []interface{}
   184  }
   185  
   186  type RecursiveSlice []RecursiveSlice
   187  
   188  var (
   189  	pointerCycleIndirect = &PointerCycleIndirect{}
   190  	mapCycle             = make(map[string]interface{})
   191  	sliceCycle           = []interface{}{nil}
   192  	sliceNoCycle         = []interface{}{nil, nil}
   193  	recursiveSliceCycle  = []RecursiveSlice{nil}
   194  )
   195  
   196  func init() {
   197  	ptr := &SamePointerNoCycle{}
   198  	samePointerNoCycle.Ptr1 = ptr
   199  	samePointerNoCycle.Ptr2 = ptr
   200  
   201  	pointerCycle.Ptr = pointerCycle
   202  	pointerCycleIndirect.Ptrs = []interface{}{pointerCycleIndirect}
   203  
   204  	mapCycle["x"] = mapCycle
   205  	sliceCycle[0] = sliceCycle
   206  	sliceNoCycle[1] = sliceNoCycle[:1]
   207  	for i := startDetectingCyclesAfter; i > 0; i-- {
   208  		sliceNoCycle = []interface{}{sliceNoCycle}
   209  	}
   210  	recursiveSliceCycle[0] = recursiveSliceCycle
   211  }
   212  
   213  func TestSamePointerNoCycle(t *testing.T) {
   214  	if _, err := Marshal(samePointerNoCycle); err != nil {
   215  		t.Fatalf("unexpected error: %v", err)
   216  	}
   217  }
   218  
   219  func TestSliceNoCycle(t *testing.T) {
   220  	if _, err := Marshal(sliceNoCycle); err != nil {
   221  		t.Fatalf("unexpected error: %v", err)
   222  	}
   223  }
   224  
   225  var unsupportedValues = []interface{}{
   226  	math.NaN(),
   227  	math.Inf(-1),
   228  	math.Inf(1),
   229  	pointerCycle,
   230  	pointerCycleIndirect,
   231  	mapCycle,
   232  	sliceCycle,
   233  	recursiveSliceCycle,
   234  }
   235  
   236  func TestUnsupportedValues(t *testing.T) {
   237  	for _, v := range unsupportedValues {
   238  		if _, err := Marshal(v); err != nil {
   239  			if _, ok := err.(*UnsupportedValueError); !ok {
   240  				t.Errorf("for %v, got %T want UnsupportedValueError", v, err)
   241  			}
   242  		} else {
   243  			t.Errorf("for %v, expected error", v)
   244  		}
   245  	}
   246  }
   247  
   248  // Issue 43207
   249  func TestMarshalTextFloatMap(t *testing.T) {
   250  	m := map[textfloat]string{
   251  		textfloat(math.NaN()): "1",
   252  		textfloat(math.NaN()): "1",
   253  	}
   254  	got, err := Marshal(m)
   255  	if err != nil {
   256  		t.Errorf("Marshal() error: %v", err)
   257  	}
   258  	want := `{"TF:NaN":"1","TF:NaN":"1"}`
   259  	if string(got) != want {
   260  		t.Errorf("Marshal() = %s, want %s", got, want)
   261  	}
   262  }
   263  
   264  // Ref has Marshaler and Unmarshaler methods with pointer receiver.
   265  type Ref int
   266  
   267  func (*Ref) MarshalJSON() ([]byte, error) {
   268  	return []byte(`"ref"`), nil
   269  }
   270  
   271  func (r *Ref) UnmarshalJSON([]byte) error {
   272  	*r = 12
   273  	return nil
   274  }
   275  
   276  // Val has Marshaler methods with value receiver.
   277  type Val int
   278  
   279  func (Val) MarshalJSON() ([]byte, error) {
   280  	return []byte(`"val"`), nil
   281  }
   282  
   283  // RefText has Marshaler and Unmarshaler methods with pointer receiver.
   284  type RefText int
   285  
   286  func (*RefText) MarshalText() ([]byte, error) {
   287  	return []byte(`"ref"`), nil
   288  }
   289  
   290  func (r *RefText) UnmarshalText([]byte) error {
   291  	*r = 13
   292  	return nil
   293  }
   294  
   295  // ValText has Marshaler methods with value receiver.
   296  type ValText int
   297  
   298  func (ValText) MarshalText() ([]byte, error) {
   299  	return []byte(`"val"`), nil
   300  }
   301  
   302  func TestRefValMarshal(t *testing.T) {
   303  	var s = struct {
   304  		R0 Ref
   305  		R1 *Ref
   306  		R2 RefText
   307  		R3 *RefText
   308  		V0 Val
   309  		V1 *Val
   310  		V2 ValText
   311  		V3 *ValText
   312  	}{
   313  		R0: 12,
   314  		R1: new(Ref),
   315  		R2: 14,
   316  		R3: new(RefText),
   317  		V0: 13,
   318  		V1: new(Val),
   319  		V2: 15,
   320  		V3: new(ValText),
   321  	}
   322  	const want = `{"R0":"ref","R1":"ref","R2":"\"ref\"","R3":"\"ref\"","V0":"val","V1":"val","V2":"\"val\"","V3":"\"val\""}`
   323  	b, err := Marshal(&s)
   324  	if err != nil {
   325  		t.Fatalf("Marshal: %v", err)
   326  	}
   327  	if got := string(b); got != want {
   328  		t.Errorf("got %q, want %q", got, want)
   329  	}
   330  }
   331  
   332  // C implements Marshaler and returns unescaped JSON.
   333  type C int
   334  
   335  func (C) MarshalJSON() ([]byte, error) {
   336  	return []byte(`"<&>"`), nil
   337  }
   338  
   339  // CText implements Marshaler and returns unescaped text.
   340  type CText int
   341  
   342  func (CText) MarshalText() ([]byte, error) {
   343  	return []byte(`"<&>"`), nil
   344  }
   345  
   346  func TestMarshalerEscaping(t *testing.T) {
   347  	var c C
   348  	want := `"\u003c\u0026\u003e"`
   349  	b, err := Marshal(c)
   350  	if err != nil {
   351  		t.Fatalf("Marshal(c): %v", err)
   352  	}
   353  	if got := string(b); got != want {
   354  		t.Errorf("Marshal(c) = %#q, want %#q", got, want)
   355  	}
   356  
   357  	var ct CText
   358  	want = `"\"\u003c\u0026\u003e\""`
   359  	b, err = Marshal(ct)
   360  	if err != nil {
   361  		t.Fatalf("Marshal(ct): %v", err)
   362  	}
   363  	if got := string(b); got != want {
   364  		t.Errorf("Marshal(ct) = %#q, want %#q", got, want)
   365  	}
   366  }
   367  
   368  func TestAnonymousFields(t *testing.T) {
   369  	tests := []struct {
   370  		label     string             // Test name
   371  		makeInput func() interface{} // Function to create input value
   372  		want      string             // Expected JSON output
   373  	}{{
   374  		// Both S1 and S2 have a field named X. From the perspective of S,
   375  		// it is ambiguous which one X refers to.
   376  		// This should not serialize either field.
   377  		label: "AmbiguousField",
   378  		makeInput: func() interface{} {
   379  			type (
   380  				S1 struct{ x, X int }
   381  				S2 struct{ x, X int }
   382  				S  struct {
   383  					S1
   384  					S2
   385  				}
   386  			)
   387  			return S{S1{1, 2}, S2{3, 4}}
   388  		},
   389  		want: `{}`,
   390  	}, {
   391  		label: "DominantField",
   392  		// Both S1 and S2 have a field named X, but since S has an X field as
   393  		// well, it takes precedence over S1.X and S2.X.
   394  		makeInput: func() interface{} {
   395  			type (
   396  				S1 struct{ x, X int }
   397  				S2 struct{ x, X int }
   398  				S  struct {
   399  					S1
   400  					S2
   401  					x, X int
   402  				}
   403  			)
   404  			return S{S1{1, 2}, S2{3, 4}, 5, 6}
   405  		},
   406  		want: `{"X":6}`,
   407  	}, {
   408  		// Unexported embedded field of non-struct type should not be serialized.
   409  		label: "UnexportedEmbeddedInt",
   410  		makeInput: func() interface{} {
   411  			type (
   412  				myInt int
   413  				S     struct{ myInt }
   414  			)
   415  			return S{5}
   416  		},
   417  		want: `{}`,
   418  	}, {
   419  		// Exported embedded field of non-struct type should be serialized.
   420  		label: "ExportedEmbeddedInt",
   421  		makeInput: func() interface{} {
   422  			type (
   423  				MyInt int
   424  				S     struct{ MyInt }
   425  			)
   426  			return S{5}
   427  		},
   428  		want: `{"MyInt":5}`,
   429  	}, {
   430  		// Unexported embedded field of pointer to non-struct type
   431  		// should not be serialized.
   432  		label: "UnexportedEmbeddedIntPointer",
   433  		makeInput: func() interface{} {
   434  			type (
   435  				myInt int
   436  				S     struct{ *myInt }
   437  			)
   438  			s := S{new(myInt)}
   439  			*s.myInt = 5
   440  			return s
   441  		},
   442  		want: `{}`,
   443  	}, {
   444  		// Exported embedded field of pointer to non-struct type
   445  		// should be serialized.
   446  		label: "ExportedEmbeddedIntPointer",
   447  		makeInput: func() interface{} {
   448  			type (
   449  				MyInt int
   450  				S     struct{ *MyInt }
   451  			)
   452  			s := S{new(MyInt)}
   453  			*s.MyInt = 5
   454  			return s
   455  		},
   456  		want: `{"MyInt":5}`,
   457  	}, {
   458  		// Exported fields of embedded structs should have their
   459  		// exported fields be serialized regardless of whether the struct types
   460  		// themselves are exported.
   461  		label: "EmbeddedStruct",
   462  		makeInput: func() interface{} {
   463  			type (
   464  				s1 struct{ x, X int }
   465  				S2 struct{ y, Y int }
   466  				S  struct {
   467  					s1
   468  					S2
   469  				}
   470  			)
   471  			return S{s1{1, 2}, S2{3, 4}}
   472  		},
   473  		want: `{"X":2,"Y":4}`,
   474  	}, {
   475  		// Exported fields of pointers to embedded structs should have their
   476  		// exported fields be serialized regardless of whether the struct types
   477  		// themselves are exported.
   478  		label: "EmbeddedStructPointer",
   479  		makeInput: func() interface{} {
   480  			type (
   481  				s1 struct{ x, X int }
   482  				S2 struct{ y, Y int }
   483  				S  struct {
   484  					*s1
   485  					*S2
   486  				}
   487  			)
   488  			return S{&s1{1, 2}, &S2{3, 4}}
   489  		},
   490  		want: `{"X":2,"Y":4}`,
   491  	}, {
   492  		// Exported fields on embedded unexported structs at multiple levels
   493  		// of nesting should still be serialized.
   494  		label: "NestedStructAndInts",
   495  		makeInput: func() interface{} {
   496  			type (
   497  				MyInt1 int
   498  				MyInt2 int
   499  				myInt  int
   500  				s2     struct {
   501  					MyInt2
   502  					myInt
   503  				}
   504  				s1 struct {
   505  					MyInt1
   506  					myInt
   507  					s2
   508  				}
   509  				S struct {
   510  					s1
   511  					myInt
   512  				}
   513  			)
   514  			return S{s1{1, 2, s2{3, 4}}, 6}
   515  		},
   516  		want: `{"MyInt1":1,"MyInt2":3}`,
   517  	}, {
   518  		// If an anonymous struct pointer field is nil, we should ignore
   519  		// the embedded fields behind it. Not properly doing so may
   520  		// result in the wrong output or reflect panics.
   521  		label: "EmbeddedFieldBehindNilPointer",
   522  		makeInput: func() interface{} {
   523  			type (
   524  				S2 struct{ Field string }
   525  				S  struct{ *S2 }
   526  			)
   527  			return S{}
   528  		},
   529  		want: `{}`,
   530  	}}
   531  
   532  	for _, tt := range tests {
   533  		t.Run(tt.label, func(t *testing.T) {
   534  			b, err := Marshal(tt.makeInput())
   535  			if err != nil {
   536  				t.Fatalf("Marshal() = %v, want nil error", err)
   537  			}
   538  			if string(b) != tt.want {
   539  				t.Fatalf("Marshal() = %q, want %q", b, tt.want)
   540  			}
   541  		})
   542  	}
   543  }
   544  
   545  type BugA struct {
   546  	S string
   547  }
   548  
   549  type BugB struct {
   550  	BugA
   551  	S string
   552  }
   553  
   554  type BugC struct {
   555  	S string
   556  }
   557  
   558  // Legal Go: We never use the repeated embedded field (S).
   559  type BugX struct {
   560  	A int
   561  	BugA
   562  	BugB
   563  }
   564  
   565  // golang.org/issue/16042.
   566  // Even if a nil interface value is passed in, as long as
   567  // it implements Marshaler, it should be marshaled.
   568  type nilJSONMarshaler string
   569  
   570  func (nm *nilJSONMarshaler) MarshalJSON() ([]byte, error) {
   571  	if nm == nil {
   572  		return Marshal("0zenil0")
   573  	}
   574  	return Marshal("zenil:" + string(*nm))
   575  }
   576  
   577  // golang.org/issue/34235.
   578  // Even if a nil interface value is passed in, as long as
   579  // it implements encoding.TextMarshaler, it should be marshaled.
   580  type nilTextMarshaler string
   581  
   582  func (nm *nilTextMarshaler) MarshalText() ([]byte, error) {
   583  	if nm == nil {
   584  		return []byte("0zenil0"), nil
   585  	}
   586  	return []byte("zenil:" + string(*nm)), nil
   587  }
   588  
   589  // See golang.org/issue/16042 and golang.org/issue/34235.
   590  func TestNilMarshal(t *testing.T) {
   591  	testCases := []struct {
   592  		v    interface{}
   593  		want string
   594  	}{
   595  		{v: nil, want: `null`},
   596  		{v: new(float64), want: `0`},
   597  		{v: []interface{}(nil), want: `null`},
   598  		{v: []string(nil), want: `null`},
   599  		{v: map[string]string(nil), want: `null`},
   600  		{v: []byte(nil), want: `null`},
   601  		{v: struct{ M string }{"gopher"}, want: `{"M":"gopher"}`},
   602  		{v: struct{ M Marshaler }{}, want: `{"M":null}`},
   603  		{v: struct{ M Marshaler }{(*nilJSONMarshaler)(nil)}, want: `{"M":"0zenil0"}`},
   604  		{v: struct{ M interface{} }{(*nilJSONMarshaler)(nil)}, want: `{"M":null}`},
   605  		{v: struct{ M encoding.TextMarshaler }{}, want: `{"M":null}`},
   606  		{v: struct{ M encoding.TextMarshaler }{(*nilTextMarshaler)(nil)}, want: `{"M":"0zenil0"}`},
   607  		{v: struct{ M interface{} }{(*nilTextMarshaler)(nil)}, want: `{"M":null}`},
   608  	}
   609  
   610  	for _, tt := range testCases {
   611  		out, err := Marshal(tt.v)
   612  		if err != nil || string(out) != tt.want {
   613  			t.Errorf("Marshal(%#v) = %#q, %#v, want %#q, nil", tt.v, out, err, tt.want)
   614  			continue
   615  		}
   616  	}
   617  }
   618  
   619  // Issue 5245.
   620  func TestEmbeddedBug(t *testing.T) {
   621  	v := BugB{
   622  		BugA{"A"},
   623  		"B",
   624  	}
   625  	b, err := Marshal(v)
   626  	if err != nil {
   627  		t.Fatal("Marshal:", err)
   628  	}
   629  	want := `{"S":"B"}`
   630  	got := string(b)
   631  	if got != want {
   632  		t.Fatalf("Marshal: got %s want %s", got, want)
   633  	}
   634  	// Now check that the duplicate field, S, does not appear.
   635  	x := BugX{
   636  		A: 23,
   637  	}
   638  	b, err = Marshal(x)
   639  	if err != nil {
   640  		t.Fatal("Marshal:", err)
   641  	}
   642  	want = `{"A":23}`
   643  	got = string(b)
   644  	if got != want {
   645  		t.Fatalf("Marshal: got %s want %s", got, want)
   646  	}
   647  }
   648  
   649  type BugD struct { // Same as BugA after tagging.
   650  	XXX string `json:"S"`
   651  }
   652  
   653  // BugD's tagged S field should dominate BugA's.
   654  type BugY struct {
   655  	BugA
   656  	BugD
   657  }
   658  
   659  // Test that a field with a tag dominates untagged fields.
   660  func TestTaggedFieldDominates(t *testing.T) {
   661  	v := BugY{
   662  		BugA{"BugA"},
   663  		BugD{"BugD"},
   664  	}
   665  	b, err := Marshal(v)
   666  	if err != nil {
   667  		t.Fatal("Marshal:", err)
   668  	}
   669  	want := `{"S":"BugD"}`
   670  	got := string(b)
   671  	if got != want {
   672  		t.Fatalf("Marshal: got %s want %s", got, want)
   673  	}
   674  }
   675  
   676  // There are no tags here, so S should not appear.
   677  type BugZ struct {
   678  	BugA
   679  	BugC
   680  	BugY // Contains a tagged S field through BugD; should not dominate.
   681  }
   682  
   683  func TestDuplicatedFieldDisappears(t *testing.T) {
   684  	v := BugZ{
   685  		BugA{"BugA"},
   686  		BugC{"BugC"},
   687  		BugY{
   688  			BugA{"nested BugA"},
   689  			BugD{"nested BugD"},
   690  		},
   691  	}
   692  	b, err := Marshal(v)
   693  	if err != nil {
   694  		t.Fatal("Marshal:", err)
   695  	}
   696  	want := `{}`
   697  	got := string(b)
   698  	if got != want {
   699  		t.Fatalf("Marshal: got %s want %s", got, want)
   700  	}
   701  }
   702  
   703  func TestStringBytes(t *testing.T) {
   704  	t.Parallel()
   705  	// Test that encodeState.stringBytes and encodeState.string use the same encoding.
   706  	var r []rune
   707  	for i := '\u0000'; i <= unicode.MaxRune; i++ {
   708  		if testing.Short() && i > 1000 {
   709  			i = unicode.MaxRune
   710  		}
   711  		r = append(r, i)
   712  	}
   713  	s := string(r) + "\xff\xff\xffhello" // some invalid UTF-8 too
   714  
   715  	for _, escapeHTML := range []bool{true, false} {
   716  		es := &encodeState{}
   717  		es.string(s, escapeHTML)
   718  
   719  		esBytes := &encodeState{}
   720  		esBytes.stringBytes([]byte(s), escapeHTML)
   721  
   722  		enc := es.Buffer.String()
   723  		encBytes := esBytes.Buffer.String()
   724  		if enc != encBytes {
   725  			i := 0
   726  			for i < len(enc) && i < len(encBytes) && enc[i] == encBytes[i] {
   727  				i++
   728  			}
   729  			enc = enc[i:]
   730  			encBytes = encBytes[i:]
   731  			i = 0
   732  			for i < len(enc) && i < len(encBytes) && enc[len(enc)-i-1] == encBytes[len(encBytes)-i-1] {
   733  				i++
   734  			}
   735  			enc = enc[:len(enc)-i]
   736  			encBytes = encBytes[:len(encBytes)-i]
   737  
   738  			if len(enc) > 20 {
   739  				enc = enc[:20] + "..."
   740  			}
   741  			if len(encBytes) > 20 {
   742  				encBytes = encBytes[:20] + "..."
   743  			}
   744  
   745  			t.Errorf("with escapeHTML=%t, encodings differ at %#q vs %#q",
   746  				escapeHTML, enc, encBytes)
   747  		}
   748  	}
   749  }
   750  
   751  func TestIssue10281(t *testing.T) {
   752  	type Foo struct {
   753  		N Number
   754  	}
   755  	x := Foo{Number(`invalid`)}
   756  
   757  	b, err := Marshal(&x)
   758  	if err == nil {
   759  		t.Errorf("Marshal(&x) = %#q; want error", b)
   760  	}
   761  }
   762  
   763  func TestHTMLEscape(t *testing.T) {
   764  	var b, want bytes.Buffer
   765  	m := `{"M":"<html>foo &` + "\xe2\x80\xa8 \xe2\x80\xa9" + `</html>"}`
   766  	want.Write([]byte(`{"M":"\u003chtml\u003efoo \u0026\u2028 \u2029\u003c/html\u003e"}`))
   767  	HTMLEscape(&b, []byte(m))
   768  	if !bytes.Equal(b.Bytes(), want.Bytes()) {
   769  		t.Errorf("HTMLEscape(&b, []byte(m)) = %s; want %s", b.Bytes(), want.Bytes())
   770  	}
   771  }
   772  
   773  // golang.org/issue/8582
   774  func TestEncodePointerString(t *testing.T) {
   775  	type stringPointer struct {
   776  		N *int64 `json:"n,string"`
   777  	}
   778  	var n int64 = 42
   779  	b, err := Marshal(stringPointer{N: &n})
   780  	if err != nil {
   781  		t.Fatalf("Marshal: %v", err)
   782  	}
   783  	if got, want := string(b), `{"n":"42"}`; got != want {
   784  		t.Errorf("Marshal = %s, want %s", got, want)
   785  	}
   786  	var back stringPointer
   787  	err = Unmarshal(b, &back)
   788  	if err != nil {
   789  		t.Fatalf("Unmarshal: %v", err)
   790  	}
   791  	if back.N == nil {
   792  		t.Fatalf("Unmarshaled nil N field")
   793  	}
   794  	if *back.N != 42 {
   795  		t.Fatalf("*N = %d; want 42", *back.N)
   796  	}
   797  }
   798  
   799  var encodeStringTests = []struct {
   800  	in  string
   801  	out string
   802  }{
   803  	{"\x00", `"\u0000"`},
   804  	{"\x01", `"\u0001"`},
   805  	{"\x02", `"\u0002"`},
   806  	{"\x03", `"\u0003"`},
   807  	{"\x04", `"\u0004"`},
   808  	{"\x05", `"\u0005"`},
   809  	{"\x06", `"\u0006"`},
   810  	{"\x07", `"\u0007"`},
   811  	{"\x08", `"\u0008"`},
   812  	{"\x09", `"\t"`},
   813  	{"\x0a", `"\n"`},
   814  	{"\x0b", `"\u000b"`},
   815  	{"\x0c", `"\u000c"`},
   816  	{"\x0d", `"\r"`},
   817  	{"\x0e", `"\u000e"`},
   818  	{"\x0f", `"\u000f"`},
   819  	{"\x10", `"\u0010"`},
   820  	{"\x11", `"\u0011"`},
   821  	{"\x12", `"\u0012"`},
   822  	{"\x13", `"\u0013"`},
   823  	{"\x14", `"\u0014"`},
   824  	{"\x15", `"\u0015"`},
   825  	{"\x16", `"\u0016"`},
   826  	{"\x17", `"\u0017"`},
   827  	{"\x18", `"\u0018"`},
   828  	{"\x19", `"\u0019"`},
   829  	{"\x1a", `"\u001a"`},
   830  	{"\x1b", `"\u001b"`},
   831  	{"\x1c", `"\u001c"`},
   832  	{"\x1d", `"\u001d"`},
   833  	{"\x1e", `"\u001e"`},
   834  	{"\x1f", `"\u001f"`},
   835  }
   836  
   837  func TestEncodeString(t *testing.T) {
   838  	for _, tt := range encodeStringTests {
   839  		b, err := Marshal(tt.in)
   840  		if err != nil {
   841  			t.Errorf("Marshal(%q): %v", tt.in, err)
   842  			continue
   843  		}
   844  		out := string(b)
   845  		if out != tt.out {
   846  			t.Errorf("Marshal(%q) = %#q, want %#q", tt.in, out, tt.out)
   847  		}
   848  	}
   849  }
   850  
   851  type jsonbyte byte
   852  
   853  func (b jsonbyte) MarshalJSON() ([]byte, error) { return tenc(`{"JB":%d}`, b) }
   854  
   855  type textbyte byte
   856  
   857  func (b textbyte) MarshalText() ([]byte, error) { return tenc(`TB:%d`, b) }
   858  
   859  type jsonint int
   860  
   861  func (i jsonint) MarshalJSON() ([]byte, error) { return tenc(`{"JI":%d}`, i) }
   862  
   863  type textint int
   864  
   865  func (i textint) MarshalText() ([]byte, error) { return tenc(`TI:%d`, i) }
   866  
   867  func tenc(format string, a ...interface{}) ([]byte, error) {
   868  	var buf bytes.Buffer
   869  	fmt.Fprintf(&buf, format, a...)
   870  	return buf.Bytes(), nil
   871  }
   872  
   873  type textfloat float64
   874  
   875  func (f textfloat) MarshalText() ([]byte, error) { return tenc(`TF:%0.2f`, f) }
   876  
   877  // Issue 13783
   878  func TestEncodeBytekind(t *testing.T) {
   879  	testdata := []struct {
   880  		data interface{}
   881  		want string
   882  	}{
   883  		{byte(7), "7"},
   884  		{jsonbyte(7), `{"JB":7}`},
   885  		{textbyte(4), `"TB:4"`},
   886  		{jsonint(5), `{"JI":5}`},
   887  		{textint(1), `"TI:1"`},
   888  		{[]byte{0, 1}, `"AAE="`},
   889  		{[]jsonbyte{0, 1}, `[{"JB":0},{"JB":1}]`},
   890  		{[][]jsonbyte{{0, 1}, {3}}, `[[{"JB":0},{"JB":1}],[{"JB":3}]]`},
   891  		{[]textbyte{2, 3}, `["TB:2","TB:3"]`},
   892  		{[]jsonint{5, 4}, `[{"JI":5},{"JI":4}]`},
   893  		{[]textint{9, 3}, `["TI:9","TI:3"]`},
   894  		{[]int{9, 3}, `[9,3]`},
   895  		{[]textfloat{12, 3}, `["TF:12.00","TF:3.00"]`},
   896  	}
   897  	for _, d := range testdata {
   898  		js, err := Marshal(d.data)
   899  		if err != nil {
   900  			t.Error(err)
   901  			continue
   902  		}
   903  		got, want := string(js), d.want
   904  		if got != want {
   905  			t.Errorf("got %s, want %s", got, want)
   906  		}
   907  	}
   908  }
   909  
   910  func TestTextMarshalerMapKeysAreSorted(t *testing.T) {
   911  	b, err := Marshal(map[unmarshalerText]int{
   912  		{"x", "y"}: 1,
   913  		{"y", "x"}: 2,
   914  		{"a", "z"}: 3,
   915  		{"z", "a"}: 4,
   916  	})
   917  	if err != nil {
   918  		t.Fatalf("Failed to Marshal text.Marshaler: %v", err)
   919  	}
   920  	const want = `{"a:z":3,"x:y":1,"y:x":2,"z:a":4}`
   921  	if string(b) != want {
   922  		t.Errorf("Marshal map with text.Marshaler keys: got %#q, want %#q", b, want)
   923  	}
   924  }
   925  
   926  // https://golang.org/issue/33675
   927  func TestNilMarshalerTextMapKey(t *testing.T) {
   928  	b, err := Marshal(map[*unmarshalerText]int{
   929  		(*unmarshalerText)(nil): 1,
   930  		{"A", "B"}:              2,
   931  	})
   932  	if err != nil {
   933  		t.Fatalf("Failed to Marshal *text.Marshaler: %v", err)
   934  	}
   935  	const want = `{"":1,"A:B":2}`
   936  	if string(b) != want {
   937  		t.Errorf("Marshal map with *text.Marshaler keys: got %#q, want %#q", b, want)
   938  	}
   939  }
   940  
   941  var re = regexp.MustCompile
   942  
   943  // syntactic checks on form of marshaled floating point numbers.
   944  var badFloatREs = []*regexp.Regexp{
   945  	re(`p`),                     // no binary exponential notation
   946  	re(`^\+`),                   // no leading + sign
   947  	re(`^-?0[^.]`),              // no unnecessary leading zeros
   948  	re(`^-?\.`),                 // leading zero required before decimal point
   949  	re(`\.(e|$)`),               // no trailing decimal
   950  	re(`\.[0-9]+0(e|$)`),        // no trailing zero in fraction
   951  	re(`^-?(0|[0-9]{2,})\..*e`), // exponential notation must have normalized mantissa
   952  	re(`e[0-9]`),                // positive exponent must be signed
   953  	re(`e[+-]0`),                // exponent must not have leading zeros
   954  	re(`e-[1-6]$`),              // not tiny enough for exponential notation
   955  	re(`e+(.|1.|20)$`),          // not big enough for exponential notation
   956  	re(`^-?0\.0000000`),         // too tiny, should use exponential notation
   957  	re(`^-?[0-9]{22}`),          // too big, should use exponential notation
   958  	re(`[1-9][0-9]{16}[1-9]`),   // too many significant digits in integer
   959  	re(`[1-9][0-9.]{17}[1-9]`),  // too many significant digits in decimal
   960  	// below here for float32 only
   961  	re(`[1-9][0-9]{8}[1-9]`),  // too many significant digits in integer
   962  	re(`[1-9][0-9.]{9}[1-9]`), // too many significant digits in decimal
   963  }
   964  
   965  func TestMarshalFloat(t *testing.T) {
   966  	t.Parallel()
   967  	nfail := 0
   968  	test := func(f float64, bits int) {
   969  		vf := interface{}(f)
   970  		if bits == 32 {
   971  			f = float64(float32(f)) // round
   972  			vf = float32(f)
   973  		}
   974  		bout, err := Marshal(vf)
   975  		if err != nil {
   976  			t.Errorf("Marshal(%T(%g)): %v", vf, vf, err)
   977  			nfail++
   978  			return
   979  		}
   980  		out := string(bout)
   981  
   982  		// result must convert back to the same float
   983  		g, err := strconv.ParseFloat(out, bits)
   984  		if err != nil {
   985  			t.Errorf("Marshal(%T(%g)) = %q, cannot parse back: %v", vf, vf, out, err)
   986  			nfail++
   987  			return
   988  		}
   989  		if f != g || fmt.Sprint(f) != fmt.Sprint(g) { // fmt.Sprint handles ±0
   990  			t.Errorf("Marshal(%T(%g)) = %q (is %g, not %g)", vf, vf, out, float32(g), vf)
   991  			nfail++
   992  			return
   993  		}
   994  
   995  		bad := badFloatREs
   996  		if bits == 64 {
   997  			bad = bad[:len(bad)-2]
   998  		}
   999  		for _, re := range bad {
  1000  			if re.MatchString(out) {
  1001  				t.Errorf("Marshal(%T(%g)) = %q, must not match /%s/", vf, vf, out, re)
  1002  				nfail++
  1003  				return
  1004  			}
  1005  		}
  1006  	}
  1007  
  1008  	var (
  1009  		bigger  = math.Inf(+1)
  1010  		smaller = math.Inf(-1)
  1011  	)
  1012  
  1013  	var digits = "1.2345678901234567890123"
  1014  	for i := len(digits); i >= 2; i-- {
  1015  		if testing.Short() && i < len(digits)-4 {
  1016  			break
  1017  		}
  1018  		for exp := -30; exp <= 30; exp++ {
  1019  			for _, sign := range "+-" {
  1020  				for bits := 32; bits <= 64; bits += 32 {
  1021  					s := fmt.Sprintf("%c%se%d", sign, digits[:i], exp)
  1022  					f, err := strconv.ParseFloat(s, bits)
  1023  					if err != nil {
  1024  						log.Fatal(err)
  1025  					}
  1026  					next := math.Nextafter
  1027  					if bits == 32 {
  1028  						next = func(g, h float64) float64 {
  1029  							return float64(math.Nextafter32(float32(g), float32(h)))
  1030  						}
  1031  					}
  1032  					test(f, bits)
  1033  					test(next(f, bigger), bits)
  1034  					test(next(f, smaller), bits)
  1035  					if nfail > 50 {
  1036  						t.Fatalf("stopping test early")
  1037  					}
  1038  				}
  1039  			}
  1040  		}
  1041  	}
  1042  	test(0, 64)
  1043  	test(math.Copysign(0, -1), 64)
  1044  	test(0, 32)
  1045  	test(math.Copysign(0, -1), 32)
  1046  }
  1047  
  1048  func TestMarshalRawMessageValue(t *testing.T) {
  1049  	type (
  1050  		T1 struct {
  1051  			M RawMessage `json:",omitempty"`
  1052  		}
  1053  		T2 struct {
  1054  			M *RawMessage `json:",omitempty"`
  1055  		}
  1056  	)
  1057  
  1058  	var (
  1059  		rawNil   = RawMessage(nil)
  1060  		rawEmpty = RawMessage([]byte{})
  1061  		rawText  = RawMessage([]byte(`"foo"`))
  1062  	)
  1063  
  1064  	tests := []struct {
  1065  		in   interface{}
  1066  		want string
  1067  		ok   bool
  1068  	}{
  1069  		// Test with nil RawMessage.
  1070  		{rawNil, "null", true},
  1071  		{&rawNil, "null", true},
  1072  		{[]interface{}{rawNil}, "[null]", true},
  1073  		{&[]interface{}{rawNil}, "[null]", true},
  1074  		{[]interface{}{&rawNil}, "[null]", true},
  1075  		{&[]interface{}{&rawNil}, "[null]", true},
  1076  		{struct{ M RawMessage }{rawNil}, `{"M":null}`, true},
  1077  		{&struct{ M RawMessage }{rawNil}, `{"M":null}`, true},
  1078  		{struct{ M *RawMessage }{&rawNil}, `{"M":null}`, true},
  1079  		{&struct{ M *RawMessage }{&rawNil}, `{"M":null}`, true},
  1080  		{map[string]interface{}{"M": rawNil}, `{"M":null}`, true},
  1081  		{&map[string]interface{}{"M": rawNil}, `{"M":null}`, true},
  1082  		{map[string]interface{}{"M": &rawNil}, `{"M":null}`, true},
  1083  		{&map[string]interface{}{"M": &rawNil}, `{"M":null}`, true},
  1084  		{T1{rawNil}, "{}", true},
  1085  		{T2{&rawNil}, `{"M":null}`, true},
  1086  		{&T1{rawNil}, "{}", true},
  1087  		{&T2{&rawNil}, `{"M":null}`, true},
  1088  
  1089  		// Test with empty, but non-nil, RawMessage.
  1090  		{rawEmpty, "", false},
  1091  		{&rawEmpty, "", false},
  1092  		{[]interface{}{rawEmpty}, "", false},
  1093  		{&[]interface{}{rawEmpty}, "", false},
  1094  		{[]interface{}{&rawEmpty}, "", false},
  1095  		{&[]interface{}{&rawEmpty}, "", false},
  1096  		{struct{ X RawMessage }{rawEmpty}, "", false},
  1097  		{&struct{ X RawMessage }{rawEmpty}, "", false},
  1098  		{struct{ X *RawMessage }{&rawEmpty}, "", false},
  1099  		{&struct{ X *RawMessage }{&rawEmpty}, "", false},
  1100  		{map[string]interface{}{"nil": rawEmpty}, "", false},
  1101  		{&map[string]interface{}{"nil": rawEmpty}, "", false},
  1102  		{map[string]interface{}{"nil": &rawEmpty}, "", false},
  1103  		{&map[string]interface{}{"nil": &rawEmpty}, "", false},
  1104  		{T1{rawEmpty}, "{}", true},
  1105  		{T2{&rawEmpty}, "", false},
  1106  		{&T1{rawEmpty}, "{}", true},
  1107  		{&T2{&rawEmpty}, "", false},
  1108  
  1109  		// Test with RawMessage with some text.
  1110  		//
  1111  		// The tests below marked with Issue6458 used to generate "ImZvbyI=" instead "foo".
  1112  		// This behavior was intentionally changed in Go 1.8.
  1113  		// See https://golang.org/issues/14493#issuecomment-255857318
  1114  		{rawText, `"foo"`, true}, // Issue6458
  1115  		{&rawText, `"foo"`, true},
  1116  		{[]interface{}{rawText}, `["foo"]`, true},  // Issue6458
  1117  		{&[]interface{}{rawText}, `["foo"]`, true}, // Issue6458
  1118  		{[]interface{}{&rawText}, `["foo"]`, true},
  1119  		{&[]interface{}{&rawText}, `["foo"]`, true},
  1120  		{struct{ M RawMessage }{rawText}, `{"M":"foo"}`, true}, // Issue6458
  1121  		{&struct{ M RawMessage }{rawText}, `{"M":"foo"}`, true},
  1122  		{struct{ M *RawMessage }{&rawText}, `{"M":"foo"}`, true},
  1123  		{&struct{ M *RawMessage }{&rawText}, `{"M":"foo"}`, true},
  1124  		{map[string]interface{}{"M": rawText}, `{"M":"foo"}`, true},  // Issue6458
  1125  		{&map[string]interface{}{"M": rawText}, `{"M":"foo"}`, true}, // Issue6458
  1126  		{map[string]interface{}{"M": &rawText}, `{"M":"foo"}`, true},
  1127  		{&map[string]interface{}{"M": &rawText}, `{"M":"foo"}`, true},
  1128  		{T1{rawText}, `{"M":"foo"}`, true}, // Issue6458
  1129  		{T2{&rawText}, `{"M":"foo"}`, true},
  1130  		{&T1{rawText}, `{"M":"foo"}`, true},
  1131  		{&T2{&rawText}, `{"M":"foo"}`, true},
  1132  	}
  1133  
  1134  	for i, tt := range tests {
  1135  		b, err := Marshal(tt.in)
  1136  		if ok := (err == nil); ok != tt.ok {
  1137  			if err != nil {
  1138  				t.Errorf("test %d, unexpected failure: %v", i, err)
  1139  			} else {
  1140  				t.Errorf("test %d, unexpected success", i)
  1141  			}
  1142  		}
  1143  		if got := string(b); got != tt.want {
  1144  			t.Errorf("test %d, Marshal(%#v) = %q, want %q", i, tt.in, got, tt.want)
  1145  		}
  1146  	}
  1147  }
  1148  
  1149  type marshalPanic struct{}
  1150  
  1151  func (marshalPanic) MarshalJSON() ([]byte, error) { panic(0xdead) }
  1152  
  1153  func TestMarshalPanic(t *testing.T) {
  1154  	defer func() {
  1155  		if got := recover(); !reflect.DeepEqual(got, 0xdead) {
  1156  			t.Errorf("panic() = (%T)(%v), want 0xdead", got, got)
  1157  		}
  1158  	}()
  1159  	Marshal(&marshalPanic{})
  1160  	t.Error("Marshal should have panicked")
  1161  }
  1162  
  1163  func TestMarshalUncommonFieldNames(t *testing.T) {
  1164  	v := struct {
  1165  		A0, À, Aβ int
  1166  	}{}
  1167  	b, err := Marshal(v)
  1168  	if err != nil {
  1169  		t.Fatal("Marshal:", err)
  1170  	}
  1171  	want := `{"A0":0,"À":0,"Aβ":0}`
  1172  	got := string(b)
  1173  	if got != want {
  1174  		t.Fatalf("Marshal: got %s want %s", got, want)
  1175  	}
  1176  }
  1177  
  1178  func TestMarshalerError(t *testing.T) {
  1179  	s := "test variable"
  1180  	st := reflect.TypeOf(s)
  1181  	errText := "json: test error"
  1182  
  1183  	tests := []struct {
  1184  		err  *MarshalerError
  1185  		want string
  1186  	}{
  1187  		{
  1188  			&MarshalerError{st, fmt.Errorf(errText), ""},
  1189  			"json: error calling MarshalJSON for type " + st.String() + ": " + errText,
  1190  		},
  1191  		{
  1192  			&MarshalerError{st, fmt.Errorf(errText), "TestMarshalerError"},
  1193  			"json: error calling TestMarshalerError for type " + st.String() + ": " + errText,
  1194  		},
  1195  	}
  1196  
  1197  	for i, tt := range tests {
  1198  		got := tt.err.Error()
  1199  		if got != tt.want {
  1200  			t.Errorf("MarshalerError test %d, got: %s, want: %s", i, got, tt.want)
  1201  		}
  1202  	}
  1203  }
  1204  

View as plain text