mirror of https://github.com/goccy/go-json.git
2417 lines
56 KiB
Go
2417 lines
56 KiB
Go
package json_test
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding"
|
|
stdjson "encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"math"
|
|
"reflect"
|
|
"regexp"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/goccy/go-json"
|
|
)
|
|
|
|
type recursiveT struct {
|
|
A *recursiveT `json:"a,omitempty"`
|
|
B *recursiveU `json:"b,omitempty"`
|
|
C *recursiveU `json:"c,omitempty"`
|
|
D string `json:"d,omitempty"`
|
|
}
|
|
|
|
type recursiveU struct {
|
|
T *recursiveT `json:"t,omitempty"`
|
|
}
|
|
|
|
func Test_Marshal(t *testing.T) {
|
|
t.Run("int", func(t *testing.T) {
|
|
bytes, err := json.Marshal(-10)
|
|
assertErr(t, err)
|
|
assertEq(t, "int", `-10`, string(bytes))
|
|
})
|
|
t.Run("int8", func(t *testing.T) {
|
|
bytes, err := json.Marshal(int8(-11))
|
|
assertErr(t, err)
|
|
assertEq(t, "int8", `-11`, string(bytes))
|
|
})
|
|
t.Run("int16", func(t *testing.T) {
|
|
bytes, err := json.Marshal(int16(-12))
|
|
assertErr(t, err)
|
|
assertEq(t, "int16", `-12`, string(bytes))
|
|
})
|
|
t.Run("int32", func(t *testing.T) {
|
|
bytes, err := json.Marshal(int32(-13))
|
|
assertErr(t, err)
|
|
assertEq(t, "int32", `-13`, string(bytes))
|
|
})
|
|
t.Run("int64", func(t *testing.T) {
|
|
bytes, err := json.Marshal(int64(-14))
|
|
assertErr(t, err)
|
|
assertEq(t, "int64", `-14`, string(bytes))
|
|
})
|
|
t.Run("uint", func(t *testing.T) {
|
|
bytes, err := json.Marshal(uint(10))
|
|
assertErr(t, err)
|
|
assertEq(t, "uint", `10`, string(bytes))
|
|
})
|
|
t.Run("uint8", func(t *testing.T) {
|
|
bytes, err := json.Marshal(uint8(11))
|
|
assertErr(t, err)
|
|
assertEq(t, "uint8", `11`, string(bytes))
|
|
})
|
|
t.Run("uint16", func(t *testing.T) {
|
|
bytes, err := json.Marshal(uint16(12))
|
|
assertErr(t, err)
|
|
assertEq(t, "uint16", `12`, string(bytes))
|
|
})
|
|
t.Run("uint32", func(t *testing.T) {
|
|
bytes, err := json.Marshal(uint32(13))
|
|
assertErr(t, err)
|
|
assertEq(t, "uint32", `13`, string(bytes))
|
|
})
|
|
t.Run("uint64", func(t *testing.T) {
|
|
bytes, err := json.Marshal(uint64(14))
|
|
assertErr(t, err)
|
|
assertEq(t, "uint64", `14`, string(bytes))
|
|
})
|
|
t.Run("float32", func(t *testing.T) {
|
|
bytes, err := json.Marshal(float32(3.14))
|
|
assertErr(t, err)
|
|
assertEq(t, "float32", `3.14`, string(bytes))
|
|
})
|
|
t.Run("float64", func(t *testing.T) {
|
|
bytes, err := json.Marshal(float64(3.14))
|
|
assertErr(t, err)
|
|
assertEq(t, "float64", `3.14`, string(bytes))
|
|
})
|
|
t.Run("bool", func(t *testing.T) {
|
|
bytes, err := json.Marshal(true)
|
|
assertErr(t, err)
|
|
assertEq(t, "bool", `true`, string(bytes))
|
|
})
|
|
t.Run("string", func(t *testing.T) {
|
|
bytes, err := json.Marshal("hello world")
|
|
assertErr(t, err)
|
|
assertEq(t, "string", `"hello world"`, string(bytes))
|
|
})
|
|
t.Run("struct", func(t *testing.T) {
|
|
bytes, err := json.Marshal(struct {
|
|
A int `json:"a"`
|
|
B uint `json:"b"`
|
|
C string `json:"c"`
|
|
D int `json:"-"` // ignore field
|
|
a int `json:"aa"` // private field
|
|
}{
|
|
A: -1,
|
|
B: 1,
|
|
C: "hello world",
|
|
})
|
|
assertErr(t, err)
|
|
assertEq(t, "struct", `{"a":-1,"b":1,"c":"hello world"}`, string(bytes))
|
|
t.Run("null", func(t *testing.T) {
|
|
type T struct {
|
|
A *struct{} `json:"a"`
|
|
}
|
|
var v T
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "struct", `{"a":null}`, string(bytes))
|
|
})
|
|
t.Run("recursive", func(t *testing.T) {
|
|
bytes, err := json.Marshal(recursiveT{
|
|
A: &recursiveT{
|
|
B: &recursiveU{
|
|
T: &recursiveT{
|
|
D: "hello",
|
|
},
|
|
},
|
|
C: &recursiveU{
|
|
T: &recursiveT{
|
|
D: "world",
|
|
},
|
|
},
|
|
},
|
|
})
|
|
assertErr(t, err)
|
|
assertEq(t, "recursive", `{"a":{"b":{"t":{"d":"hello"}},"c":{"t":{"d":"world"}}}}`, string(bytes))
|
|
})
|
|
t.Run("embedded", func(t *testing.T) {
|
|
type T struct {
|
|
A string `json:"a"`
|
|
}
|
|
type U struct {
|
|
*T
|
|
B string `json:"b"`
|
|
}
|
|
type T2 struct {
|
|
A string `json:"a,omitempty"`
|
|
}
|
|
type U2 struct {
|
|
*T2
|
|
B string `json:"b,omitempty"`
|
|
}
|
|
t.Run("exists field", func(t *testing.T) {
|
|
bytes, err := json.Marshal(&U{
|
|
T: &T{
|
|
A: "aaa",
|
|
},
|
|
B: "bbb",
|
|
})
|
|
assertErr(t, err)
|
|
assertEq(t, "embedded", `{"a":"aaa","b":"bbb"}`, string(bytes))
|
|
t.Run("omitempty", func(t *testing.T) {
|
|
bytes, err := json.Marshal(&U2{
|
|
T2: &T2{
|
|
A: "aaa",
|
|
},
|
|
B: "bbb",
|
|
})
|
|
assertErr(t, err)
|
|
assertEq(t, "embedded", `{"a":"aaa","b":"bbb"}`, string(bytes))
|
|
})
|
|
})
|
|
t.Run("none field", func(t *testing.T) {
|
|
bytes, err := json.Marshal(&U{
|
|
B: "bbb",
|
|
})
|
|
assertErr(t, err)
|
|
assertEq(t, "embedded", `{"b":"bbb"}`, string(bytes))
|
|
t.Run("omitempty", func(t *testing.T) {
|
|
bytes, err := json.Marshal(&U2{
|
|
B: "bbb",
|
|
})
|
|
assertErr(t, err)
|
|
assertEq(t, "embedded", `{"b":"bbb"}`, string(bytes))
|
|
})
|
|
})
|
|
})
|
|
|
|
t.Run("embedded with tag", func(t *testing.T) {
|
|
type T struct {
|
|
A string `json:"a"`
|
|
}
|
|
type U struct {
|
|
*T `json:"t"`
|
|
B string `json:"b"`
|
|
}
|
|
type T2 struct {
|
|
A string `json:"a,omitempty"`
|
|
}
|
|
type U2 struct {
|
|
*T2 `json:"t,omitempty"`
|
|
B string `json:"b,omitempty"`
|
|
}
|
|
t.Run("exists field", func(t *testing.T) {
|
|
bytes, err := json.Marshal(&U{
|
|
T: &T{
|
|
A: "aaa",
|
|
},
|
|
B: "bbb",
|
|
})
|
|
assertErr(t, err)
|
|
assertEq(t, "embedded", `{"t":{"a":"aaa"},"b":"bbb"}`, string(bytes))
|
|
t.Run("omitempty", func(t *testing.T) {
|
|
bytes, err := json.Marshal(&U2{
|
|
T2: &T2{
|
|
A: "aaa",
|
|
},
|
|
B: "bbb",
|
|
})
|
|
assertErr(t, err)
|
|
assertEq(t, "embedded", `{"t":{"a":"aaa"},"b":"bbb"}`, string(bytes))
|
|
})
|
|
})
|
|
|
|
t.Run("none field", func(t *testing.T) {
|
|
bytes, err := json.Marshal(&U{
|
|
B: "bbb",
|
|
})
|
|
assertErr(t, err)
|
|
assertEq(t, "embedded", `{"t":null,"b":"bbb"}`, string(bytes))
|
|
t.Run("omitempty", func(t *testing.T) {
|
|
bytes, err := json.Marshal(&U2{
|
|
B: "bbb",
|
|
})
|
|
assertErr(t, err)
|
|
assertEq(t, "embedded", `{"b":"bbb"}`, string(bytes))
|
|
})
|
|
})
|
|
})
|
|
|
|
t.Run("omitempty", func(t *testing.T) {
|
|
type T struct {
|
|
A int `json:",omitempty"`
|
|
B int8 `json:",omitempty"`
|
|
C int16 `json:",omitempty"`
|
|
D int32 `json:",omitempty"`
|
|
E int64 `json:",omitempty"`
|
|
F uint `json:",omitempty"`
|
|
G uint8 `json:",omitempty"`
|
|
H uint16 `json:",omitempty"`
|
|
I uint32 `json:",omitempty"`
|
|
J uint64 `json:",omitempty"`
|
|
K float32 `json:",omitempty"`
|
|
L float64 `json:",omitempty"`
|
|
O string `json:",omitempty"`
|
|
P bool `json:",omitempty"`
|
|
Q []int `json:",omitempty"`
|
|
R map[string]interface{} `json:",omitempty"`
|
|
S *struct{} `json:",omitempty"`
|
|
T int `json:"t,omitempty"`
|
|
}
|
|
var v T
|
|
v.T = 1
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "struct", `{"t":1}`, string(bytes))
|
|
t.Run("int", func(t *testing.T) {
|
|
var v struct {
|
|
A int `json:"a,omitempty"`
|
|
B int `json:"b"`
|
|
}
|
|
v.B = 1
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "int", `{"b":1}`, string(bytes))
|
|
})
|
|
t.Run("int8", func(t *testing.T) {
|
|
var v struct {
|
|
A int `json:"a,omitempty"`
|
|
B int8 `json:"b"`
|
|
}
|
|
v.B = 1
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "int8", `{"b":1}`, string(bytes))
|
|
})
|
|
t.Run("int16", func(t *testing.T) {
|
|
var v struct {
|
|
A int `json:"a,omitempty"`
|
|
B int16 `json:"b"`
|
|
}
|
|
v.B = 1
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "int16", `{"b":1}`, string(bytes))
|
|
})
|
|
t.Run("int32", func(t *testing.T) {
|
|
var v struct {
|
|
A int `json:"a,omitempty"`
|
|
B int32 `json:"b"`
|
|
}
|
|
v.B = 1
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "int32", `{"b":1}`, string(bytes))
|
|
})
|
|
t.Run("int64", func(t *testing.T) {
|
|
var v struct {
|
|
A int `json:"a,omitempty"`
|
|
B int64 `json:"b"`
|
|
}
|
|
v.B = 1
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "int64", `{"b":1}`, string(bytes))
|
|
})
|
|
t.Run("string", func(t *testing.T) {
|
|
var v struct {
|
|
A int `json:"a,omitempty"`
|
|
B string `json:"b"`
|
|
}
|
|
v.B = "b"
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "string", `{"b":"b"}`, string(bytes))
|
|
})
|
|
t.Run("float32", func(t *testing.T) {
|
|
var v struct {
|
|
A int `json:"a,omitempty"`
|
|
B float32 `json:"b"`
|
|
}
|
|
v.B = 1.1
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "float32", `{"b":1.1}`, string(bytes))
|
|
})
|
|
t.Run("float64", func(t *testing.T) {
|
|
var v struct {
|
|
A int `json:"a,omitempty"`
|
|
B float64 `json:"b"`
|
|
}
|
|
v.B = 3.14
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "float64", `{"b":3.14}`, string(bytes))
|
|
})
|
|
t.Run("slice", func(t *testing.T) {
|
|
var v struct {
|
|
A int `json:"a,omitempty"`
|
|
B []int `json:"b"`
|
|
}
|
|
v.B = []int{1, 2, 3}
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "slice", `{"b":[1,2,3]}`, string(bytes))
|
|
})
|
|
t.Run("array", func(t *testing.T) {
|
|
var v struct {
|
|
A int `json:"a,omitempty"`
|
|
B [2]int `json:"b"`
|
|
}
|
|
v.B = [2]int{1, 2}
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "array", `{"b":[1,2]}`, string(bytes))
|
|
})
|
|
t.Run("map", func(t *testing.T) {
|
|
v := new(struct {
|
|
A int `json:"a,omitempty"`
|
|
B map[string]interface{} `json:"b"`
|
|
})
|
|
v.B = map[string]interface{}{"c": 1}
|
|
bytes, err := json.Marshal(v)
|
|
assertErr(t, err)
|
|
assertEq(t, "array", `{"b":{"c":1}}`, string(bytes))
|
|
})
|
|
})
|
|
t.Run("head_omitempty", func(t *testing.T) {
|
|
type T struct {
|
|
A *struct{} `json:"a,omitempty"`
|
|
}
|
|
var v T
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "struct", `{}`, string(bytes))
|
|
})
|
|
t.Run("pointer_head_omitempty", func(t *testing.T) {
|
|
type V struct{}
|
|
type U struct {
|
|
B *V `json:"b,omitempty"`
|
|
}
|
|
type T struct {
|
|
A *U `json:"a"`
|
|
}
|
|
bytes, err := json.Marshal(&T{A: &U{}})
|
|
assertErr(t, err)
|
|
assertEq(t, "struct", `{"a":{}}`, string(bytes))
|
|
})
|
|
t.Run("head_int_omitempty", func(t *testing.T) {
|
|
type T struct {
|
|
A int `json:"a,omitempty"`
|
|
}
|
|
var v T
|
|
bytes, err := json.Marshal(&v)
|
|
assertErr(t, err)
|
|
assertEq(t, "struct", `{}`, string(bytes))
|
|
})
|
|
})
|
|
t.Run("slice", func(t *testing.T) {
|
|
t.Run("[]int", func(t *testing.T) {
|
|
bytes, err := json.Marshal([]int{1, 2, 3, 4})
|
|
assertErr(t, err)
|
|
assertEq(t, "[]int", `[1,2,3,4]`, string(bytes))
|
|
})
|
|
t.Run("[]interface{}", func(t *testing.T) {
|
|
bytes, err := json.Marshal([]interface{}{1, 2.1, "hello"})
|
|
assertErr(t, err)
|
|
assertEq(t, "[]interface{}", `[1,2.1,"hello"]`, string(bytes))
|
|
})
|
|
})
|
|
|
|
t.Run("array", func(t *testing.T) {
|
|
bytes, err := json.Marshal([4]int{1, 2, 3, 4})
|
|
assertErr(t, err)
|
|
assertEq(t, "array", `[1,2,3,4]`, string(bytes))
|
|
})
|
|
t.Run("map", func(t *testing.T) {
|
|
t.Run("map[string]int", func(t *testing.T) {
|
|
v := map[string]int{
|
|
"a": 1,
|
|
"b": 2,
|
|
"c": 3,
|
|
"d": 4,
|
|
}
|
|
bytes, err := json.Marshal(v)
|
|
assertErr(t, err)
|
|
assertEq(t, "map", `{"a":1,"b":2,"c":3,"d":4}`, string(bytes))
|
|
b, err := json.MarshalWithOption(v, json.UnorderedMap())
|
|
assertErr(t, err)
|
|
assertEq(t, "unordered map", len(`{"a":1,"b":2,"c":3,"d":4}`), len(string(b)))
|
|
})
|
|
t.Run("map[string]interface{}", func(t *testing.T) {
|
|
type T struct {
|
|
A int
|
|
}
|
|
v := map[string]interface{}{
|
|
"a": 1,
|
|
"b": 2.1,
|
|
"c": &T{
|
|
A: 10,
|
|
},
|
|
"d": 4,
|
|
}
|
|
bytes, err := json.Marshal(v)
|
|
assertErr(t, err)
|
|
assertEq(t, "map[string]interface{}", `{"a":1,"b":2.1,"c":{"A":10},"d":4}`, string(bytes))
|
|
})
|
|
})
|
|
}
|
|
|
|
type mustErrTypeForDebug struct{}
|
|
|
|
func (mustErrTypeForDebug) MarshalJSON() ([]byte, error) {
|
|
panic("panic")
|
|
return nil, fmt.Errorf("panic")
|
|
}
|
|
|
|
func TestDebugMode(t *testing.T) {
|
|
defer func() {
|
|
if err := recover(); err == nil {
|
|
t.Fatal("expected error")
|
|
}
|
|
}()
|
|
var buf bytes.Buffer
|
|
json.MarshalWithOption(mustErrTypeForDebug{}, json.Debug(), json.DebugWith(&buf))
|
|
}
|
|
|
|
func TestIssue116(t *testing.T) {
|
|
t.Run("first", func(t *testing.T) {
|
|
type Boo struct{ B string }
|
|
type Struct struct {
|
|
A int
|
|
Boo *Boo
|
|
}
|
|
type Embedded struct {
|
|
Struct
|
|
}
|
|
b, err := json.Marshal(Embedded{Struct: Struct{
|
|
A: 1,
|
|
Boo: &Boo{B: "foo"},
|
|
}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
expected := `{"A":1,"Boo":{"B":"foo"}}`
|
|
actual := string(b)
|
|
if actual != expected {
|
|
t.Fatalf("expected %s but got %s", expected, actual)
|
|
}
|
|
})
|
|
t.Run("second", func(t *testing.T) {
|
|
type Boo struct{ B string }
|
|
type Struct struct {
|
|
A int
|
|
B *Boo
|
|
}
|
|
type Embedded struct {
|
|
Struct
|
|
}
|
|
b, err := json.Marshal(Embedded{Struct: Struct{
|
|
A: 1,
|
|
B: &Boo{B: "foo"},
|
|
}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
actual := string(b)
|
|
expected := `{"A":1,"B":{"B":"foo"}}`
|
|
if actual != expected {
|
|
t.Fatalf("expected %s but got %s", expected, actual)
|
|
}
|
|
})
|
|
}
|
|
|
|
type marshalJSON struct{}
|
|
|
|
func (*marshalJSON) MarshalJSON() ([]byte, error) {
|
|
return []byte(`1`), nil
|
|
}
|
|
|
|
func Test_MarshalJSON(t *testing.T) {
|
|
t.Run("*struct", func(t *testing.T) {
|
|
bytes, err := json.Marshal(&marshalJSON{})
|
|
assertErr(t, err)
|
|
assertEq(t, "MarshalJSON", "1", string(bytes))
|
|
})
|
|
t.Run("time", func(t *testing.T) {
|
|
bytes, err := json.Marshal(time.Time{})
|
|
assertErr(t, err)
|
|
assertEq(t, "MarshalJSON", `"0001-01-01T00:00:00Z"`, string(bytes))
|
|
})
|
|
}
|
|
|
|
func Test_MarshalIndent(t *testing.T) {
|
|
prefix := "-"
|
|
indent := "\t"
|
|
t.Run("struct", func(t *testing.T) {
|
|
v := struct {
|
|
A int `json:"a"`
|
|
B uint `json:"b"`
|
|
C string `json:"c"`
|
|
D interface{} `json:"d"`
|
|
X int `json:"-"` // ignore field
|
|
a int `json:"aa"` // private field
|
|
}{
|
|
A: -1,
|
|
B: 1,
|
|
C: "hello world",
|
|
D: struct {
|
|
E bool `json:"e"`
|
|
}{
|
|
E: true,
|
|
},
|
|
}
|
|
expected, err := stdjson.MarshalIndent(v, prefix, indent)
|
|
assertErr(t, err)
|
|
got, err := json.MarshalIndent(v, prefix, indent)
|
|
assertErr(t, err)
|
|
assertEq(t, "struct", string(expected), string(got))
|
|
})
|
|
t.Run("slice", func(t *testing.T) {
|
|
t.Run("[]int", func(t *testing.T) {
|
|
bytes, err := json.MarshalIndent([]int{1, 2, 3, 4}, prefix, indent)
|
|
assertErr(t, err)
|
|
result := "[\n-\t1,\n-\t2,\n-\t3,\n-\t4\n-]"
|
|
assertEq(t, "[]int", result, string(bytes))
|
|
})
|
|
t.Run("[]interface{}", func(t *testing.T) {
|
|
bytes, err := json.MarshalIndent([]interface{}{1, 2.1, "hello"}, prefix, indent)
|
|
assertErr(t, err)
|
|
result := "[\n-\t1,\n-\t2.1,\n-\t\"hello\"\n-]"
|
|
assertEq(t, "[]interface{}", result, string(bytes))
|
|
})
|
|
})
|
|
|
|
t.Run("array", func(t *testing.T) {
|
|
bytes, err := json.MarshalIndent([4]int{1, 2, 3, 4}, prefix, indent)
|
|
assertErr(t, err)
|
|
result := "[\n-\t1,\n-\t2,\n-\t3,\n-\t4\n-]"
|
|
assertEq(t, "array", result, string(bytes))
|
|
})
|
|
t.Run("map", func(t *testing.T) {
|
|
t.Run("map[string]int", func(t *testing.T) {
|
|
bytes, err := json.MarshalIndent(map[string]int{
|
|
"a": 1,
|
|
"b": 2,
|
|
"c": 3,
|
|
"d": 4,
|
|
}, prefix, indent)
|
|
assertErr(t, err)
|
|
result := "{\n-\t\"a\": 1,\n-\t\"b\": 2,\n-\t\"c\": 3,\n-\t\"d\": 4\n-}"
|
|
assertEq(t, "map", result, string(bytes))
|
|
})
|
|
t.Run("map[string]interface{}", func(t *testing.T) {
|
|
type T struct {
|
|
E int
|
|
F int
|
|
}
|
|
v := map[string]interface{}{
|
|
"a": 1,
|
|
"b": 2.1,
|
|
"c": &T{
|
|
E: 10,
|
|
F: 11,
|
|
},
|
|
"d": 4,
|
|
}
|
|
bytes, err := json.MarshalIndent(v, prefix, indent)
|
|
assertErr(t, err)
|
|
result := "{\n-\t\"a\": 1,\n-\t\"b\": 2.1,\n-\t\"c\": {\n-\t\t\"E\": 10,\n-\t\t\"F\": 11\n-\t},\n-\t\"d\": 4\n-}"
|
|
assertEq(t, "map[string]interface{}", result, string(bytes))
|
|
})
|
|
})
|
|
}
|
|
|
|
type StringTag struct {
|
|
BoolStr bool `json:",string"`
|
|
IntStr int64 `json:",string"`
|
|
UintptrStr uintptr `json:",string"`
|
|
StrStr string `json:",string"`
|
|
NumberStr json.Number `json:",string"`
|
|
}
|
|
|
|
func TestRoundtripStringTag(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
in StringTag
|
|
want string // empty to just test that we roundtrip
|
|
}{
|
|
{
|
|
name: "AllTypes",
|
|
in: StringTag{
|
|
BoolStr: true,
|
|
IntStr: 42,
|
|
UintptrStr: 44,
|
|
StrStr: "xzbit",
|
|
NumberStr: "46",
|
|
},
|
|
want: `{
|
|
"BoolStr": "true",
|
|
"IntStr": "42",
|
|
"UintptrStr": "44",
|
|
"StrStr": "\"xzbit\"",
|
|
"NumberStr": "46"
|
|
}`,
|
|
},
|
|
{
|
|
// See golang.org/issues/38173.
|
|
name: "StringDoubleEscapes",
|
|
in: StringTag{
|
|
StrStr: "\b\f\n\r\t\"\\",
|
|
NumberStr: "0", // just to satisfy the roundtrip
|
|
},
|
|
want: `{
|
|
"BoolStr": "false",
|
|
"IntStr": "0",
|
|
"UintptrStr": "0",
|
|
"StrStr": "\"\\u0008\\u000c\\n\\r\\t\\\"\\\\\"",
|
|
"NumberStr": "0"
|
|
}`,
|
|
},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
// Indent with a tab prefix to make the multi-line string
|
|
// literals in the table nicer to read.
|
|
got, err := json.MarshalIndent(&test.in, "\t\t\t", "\t")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := string(got); got != test.want {
|
|
t.Fatalf(" got: %s\nwant: %s\n", got, test.want)
|
|
}
|
|
|
|
// Verify that it round-trips.
|
|
var s2 StringTag
|
|
if err := json.Unmarshal(got, &s2); err != nil {
|
|
t.Fatalf("Decode: %v", err)
|
|
}
|
|
if !reflect.DeepEqual(test.in, s2) {
|
|
t.Fatalf("decode didn't match.\nsource: %#v\nEncoded as:\n%s\ndecode: %#v", test.in, 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 := json.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 = json.Marshal(r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if string(result) != expect {
|
|
t.Errorf(" got %s want %s", result, expect)
|
|
}
|
|
}
|
|
|
|
func TestMarshalRawMessageValue(t *testing.T) {
|
|
type (
|
|
T1 struct {
|
|
M json.RawMessage `json:",omitempty"`
|
|
}
|
|
T2 struct {
|
|
M *json.RawMessage `json:",omitempty"`
|
|
}
|
|
)
|
|
|
|
var (
|
|
rawNil = json.RawMessage(nil)
|
|
rawEmpty = json.RawMessage([]byte{})
|
|
rawText = json.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 json.RawMessage }{rawNil}, `{"M":null}`, true},
|
|
{&struct{ M json.RawMessage }{rawNil}, `{"M":null}`, true},
|
|
{struct{ M *json.RawMessage }{&rawNil}, `{"M":null}`, true},
|
|
{&struct{ M *json.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 json.RawMessage }{rawEmpty}, "", false},
|
|
{&struct{ X json.RawMessage }{rawEmpty}, "", false},
|
|
{struct{ X *json.RawMessage }{&rawEmpty}, "", false},
|
|
{&struct{ X *json.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://golang.org/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 json.RawMessage }{rawText}, `{"M":"foo"}`, true}, // Issue6458
|
|
{&struct{ M json.RawMessage }{rawText}, `{"M":"foo"}`, true},
|
|
{struct{ M *json.RawMessage }{&rawText}, `{"M":"foo"}`, true},
|
|
{&struct{ M *json.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 := json.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)
|
|
}
|
|
}
|
|
}
|
|
|
|
type marshalerError struct{}
|
|
|
|
func (*marshalerError) MarshalJSON() ([]byte, error) {
|
|
return nil, errors.New("unexpected error")
|
|
}
|
|
|
|
func Test_MarshalerError(t *testing.T) {
|
|
var v marshalerError
|
|
_, err := json.Marshal(&v)
|
|
expect := `json: error calling MarshalJSON for type *json_test.marshalerError: unexpected error`
|
|
assertEq(t, "marshaler error", expect, fmt.Sprint(err))
|
|
}
|
|
|
|
// 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 := json.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 := json.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 = json.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 marshalPanic struct{}
|
|
|
|
func (marshalPanic) MarshalJSON() ([]byte, error) { panic(0xdead) }
|
|
|
|
func TestMarshalPanic(t *testing.T) {
|
|
defer func() {
|
|
if got := recover(); !reflect.DeepEqual(got, 0xdead) {
|
|
t.Errorf("panic() = (%T)(%v), want 0xdead", got, got)
|
|
}
|
|
}()
|
|
json.Marshal(&marshalPanic{})
|
|
t.Error("Marshal should have panicked")
|
|
}
|
|
|
|
func TestMarshalUncommonFieldNames(t *testing.T) {
|
|
v := struct {
|
|
A0, À, Aβ int
|
|
}{}
|
|
b, err := json.Marshal(v)
|
|
if err != nil {
|
|
t.Fatal("Marshal:", err)
|
|
}
|
|
want := `{"A0":0,"À":0,"Aβ":0}`
|
|
got := string(b)
|
|
if got != want {
|
|
t.Fatalf("Marshal: got %s want %s", got, want)
|
|
}
|
|
}
|
|
|
|
func TestMarshalerError(t *testing.T) {
|
|
s := "test variable"
|
|
st := reflect.TypeOf(s)
|
|
errText := "json: test error"
|
|
|
|
tests := []struct {
|
|
err *json.MarshalerError
|
|
want string
|
|
}{
|
|
{
|
|
json.NewMarshalerError(st, fmt.Errorf(errText), ""),
|
|
"json: error calling MarshalJSON for type " + st.String() + ": " + errText,
|
|
},
|
|
{
|
|
json.NewMarshalerError(st, fmt.Errorf(errText), "TestMarshalerError"),
|
|
"json: error calling TestMarshalerError for type " + st.String() + ": " + errText,
|
|
},
|
|
}
|
|
|
|
for i, tt := range tests {
|
|
got := tt.err.Error()
|
|
if got != tt.want {
|
|
t.Errorf("MarshalerError test %d, got: %s, want: %s", i, got, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
type unmarshalerText struct {
|
|
A, B string
|
|
}
|
|
|
|
// needed for re-marshaling tests
|
|
func (u unmarshalerText) MarshalText() ([]byte, error) {
|
|
return []byte(u.A + ":" + u.B), nil
|
|
}
|
|
|
|
func (u *unmarshalerText) UnmarshalText(b []byte) error {
|
|
pos := bytes.IndexByte(b, ':')
|
|
if pos == -1 {
|
|
return errors.New("missing separator")
|
|
}
|
|
u.A, u.B = string(b[:pos]), string(b[pos+1:])
|
|
return nil
|
|
}
|
|
|
|
func TestTextMarshalerMapKeysAreSorted(t *testing.T) {
|
|
b, err := json.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)
|
|
}
|
|
}
|
|
|
|
// https://golang.org/issue/33675
|
|
func TestNilMarshalerTextMapKey(t *testing.T) {
|
|
v := map[*unmarshalerText]int{
|
|
(*unmarshalerText)(nil): 1,
|
|
{"A", "B"}: 2,
|
|
}
|
|
b, err := json.Marshal(v)
|
|
if err != nil {
|
|
t.Fatalf("Failed to Marshal *text.Marshaler: %v", err)
|
|
}
|
|
const want = `{"":1,"A:B":2}`
|
|
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 := json.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-- {
|
|
if testing.Short() && i < len(digits)-4 {
|
|
break
|
|
}
|
|
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)
|
|
}
|
|
|
|
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 := json.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 i, d := range testdata {
|
|
js, err := json.Marshal(d.data)
|
|
if err != nil {
|
|
t.Error(err)
|
|
continue
|
|
}
|
|
got, want := string(js), d.want
|
|
if got != want {
|
|
t.Errorf("%d: got %s, want %s", i, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
// golang.org/issue/8582
|
|
func TestEncodePointerString(t *testing.T) {
|
|
type stringPointer struct {
|
|
N *int64 `json:"n,string"`
|
|
}
|
|
var n int64 = 42
|
|
b, err := json.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 = json.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)
|
|
}
|
|
}
|
|
|
|
type SamePointerNoCycle struct {
|
|
Ptr1, Ptr2 *SamePointerNoCycle
|
|
}
|
|
|
|
var samePointerNoCycle = &SamePointerNoCycle{}
|
|
|
|
type PointerCycle struct {
|
|
Ptr *PointerCycle
|
|
}
|
|
|
|
var pointerCycle = &PointerCycle{}
|
|
|
|
type PointerCycleIndirect struct {
|
|
Ptrs []interface{}
|
|
}
|
|
|
|
var pointerCycleIndirect = &PointerCycleIndirect{}
|
|
|
|
func init() {
|
|
ptr := &SamePointerNoCycle{}
|
|
samePointerNoCycle.Ptr1 = ptr
|
|
samePointerNoCycle.Ptr2 = ptr
|
|
|
|
pointerCycle.Ptr = pointerCycle
|
|
pointerCycleIndirect.Ptrs = []interface{}{pointerCycleIndirect}
|
|
}
|
|
|
|
func TestSamePointerNoCycle(t *testing.T) {
|
|
if _, err := json.Marshal(samePointerNoCycle); err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
}
|
|
|
|
var unsupportedValues = []interface{}{
|
|
math.NaN(),
|
|
math.Inf(-1),
|
|
math.Inf(1),
|
|
pointerCycle,
|
|
pointerCycleIndirect,
|
|
}
|
|
|
|
func TestUnsupportedValues(t *testing.T) {
|
|
for _, v := range unsupportedValues {
|
|
if _, err := json.Marshal(v); err != nil {
|
|
if _, ok := err.(*json.UnsupportedValueError); !ok {
|
|
t.Errorf("for %v, got %T want UnsupportedValueError", v, err)
|
|
}
|
|
} else {
|
|
t.Errorf("for %v, expected error", v)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIssue10281(t *testing.T) {
|
|
type Foo struct {
|
|
N json.Number
|
|
}
|
|
x := Foo{json.Number(`invalid`)}
|
|
|
|
b, err := json.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"}`))
|
|
json.HTMLEscape(&b, []byte(m))
|
|
if !bytes.Equal(b.Bytes(), want.Bytes()) {
|
|
t.Errorf("HTMLEscape(&b, []byte(m)) = %s; want %s", b.Bytes(), want.Bytes())
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
// golang.org/issue/16042.
|
|
// Even if a nil interface value is passed in, as long as
|
|
// it implements Marshaler, it should be marshaled.
|
|
type nilJSONMarshaler string
|
|
|
|
func (nm *nilJSONMarshaler) MarshalJSON() ([]byte, error) {
|
|
if nm == nil {
|
|
return json.Marshal("0zenil0")
|
|
}
|
|
return json.Marshal("zenil:" + string(*nm))
|
|
}
|
|
|
|
// golang.org/issue/34235.
|
|
// Even if a nil interface value is passed in, as long as
|
|
// it implements encoding.TextMarshaler, it should be marshaled.
|
|
type nilTextMarshaler string
|
|
|
|
func (nm *nilTextMarshaler) MarshalText() ([]byte, error) {
|
|
if nm == nil {
|
|
return []byte("0zenil0"), nil
|
|
}
|
|
return []byte("zenil:" + string(*nm)), nil
|
|
}
|
|
|
|
// See golang.org/issue/16042 and golang.org/issue/34235.
|
|
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 json.Marshaler }{}, want: `{"M":null}`},
|
|
{v: struct{ M json.Marshaler }{(*nilJSONMarshaler)(nil)}, want: `{"M":"0zenil0"}`},
|
|
{v: struct{ M interface{} }{(*nilJSONMarshaler)(nil)}, want: `{"M":null}`},
|
|
{v: struct{ M encoding.TextMarshaler }{}, want: `{"M":null}`},
|
|
{v: struct{ M encoding.TextMarshaler }{(*nilTextMarshaler)(nil)}, want: `{"M":"0zenil0"}`},
|
|
{v: struct{ M interface{} }{(*nilTextMarshaler)(nil)}, want: `{"M":null}`},
|
|
}
|
|
|
|
for i, tt := range testCases {
|
|
out, err := json.Marshal(tt.v)
|
|
if err != nil || string(out) != tt.want {
|
|
t.Errorf("%d: Marshal(%#v) = %#q, %#v, want %#q, nil", i, tt.v, out, err, tt.want)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
// Issue 5245.
|
|
func TestEmbeddedBug(t *testing.T) {
|
|
v := BugB{
|
|
BugA{"A"},
|
|
"B",
|
|
}
|
|
b, err := json.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 = json.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 := json.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 := json.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 TestAnonymousFields(t *testing.T) {
|
|
tests := []struct {
|
|
label string // Test name
|
|
makeInput func() interface{} // Function to create input value
|
|
want string // Expected JSON output
|
|
}{{
|
|
// Both S1 and S2 have a field named X. From the perspective of S,
|
|
// it is ambiguous which one X refers to.
|
|
// This should not serialize either field.
|
|
label: "AmbiguousField",
|
|
makeInput: func() interface{} {
|
|
type (
|
|
S1 struct{ x, X int }
|
|
S2 struct{ x, X int }
|
|
S struct {
|
|
S1
|
|
S2
|
|
}
|
|
)
|
|
return S{S1{1, 2}, S2{3, 4}}
|
|
},
|
|
want: `{}`,
|
|
}, {
|
|
label: "DominantField",
|
|
// Both S1 and S2 have a field named X, but since S has an X field as
|
|
// well, it takes precedence over S1.X and S2.X.
|
|
makeInput: func() interface{} {
|
|
type (
|
|
S1 struct{ x, X int }
|
|
S2 struct{ x, X int }
|
|
S struct {
|
|
S1
|
|
S2
|
|
x, X int
|
|
}
|
|
)
|
|
return S{S1{1, 2}, S2{3, 4}, 5, 6}
|
|
},
|
|
want: `{"X":6}`,
|
|
}, {
|
|
// Unexported embedded field of non-struct type should not be serialized.
|
|
label: "UnexportedEmbeddedInt",
|
|
makeInput: func() interface{} {
|
|
type (
|
|
myInt int
|
|
S struct{ myInt }
|
|
)
|
|
return S{5}
|
|
},
|
|
want: `{}`,
|
|
}, {
|
|
// Exported embedded field of non-struct type should be serialized.
|
|
label: "ExportedEmbeddedInt",
|
|
makeInput: func() interface{} {
|
|
type (
|
|
MyInt int
|
|
S struct{ MyInt }
|
|
)
|
|
return S{5}
|
|
},
|
|
want: `{"MyInt":5}`,
|
|
}, {
|
|
// Unexported embedded field of pointer to non-struct type
|
|
// should not be serialized.
|
|
label: "UnexportedEmbeddedIntPointer",
|
|
makeInput: func() interface{} {
|
|
type (
|
|
myInt int
|
|
S struct{ *myInt }
|
|
)
|
|
s := S{new(myInt)}
|
|
*s.myInt = 5
|
|
return s
|
|
},
|
|
want: `{}`,
|
|
}, {
|
|
// Exported embedded field of pointer to non-struct type
|
|
// should be serialized.
|
|
label: "ExportedEmbeddedIntPointer",
|
|
makeInput: func() interface{} {
|
|
type (
|
|
MyInt int
|
|
S struct{ *MyInt }
|
|
)
|
|
s := S{new(MyInt)}
|
|
*s.MyInt = 5
|
|
return s
|
|
},
|
|
want: `{"MyInt":5}`,
|
|
}, {
|
|
// Exported fields of embedded structs should have their
|
|
// exported fields be serialized regardless of whether the struct types
|
|
// themselves are exported.
|
|
label: "EmbeddedStruct",
|
|
makeInput: func() interface{} {
|
|
type (
|
|
s1 struct{ x, X int }
|
|
S2 struct{ y, Y int }
|
|
S struct {
|
|
s1
|
|
S2
|
|
}
|
|
)
|
|
return S{s1{1, 2}, S2{3, 4}}
|
|
},
|
|
want: `{"X":2,"Y":4}`,
|
|
}, {
|
|
// Exported fields of pointers to embedded structs should have their
|
|
// exported fields be serialized regardless of whether the struct types
|
|
// themselves are exported.
|
|
label: "EmbeddedStructPointer",
|
|
makeInput: func() interface{} {
|
|
type (
|
|
s1 struct{ x, X int }
|
|
S2 struct{ y, Y int }
|
|
S struct {
|
|
*s1
|
|
*S2
|
|
}
|
|
)
|
|
return S{&s1{1, 2}, &S2{3, 4}}
|
|
},
|
|
want: `{"X":2,"Y":4}`,
|
|
}, {
|
|
// Exported fields on embedded unexported structs at multiple levels
|
|
// of nesting should still be serialized.
|
|
label: "NestedStructAndInts",
|
|
makeInput: func() interface{} {
|
|
type (
|
|
MyInt1 int
|
|
MyInt2 int
|
|
myInt int
|
|
s2 struct {
|
|
MyInt2
|
|
myInt
|
|
}
|
|
s1 struct {
|
|
MyInt1
|
|
myInt
|
|
s2
|
|
}
|
|
S struct {
|
|
s1
|
|
myInt
|
|
}
|
|
)
|
|
return S{s1{1, 2, s2{3, 4}}, 6}
|
|
},
|
|
want: `{"MyInt1":1,"MyInt2":3}`,
|
|
}, {
|
|
// If an anonymous struct pointer field is nil, we should ignore
|
|
// the embedded fields behind it. Not properly doing so may
|
|
// result in the wrong output or reflect panics.
|
|
label: "EmbeddedFieldBehindNilPointer",
|
|
makeInput: func() interface{} {
|
|
type (
|
|
S2 struct{ Field string }
|
|
S struct{ *S2 }
|
|
)
|
|
return S{}
|
|
},
|
|
want: `{}`,
|
|
}}
|
|
|
|
for i, tt := range tests {
|
|
t.Run(tt.label, func(t *testing.T) {
|
|
b, err := json.Marshal(tt.makeInput())
|
|
if err != nil {
|
|
t.Fatalf("%d: Marshal() = %v, want nil error", i, err)
|
|
}
|
|
if string(b) != tt.want {
|
|
t.Fatalf("%d: Marshal() = %q, want %q", i, b, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
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 := json.MarshalIndent(&o, "", " ")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := string(got); got != optionalsExpected {
|
|
t.Errorf(" got: %s\nwant: %s\n", got, optionalsExpected)
|
|
}
|
|
}
|
|
|
|
type testNullStr string
|
|
|
|
func (v *testNullStr) MarshalJSON() ([]byte, error) {
|
|
if *v == "" {
|
|
return []byte("null"), nil
|
|
}
|
|
|
|
return []byte(*v), nil
|
|
}
|
|
|
|
func TestIssue147(t *testing.T) {
|
|
type T struct {
|
|
Field1 string `json:"field1"`
|
|
Field2 testNullStr `json:"field2,omitempty"`
|
|
}
|
|
got, err := json.Marshal(T{
|
|
Field1: "a",
|
|
Field2: "b",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
expect, _ := stdjson.Marshal(T{
|
|
Field1: "a",
|
|
Field2: "b",
|
|
})
|
|
if !bytes.Equal(expect, got) {
|
|
t.Fatalf("expect %q but got %q", string(expect), string(got))
|
|
}
|
|
}
|
|
|
|
type testIssue144 struct {
|
|
name string
|
|
number int64
|
|
}
|
|
|
|
func (v *testIssue144) MarshalJSON() ([]byte, error) {
|
|
if v.name != "" {
|
|
return json.Marshal(v.name)
|
|
}
|
|
return json.Marshal(v.number)
|
|
}
|
|
|
|
func TestIssue144(t *testing.T) {
|
|
type Embeded struct {
|
|
Field *testIssue144 `json:"field,omitempty"`
|
|
}
|
|
type T struct {
|
|
Embeded
|
|
}
|
|
{
|
|
v := T{
|
|
Embeded: Embeded{Field: &testIssue144{name: "hoge"}},
|
|
}
|
|
got, err := json.Marshal(v)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
expect, _ := stdjson.Marshal(v)
|
|
if !bytes.Equal(expect, got) {
|
|
t.Fatalf("expect %q but got %q", string(expect), string(got))
|
|
}
|
|
}
|
|
{
|
|
v := &T{
|
|
Embeded: Embeded{Field: &testIssue144{name: "hoge"}},
|
|
}
|
|
got, err := json.Marshal(v)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
expect, _ := stdjson.Marshal(v)
|
|
if !bytes.Equal(expect, got) {
|
|
t.Fatalf("expect %q but got %q", string(expect), string(got))
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIssue118(t *testing.T) {
|
|
type data struct {
|
|
Columns []string `json:"columns"`
|
|
Rows1 [][]string `json:"rows1"`
|
|
Rows2 [][]string `json:"rows2"`
|
|
}
|
|
v := data{Columns: []string{"1", "2", "3"}}
|
|
got, err := json.MarshalIndent(v, "", " ")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
expect, _ := stdjson.MarshalIndent(v, "", " ")
|
|
if !bytes.Equal(expect, got) {
|
|
t.Fatalf("expect %q but got %q", string(expect), string(got))
|
|
}
|
|
}
|
|
|
|
func TestIssue104(t *testing.T) {
|
|
type A struct {
|
|
Field1 string
|
|
Field2 int
|
|
Field3 float64
|
|
}
|
|
type T struct {
|
|
Field A
|
|
}
|
|
got, err := json.Marshal(T{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
expect, _ := stdjson.Marshal(T{})
|
|
if !bytes.Equal(expect, got) {
|
|
t.Fatalf("expect %q but got %q", string(expect), string(got))
|
|
}
|
|
}
|
|
|
|
func TestIssue179(t *testing.T) {
|
|
data := `
|
|
{
|
|
"t": {
|
|
"t1": false,
|
|
"t2": 0,
|
|
"t3": "",
|
|
"t4": [],
|
|
"t5": null,
|
|
"t6": null
|
|
}
|
|
}`
|
|
type T struct {
|
|
X struct {
|
|
T1 bool `json:"t1,omitempty"`
|
|
T2 float64 `json:"t2,omitempty"`
|
|
T3 string `json:"t3,omitempty"`
|
|
T4 []string `json:"t4,omitempty"`
|
|
T5 *struct{} `json:"t5,omitempty"`
|
|
T6 interface{} `json:"t6,omitempty"`
|
|
} `json:"x"`
|
|
}
|
|
var v T
|
|
if err := stdjson.Unmarshal([]byte(data), &v); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var v2 T
|
|
if err := json.Unmarshal([]byte(data), &v2); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !reflect.DeepEqual(v, v2) {
|
|
t.Fatalf("failed to decode: expected %v got %v", v, v2)
|
|
}
|
|
b1, err := stdjson.Marshal(v)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
b2, err := json.Marshal(v2)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(b1, b2) {
|
|
t.Fatalf("failed to equal encoded result: expected %q but got %q", b1, b2)
|
|
}
|
|
}
|
|
|
|
func TestIssue180(t *testing.T) {
|
|
v := struct {
|
|
T struct {
|
|
T1 bool `json:"t1"`
|
|
T2 float64 `json:"t2"`
|
|
T3 string `json:"t3"`
|
|
T4 []string `json:"t4"`
|
|
T5 *struct{} `json:"t5"`
|
|
T6 interface{} `json:"t6"`
|
|
T7 [][]string `json:"t7"`
|
|
} `json:"t"`
|
|
}{
|
|
T: struct {
|
|
T1 bool `json:"t1"`
|
|
T2 float64 `json:"t2"`
|
|
T3 string `json:"t3"`
|
|
T4 []string `json:"t4"`
|
|
T5 *struct{} `json:"t5"`
|
|
T6 interface{} `json:"t6"`
|
|
T7 [][]string `json:"t7"`
|
|
}{
|
|
T4: []string{},
|
|
T7: [][]string{
|
|
[]string{""},
|
|
[]string{"hello", "world"},
|
|
[]string{},
|
|
},
|
|
},
|
|
}
|
|
b1, err := stdjson.MarshalIndent(v, "", "\t")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
b2, err := json.MarshalIndent(v, "", "\t")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(b1, b2) {
|
|
t.Fatalf("failed to equal encoded result: expected %s but got %s", string(b1), string(b2))
|
|
}
|
|
}
|
|
|
|
func TestIssue235(t *testing.T) {
|
|
type TaskMessage struct {
|
|
Type string
|
|
Payload map[string]interface{}
|
|
UniqueKey string
|
|
}
|
|
msg := TaskMessage{
|
|
Payload: map[string]interface{}{
|
|
"sent_at": map[string]interface{}{
|
|
"Time": "0001-01-01T00:00:00Z",
|
|
"Valid": false,
|
|
},
|
|
},
|
|
}
|
|
if _, err := json.Marshal(msg); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestEncodeMapKeyTypeInterface(t *testing.T) {
|
|
if _, err := json.Marshal(map[interface{}]interface{}{"a": 1}); err == nil {
|
|
t.Fatal("expected error")
|
|
}
|
|
}
|
|
|
|
type marshalContextKey struct{}
|
|
|
|
type marshalContextStructType struct{}
|
|
|
|
func (t *marshalContextStructType) MarshalJSON(ctx context.Context) ([]byte, error) {
|
|
v := ctx.Value(marshalContextKey{})
|
|
s, ok := v.(string)
|
|
if !ok {
|
|
return nil, fmt.Errorf("failed to propagate parent context.Context")
|
|
}
|
|
if s != "hello" {
|
|
return nil, fmt.Errorf("failed to propagate parent context.Context")
|
|
}
|
|
return []byte(`"success"`), nil
|
|
}
|
|
|
|
func TestEncodeContextOption(t *testing.T) {
|
|
t.Run("MarshalContext", func(t *testing.T) {
|
|
ctx := context.WithValue(context.Background(), marshalContextKey{}, "hello")
|
|
b, err := json.MarshalContext(ctx, &marshalContextStructType{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if string(b) != `"success"` {
|
|
t.Fatal("failed to encode with MarshalerContext")
|
|
}
|
|
})
|
|
t.Run("EncodeContext", func(t *testing.T) {
|
|
ctx := context.WithValue(context.Background(), marshalContextKey{}, "hello")
|
|
buf := bytes.NewBuffer([]byte{})
|
|
if err := json.NewEncoder(buf).EncodeContext(ctx, &marshalContextStructType{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if buf.String() != "\"success\"\n" {
|
|
t.Fatal("failed to encode with EncodeContext")
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestInterfaceWithPointer(t *testing.T) {
|
|
var (
|
|
ivalue int = 10
|
|
uvalue uint = 20
|
|
svalue string = "value"
|
|
bvalue bool = true
|
|
fvalue float32 = 3.14
|
|
nvalue json.Number = "1.23"
|
|
structv = struct{ A int }{A: 10}
|
|
slice = []int{1, 2, 3, 4}
|
|
array = [4]int{1, 2, 3, 4}
|
|
mapvalue = map[string]int{"a": 1}
|
|
)
|
|
data := map[string]interface{}{
|
|
"ivalue": ivalue,
|
|
"uvalue": uvalue,
|
|
"svalue": svalue,
|
|
"bvalue": bvalue,
|
|
"fvalue": fvalue,
|
|
"nvalue": nvalue,
|
|
"struct": structv,
|
|
"slice": slice,
|
|
"array": array,
|
|
"map": mapvalue,
|
|
"pivalue": &ivalue,
|
|
"puvalue": &uvalue,
|
|
"psvalue": &svalue,
|
|
"pbvalue": &bvalue,
|
|
"pfvalue": &fvalue,
|
|
"pnvalue": &nvalue,
|
|
"pstruct": &structv,
|
|
"pslice": &slice,
|
|
"parray": &array,
|
|
"pmap": &mapvalue,
|
|
}
|
|
expected, err := stdjson.Marshal(data)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
actual, err := json.Marshal(data)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assertEq(t, "interface{}", string(expected), string(actual))
|
|
}
|
|
|
|
func TestIssue263(t *testing.T) {
|
|
type Foo struct {
|
|
A []string `json:"a"`
|
|
B int `json:"b"`
|
|
}
|
|
|
|
type MyStruct struct {
|
|
Foo *Foo `json:"foo,omitempty"`
|
|
}
|
|
|
|
s := MyStruct{
|
|
Foo: &Foo{
|
|
A: []string{"ls -lah"},
|
|
B: 0,
|
|
},
|
|
}
|
|
expected, err := stdjson.Marshal(s)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
actual, err := json.Marshal(s)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(expected, actual) {
|
|
t.Fatalf("expected:[%s] but got:[%s]", string(expected), string(actual))
|
|
}
|
|
}
|
|
|
|
func TestEmbeddedNotFirstField(t *testing.T) {
|
|
type Embedded struct {
|
|
Has bool `json:"has"`
|
|
}
|
|
type T struct {
|
|
X int `json:"is"`
|
|
Embedded `json:"child"`
|
|
}
|
|
p := T{X: 10, Embedded: Embedded{Has: true}}
|
|
expected, err := stdjson.Marshal(&p)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := json.Marshal(&p)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(expected, got) {
|
|
t.Fatalf("failed to encode embedded structure. expected = %q but got %q", expected, got)
|
|
}
|
|
}
|
|
|
|
type implementedMethodIface interface {
|
|
M()
|
|
}
|
|
|
|
type implementedIfaceType struct {
|
|
A int
|
|
B string
|
|
}
|
|
|
|
func (implementedIfaceType) M() {}
|
|
|
|
func TestImplementedMethodInterfaceType(t *testing.T) {
|
|
data := []implementedIfaceType{implementedIfaceType{}}
|
|
expected, err := stdjson.Marshal(data)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := json.Marshal(data)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(expected, got) {
|
|
t.Fatalf("failed to encode implemented method interface type. expected:[%q] but got:[%q]", expected, got)
|
|
}
|
|
}
|
|
|
|
func TestEmptyStructInterface(t *testing.T) {
|
|
expected, err := stdjson.Marshal([]interface{}{struct{}{}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := json.Marshal([]interface{}{struct{}{}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(expected, got) {
|
|
t.Fatalf("failed to encode empty struct interface. expected:[%q] but got:[%q]", expected, got)
|
|
}
|
|
}
|
|
|
|
func TestIssue290(t *testing.T) {
|
|
type Issue290 interface {
|
|
A()
|
|
}
|
|
var a struct {
|
|
A Issue290
|
|
}
|
|
expected, err := stdjson.Marshal(a)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := json.Marshal(a)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(expected, got) {
|
|
t.Fatalf("failed to encode non empty interface. expected = %q but got %q", expected, got)
|
|
}
|
|
}
|
|
|
|
func TestIssue299(t *testing.T) {
|
|
t.Run("conflict second field", func(t *testing.T) {
|
|
type Embedded struct {
|
|
ID string `json:"id"`
|
|
Name map[string]string `json:"name"`
|
|
}
|
|
type Container struct {
|
|
Embedded
|
|
Name string `json:"name"`
|
|
}
|
|
c := &Container{
|
|
Embedded: Embedded{
|
|
ID: "1",
|
|
Name: map[string]string{"en": "Hello", "es": "Hola"},
|
|
},
|
|
Name: "Hi",
|
|
}
|
|
expected, _ := stdjson.Marshal(c)
|
|
got, err := json.Marshal(c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(expected, got) {
|
|
t.Fatalf("expected %q but got %q", expected, got)
|
|
}
|
|
})
|
|
t.Run("conflict map field", func(t *testing.T) {
|
|
type Embedded struct {
|
|
Name map[string]string `json:"name"`
|
|
}
|
|
type Container struct {
|
|
Embedded
|
|
Name string `json:"name"`
|
|
}
|
|
c := &Container{
|
|
Embedded: Embedded{
|
|
Name: map[string]string{"en": "Hello", "es": "Hola"},
|
|
},
|
|
Name: "Hi",
|
|
}
|
|
expected, _ := stdjson.Marshal(c)
|
|
got, err := json.Marshal(c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(expected, got) {
|
|
t.Fatalf("expected %q but got %q", expected, got)
|
|
}
|
|
})
|
|
t.Run("conflict slice field", func(t *testing.T) {
|
|
type Embedded struct {
|
|
Name []string `json:"name"`
|
|
}
|
|
type Container struct {
|
|
Embedded
|
|
Name string `json:"name"`
|
|
}
|
|
c := &Container{
|
|
Embedded: Embedded{
|
|
Name: []string{"Hello"},
|
|
},
|
|
Name: "Hi",
|
|
}
|
|
expected, _ := stdjson.Marshal(c)
|
|
got, err := json.Marshal(c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(expected, got) {
|
|
t.Fatalf("expected %q but got %q", expected, got)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestRecursivePtrHead(t *testing.T) {
|
|
type User struct {
|
|
Account *string `json:"account"`
|
|
Password *string `json:"password"`
|
|
Nickname *string `json:"nickname"`
|
|
Address *string `json:"address,omitempty"`
|
|
Friends []*User `json:"friends,omitempty"`
|
|
}
|
|
user1Account, user1Password, user1Nickname := "abcdef", "123456", "user1"
|
|
user1 := &User{
|
|
Account: &user1Account,
|
|
Password: &user1Password,
|
|
Nickname: &user1Nickname,
|
|
Address: nil,
|
|
}
|
|
user2Account, user2Password, user2Nickname := "ghijkl", "123456", "user2"
|
|
user2 := &User{
|
|
Account: &user2Account,
|
|
Password: &user2Password,
|
|
Nickname: &user2Nickname,
|
|
Address: nil,
|
|
}
|
|
user1.Friends = []*User{user2}
|
|
expected, err := stdjson.Marshal(user1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := json.Marshal(user1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(expected, got) {
|
|
t.Fatalf("failed to encode. expected %q but got %q", expected, got)
|
|
}
|
|
}
|
|
|
|
func TestMarshalIndent(t *testing.T) {
|
|
v := map[string]map[string]interface{}{
|
|
"a": {
|
|
"b": "1",
|
|
"c": map[string]interface{}{
|
|
"d": "1",
|
|
},
|
|
},
|
|
}
|
|
expected, err := stdjson.MarshalIndent(v, "", " ")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := json.MarshalIndent(v, "", " ")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(expected, got) {
|
|
t.Fatalf("expected: %q but got %q", expected, got)
|
|
}
|
|
}
|
|
|
|
type issue318Embedded struct {
|
|
_ [64]byte
|
|
}
|
|
|
|
type issue318 struct {
|
|
issue318Embedded `json:"-"`
|
|
ID issue318MarshalText `json:"id,omitempty"`
|
|
}
|
|
|
|
type issue318MarshalText struct {
|
|
ID string
|
|
}
|
|
|
|
func (i issue318MarshalText) MarshalText() ([]byte, error) {
|
|
return []byte(i.ID), nil
|
|
}
|
|
|
|
func TestIssue318(t *testing.T) {
|
|
v := issue318{
|
|
ID: issue318MarshalText{ID: "1"},
|
|
}
|
|
b, err := json.Marshal(v)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
expected := `{"id":"1"}`
|
|
if string(b) != expected {
|
|
t.Fatalf("failed to encode. expected %s but got %s", expected, string(b))
|
|
}
|
|
}
|
|
|
|
type emptyStringMarshaler struct {
|
|
Value stringMarshaler `json:"value,omitempty"`
|
|
}
|
|
|
|
type stringMarshaler string
|
|
|
|
func (s stringMarshaler) MarshalJSON() ([]byte, error) {
|
|
return []byte(`"` + s + `"`), nil
|
|
}
|
|
|
|
func TestEmptyStringMarshaler(t *testing.T) {
|
|
value := emptyStringMarshaler{}
|
|
expected, err := stdjson.Marshal(value)
|
|
assertErr(t, err)
|
|
got, err := json.Marshal(value)
|
|
assertErr(t, err)
|
|
assertEq(t, "struct", string(expected), string(got))
|
|
}
|
|
|
|
func TestIssue324(t *testing.T) {
|
|
type T struct {
|
|
FieldA *string `json:"fieldA,omitempty"`
|
|
FieldB *string `json:"fieldB,omitempty"`
|
|
FieldC *bool `json:"fieldC"`
|
|
FieldD []string `json:"fieldD,omitempty"`
|
|
}
|
|
v := &struct {
|
|
Code string `json:"code"`
|
|
*T
|
|
}{
|
|
T: &T{},
|
|
}
|
|
var sv = "Test Field"
|
|
v.Code = "Test"
|
|
v.T.FieldB = &sv
|
|
expected, err := stdjson.Marshal(v)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := json.Marshal(v)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(expected, got) {
|
|
t.Fatalf("failed to encode. expected %q but got %q", expected, got)
|
|
}
|
|
}
|
|
|
|
func TestCamelCaseField(t *testing.T) {
|
|
type T struct {
|
|
FieldA bool
|
|
}
|
|
|
|
type T2 struct {
|
|
FieldA bool `json:"fieldA"`
|
|
}
|
|
|
|
v := T{FieldA: true}
|
|
got, err := json.MarshalWithOption(v, json.EnableCamelCase())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
v2 := T2{FieldA: true}
|
|
expected, err := json.Marshal(v2)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !bytes.Equal(expected, got) {
|
|
t.Fatalf("failed to encode. expected %q but got %q", expected, got)
|
|
}
|
|
}
|