mirror of
https://github.com/json-iterator/go.git
synced 2025-04-04 21:34:16 +02:00
Add output tests for maps of maps/slices/structs
This commit is contained in:
parent
7d6c9374e8
commit
7cd7a6cc7c
139
output_tests/maps/builtins/int32/map/json_test.go
Normal file
139
output_tests/maps/builtins/int32/map/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
3
output_tests/maps/builtins/int32/map/types.go
Normal file
3
output_tests/maps/builtins/int32/map/types.go
Normal file
@ -0,0 +1,3 @@
|
||||
package test
|
||||
|
||||
type T map[string]map[string]string
|
139
output_tests/maps/builtins/int32/ptr_struct/json_test.go
Normal file
139
output_tests/maps/builtins/int32/ptr_struct/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
14
output_tests/maps/builtins/int32/ptr_struct/types.go
Normal file
14
output_tests/maps/builtins/int32/ptr_struct/types.go
Normal file
@ -0,0 +1,14 @@
|
||||
package test
|
||||
|
||||
type Struct struct {
|
||||
String string
|
||||
Int int32
|
||||
Float float64
|
||||
Struct struct {
|
||||
X string
|
||||
}
|
||||
Slice []string
|
||||
Map map[string]string
|
||||
}
|
||||
|
||||
type T map[string]*Struct
|
139
output_tests/maps/builtins/int32/slice/json_test.go
Normal file
139
output_tests/maps/builtins/int32/slice/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
3
output_tests/maps/builtins/int32/slice/types.go
Normal file
3
output_tests/maps/builtins/int32/slice/types.go
Normal file
@ -0,0 +1,3 @@
|
||||
package test
|
||||
|
||||
type T map[string][]string
|
139
output_tests/maps/builtins/int32/struct/json_test.go
Normal file
139
output_tests/maps/builtins/int32/struct/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
14
output_tests/maps/builtins/int32/struct/types.go
Normal file
14
output_tests/maps/builtins/int32/struct/types.go
Normal file
@ -0,0 +1,14 @@
|
||||
package test
|
||||
|
||||
type Struct struct {
|
||||
String string
|
||||
Int int32
|
||||
Float float64
|
||||
Struct struct {
|
||||
X string
|
||||
}
|
||||
Slice []string
|
||||
Map map[string]string
|
||||
}
|
||||
|
||||
type T map[string]Struct
|
139
output_tests/maps/builtins/string/map/json_test.go
Normal file
139
output_tests/maps/builtins/string/map/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
3
output_tests/maps/builtins/string/map/types.go
Normal file
3
output_tests/maps/builtins/string/map/types.go
Normal file
@ -0,0 +1,3 @@
|
||||
package test
|
||||
|
||||
type T map[string]map[string]string
|
139
output_tests/maps/builtins/string/ptr_struct/json_test.go
Normal file
139
output_tests/maps/builtins/string/ptr_struct/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
14
output_tests/maps/builtins/string/ptr_struct/types.go
Normal file
14
output_tests/maps/builtins/string/ptr_struct/types.go
Normal file
@ -0,0 +1,14 @@
|
||||
package test
|
||||
|
||||
type Struct struct {
|
||||
String string
|
||||
Int int32
|
||||
Float float64
|
||||
Struct struct {
|
||||
X string
|
||||
}
|
||||
Slice []string
|
||||
Map map[string]string
|
||||
}
|
||||
|
||||
type T map[string]*Struct
|
139
output_tests/maps/builtins/string/slice/json_test.go
Normal file
139
output_tests/maps/builtins/string/slice/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
3
output_tests/maps/builtins/string/slice/types.go
Normal file
3
output_tests/maps/builtins/string/slice/types.go
Normal file
@ -0,0 +1,3 @@
|
||||
package test
|
||||
|
||||
type T map[string][]string
|
139
output_tests/maps/builtins/string/struct/json_test.go
Normal file
139
output_tests/maps/builtins/string/struct/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
14
output_tests/maps/builtins/string/struct/types.go
Normal file
14
output_tests/maps/builtins/string/struct/types.go
Normal file
@ -0,0 +1,14 @@
|
||||
package test
|
||||
|
||||
type Struct struct {
|
||||
String string
|
||||
Int int32
|
||||
Float float64
|
||||
Struct struct {
|
||||
X string
|
||||
}
|
||||
Slice []string
|
||||
Map map[string]string
|
||||
}
|
||||
|
||||
type T map[string]Struct
|
139
output_tests/maps/builtins/string_alias/map/json_test.go
Normal file
139
output_tests/maps/builtins/string_alias/map/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
3
output_tests/maps/builtins/string_alias/map/types.go
Normal file
3
output_tests/maps/builtins/string_alias/map/types.go
Normal file
@ -0,0 +1,3 @@
|
||||
package test
|
||||
|
||||
type T map[string]map[string]string
|
139
output_tests/maps/builtins/string_alias/ptr_struct/json_test.go
Normal file
139
output_tests/maps/builtins/string_alias/ptr_struct/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
14
output_tests/maps/builtins/string_alias/ptr_struct/types.go
Normal file
14
output_tests/maps/builtins/string_alias/ptr_struct/types.go
Normal file
@ -0,0 +1,14 @@
|
||||
package test
|
||||
|
||||
type Struct struct {
|
||||
String string
|
||||
Int int32
|
||||
Float float64
|
||||
Struct struct {
|
||||
X string
|
||||
}
|
||||
Slice []string
|
||||
Map map[string]string
|
||||
}
|
||||
|
||||
type T map[string]*Struct
|
139
output_tests/maps/builtins/string_alias/slice/json_test.go
Normal file
139
output_tests/maps/builtins/string_alias/slice/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
3
output_tests/maps/builtins/string_alias/slice/types.go
Normal file
3
output_tests/maps/builtins/string_alias/slice/types.go
Normal file
@ -0,0 +1,3 @@
|
||||
package test
|
||||
|
||||
type T map[string][]string
|
139
output_tests/maps/builtins/string_alias/struct/json_test.go
Normal file
139
output_tests/maps/builtins/string_alias/struct/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
14
output_tests/maps/builtins/string_alias/struct/types.go
Normal file
14
output_tests/maps/builtins/string_alias/struct/types.go
Normal file
@ -0,0 +1,14 @@
|
||||
package test
|
||||
|
||||
type Struct struct {
|
||||
String string
|
||||
Int int32
|
||||
Float float64
|
||||
Struct struct {
|
||||
X string
|
||||
}
|
||||
Slice []string
|
||||
Map map[string]string
|
||||
}
|
||||
|
||||
type T map[string]Struct
|
139
output_tests/maps/builtins/uint8/map/json_test.go
Normal file
139
output_tests/maps/builtins/uint8/map/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
3
output_tests/maps/builtins/uint8/map/types.go
Normal file
3
output_tests/maps/builtins/uint8/map/types.go
Normal file
@ -0,0 +1,3 @@
|
||||
package test
|
||||
|
||||
type T map[string]map[string]string
|
139
output_tests/maps/builtins/uint8/ptr_struct/json_test.go
Normal file
139
output_tests/maps/builtins/uint8/ptr_struct/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
14
output_tests/maps/builtins/uint8/ptr_struct/types.go
Normal file
14
output_tests/maps/builtins/uint8/ptr_struct/types.go
Normal file
@ -0,0 +1,14 @@
|
||||
package test
|
||||
|
||||
type Struct struct {
|
||||
String string
|
||||
Int int32
|
||||
Float float64
|
||||
Struct struct {
|
||||
X string
|
||||
}
|
||||
Slice []string
|
||||
Map map[string]string
|
||||
}
|
||||
|
||||
type T map[string]*Struct
|
139
output_tests/maps/builtins/uint8/slice/json_test.go
Normal file
139
output_tests/maps/builtins/uint8/slice/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
3
output_tests/maps/builtins/uint8/slice/types.go
Normal file
3
output_tests/maps/builtins/uint8/slice/types.go
Normal file
@ -0,0 +1,3 @@
|
||||
package test
|
||||
|
||||
type T map[string][]string
|
139
output_tests/maps/builtins/uint8/struct/json_test.go
Normal file
139
output_tests/maps/builtins/uint8/struct/json_test.go
Normal file
@ -0,0 +1,139 @@
|
||||
package test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
fuzz "github.com/google/gofuzz"
|
||||
jsoniter "github.com/json-iterator/go"
|
||||
)
|
||||
|
||||
func Test_Roundtrip(t *testing.T) {
|
||||
fz := fuzz.New().MaxDepth(10).NilChance(0.3)
|
||||
for i := 0; i < 1000; i++ {
|
||||
var before T
|
||||
fz.Fuzz(&before)
|
||||
|
||||
jbStd, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with stdlib: %v", err)
|
||||
}
|
||||
jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before)
|
||||
if err != nil {
|
||||
t.Errorf("failed to marshal with jsoniter: %v", err)
|
||||
}
|
||||
if string(jbStd) != string(jbIter) {
|
||||
t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s",
|
||||
indent(jbStd, " "), indent(jbIter, " "), dump(before))
|
||||
}
|
||||
|
||||
var afterStd T
|
||||
err = json.Unmarshal(jbIter, &afterStd)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with stdlib: %v", err)
|
||||
}
|
||||
var afterIter T
|
||||
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
|
||||
if err != nil {
|
||||
t.Errorf("failed to unmarshal with jsoniter: %v", err)
|
||||
}
|
||||
if fingerprint(afterStd) != fingerprint(afterIter) {
|
||||
t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s",
|
||||
dump(afterStd), dump(afterIter), indent(jbIter, " "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const indentStr = "> "
|
||||
|
||||
func fingerprint(obj interface{}) string {
|
||||
c := spew.ConfigState{
|
||||
SortKeys: true,
|
||||
SpewKeys: true,
|
||||
}
|
||||
return c.Sprintf("%v", obj)
|
||||
}
|
||||
|
||||
func dump(obj interface{}) string {
|
||||
cfg := spew.ConfigState{
|
||||
Indent: indentStr,
|
||||
}
|
||||
return cfg.Sdump(obj)
|
||||
}
|
||||
|
||||
func indent(src []byte, prefix string) string {
|
||||
var buf bytes.Buffer
|
||||
json.Indent(&buf, src, prefix, indentStr)
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var obj T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&obj)
|
||||
for i := 0; i < t.N; i++ {
|
||||
jb, err := fn(obj)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err)
|
||||
}
|
||||
_ = jb
|
||||
}
|
||||
}
|
||||
|
||||
func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) {
|
||||
t.ReportAllocs()
|
||||
t.ResetTimer()
|
||||
|
||||
var before T
|
||||
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
|
||||
fz.Fuzz(&before)
|
||||
jb, err := json.Marshal(before)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to marshal: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < t.N; i++ {
|
||||
var after T
|
||||
err = fn(jb, &after)
|
||||
if err != nil {
|
||||
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkStandardMarshal(t *testing.B) {
|
||||
benchmarkMarshal(t, "stdlib", json.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkStandardUnmarshal(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "stdlib", json.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalFastest(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalFastest(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalDefault(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalDefault(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterMarshalCompatible(t *testing.B) {
|
||||
benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal)
|
||||
}
|
||||
|
||||
func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) {
|
||||
benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal)
|
||||
}
|
14
output_tests/maps/builtins/uint8/struct/types.go
Normal file
14
output_tests/maps/builtins/uint8/struct/types.go
Normal file
@ -0,0 +1,14 @@
|
||||
package test
|
||||
|
||||
type Struct struct {
|
||||
String string
|
||||
Int int32
|
||||
Float float64
|
||||
Struct struct {
|
||||
X string
|
||||
}
|
||||
Slice []string
|
||||
Map map[string]string
|
||||
}
|
||||
|
||||
type T map[string]Struct
|
Loading…
x
Reference in New Issue
Block a user