...
Run Format

Source file src/encoding/json/encode_test.go

Documentation: encoding/json

  // Copyright 2011 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  package json
  
  import (
  	"bytes"
  	"fmt"
  	"log"
  	"math"
  	"reflect"
  	"regexp"
  	"strconv"
  	"testing"
  	"unicode"
  )
  
  type Optionals struct {
  	Sr string `json:"sr"`
  	So string `json:"so,omitempty"`
  	Sw string `json:"-"`
  
  	Ir int `json:"omitempty"` // actually named omitempty, not an option
  	Io int `json:"io,omitempty"`
  
  	Slr []string `json:"slr,random"`
  	Slo []string `json:"slo,omitempty"`
  
  	Mr map[string]interface{} `json:"mr"`
  	Mo map[string]interface{} `json:",omitempty"`
  
  	Fr float64 `json:"fr"`
  	Fo float64 `json:"fo,omitempty"`
  
  	Br bool `json:"br"`
  	Bo bool `json:"bo,omitempty"`
  
  	Ur uint `json:"ur"`
  	Uo uint `json:"uo,omitempty"`
  
  	Str struct{} `json:"str"`
  	Sto struct{} `json:"sto,omitempty"`
  }
  
  var optionalsExpected = `{
   "sr": "",
   "omitempty": 0,
   "slr": null,
   "mr": {},
   "fr": 0,
   "br": false,
   "ur": 0,
   "str": {},
   "sto": {}
  }`
  
  func TestOmitEmpty(t *testing.T) {
  	var o Optionals
  	o.Sw = "something"
  	o.Mr = map[string]interface{}{}
  	o.Mo = map[string]interface{}{}
  
  	got, err := MarshalIndent(&o, "", " ")
  	if err != nil {
  		t.Fatal(err)
  	}
  	if got := string(got); got != optionalsExpected {
  		t.Errorf(" got: %s\nwant: %s\n", got, optionalsExpected)
  	}
  }
  
  type StringTag struct {
  	BoolStr bool   `json:",string"`
  	IntStr  int64  `json:",string"`
  	StrStr  string `json:",string"`
  }
  
  var stringTagExpected = `{
   "BoolStr": "true",
   "IntStr": "42",
   "StrStr": "\"xzbit\""
  }`
  
  func TestStringTag(t *testing.T) {
  	var s StringTag
  	s.BoolStr = true
  	s.IntStr = 42
  	s.StrStr = "xzbit"
  	got, err := MarshalIndent(&s, "", " ")
  	if err != nil {
  		t.Fatal(err)
  	}
  	if got := string(got); got != stringTagExpected {
  		t.Fatalf(" got: %s\nwant: %s\n", got, stringTagExpected)
  	}
  
  	// Verify that it round-trips.
  	var s2 StringTag
  	err = NewDecoder(bytes.NewReader(got)).Decode(&s2)
  	if err != nil {
  		t.Fatalf("Decode: %v", err)
  	}
  	if !reflect.DeepEqual(s, s2) {
  		t.Fatalf("decode didn't match.\nsource: %#v\nEncoded as:\n%s\ndecode: %#v", s, string(got), s2)
  	}
  }
  
  // byte slices are special even if they're renamed types.
  type renamedByte byte
  type renamedByteSlice []byte
  type renamedRenamedByteSlice []renamedByte
  
  func TestEncodeRenamedByteSlice(t *testing.T) {
  	s := renamedByteSlice("abc")
  	result, err := Marshal(s)
  	if err != nil {
  		t.Fatal(err)
  	}
  	expect := `"YWJj"`
  	if string(result) != expect {
  		t.Errorf(" got %s want %s", result, expect)
  	}
  	r := renamedRenamedByteSlice("abc")
  	result, err = Marshal(r)
  	if err != nil {
  		t.Fatal(err)
  	}
  	if string(result) != expect {
  		t.Errorf(" got %s want %s", result, expect)
  	}
  }
  
  var unsupportedValues = []interface{}{
  	math.NaN(),
  	math.Inf(-1),
  	math.Inf(1),
  }
  
  func TestUnsupportedValues(t *testing.T) {
  	for _, v := range unsupportedValues {
  		if _, err := Marshal(v); err != nil {
  			if _, ok := err.(*UnsupportedValueError); !ok {
  				t.Errorf("for %v, got %T want UnsupportedValueError", v, err)
  			}
  		} else {
  			t.Errorf("for %v, expected error", v)
  		}
  	}
  }
  
  // Ref has Marshaler and Unmarshaler methods with pointer receiver.
  type Ref int
  
  func (*Ref) MarshalJSON() ([]byte, error) {
  	return []byte(`"ref"`), nil
  }
  
  func (r *Ref) UnmarshalJSON([]byte) error {
  	*r = 12
  	return nil
  }
  
  // Val has Marshaler methods with value receiver.
  type Val int
  
  func (Val) MarshalJSON() ([]byte, error) {
  	return []byte(`"val"`), nil
  }
  
  // RefText has Marshaler and Unmarshaler methods with pointer receiver.
  type RefText int
  
  func (*RefText) MarshalText() ([]byte, error) {
  	return []byte(`"ref"`), nil
  }
  
  func (r *RefText) UnmarshalText([]byte) error {
  	*r = 13
  	return nil
  }
  
  // ValText has Marshaler methods with value receiver.
  type ValText int
  
  func (ValText) MarshalText() ([]byte, error) {
  	return []byte(`"val"`), nil
  }
  
  func TestRefValMarshal(t *testing.T) {
  	var s = struct {
  		R0 Ref
  		R1 *Ref
  		R2 RefText
  		R3 *RefText
  		V0 Val
  		V1 *Val
  		V2 ValText
  		V3 *ValText
  	}{
  		R0: 12,
  		R1: new(Ref),
  		R2: 14,
  		R3: new(RefText),
  		V0: 13,
  		V1: new(Val),
  		V2: 15,
  		V3: new(ValText),
  	}
  	const want = `{"R0":"ref","R1":"ref","R2":"\"ref\"","R3":"\"ref\"","V0":"val","V1":"val","V2":"\"val\"","V3":"\"val\""}`
  	b, err := Marshal(&s)
  	if err != nil {
  		t.Fatalf("Marshal: %v", err)
  	}
  	if got := string(b); got != want {
  		t.Errorf("got %q, want %q", got, want)
  	}
  }
  
  // C implements Marshaler and returns unescaped JSON.
  type C int
  
  func (C) MarshalJSON() ([]byte, error) {
  	return []byte(`"<&>"`), nil
  }
  
  // CText implements Marshaler and returns unescaped text.
  type CText int
  
  func (CText) MarshalText() ([]byte, error) {
  	return []byte(`"<&>"`), nil
  }
  
  func TestMarshalerEscaping(t *testing.T) {
  	var c C
  	want := `"\u003c\u0026\u003e"`
  	b, err := Marshal(c)
  	if err != nil {
  		t.Fatalf("Marshal(c): %v", err)
  	}
  	if got := string(b); got != want {
  		t.Errorf("Marshal(c) = %#q, want %#q", got, want)
  	}
  
  	var ct CText
  	want = `"\"\u003c\u0026\u003e\""`
  	b, err = Marshal(ct)
  	if err != nil {
  		t.Fatalf("Marshal(ct): %v", err)
  	}
  	if got := string(b); got != want {
  		t.Errorf("Marshal(ct) = %#q, want %#q", got, want)
  	}
  }
  
  type IntType int
  
  type MyStruct struct {
  	IntType
  }
  
  func TestAnonymousNonstruct(t *testing.T) {
  	var i IntType = 11
  	a := MyStruct{i}
  	const want = `{"IntType":11}`
  
  	b, err := Marshal(a)
  	if err != nil {
  		t.Fatalf("Marshal: %v", err)
  	}
  	if got := string(b); got != want {
  		t.Errorf("got %q, want %q", got, want)
  	}
  }
  
  type BugA struct {
  	S string
  }
  
  type BugB struct {
  	BugA
  	S string
  }
  
  type BugC struct {
  	S string
  }
  
  // Legal Go: We never use the repeated embedded field (S).
  type BugX struct {
  	A int
  	BugA
  	BugB
  }
  
  // Issue 16042. Even if a nil interface value is passed in
  // as long as it implements MarshalJSON, it should be marshaled.
  type nilMarshaler string
  
  func (nm *nilMarshaler) MarshalJSON() ([]byte, error) {
  	if nm == nil {
  		return Marshal("0zenil0")
  	}
  	return Marshal("zenil:" + string(*nm))
  }
  
  // Issue 16042.
  func TestNilMarshal(t *testing.T) {
  	testCases := []struct {
  		v    interface{}
  		want string
  	}{
  		{v: nil, want: `null`},
  		{v: new(float64), want: `0`},
  		{v: []interface{}(nil), want: `null`},
  		{v: []string(nil), want: `null`},
  		{v: map[string]string(nil), want: `null`},
  		{v: []byte(nil), want: `null`},
  		{v: struct{ M string }{"gopher"}, want: `{"M":"gopher"}`},
  		{v: struct{ M Marshaler }{}, want: `{"M":null}`},
  		{v: struct{ M Marshaler }{(*nilMarshaler)(nil)}, want: `{"M":"0zenil0"}`},
  		{v: struct{ M interface{} }{(*nilMarshaler)(nil)}, want: `{"M":null}`},
  	}
  
  	for _, tt := range testCases {
  		out, err := Marshal(tt.v)
  		if err != nil || string(out) != tt.want {
  			t.Errorf("Marshal(%#v) = %#q, %#v, want %#q, nil", tt.v, out, err, tt.want)
  			continue
  		}
  	}
  }
  
  // Issue 5245.
  func TestEmbeddedBug(t *testing.T) {
  	v := BugB{
  		BugA{"A"},
  		"B",
  	}
  	b, err := Marshal(v)
  	if err != nil {
  		t.Fatal("Marshal:", err)
  	}
  	want := `{"S":"B"}`
  	got := string(b)
  	if got != want {
  		t.Fatalf("Marshal: got %s want %s", got, want)
  	}
  	// Now check that the duplicate field, S, does not appear.
  	x := BugX{
  		A: 23,
  	}
  	b, err = Marshal(x)
  	if err != nil {
  		t.Fatal("Marshal:", err)
  	}
  	want = `{"A":23}`
  	got = string(b)
  	if got != want {
  		t.Fatalf("Marshal: got %s want %s", got, want)
  	}
  }
  
  type BugD struct { // Same as BugA after tagging.
  	XXX string `json:"S"`
  }
  
  // BugD's tagged S field should dominate BugA's.
  type BugY struct {
  	BugA
  	BugD
  }
  
  // Test that a field with a tag dominates untagged fields.
  func TestTaggedFieldDominates(t *testing.T) {
  	v := BugY{
  		BugA{"BugA"},
  		BugD{"BugD"},
  	}
  	b, err := Marshal(v)
  	if err != nil {
  		t.Fatal("Marshal:", err)
  	}
  	want := `{"S":"BugD"}`
  	got := string(b)
  	if got != want {
  		t.Fatalf("Marshal: got %s want %s", got, want)
  	}
  }
  
  // There are no tags here, so S should not appear.
  type BugZ struct {
  	BugA
  	BugC
  	BugY // Contains a tagged S field through BugD; should not dominate.
  }
  
  func TestDuplicatedFieldDisappears(t *testing.T) {
  	v := BugZ{
  		BugA{"BugA"},
  		BugC{"BugC"},
  		BugY{
  			BugA{"nested BugA"},
  			BugD{"nested BugD"},
  		},
  	}
  	b, err := Marshal(v)
  	if err != nil {
  		t.Fatal("Marshal:", err)
  	}
  	want := `{}`
  	got := string(b)
  	if got != want {
  		t.Fatalf("Marshal: got %s want %s", got, want)
  	}
  }
  
  func TestStringBytes(t *testing.T) {
  	t.Parallel()
  	// Test that encodeState.stringBytes and encodeState.string use the same encoding.
  	var r []rune
  	for i := '\u0000'; i <= unicode.MaxRune; i++ {
  		r = append(r, i)
  	}
  	s := string(r) + "\xff\xff\xffhello" // some invalid UTF-8 too
  
  	for _, escapeHTML := range []bool{true, false} {
  		es := &encodeState{}
  		es.string(s, escapeHTML)
  
  		esBytes := &encodeState{}
  		esBytes.stringBytes([]byte(s), escapeHTML)
  
  		enc := es.Buffer.String()
  		encBytes := esBytes.Buffer.String()
  		if enc != encBytes {
  			i := 0
  			for i < len(enc) && i < len(encBytes) && enc[i] == encBytes[i] {
  				i++
  			}
  			enc = enc[i:]
  			encBytes = encBytes[i:]
  			i = 0
  			for i < len(enc) && i < len(encBytes) && enc[len(enc)-i-1] == encBytes[len(encBytes)-i-1] {
  				i++
  			}
  			enc = enc[:len(enc)-i]
  			encBytes = encBytes[:len(encBytes)-i]
  
  			if len(enc) > 20 {
  				enc = enc[:20] + "..."
  			}
  			if len(encBytes) > 20 {
  				encBytes = encBytes[:20] + "..."
  			}
  
  			t.Errorf("with escapeHTML=%t, encodings differ at %#q vs %#q",
  				escapeHTML, enc, encBytes)
  		}
  	}
  }
  
  func TestIssue10281(t *testing.T) {
  	type Foo struct {
  		N Number
  	}
  	x := Foo{Number(`invalid`)}
  
  	b, err := Marshal(&x)
  	if err == nil {
  		t.Errorf("Marshal(&x) = %#q; want error", b)
  	}
  }
  
  func TestHTMLEscape(t *testing.T) {
  	var b, want bytes.Buffer
  	m := `{"M":"<html>foo &` + "\xe2\x80\xa8 \xe2\x80\xa9" + `</html>"}`
  	want.Write([]byte(`{"M":"\u003chtml\u003efoo \u0026\u2028 \u2029\u003c/html\u003e"}`))
  	HTMLEscape(&b, []byte(m))
  	if !bytes.Equal(b.Bytes(), want.Bytes()) {
  		t.Errorf("HTMLEscape(&b, []byte(m)) = %s; want %s", b.Bytes(), want.Bytes())
  	}
  }
  
  // golang.org/issue/8582
  func TestEncodePointerString(t *testing.T) {
  	type stringPointer struct {
  		N *int64 `json:"n,string"`
  	}
  	var n int64 = 42
  	b, err := Marshal(stringPointer{N: &n})
  	if err != nil {
  		t.Fatalf("Marshal: %v", err)
  	}
  	if got, want := string(b), `{"n":"42"}`; got != want {
  		t.Errorf("Marshal = %s, want %s", got, want)
  	}
  	var back stringPointer
  	err = Unmarshal(b, &back)
  	if err != nil {
  		t.Fatalf("Unmarshal: %v", err)
  	}
  	if back.N == nil {
  		t.Fatalf("Unmarshaled nil N field")
  	}
  	if *back.N != 42 {
  		t.Fatalf("*N = %d; want 42", *back.N)
  	}
  }
  
  var encodeStringTests = []struct {
  	in  string
  	out string
  }{
  	{"\x00", `"\u0000"`},
  	{"\x01", `"\u0001"`},
  	{"\x02", `"\u0002"`},
  	{"\x03", `"\u0003"`},
  	{"\x04", `"\u0004"`},
  	{"\x05", `"\u0005"`},
  	{"\x06", `"\u0006"`},
  	{"\x07", `"\u0007"`},
  	{"\x08", `"\u0008"`},
  	{"\x09", `"\t"`},
  	{"\x0a", `"\n"`},
  	{"\x0b", `"\u000b"`},
  	{"\x0c", `"\u000c"`},
  	{"\x0d", `"\r"`},
  	{"\x0e", `"\u000e"`},
  	{"\x0f", `"\u000f"`},
  	{"\x10", `"\u0010"`},
  	{"\x11", `"\u0011"`},
  	{"\x12", `"\u0012"`},
  	{"\x13", `"\u0013"`},
  	{"\x14", `"\u0014"`},
  	{"\x15", `"\u0015"`},
  	{"\x16", `"\u0016"`},
  	{"\x17", `"\u0017"`},
  	{"\x18", `"\u0018"`},
  	{"\x19", `"\u0019"`},
  	{"\x1a", `"\u001a"`},
  	{"\x1b", `"\u001b"`},
  	{"\x1c", `"\u001c"`},
  	{"\x1d", `"\u001d"`},
  	{"\x1e", `"\u001e"`},
  	{"\x1f", `"\u001f"`},
  }
  
  func TestEncodeString(t *testing.T) {
  	for _, tt := range encodeStringTests {
  		b, err := Marshal(tt.in)
  		if err != nil {
  			t.Errorf("Marshal(%q): %v", tt.in, err)
  			continue
  		}
  		out := string(b)
  		if out != tt.out {
  			t.Errorf("Marshal(%q) = %#q, want %#q", tt.in, out, tt.out)
  		}
  	}
  }
  
  type jsonbyte byte
  
  func (b jsonbyte) MarshalJSON() ([]byte, error) { return tenc(`{"JB":%d}`, b) }
  
  type textbyte byte
  
  func (b textbyte) MarshalText() ([]byte, error) { return tenc(`TB:%d`, b) }
  
  type jsonint int
  
  func (i jsonint) MarshalJSON() ([]byte, error) { return tenc(`{"JI":%d}`, i) }
  
  type textint int
  
  func (i textint) MarshalText() ([]byte, error) { return tenc(`TI:%d`, i) }
  
  func tenc(format string, a ...interface{}) ([]byte, error) {
  	var buf bytes.Buffer
  	fmt.Fprintf(&buf, format, a...)
  	return buf.Bytes(), nil
  }
  
  // Issue 13783
  func TestEncodeBytekind(t *testing.T) {
  	testdata := []struct {
  		data interface{}
  		want string
  	}{
  		{byte(7), "7"},
  		{jsonbyte(7), `{"JB":7}`},
  		{textbyte(4), `"TB:4"`},
  		{jsonint(5), `{"JI":5}`},
  		{textint(1), `"TI:1"`},
  		{[]byte{0, 1}, `"AAE="`},
  		{[]jsonbyte{0, 1}, `[{"JB":0},{"JB":1}]`},
  		{[][]jsonbyte{{0, 1}, {3}}, `[[{"JB":0},{"JB":1}],[{"JB":3}]]`},
  		{[]textbyte{2, 3}, `["TB:2","TB:3"]`},
  		{[]jsonint{5, 4}, `[{"JI":5},{"JI":4}]`},
  		{[]textint{9, 3}, `["TI:9","TI:3"]`},
  		{[]int{9, 3}, `[9,3]`},
  	}
  	for _, d := range testdata {
  		js, err := Marshal(d.data)
  		if err != nil {
  			t.Error(err)
  			continue
  		}
  		got, want := string(js), d.want
  		if got != want {
  			t.Errorf("got %s, want %s", got, want)
  		}
  	}
  }
  
  func TestTextMarshalerMapKeysAreSorted(t *testing.T) {
  	b, err := Marshal(map[unmarshalerText]int{
  		{"x", "y"}: 1,
  		{"y", "x"}: 2,
  		{"a", "z"}: 3,
  		{"z", "a"}: 4,
  	})
  	if err != nil {
  		t.Fatalf("Failed to Marshal text.Marshaler: %v", err)
  	}
  	const want = `{"a:z":3,"x:y":1,"y:x":2,"z:a":4}`
  	if string(b) != want {
  		t.Errorf("Marshal map with text.Marshaler keys: got %#q, want %#q", b, want)
  	}
  }
  
  var re = regexp.MustCompile
  
  // syntactic checks on form of marshaled floating point numbers.
  var badFloatREs = []*regexp.Regexp{
  	re(`p`),                     // no binary exponential notation
  	re(`^\+`),                   // no leading + sign
  	re(`^-?0[^.]`),              // no unnecessary leading zeros
  	re(`^-?\.`),                 // leading zero required before decimal point
  	re(`\.(e|$)`),               // no trailing decimal
  	re(`\.[0-9]+0(e|$)`),        // no trailing zero in fraction
  	re(`^-?(0|[0-9]{2,})\..*e`), // exponential notation must have normalized mantissa
  	re(`e[0-9]`),                // positive exponent must be signed
  	re(`e[+-]0`),                // exponent must not have leading zeros
  	re(`e-[1-6]$`),              // not tiny enough for exponential notation
  	re(`e+(.|1.|20)$`),          // not big enough for exponential notation
  	re(`^-?0\.0000000`),         // too tiny, should use exponential notation
  	re(`^-?[0-9]{22}`),          // too big, should use exponential notation
  	re(`[1-9][0-9]{16}[1-9]`),   // too many significant digits in integer
  	re(`[1-9][0-9.]{17}[1-9]`),  // too many significant digits in decimal
  	// below here for float32 only
  	re(`[1-9][0-9]{8}[1-9]`),  // too many significant digits in integer
  	re(`[1-9][0-9.]{9}[1-9]`), // too many significant digits in decimal
  }
  
  func TestMarshalFloat(t *testing.T) {
  	t.Parallel()
  	nfail := 0
  	test := func(f float64, bits int) {
  		vf := interface{}(f)
  		if bits == 32 {
  			f = float64(float32(f)) // round
  			vf = float32(f)
  		}
  		bout, err := Marshal(vf)
  		if err != nil {
  			t.Errorf("Marshal(%T(%g)): %v", vf, vf, err)
  			nfail++
  			return
  		}
  		out := string(bout)
  
  		// result must convert back to the same float
  		g, err := strconv.ParseFloat(out, bits)
  		if err != nil {
  			t.Errorf("Marshal(%T(%g)) = %q, cannot parse back: %v", vf, vf, out, err)
  			nfail++
  			return
  		}
  		if f != g || fmt.Sprint(f) != fmt.Sprint(g) { // fmt.Sprint handles ±0
  			t.Errorf("Marshal(%T(%g)) = %q (is %g, not %g)", vf, vf, out, float32(g), vf)
  			nfail++
  			return
  		}
  
  		bad := badFloatREs
  		if bits == 64 {
  			bad = bad[:len(bad)-2]
  		}
  		for _, re := range bad {
  			if re.MatchString(out) {
  				t.Errorf("Marshal(%T(%g)) = %q, must not match /%s/", vf, vf, out, re)
  				nfail++
  				return
  			}
  		}
  	}
  
  	var (
  		bigger  = math.Inf(+1)
  		smaller = math.Inf(-1)
  	)
  
  	var digits = "1.2345678901234567890123"
  	for i := len(digits); i >= 2; i-- {
  		for exp := -30; exp <= 30; exp++ {
  			for _, sign := range "+-" {
  				for bits := 32; bits <= 64; bits += 32 {
  					s := fmt.Sprintf("%c%se%d", sign, digits[:i], exp)
  					f, err := strconv.ParseFloat(s, bits)
  					if err != nil {
  						log.Fatal(err)
  					}
  					next := math.Nextafter
  					if bits == 32 {
  						next = func(g, h float64) float64 {
  							return float64(math.Nextafter32(float32(g), float32(h)))
  						}
  					}
  					test(f, bits)
  					test(next(f, bigger), bits)
  					test(next(f, smaller), bits)
  					if nfail > 50 {
  						t.Fatalf("stopping test early")
  					}
  				}
  			}
  		}
  	}
  	test(0, 64)
  	test(math.Copysign(0, -1), 64)
  	test(0, 32)
  	test(math.Copysign(0, -1), 32)
  }
  
  func TestMarshalRawMessageValue(t *testing.T) {
  	type (
  		T1 struct {
  			M RawMessage `json:",omitempty"`
  		}
  		T2 struct {
  			M *RawMessage `json:",omitempty"`
  		}
  	)
  
  	var (
  		rawNil   = RawMessage(nil)
  		rawEmpty = RawMessage([]byte{})
  		rawText  = RawMessage([]byte(`"foo"`))
  	)
  
  	tests := []struct {
  		in   interface{}
  		want string
  		ok   bool
  	}{
  		// Test with nil RawMessage.
  		{rawNil, "null", true},
  		{&rawNil, "null", true},
  		{[]interface{}{rawNil}, "[null]", true},
  		{&[]interface{}{rawNil}, "[null]", true},
  		{[]interface{}{&rawNil}, "[null]", true},
  		{&[]interface{}{&rawNil}, "[null]", true},
  		{struct{ M RawMessage }{rawNil}, `{"M":null}`, true},
  		{&struct{ M RawMessage }{rawNil}, `{"M":null}`, true},
  		{struct{ M *RawMessage }{&rawNil}, `{"M":null}`, true},
  		{&struct{ M *RawMessage }{&rawNil}, `{"M":null}`, true},
  		{map[string]interface{}{"M": rawNil}, `{"M":null}`, true},
  		{&map[string]interface{}{"M": rawNil}, `{"M":null}`, true},
  		{map[string]interface{}{"M": &rawNil}, `{"M":null}`, true},
  		{&map[string]interface{}{"M": &rawNil}, `{"M":null}`, true},
  		{T1{rawNil}, "{}", true},
  		{T2{&rawNil}, `{"M":null}`, true},
  		{&T1{rawNil}, "{}", true},
  		{&T2{&rawNil}, `{"M":null}`, true},
  
  		// Test with empty, but non-nil, RawMessage.
  		{rawEmpty, "", false},
  		{&rawEmpty, "", false},
  		{[]interface{}{rawEmpty}, "", false},
  		{&[]interface{}{rawEmpty}, "", false},
  		{[]interface{}{&rawEmpty}, "", false},
  		{&[]interface{}{&rawEmpty}, "", false},
  		{struct{ X RawMessage }{rawEmpty}, "", false},
  		{&struct{ X RawMessage }{rawEmpty}, "", false},
  		{struct{ X *RawMessage }{&rawEmpty}, "", false},
  		{&struct{ X *RawMessage }{&rawEmpty}, "", false},
  		{map[string]interface{}{"nil": rawEmpty}, "", false},
  		{&map[string]interface{}{"nil": rawEmpty}, "", false},
  		{map[string]interface{}{"nil": &rawEmpty}, "", false},
  		{&map[string]interface{}{"nil": &rawEmpty}, "", false},
  		{T1{rawEmpty}, "{}", true},
  		{T2{&rawEmpty}, "", false},
  		{&T1{rawEmpty}, "{}", true},
  		{&T2{&rawEmpty}, "", false},
  
  		// Test with RawMessage with some text.
  		//
  		// The tests below marked with Issue6458 used to generate "ImZvbyI=" instead "foo".
  		// This behavior was intentionally changed in Go 1.8.
  		// See https://github.com/golang/go/issues/14493#issuecomment-255857318
  		{rawText, `"foo"`, true}, // Issue6458
  		{&rawText, `"foo"`, true},
  		{[]interface{}{rawText}, `["foo"]`, true},  // Issue6458
  		{&[]interface{}{rawText}, `["foo"]`, true}, // Issue6458
  		{[]interface{}{&rawText}, `["foo"]`, true},
  		{&[]interface{}{&rawText}, `["foo"]`, true},
  		{struct{ M RawMessage }{rawText}, `{"M":"foo"}`, true}, // Issue6458
  		{&struct{ M RawMessage }{rawText}, `{"M":"foo"}`, true},
  		{struct{ M *RawMessage }{&rawText}, `{"M":"foo"}`, true},
  		{&struct{ M *RawMessage }{&rawText}, `{"M":"foo"}`, true},
  		{map[string]interface{}{"M": rawText}, `{"M":"foo"}`, true},  // Issue6458
  		{&map[string]interface{}{"M": rawText}, `{"M":"foo"}`, true}, // Issue6458
  		{map[string]interface{}{"M": &rawText}, `{"M":"foo"}`, true},
  		{&map[string]interface{}{"M": &rawText}, `{"M":"foo"}`, true},
  		{T1{rawText}, `{"M":"foo"}`, true}, // Issue6458
  		{T2{&rawText}, `{"M":"foo"}`, true},
  		{&T1{rawText}, `{"M":"foo"}`, true},
  		{&T2{&rawText}, `{"M":"foo"}`, true},
  	}
  
  	for i, tt := range tests {
  		b, err := Marshal(tt.in)
  		if ok := (err == nil); ok != tt.ok {
  			if err != nil {
  				t.Errorf("test %d, unexpected failure: %v", i, err)
  			} else {
  				t.Errorf("test %d, unexpected success", i)
  			}
  		}
  		if got := string(b); got != tt.want {
  			t.Errorf("test %d, Marshal(%#v) = %q, want %q", i, tt.in, got, tt.want)
  		}
  	}
  }
  

View as plain text