third_party/gofrontend/libgo/go/encoding/json/encode_test.go - llvm-project/llgo - Git at Google

 // 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"
 	"math"
 	"reflect"
 	"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 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) {
 	// Test that encodeState.stringBytes and encodeState.string use the same encoding.
 	es := &encodeState{}
 	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
 	_, err := es.string(s)
 	if err != nil {
 		t.Fatal(err)
 	}

 	esBytes := &encodeState{}
 	_, err = esBytes.stringBytes([]byte(s))
 	if err != nil {
 		t.Fatal(err)
 	}

 	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("encodings differ at %#q vs %#q", enc, encBytes)
 	}
 }

 func TestIssue6458(t *testing.T) {
 	type Foo struct {
 		M RawMessage
 	}
 	x := Foo{RawMessage(`"foo"`)}

 	b, err := Marshal(&x)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if want := `{"M":"foo"}`; string(b) != want {
 		t.Errorf("Marshal(&x) = %#q; want %#q", b, want)
 	}

 	b, err = Marshal(x)
 	if err != nil {
 		t.Fatal(err)
 	}

 	if want := `{"M":"ImZvbyI="}`; string(b) != want {
 		t.Errorf("Marshal(x) = %#q; want %#q", b, want)
 	}
 }

 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("Unmarshalled 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)
 		}
 	}
 }
	// 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"
	"math"
	"reflect"
	"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 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) {
	// Test that encodeState.stringBytes and encodeState.string use the same encoding.
	es := &encodeState{}
	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
	_, err := es.string(s)
	if err != nil {
	t.Fatal(err)
	}

	esBytes := &encodeState{}
	_, err = esBytes.stringBytes([]byte(s))
	if err != nil {
	t.Fatal(err)
	}

	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("encodings differ at %#q vs %#q", enc, encBytes)
	}
	}

	func TestIssue6458(t *testing.T) {
	type Foo struct {
	M RawMessage
	}
	x := Foo{RawMessage(`"foo"`)}

	b, err := Marshal(&x)
	if err != nil {
	t.Fatal(err)
	}
	if want := `{"M":"foo"}`; string(b) != want {
	t.Errorf("Marshal(&x) = %#q; want %#q", b, want)
	}

	b, err = Marshal(x)
	if err != nil {
	t.Fatal(err)
	}

	if want := `{"M":"ImZvbyI="}`; string(b) != want {
	t.Errorf("Marshal(x) = %#q; want %#q", b, want)
	}
	}

	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("Unmarshalled 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)
	}
	}
	}