From cf6367546b2295999fc11549b237a540d9a6e43a Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 11:28:17 +0100 Subject: [PATCH 01/18] Add output tests for structs of structs --- .../structs/structs/empties/json_test.go | 139 ++++++++++++++++++ output_tests/structs/structs/empties/types.go | 7 + .../structs/structs/empty/json_test.go | 139 ++++++++++++++++++ output_tests/structs/structs/empty/types.go | 5 + .../structs/structs/empty_alias/json_test.go | 139 ++++++++++++++++++ .../structs/structs/empty_alias/types.go | 7 + .../structs/structs/float32s/json_test.go | 139 ++++++++++++++++++ .../structs/structs/float32s/types.go | 9 ++ .../structs/structs/float64/json_test.go | 139 ++++++++++++++++++ output_tests/structs/structs/float64/types.go | 7 + .../structs/float64_alias/json_test.go | 139 ++++++++++++++++++ .../structs/structs/float64_alias/types.go | 9 ++ .../structs/structs/int32s/json_test.go | 139 ++++++++++++++++++ output_tests/structs/structs/int32s/types.go | 9 ++ .../structs/structs/strings/json_test.go | 139 ++++++++++++++++++ output_tests/structs/structs/strings/types.go | 9 ++ .../structs/strings_alias/json_test.go | 139 ++++++++++++++++++ .../structs/structs/strings_alias/types.go | 13 ++ 18 files changed, 1326 insertions(+) create mode 100644 output_tests/structs/structs/empties/json_test.go create mode 100644 output_tests/structs/structs/empties/types.go create mode 100644 output_tests/structs/structs/empty/json_test.go create mode 100644 output_tests/structs/structs/empty/types.go create mode 100644 output_tests/structs/structs/empty_alias/json_test.go create mode 100644 output_tests/structs/structs/empty_alias/types.go create mode 100644 output_tests/structs/structs/float32s/json_test.go create mode 100644 output_tests/structs/structs/float32s/types.go create mode 100644 output_tests/structs/structs/float64/json_test.go create mode 100644 output_tests/structs/structs/float64/types.go create mode 100644 output_tests/structs/structs/float64_alias/json_test.go create mode 100644 output_tests/structs/structs/float64_alias/types.go create mode 100644 output_tests/structs/structs/int32s/json_test.go create mode 100644 output_tests/structs/structs/int32s/types.go create mode 100644 output_tests/structs/structs/strings/json_test.go create mode 100644 output_tests/structs/structs/strings/types.go create mode 100644 output_tests/structs/structs/strings_alias/json_test.go create mode 100644 output_tests/structs/structs/strings_alias/types.go diff --git a/output_tests/structs/structs/empties/json_test.go b/output_tests/structs/structs/empties/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/structs/empties/json_test.go @@ -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) +} diff --git a/output_tests/structs/structs/empties/types.go b/output_tests/structs/structs/empties/types.go new file mode 100644 index 0000000..8bfea4e --- /dev/null +++ b/output_tests/structs/structs/empties/types.go @@ -0,0 +1,7 @@ +package test + +type T struct { + F1 struct{} + F2 struct{} + F3 struct{} +} diff --git a/output_tests/structs/structs/empty/json_test.go b/output_tests/structs/structs/empty/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/structs/empty/json_test.go @@ -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) +} diff --git a/output_tests/structs/structs/empty/types.go b/output_tests/structs/structs/empty/types.go new file mode 100644 index 0000000..3c8ff89 --- /dev/null +++ b/output_tests/structs/structs/empty/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F struct{} +} diff --git a/output_tests/structs/structs/empty_alias/json_test.go b/output_tests/structs/structs/empty_alias/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/structs/empty_alias/json_test.go @@ -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) +} diff --git a/output_tests/structs/structs/empty_alias/types.go b/output_tests/structs/structs/empty_alias/types.go new file mode 100644 index 0000000..3e80808 --- /dev/null +++ b/output_tests/structs/structs/empty_alias/types.go @@ -0,0 +1,7 @@ +package test + +type A struct{} + +type T struct { + F A +} diff --git a/output_tests/structs/structs/float32s/json_test.go b/output_tests/structs/structs/float32s/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/structs/float32s/json_test.go @@ -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) +} diff --git a/output_tests/structs/structs/float32s/types.go b/output_tests/structs/structs/float32s/types.go new file mode 100644 index 0000000..db72613 --- /dev/null +++ b/output_tests/structs/structs/float32s/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F struct { + F1 float32 + F2 float32 + F3 float32 + } +} diff --git a/output_tests/structs/structs/float64/json_test.go b/output_tests/structs/structs/float64/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/structs/float64/json_test.go @@ -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) +} diff --git a/output_tests/structs/structs/float64/types.go b/output_tests/structs/structs/float64/types.go new file mode 100644 index 0000000..1df48ac --- /dev/null +++ b/output_tests/structs/structs/float64/types.go @@ -0,0 +1,7 @@ +package test + +type T struct { + F struct { + F float32 + } +} diff --git a/output_tests/structs/structs/float64_alias/json_test.go b/output_tests/structs/structs/float64_alias/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/structs/float64_alias/json_test.go @@ -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) +} diff --git a/output_tests/structs/structs/float64_alias/types.go b/output_tests/structs/structs/float64_alias/types.go new file mode 100644 index 0000000..d813246 --- /dev/null +++ b/output_tests/structs/structs/float64_alias/types.go @@ -0,0 +1,9 @@ +package test + +type A struct { + F float64 +} + +type T struct { + F A +} diff --git a/output_tests/structs/structs/int32s/json_test.go b/output_tests/structs/structs/int32s/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/structs/int32s/json_test.go @@ -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) +} diff --git a/output_tests/structs/structs/int32s/types.go b/output_tests/structs/structs/int32s/types.go new file mode 100644 index 0000000..e91bda7 --- /dev/null +++ b/output_tests/structs/structs/int32s/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F struct { + F1 int32 + F2 int32 + F3 int32 + } +} diff --git a/output_tests/structs/structs/strings/json_test.go b/output_tests/structs/structs/strings/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/structs/strings/json_test.go @@ -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) +} diff --git a/output_tests/structs/structs/strings/types.go b/output_tests/structs/structs/strings/types.go new file mode 100644 index 0000000..b5b4e67 --- /dev/null +++ b/output_tests/structs/structs/strings/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F struct { + F1 string + F2 string + F3 string + } +} diff --git a/output_tests/structs/structs/strings_alias/json_test.go b/output_tests/structs/structs/strings_alias/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/structs/strings_alias/json_test.go @@ -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) +} diff --git a/output_tests/structs/structs/strings_alias/types.go b/output_tests/structs/structs/strings_alias/types.go new file mode 100644 index 0000000..513ac8d --- /dev/null +++ b/output_tests/structs/structs/strings_alias/types.go @@ -0,0 +1,13 @@ +package test + +type S string + +type A struct { + F1 S + F2 S + F3 S +} + +type T struct { + F A +} From e16ee7f8ac61dcf54a03a3ea1125701cef403211 Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 11:41:17 +0100 Subject: [PATCH 02/18] Add output tests for structs of slices and maps --- .../maps/builtins/float32/json_test.go | 139 ++++++++++++++++++ .../structs/maps/builtins/float32/types.go | 5 + .../structs/maps/builtins/int32/json_test.go | 139 ++++++++++++++++++ .../structs/maps/builtins/int32/types.go | 5 + .../structs/maps/builtins/string/json_test.go | 139 ++++++++++++++++++ .../structs/maps/builtins/string/types.go | 5 + .../maps/builtins/string_alias/json_test.go | 139 ++++++++++++++++++ .../maps/builtins/string_alias/types.go | 9 ++ .../maps/builtins/strings/json_test.go | 139 ++++++++++++++++++ .../structs/maps/builtins/strings/types.go | 7 + .../maps/pointers/float32/json_test.go | 139 ++++++++++++++++++ .../structs/maps/pointers/float32/types.go | 5 + .../structs/maps/pointers/int32/json_test.go | 139 ++++++++++++++++++ .../structs/maps/pointers/int32/types.go | 5 + .../structs/maps/pointers/string/json_test.go | 139 ++++++++++++++++++ .../structs/maps/pointers/string/types.go | 5 + .../maps/pointers/string_alias/json_test.go | 139 ++++++++++++++++++ .../maps/pointers/string_alias/types.go | 9 ++ .../maps/pointers/strings/json_test.go | 139 ++++++++++++++++++ .../structs/maps/pointers/strings/types.go | 7 + .../structs/maps/structs/empty/json_test.go | 139 ++++++++++++++++++ .../structs/maps/structs/empty/types.go | 5 + .../maps/structs/float32s/json_test.go | 139 ++++++++++++++++++ .../structs/maps/structs/float32s/types.go | 9 ++ .../structs/maps/structs/int32s/json_test.go | 139 ++++++++++++++++++ .../structs/maps/structs/int32s/types.go | 9 ++ .../maps/structs/ptr_to_strings/json_test.go | 139 ++++++++++++++++++ .../maps/structs/ptr_to_strings/types.go | 9 ++ .../structs/maps/structs/strings/json_test.go | 139 ++++++++++++++++++ .../structs/maps/structs/strings/types.go | 9 ++ .../slices/builtins/float32/json_test.go | 139 ++++++++++++++++++ .../structs/slices/builtins/float32/types.go | 5 + .../slices/builtins/int32/json_test.go | 139 ++++++++++++++++++ .../structs/slices/builtins/int32/types.go | 5 + .../slices/builtins/string/json_test.go | 139 ++++++++++++++++++ .../structs/slices/builtins/string/types.go | 5 + .../slices/builtins/string_alias/json_test.go | 139 ++++++++++++++++++ .../slices/builtins/string_alias/types.go | 9 ++ .../slices/builtins/strings/json_test.go | 139 ++++++++++++++++++ .../structs/slices/builtins/strings/types.go | 7 + .../slices/pointers/float32/json_test.go | 139 ++++++++++++++++++ .../structs/slices/pointers/float32/types.go | 5 + .../slices/pointers/int32/json_test.go | 139 ++++++++++++++++++ .../structs/slices/pointers/int32/types.go | 5 + .../slices/pointers/string/json_test.go | 139 ++++++++++++++++++ .../structs/slices/pointers/string/types.go | 5 + .../slices/pointers/string_alias/json_test.go | 139 ++++++++++++++++++ .../slices/pointers/string_alias/types.go | 9 ++ .../slices/pointers/strings/json_test.go | 139 ++++++++++++++++++ .../structs/slices/pointers/strings/types.go | 7 + .../structs/slices/structs/empty/json_test.go | 139 ++++++++++++++++++ .../structs/slices/structs/empty/types.go | 5 + .../slices/structs/float32s/json_test.go | 139 ++++++++++++++++++ .../structs/slices/structs/float32s/types.go | 9 ++ .../slices/structs/int32s/json_test.go | 139 ++++++++++++++++++ .../structs/slices/structs/int32s/types.go | 9 ++ .../structs/ptr_to_strings/json_test.go | 139 ++++++++++++++++++ .../slices/structs/ptr_to_strings/types.go | 9 ++ .../slices/structs/strings/json_test.go | 139 ++++++++++++++++++ .../structs/slices/structs/strings/types.go | 9 ++ 60 files changed, 4376 insertions(+) create mode 100644 output_tests/structs/maps/builtins/float32/json_test.go create mode 100644 output_tests/structs/maps/builtins/float32/types.go create mode 100644 output_tests/structs/maps/builtins/int32/json_test.go create mode 100644 output_tests/structs/maps/builtins/int32/types.go create mode 100644 output_tests/structs/maps/builtins/string/json_test.go create mode 100644 output_tests/structs/maps/builtins/string/types.go create mode 100644 output_tests/structs/maps/builtins/string_alias/json_test.go create mode 100644 output_tests/structs/maps/builtins/string_alias/types.go create mode 100644 output_tests/structs/maps/builtins/strings/json_test.go create mode 100644 output_tests/structs/maps/builtins/strings/types.go create mode 100644 output_tests/structs/maps/pointers/float32/json_test.go create mode 100644 output_tests/structs/maps/pointers/float32/types.go create mode 100644 output_tests/structs/maps/pointers/int32/json_test.go create mode 100644 output_tests/structs/maps/pointers/int32/types.go create mode 100644 output_tests/structs/maps/pointers/string/json_test.go create mode 100644 output_tests/structs/maps/pointers/string/types.go create mode 100644 output_tests/structs/maps/pointers/string_alias/json_test.go create mode 100644 output_tests/structs/maps/pointers/string_alias/types.go create mode 100644 output_tests/structs/maps/pointers/strings/json_test.go create mode 100644 output_tests/structs/maps/pointers/strings/types.go create mode 100644 output_tests/structs/maps/structs/empty/json_test.go create mode 100644 output_tests/structs/maps/structs/empty/types.go create mode 100644 output_tests/structs/maps/structs/float32s/json_test.go create mode 100644 output_tests/structs/maps/structs/float32s/types.go create mode 100644 output_tests/structs/maps/structs/int32s/json_test.go create mode 100644 output_tests/structs/maps/structs/int32s/types.go create mode 100644 output_tests/structs/maps/structs/ptr_to_strings/json_test.go create mode 100644 output_tests/structs/maps/structs/ptr_to_strings/types.go create mode 100644 output_tests/structs/maps/structs/strings/json_test.go create mode 100644 output_tests/structs/maps/structs/strings/types.go create mode 100644 output_tests/structs/slices/builtins/float32/json_test.go create mode 100644 output_tests/structs/slices/builtins/float32/types.go create mode 100644 output_tests/structs/slices/builtins/int32/json_test.go create mode 100644 output_tests/structs/slices/builtins/int32/types.go create mode 100644 output_tests/structs/slices/builtins/string/json_test.go create mode 100644 output_tests/structs/slices/builtins/string/types.go create mode 100644 output_tests/structs/slices/builtins/string_alias/json_test.go create mode 100644 output_tests/structs/slices/builtins/string_alias/types.go create mode 100644 output_tests/structs/slices/builtins/strings/json_test.go create mode 100644 output_tests/structs/slices/builtins/strings/types.go create mode 100644 output_tests/structs/slices/pointers/float32/json_test.go create mode 100644 output_tests/structs/slices/pointers/float32/types.go create mode 100644 output_tests/structs/slices/pointers/int32/json_test.go create mode 100644 output_tests/structs/slices/pointers/int32/types.go create mode 100644 output_tests/structs/slices/pointers/string/json_test.go create mode 100644 output_tests/structs/slices/pointers/string/types.go create mode 100644 output_tests/structs/slices/pointers/string_alias/json_test.go create mode 100644 output_tests/structs/slices/pointers/string_alias/types.go create mode 100644 output_tests/structs/slices/pointers/strings/json_test.go create mode 100644 output_tests/structs/slices/pointers/strings/types.go create mode 100644 output_tests/structs/slices/structs/empty/json_test.go create mode 100644 output_tests/structs/slices/structs/empty/types.go create mode 100644 output_tests/structs/slices/structs/float32s/json_test.go create mode 100644 output_tests/structs/slices/structs/float32s/types.go create mode 100644 output_tests/structs/slices/structs/int32s/json_test.go create mode 100644 output_tests/structs/slices/structs/int32s/types.go create mode 100644 output_tests/structs/slices/structs/ptr_to_strings/json_test.go create mode 100644 output_tests/structs/slices/structs/ptr_to_strings/types.go create mode 100644 output_tests/structs/slices/structs/strings/json_test.go create mode 100644 output_tests/structs/slices/structs/strings/types.go diff --git a/output_tests/structs/maps/builtins/float32/json_test.go b/output_tests/structs/maps/builtins/float32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/builtins/float32/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/builtins/float32/types.go b/output_tests/structs/maps/builtins/float32/types.go new file mode 100644 index 0000000..4cf8288 --- /dev/null +++ b/output_tests/structs/maps/builtins/float32/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F map[string]float32 +} diff --git a/output_tests/structs/maps/builtins/int32/json_test.go b/output_tests/structs/maps/builtins/int32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/builtins/int32/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/builtins/int32/types.go b/output_tests/structs/maps/builtins/int32/types.go new file mode 100644 index 0000000..9bdad18 --- /dev/null +++ b/output_tests/structs/maps/builtins/int32/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F map[string]int32 +} diff --git a/output_tests/structs/maps/builtins/string/json_test.go b/output_tests/structs/maps/builtins/string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/builtins/string/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/builtins/string/types.go b/output_tests/structs/maps/builtins/string/types.go new file mode 100644 index 0000000..8e3cf1f --- /dev/null +++ b/output_tests/structs/maps/builtins/string/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F map[string]string +} diff --git a/output_tests/structs/maps/builtins/string_alias/json_test.go b/output_tests/structs/maps/builtins/string_alias/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/builtins/string_alias/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/builtins/string_alias/types.go b/output_tests/structs/maps/builtins/string_alias/types.go new file mode 100644 index 0000000..e2ecc99 --- /dev/null +++ b/output_tests/structs/maps/builtins/string_alias/types.go @@ -0,0 +1,9 @@ +package test + +type A1 string +type A2 map[string]A1 + +type T struct { + F1 map[string]A1 + F2 A2 +} diff --git a/output_tests/structs/maps/builtins/strings/json_test.go b/output_tests/structs/maps/builtins/strings/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/builtins/strings/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/builtins/strings/types.go b/output_tests/structs/maps/builtins/strings/types.go new file mode 100644 index 0000000..312dcc4 --- /dev/null +++ b/output_tests/structs/maps/builtins/strings/types.go @@ -0,0 +1,7 @@ +package test + +type T struct { + F1 map[string]string + F2 map[string]string + F3 map[string]string +} diff --git a/output_tests/structs/maps/pointers/float32/json_test.go b/output_tests/structs/maps/pointers/float32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/pointers/float32/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/pointers/float32/types.go b/output_tests/structs/maps/pointers/float32/types.go new file mode 100644 index 0000000..9e24661 --- /dev/null +++ b/output_tests/structs/maps/pointers/float32/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F map[string]*float32 +} diff --git a/output_tests/structs/maps/pointers/int32/json_test.go b/output_tests/structs/maps/pointers/int32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/pointers/int32/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/pointers/int32/types.go b/output_tests/structs/maps/pointers/int32/types.go new file mode 100644 index 0000000..dab3575 --- /dev/null +++ b/output_tests/structs/maps/pointers/int32/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F map[string]*int32 +} diff --git a/output_tests/structs/maps/pointers/string/json_test.go b/output_tests/structs/maps/pointers/string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/pointers/string/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/pointers/string/types.go b/output_tests/structs/maps/pointers/string/types.go new file mode 100644 index 0000000..bc5bc88 --- /dev/null +++ b/output_tests/structs/maps/pointers/string/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F map[string]*string +} diff --git a/output_tests/structs/maps/pointers/string_alias/json_test.go b/output_tests/structs/maps/pointers/string_alias/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/pointers/string_alias/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/pointers/string_alias/types.go b/output_tests/structs/maps/pointers/string_alias/types.go new file mode 100644 index 0000000..537d59b --- /dev/null +++ b/output_tests/structs/maps/pointers/string_alias/types.go @@ -0,0 +1,9 @@ +package test + +type A1 *string +type A2 map[string]*A1 + +type T struct { + F1 map[string]A1 + F2 A2 +} diff --git a/output_tests/structs/maps/pointers/strings/json_test.go b/output_tests/structs/maps/pointers/strings/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/pointers/strings/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/pointers/strings/types.go b/output_tests/structs/maps/pointers/strings/types.go new file mode 100644 index 0000000..6e0f498 --- /dev/null +++ b/output_tests/structs/maps/pointers/strings/types.go @@ -0,0 +1,7 @@ +package test + +type T struct { + F1 map[string]*string + F2 map[string]*string + F3 map[string]*string +} diff --git a/output_tests/structs/maps/structs/empty/json_test.go b/output_tests/structs/maps/structs/empty/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/structs/empty/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/structs/empty/types.go b/output_tests/structs/maps/structs/empty/types.go new file mode 100644 index 0000000..b52b62d --- /dev/null +++ b/output_tests/structs/maps/structs/empty/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F map[string]struct{} +} diff --git a/output_tests/structs/maps/structs/float32s/json_test.go b/output_tests/structs/maps/structs/float32s/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/structs/float32s/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/structs/float32s/types.go b/output_tests/structs/maps/structs/float32s/types.go new file mode 100644 index 0000000..c79868c --- /dev/null +++ b/output_tests/structs/maps/structs/float32s/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F map[string]struct { + F1 float32 + F2 float32 + F3 float32 + } +} diff --git a/output_tests/structs/maps/structs/int32s/json_test.go b/output_tests/structs/maps/structs/int32s/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/structs/int32s/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/structs/int32s/types.go b/output_tests/structs/maps/structs/int32s/types.go new file mode 100644 index 0000000..891595f --- /dev/null +++ b/output_tests/structs/maps/structs/int32s/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F map[string]struct { + F1 int32 + F2 int32 + F3 int32 + } +} diff --git a/output_tests/structs/maps/structs/ptr_to_strings/json_test.go b/output_tests/structs/maps/structs/ptr_to_strings/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/structs/ptr_to_strings/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/structs/ptr_to_strings/types.go b/output_tests/structs/maps/structs/ptr_to_strings/types.go new file mode 100644 index 0000000..c537c2d --- /dev/null +++ b/output_tests/structs/maps/structs/ptr_to_strings/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F map[string]struct { + F1 *string + F2 *string + F3 *string + } +} diff --git a/output_tests/structs/maps/structs/strings/json_test.go b/output_tests/structs/maps/structs/strings/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/maps/structs/strings/json_test.go @@ -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) +} diff --git a/output_tests/structs/maps/structs/strings/types.go b/output_tests/structs/maps/structs/strings/types.go new file mode 100644 index 0000000..91c6d13 --- /dev/null +++ b/output_tests/structs/maps/structs/strings/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F map[string]struct { + F1 string + F2 string + F3 string + } +} diff --git a/output_tests/structs/slices/builtins/float32/json_test.go b/output_tests/structs/slices/builtins/float32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/builtins/float32/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/builtins/float32/types.go b/output_tests/structs/slices/builtins/float32/types.go new file mode 100644 index 0000000..74ad37a --- /dev/null +++ b/output_tests/structs/slices/builtins/float32/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F []float32 +} diff --git a/output_tests/structs/slices/builtins/int32/json_test.go b/output_tests/structs/slices/builtins/int32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/builtins/int32/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/builtins/int32/types.go b/output_tests/structs/slices/builtins/int32/types.go new file mode 100644 index 0000000..a5da597 --- /dev/null +++ b/output_tests/structs/slices/builtins/int32/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F []int32 +} diff --git a/output_tests/structs/slices/builtins/string/json_test.go b/output_tests/structs/slices/builtins/string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/builtins/string/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/builtins/string/types.go b/output_tests/structs/slices/builtins/string/types.go new file mode 100644 index 0000000..9cd82b6 --- /dev/null +++ b/output_tests/structs/slices/builtins/string/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F []string +} diff --git a/output_tests/structs/slices/builtins/string_alias/json_test.go b/output_tests/structs/slices/builtins/string_alias/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/builtins/string_alias/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/builtins/string_alias/types.go b/output_tests/structs/slices/builtins/string_alias/types.go new file mode 100644 index 0000000..726a569 --- /dev/null +++ b/output_tests/structs/slices/builtins/string_alias/types.go @@ -0,0 +1,9 @@ +package test + +type A1 string +type A2 []A1 + +type T struct { + F1 []A1 + F2 A2 +} diff --git a/output_tests/structs/slices/builtins/strings/json_test.go b/output_tests/structs/slices/builtins/strings/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/builtins/strings/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/builtins/strings/types.go b/output_tests/structs/slices/builtins/strings/types.go new file mode 100644 index 0000000..e7ed6ee --- /dev/null +++ b/output_tests/structs/slices/builtins/strings/types.go @@ -0,0 +1,7 @@ +package test + +type T struct { + F1 []string + F2 []string + F3 []string +} diff --git a/output_tests/structs/slices/pointers/float32/json_test.go b/output_tests/structs/slices/pointers/float32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/pointers/float32/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/pointers/float32/types.go b/output_tests/structs/slices/pointers/float32/types.go new file mode 100644 index 0000000..b18535b --- /dev/null +++ b/output_tests/structs/slices/pointers/float32/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F []*float32 +} diff --git a/output_tests/structs/slices/pointers/int32/json_test.go b/output_tests/structs/slices/pointers/int32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/pointers/int32/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/pointers/int32/types.go b/output_tests/structs/slices/pointers/int32/types.go new file mode 100644 index 0000000..e12c2e2 --- /dev/null +++ b/output_tests/structs/slices/pointers/int32/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F []*int32 +} diff --git a/output_tests/structs/slices/pointers/string/json_test.go b/output_tests/structs/slices/pointers/string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/pointers/string/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/pointers/string/types.go b/output_tests/structs/slices/pointers/string/types.go new file mode 100644 index 0000000..89c1317 --- /dev/null +++ b/output_tests/structs/slices/pointers/string/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F []*string +} diff --git a/output_tests/structs/slices/pointers/string_alias/json_test.go b/output_tests/structs/slices/pointers/string_alias/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/pointers/string_alias/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/pointers/string_alias/types.go b/output_tests/structs/slices/pointers/string_alias/types.go new file mode 100644 index 0000000..f0e825a --- /dev/null +++ b/output_tests/structs/slices/pointers/string_alias/types.go @@ -0,0 +1,9 @@ +package test + +type A1 *string +type A2 []*A1 + +type T struct { + F1 []A1 + F2 A2 +} diff --git a/output_tests/structs/slices/pointers/strings/json_test.go b/output_tests/structs/slices/pointers/strings/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/pointers/strings/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/pointers/strings/types.go b/output_tests/structs/slices/pointers/strings/types.go new file mode 100644 index 0000000..adefc13 --- /dev/null +++ b/output_tests/structs/slices/pointers/strings/types.go @@ -0,0 +1,7 @@ +package test + +type T struct { + F1 []*string + F2 []*string + F3 []*string +} diff --git a/output_tests/structs/slices/structs/empty/json_test.go b/output_tests/structs/slices/structs/empty/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/structs/empty/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/structs/empty/types.go b/output_tests/structs/slices/structs/empty/types.go new file mode 100644 index 0000000..cd2c828 --- /dev/null +++ b/output_tests/structs/slices/structs/empty/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F []struct{} +} diff --git a/output_tests/structs/slices/structs/float32s/json_test.go b/output_tests/structs/slices/structs/float32s/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/structs/float32s/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/structs/float32s/types.go b/output_tests/structs/slices/structs/float32s/types.go new file mode 100644 index 0000000..be5139c --- /dev/null +++ b/output_tests/structs/slices/structs/float32s/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F []struct { + F1 float32 + F2 float32 + F3 float32 + } +} diff --git a/output_tests/structs/slices/structs/int32s/json_test.go b/output_tests/structs/slices/structs/int32s/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/structs/int32s/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/structs/int32s/types.go b/output_tests/structs/slices/structs/int32s/types.go new file mode 100644 index 0000000..cd4b948 --- /dev/null +++ b/output_tests/structs/slices/structs/int32s/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F []struct { + F1 int32 + F2 int32 + F3 int32 + } +} diff --git a/output_tests/structs/slices/structs/ptr_to_strings/json_test.go b/output_tests/structs/slices/structs/ptr_to_strings/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/structs/ptr_to_strings/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/structs/ptr_to_strings/types.go b/output_tests/structs/slices/structs/ptr_to_strings/types.go new file mode 100644 index 0000000..876d63a --- /dev/null +++ b/output_tests/structs/slices/structs/ptr_to_strings/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F []struct { + F1 *string + F2 *string + F3 *string + } +} diff --git a/output_tests/structs/slices/structs/strings/json_test.go b/output_tests/structs/slices/structs/strings/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/slices/structs/strings/json_test.go @@ -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) +} diff --git a/output_tests/structs/slices/structs/strings/types.go b/output_tests/structs/slices/structs/strings/types.go new file mode 100644 index 0000000..0236420 --- /dev/null +++ b/output_tests/structs/slices/structs/strings/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F []struct { + F1 string + F2 string + F3 string + } +} From 7d6c9374e8877520769a38db3f5740152391491e Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 11:46:55 +0100 Subject: [PATCH 03/18] Add output test for structs of struct ptrs --- .../pointers/structs/empty/json_test.go | 139 ++++++++++++++++++ .../structs/pointers/structs/empty/types.go | 5 + .../pointers/structs/float64/json_test.go | 139 ++++++++++++++++++ .../structs/pointers/structs/float64/types.go | 7 + .../pointers/structs/int32s/json_test.go | 139 ++++++++++++++++++ .../structs/pointers/structs/int32s/types.go | 9 ++ .../structs/pointers/empty/json_test.go | 139 ++++++++++++++++++ .../pointers/structs/pointers/empty/types.go | 5 + .../structs/pointers/float64/json_test.go | 139 ++++++++++++++++++ .../structs/pointers/float64/types.go | 7 + .../structs/pointers/int32s/json_test.go | 139 ++++++++++++++++++ .../pointers/structs/pointers/int32s/types.go | 9 ++ .../structs/pointers/strings/json_test.go | 139 ++++++++++++++++++ .../structs/pointers/strings/types.go | 9 ++ .../pointers/structs/strings/json_test.go | 139 ++++++++++++++++++ .../structs/pointers/structs/strings/types.go | 9 ++ 16 files changed, 1172 insertions(+) create mode 100644 output_tests/structs/pointers/structs/empty/json_test.go create mode 100644 output_tests/structs/pointers/structs/empty/types.go create mode 100644 output_tests/structs/pointers/structs/float64/json_test.go create mode 100644 output_tests/structs/pointers/structs/float64/types.go create mode 100644 output_tests/structs/pointers/structs/int32s/json_test.go create mode 100644 output_tests/structs/pointers/structs/int32s/types.go create mode 100644 output_tests/structs/pointers/structs/pointers/empty/json_test.go create mode 100644 output_tests/structs/pointers/structs/pointers/empty/types.go create mode 100644 output_tests/structs/pointers/structs/pointers/float64/json_test.go create mode 100644 output_tests/structs/pointers/structs/pointers/float64/types.go create mode 100644 output_tests/structs/pointers/structs/pointers/int32s/json_test.go create mode 100644 output_tests/structs/pointers/structs/pointers/int32s/types.go create mode 100644 output_tests/structs/pointers/structs/pointers/strings/json_test.go create mode 100644 output_tests/structs/pointers/structs/pointers/strings/types.go create mode 100644 output_tests/structs/pointers/structs/strings/json_test.go create mode 100644 output_tests/structs/pointers/structs/strings/types.go diff --git a/output_tests/structs/pointers/structs/empty/json_test.go b/output_tests/structs/pointers/structs/empty/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/pointers/structs/empty/json_test.go @@ -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) +} diff --git a/output_tests/structs/pointers/structs/empty/types.go b/output_tests/structs/pointers/structs/empty/types.go new file mode 100644 index 0000000..e2177e2 --- /dev/null +++ b/output_tests/structs/pointers/structs/empty/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F *struct{} +} diff --git a/output_tests/structs/pointers/structs/float64/json_test.go b/output_tests/structs/pointers/structs/float64/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/pointers/structs/float64/json_test.go @@ -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) +} diff --git a/output_tests/structs/pointers/structs/float64/types.go b/output_tests/structs/pointers/structs/float64/types.go new file mode 100644 index 0000000..113087a --- /dev/null +++ b/output_tests/structs/pointers/structs/float64/types.go @@ -0,0 +1,7 @@ +package test + +type T struct { + F *struct { + F float32 + } +} diff --git a/output_tests/structs/pointers/structs/int32s/json_test.go b/output_tests/structs/pointers/structs/int32s/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/pointers/structs/int32s/json_test.go @@ -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) +} diff --git a/output_tests/structs/pointers/structs/int32s/types.go b/output_tests/structs/pointers/structs/int32s/types.go new file mode 100644 index 0000000..78f41cb --- /dev/null +++ b/output_tests/structs/pointers/structs/int32s/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F *struct { + F1 int32 + F2 int32 + F3 int32 + } +} diff --git a/output_tests/structs/pointers/structs/pointers/empty/json_test.go b/output_tests/structs/pointers/structs/pointers/empty/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/pointers/structs/pointers/empty/json_test.go @@ -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) +} diff --git a/output_tests/structs/pointers/structs/pointers/empty/types.go b/output_tests/structs/pointers/structs/pointers/empty/types.go new file mode 100644 index 0000000..40a5abe --- /dev/null +++ b/output_tests/structs/pointers/structs/pointers/empty/types.go @@ -0,0 +1,5 @@ +package test + +type T struct { + F **struct{} +} diff --git a/output_tests/structs/pointers/structs/pointers/float64/json_test.go b/output_tests/structs/pointers/structs/pointers/float64/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/pointers/structs/pointers/float64/json_test.go @@ -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) +} diff --git a/output_tests/structs/pointers/structs/pointers/float64/types.go b/output_tests/structs/pointers/structs/pointers/float64/types.go new file mode 100644 index 0000000..0f7d558 --- /dev/null +++ b/output_tests/structs/pointers/structs/pointers/float64/types.go @@ -0,0 +1,7 @@ +package test + +type T struct { + F **struct { + F float32 + } +} diff --git a/output_tests/structs/pointers/structs/pointers/int32s/json_test.go b/output_tests/structs/pointers/structs/pointers/int32s/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/pointers/structs/pointers/int32s/json_test.go @@ -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) +} diff --git a/output_tests/structs/pointers/structs/pointers/int32s/types.go b/output_tests/structs/pointers/structs/pointers/int32s/types.go new file mode 100644 index 0000000..f8b1a33 --- /dev/null +++ b/output_tests/structs/pointers/structs/pointers/int32s/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F **struct { + F1 int32 + F2 int32 + F3 int32 + } +} diff --git a/output_tests/structs/pointers/structs/pointers/strings/json_test.go b/output_tests/structs/pointers/structs/pointers/strings/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/pointers/structs/pointers/strings/json_test.go @@ -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) +} diff --git a/output_tests/structs/pointers/structs/pointers/strings/types.go b/output_tests/structs/pointers/structs/pointers/strings/types.go new file mode 100644 index 0000000..67f2807 --- /dev/null +++ b/output_tests/structs/pointers/structs/pointers/strings/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F **struct { + F1 string + F2 string + F3 string + } +} diff --git a/output_tests/structs/pointers/structs/strings/json_test.go b/output_tests/structs/pointers/structs/strings/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/structs/pointers/structs/strings/json_test.go @@ -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) +} diff --git a/output_tests/structs/pointers/structs/strings/types.go b/output_tests/structs/pointers/structs/strings/types.go new file mode 100644 index 0000000..7410b4f --- /dev/null +++ b/output_tests/structs/pointers/structs/strings/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F *struct { + F1 string + F2 string + F3 string + } +} From 7cd7a6cc7c5021646bae8e6adf988f2909888f08 Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 11:58:07 +0100 Subject: [PATCH 04/18] Add output tests for maps of maps/slices/structs --- .../maps/builtins/int32/map/json_test.go | 139 ++++++++++++++++++ output_tests/maps/builtins/int32/map/types.go | 3 + .../builtins/int32/ptr_struct/json_test.go | 139 ++++++++++++++++++ .../maps/builtins/int32/ptr_struct/types.go | 14 ++ .../maps/builtins/int32/slice/json_test.go | 139 ++++++++++++++++++ .../maps/builtins/int32/slice/types.go | 3 + .../maps/builtins/int32/struct/json_test.go | 139 ++++++++++++++++++ .../maps/builtins/int32/struct/types.go | 14 ++ .../maps/builtins/string/map/json_test.go | 139 ++++++++++++++++++ .../maps/builtins/string/map/types.go | 3 + .../builtins/string/ptr_struct/json_test.go | 139 ++++++++++++++++++ .../maps/builtins/string/ptr_struct/types.go | 14 ++ .../maps/builtins/string/slice/json_test.go | 139 ++++++++++++++++++ .../maps/builtins/string/slice/types.go | 3 + .../maps/builtins/string/struct/json_test.go | 139 ++++++++++++++++++ .../maps/builtins/string/struct/types.go | 14 ++ .../builtins/string_alias/map/json_test.go | 139 ++++++++++++++++++ .../maps/builtins/string_alias/map/types.go | 3 + .../string_alias/ptr_struct/json_test.go | 139 ++++++++++++++++++ .../builtins/string_alias/ptr_struct/types.go | 14 ++ .../builtins/string_alias/slice/json_test.go | 139 ++++++++++++++++++ .../maps/builtins/string_alias/slice/types.go | 3 + .../builtins/string_alias/struct/json_test.go | 139 ++++++++++++++++++ .../builtins/string_alias/struct/types.go | 14 ++ .../maps/builtins/uint8/map/json_test.go | 139 ++++++++++++++++++ output_tests/maps/builtins/uint8/map/types.go | 3 + .../builtins/uint8/ptr_struct/json_test.go | 139 ++++++++++++++++++ .../maps/builtins/uint8/ptr_struct/types.go | 14 ++ .../maps/builtins/uint8/slice/json_test.go | 139 ++++++++++++++++++ .../maps/builtins/uint8/slice/types.go | 3 + .../maps/builtins/uint8/struct/json_test.go | 139 ++++++++++++++++++ .../maps/builtins/uint8/struct/types.go | 14 ++ 32 files changed, 2360 insertions(+) create mode 100644 output_tests/maps/builtins/int32/map/json_test.go create mode 100644 output_tests/maps/builtins/int32/map/types.go create mode 100644 output_tests/maps/builtins/int32/ptr_struct/json_test.go create mode 100644 output_tests/maps/builtins/int32/ptr_struct/types.go create mode 100644 output_tests/maps/builtins/int32/slice/json_test.go create mode 100644 output_tests/maps/builtins/int32/slice/types.go create mode 100644 output_tests/maps/builtins/int32/struct/json_test.go create mode 100644 output_tests/maps/builtins/int32/struct/types.go create mode 100644 output_tests/maps/builtins/string/map/json_test.go create mode 100644 output_tests/maps/builtins/string/map/types.go create mode 100644 output_tests/maps/builtins/string/ptr_struct/json_test.go create mode 100644 output_tests/maps/builtins/string/ptr_struct/types.go create mode 100644 output_tests/maps/builtins/string/slice/json_test.go create mode 100644 output_tests/maps/builtins/string/slice/types.go create mode 100644 output_tests/maps/builtins/string/struct/json_test.go create mode 100644 output_tests/maps/builtins/string/struct/types.go create mode 100644 output_tests/maps/builtins/string_alias/map/json_test.go create mode 100644 output_tests/maps/builtins/string_alias/map/types.go create mode 100644 output_tests/maps/builtins/string_alias/ptr_struct/json_test.go create mode 100644 output_tests/maps/builtins/string_alias/ptr_struct/types.go create mode 100644 output_tests/maps/builtins/string_alias/slice/json_test.go create mode 100644 output_tests/maps/builtins/string_alias/slice/types.go create mode 100644 output_tests/maps/builtins/string_alias/struct/json_test.go create mode 100644 output_tests/maps/builtins/string_alias/struct/types.go create mode 100644 output_tests/maps/builtins/uint8/map/json_test.go create mode 100644 output_tests/maps/builtins/uint8/map/types.go create mode 100644 output_tests/maps/builtins/uint8/ptr_struct/json_test.go create mode 100644 output_tests/maps/builtins/uint8/ptr_struct/types.go create mode 100644 output_tests/maps/builtins/uint8/slice/json_test.go create mode 100644 output_tests/maps/builtins/uint8/slice/types.go create mode 100644 output_tests/maps/builtins/uint8/struct/json_test.go create mode 100644 output_tests/maps/builtins/uint8/struct/types.go diff --git a/output_tests/maps/builtins/int32/map/json_test.go b/output_tests/maps/builtins/int32/map/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/int32/map/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/int32/map/types.go b/output_tests/maps/builtins/int32/map/types.go new file mode 100644 index 0000000..cd51eed --- /dev/null +++ b/output_tests/maps/builtins/int32/map/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]map[string]string diff --git a/output_tests/maps/builtins/int32/ptr_struct/json_test.go b/output_tests/maps/builtins/int32/ptr_struct/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/int32/ptr_struct/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/int32/ptr_struct/types.go b/output_tests/maps/builtins/int32/ptr_struct/types.go new file mode 100644 index 0000000..0a1c237 --- /dev/null +++ b/output_tests/maps/builtins/int32/ptr_struct/types.go @@ -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 diff --git a/output_tests/maps/builtins/int32/slice/json_test.go b/output_tests/maps/builtins/int32/slice/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/int32/slice/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/int32/slice/types.go b/output_tests/maps/builtins/int32/slice/types.go new file mode 100644 index 0000000..1e12e7d --- /dev/null +++ b/output_tests/maps/builtins/int32/slice/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string][]string diff --git a/output_tests/maps/builtins/int32/struct/json_test.go b/output_tests/maps/builtins/int32/struct/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/int32/struct/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/int32/struct/types.go b/output_tests/maps/builtins/int32/struct/types.go new file mode 100644 index 0000000..263d4a6 --- /dev/null +++ b/output_tests/maps/builtins/int32/struct/types.go @@ -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 diff --git a/output_tests/maps/builtins/string/map/json_test.go b/output_tests/maps/builtins/string/map/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/string/map/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/string/map/types.go b/output_tests/maps/builtins/string/map/types.go new file mode 100644 index 0000000..cd51eed --- /dev/null +++ b/output_tests/maps/builtins/string/map/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]map[string]string diff --git a/output_tests/maps/builtins/string/ptr_struct/json_test.go b/output_tests/maps/builtins/string/ptr_struct/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/string/ptr_struct/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/string/ptr_struct/types.go b/output_tests/maps/builtins/string/ptr_struct/types.go new file mode 100644 index 0000000..0a1c237 --- /dev/null +++ b/output_tests/maps/builtins/string/ptr_struct/types.go @@ -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 diff --git a/output_tests/maps/builtins/string/slice/json_test.go b/output_tests/maps/builtins/string/slice/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/string/slice/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/string/slice/types.go b/output_tests/maps/builtins/string/slice/types.go new file mode 100644 index 0000000..1e12e7d --- /dev/null +++ b/output_tests/maps/builtins/string/slice/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string][]string diff --git a/output_tests/maps/builtins/string/struct/json_test.go b/output_tests/maps/builtins/string/struct/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/string/struct/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/string/struct/types.go b/output_tests/maps/builtins/string/struct/types.go new file mode 100644 index 0000000..263d4a6 --- /dev/null +++ b/output_tests/maps/builtins/string/struct/types.go @@ -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 diff --git a/output_tests/maps/builtins/string_alias/map/json_test.go b/output_tests/maps/builtins/string_alias/map/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/string_alias/map/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/string_alias/map/types.go b/output_tests/maps/builtins/string_alias/map/types.go new file mode 100644 index 0000000..cd51eed --- /dev/null +++ b/output_tests/maps/builtins/string_alias/map/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]map[string]string diff --git a/output_tests/maps/builtins/string_alias/ptr_struct/json_test.go b/output_tests/maps/builtins/string_alias/ptr_struct/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/string_alias/ptr_struct/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/string_alias/ptr_struct/types.go b/output_tests/maps/builtins/string_alias/ptr_struct/types.go new file mode 100644 index 0000000..0a1c237 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/ptr_struct/types.go @@ -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 diff --git a/output_tests/maps/builtins/string_alias/slice/json_test.go b/output_tests/maps/builtins/string_alias/slice/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/string_alias/slice/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/string_alias/slice/types.go b/output_tests/maps/builtins/string_alias/slice/types.go new file mode 100644 index 0000000..1e12e7d --- /dev/null +++ b/output_tests/maps/builtins/string_alias/slice/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string][]string diff --git a/output_tests/maps/builtins/string_alias/struct/json_test.go b/output_tests/maps/builtins/string_alias/struct/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/string_alias/struct/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/string_alias/struct/types.go b/output_tests/maps/builtins/string_alias/struct/types.go new file mode 100644 index 0000000..263d4a6 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/struct/types.go @@ -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 diff --git a/output_tests/maps/builtins/uint8/map/json_test.go b/output_tests/maps/builtins/uint8/map/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/uint8/map/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/uint8/map/types.go b/output_tests/maps/builtins/uint8/map/types.go new file mode 100644 index 0000000..cd51eed --- /dev/null +++ b/output_tests/maps/builtins/uint8/map/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]map[string]string diff --git a/output_tests/maps/builtins/uint8/ptr_struct/json_test.go b/output_tests/maps/builtins/uint8/ptr_struct/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/uint8/ptr_struct/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/uint8/ptr_struct/types.go b/output_tests/maps/builtins/uint8/ptr_struct/types.go new file mode 100644 index 0000000..0a1c237 --- /dev/null +++ b/output_tests/maps/builtins/uint8/ptr_struct/types.go @@ -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 diff --git a/output_tests/maps/builtins/uint8/slice/json_test.go b/output_tests/maps/builtins/uint8/slice/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/uint8/slice/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/uint8/slice/types.go b/output_tests/maps/builtins/uint8/slice/types.go new file mode 100644 index 0000000..1e12e7d --- /dev/null +++ b/output_tests/maps/builtins/uint8/slice/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string][]string diff --git a/output_tests/maps/builtins/uint8/struct/json_test.go b/output_tests/maps/builtins/uint8/struct/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/maps/builtins/uint8/struct/json_test.go @@ -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) +} diff --git a/output_tests/maps/builtins/uint8/struct/types.go b/output_tests/maps/builtins/uint8/struct/types.go new file mode 100644 index 0000000..263d4a6 --- /dev/null +++ b/output_tests/maps/builtins/uint8/struct/types.go @@ -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 From f93d25f8b1cecf42cd27b9547c281d63a0f0466b Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 18:28:24 +0100 Subject: [PATCH 05/18] Add output tests for slices of slices --- output_tests/slices/slices/bool/json_test.go | 139 ++++++++++++++++++ output_tests/slices/slices/bool/types.go | 3 + output_tests/slices/slices/byte/json_test.go | 139 ++++++++++++++++++ output_tests/slices/slices/byte/types.go | 3 + .../slices/slices/float64/json_test.go | 139 ++++++++++++++++++ output_tests/slices/slices/float64/types.go | 3 + output_tests/slices/slices/int32/json_test.go | 139 ++++++++++++++++++ output_tests/slices/slices/int32/types.go | 3 + output_tests/slices/slices/int8/json_test.go | 139 ++++++++++++++++++ output_tests/slices/slices/int8/types.go | 3 + .../slices/slices/ptr_string/json_test.go | 139 ++++++++++++++++++ .../slices/slices/ptr_string/types.go | 3 + .../slices/slices/string/json_test.go | 139 ++++++++++++++++++ output_tests/slices/slices/string/types.go | 3 + .../slices/slices/struct_empty/json_test.go | 139 ++++++++++++++++++ .../slices/slices/struct_empty/types.go | 3 + .../slices/struct_ptr_string/json_test.go | 139 ++++++++++++++++++ .../slices/slices/struct_ptr_string/types.go | 5 + .../slices/struct_ptrs_string/json_test.go | 139 ++++++++++++++++++ .../slices/slices/struct_ptrs_string/types.go | 7 + .../slices/slices/struct_string/json_test.go | 139 ++++++++++++++++++ .../slices/slices/struct_string/types.go | 5 + .../slices/slices/struct_strings/json_test.go | 139 ++++++++++++++++++ .../slices/slices/struct_strings/types.go | 7 + 24 files changed, 1716 insertions(+) create mode 100644 output_tests/slices/slices/bool/json_test.go create mode 100644 output_tests/slices/slices/bool/types.go create mode 100644 output_tests/slices/slices/byte/json_test.go create mode 100644 output_tests/slices/slices/byte/types.go create mode 100644 output_tests/slices/slices/float64/json_test.go create mode 100644 output_tests/slices/slices/float64/types.go create mode 100644 output_tests/slices/slices/int32/json_test.go create mode 100644 output_tests/slices/slices/int32/types.go create mode 100644 output_tests/slices/slices/int8/json_test.go create mode 100644 output_tests/slices/slices/int8/types.go create mode 100644 output_tests/slices/slices/ptr_string/json_test.go create mode 100644 output_tests/slices/slices/ptr_string/types.go create mode 100644 output_tests/slices/slices/string/json_test.go create mode 100644 output_tests/slices/slices/string/types.go create mode 100644 output_tests/slices/slices/struct_empty/json_test.go create mode 100644 output_tests/slices/slices/struct_empty/types.go create mode 100644 output_tests/slices/slices/struct_ptr_string/json_test.go create mode 100644 output_tests/slices/slices/struct_ptr_string/types.go create mode 100644 output_tests/slices/slices/struct_ptrs_string/json_test.go create mode 100644 output_tests/slices/slices/struct_ptrs_string/types.go create mode 100644 output_tests/slices/slices/struct_string/json_test.go create mode 100644 output_tests/slices/slices/struct_string/types.go create mode 100644 output_tests/slices/slices/struct_strings/json_test.go create mode 100644 output_tests/slices/slices/struct_strings/types.go diff --git a/output_tests/slices/slices/bool/json_test.go b/output_tests/slices/slices/bool/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slices/slices/bool/json_test.go @@ -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) +} diff --git a/output_tests/slices/slices/bool/types.go b/output_tests/slices/slices/bool/types.go new file mode 100644 index 0000000..2567469 --- /dev/null +++ b/output_tests/slices/slices/bool/types.go @@ -0,0 +1,3 @@ +package test + +type T [][]bool diff --git a/output_tests/slices/slices/byte/json_test.go b/output_tests/slices/slices/byte/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slices/slices/byte/json_test.go @@ -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) +} diff --git a/output_tests/slices/slices/byte/types.go b/output_tests/slices/slices/byte/types.go new file mode 100644 index 0000000..256b9c9 --- /dev/null +++ b/output_tests/slices/slices/byte/types.go @@ -0,0 +1,3 @@ +package test + +type T [][]byte diff --git a/output_tests/slices/slices/float64/json_test.go b/output_tests/slices/slices/float64/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slices/slices/float64/json_test.go @@ -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) +} diff --git a/output_tests/slices/slices/float64/types.go b/output_tests/slices/slices/float64/types.go new file mode 100644 index 0000000..a6a1439 --- /dev/null +++ b/output_tests/slices/slices/float64/types.go @@ -0,0 +1,3 @@ +package test + +type T [][]float64 diff --git a/output_tests/slices/slices/int32/json_test.go b/output_tests/slices/slices/int32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slices/slices/int32/json_test.go @@ -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) +} diff --git a/output_tests/slices/slices/int32/types.go b/output_tests/slices/slices/int32/types.go new file mode 100644 index 0000000..03f2804 --- /dev/null +++ b/output_tests/slices/slices/int32/types.go @@ -0,0 +1,3 @@ +package test + +type T [][]int32 diff --git a/output_tests/slices/slices/int8/json_test.go b/output_tests/slices/slices/int8/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slices/slices/int8/json_test.go @@ -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) +} diff --git a/output_tests/slices/slices/int8/types.go b/output_tests/slices/slices/int8/types.go new file mode 100644 index 0000000..5027f30 --- /dev/null +++ b/output_tests/slices/slices/int8/types.go @@ -0,0 +1,3 @@ +package test + +type T [][]int8 diff --git a/output_tests/slices/slices/ptr_string/json_test.go b/output_tests/slices/slices/ptr_string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slices/slices/ptr_string/json_test.go @@ -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) +} diff --git a/output_tests/slices/slices/ptr_string/types.go b/output_tests/slices/slices/ptr_string/types.go new file mode 100644 index 0000000..73a419c --- /dev/null +++ b/output_tests/slices/slices/ptr_string/types.go @@ -0,0 +1,3 @@ +package test + +type T [][]*string diff --git a/output_tests/slices/slices/string/json_test.go b/output_tests/slices/slices/string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slices/slices/string/json_test.go @@ -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) +} diff --git a/output_tests/slices/slices/string/types.go b/output_tests/slices/slices/string/types.go new file mode 100644 index 0000000..14d10c5 --- /dev/null +++ b/output_tests/slices/slices/string/types.go @@ -0,0 +1,3 @@ +package test + +type T [][]string diff --git a/output_tests/slices/slices/struct_empty/json_test.go b/output_tests/slices/slices/struct_empty/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slices/slices/struct_empty/json_test.go @@ -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) +} diff --git a/output_tests/slices/slices/struct_empty/types.go b/output_tests/slices/slices/struct_empty/types.go new file mode 100644 index 0000000..d454cb8 --- /dev/null +++ b/output_tests/slices/slices/struct_empty/types.go @@ -0,0 +1,3 @@ +package test + +type T [][]struct{} diff --git a/output_tests/slices/slices/struct_ptr_string/json_test.go b/output_tests/slices/slices/struct_ptr_string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slices/slices/struct_ptr_string/json_test.go @@ -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) +} diff --git a/output_tests/slices/slices/struct_ptr_string/types.go b/output_tests/slices/slices/struct_ptr_string/types.go new file mode 100644 index 0000000..3ee04c7 --- /dev/null +++ b/output_tests/slices/slices/struct_ptr_string/types.go @@ -0,0 +1,5 @@ +package test + +type T [][]struct { + F1 *string +} diff --git a/output_tests/slices/slices/struct_ptrs_string/json_test.go b/output_tests/slices/slices/struct_ptrs_string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slices/slices/struct_ptrs_string/json_test.go @@ -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) +} diff --git a/output_tests/slices/slices/struct_ptrs_string/types.go b/output_tests/slices/slices/struct_ptrs_string/types.go new file mode 100644 index 0000000..c795d67 --- /dev/null +++ b/output_tests/slices/slices/struct_ptrs_string/types.go @@ -0,0 +1,7 @@ +package test + +type T [][]struct { + F1 *string + F2 *string + F3 *string +} diff --git a/output_tests/slices/slices/struct_string/json_test.go b/output_tests/slices/slices/struct_string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slices/slices/struct_string/json_test.go @@ -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) +} diff --git a/output_tests/slices/slices/struct_string/types.go b/output_tests/slices/slices/struct_string/types.go new file mode 100644 index 0000000..cb5fea9 --- /dev/null +++ b/output_tests/slices/slices/struct_string/types.go @@ -0,0 +1,5 @@ +package test + +type T [][]struct { + F1 string +} diff --git a/output_tests/slices/slices/struct_strings/json_test.go b/output_tests/slices/slices/struct_strings/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slices/slices/struct_strings/json_test.go @@ -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) +} diff --git a/output_tests/slices/slices/struct_strings/types.go b/output_tests/slices/slices/struct_strings/types.go new file mode 100644 index 0000000..b9903d9 --- /dev/null +++ b/output_tests/slices/slices/struct_strings/types.go @@ -0,0 +1,7 @@ +package test + +type T [][]struct { + F1 string + F2 string + F3 string +} From 9fc858b117875ad719898d424cd3aebf373e2818 Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 18:53:20 +0100 Subject: [PATCH 06/18] Reorganize output_tests for maps As I added more and more cases, I found the dir structure hard to navigate. The new structure follows how you read a type: e.g. map[string]*string -> map/string/ptr_string This exposed some redundant cases and some missing cases, too. Now map[string] is the "main" test case that exercises all the variants of value types, and the other key types are just to prove that they basically work. --- .../bool => map/int16/string}/json_test.go | 0 output_tests/map/int16/string/types.go | 3 + .../byte => map/int32/string}/json_test.go | 0 .../builtins => map}/int32/string/types.go | 0 .../float32 => map/int8/string}/json_test.go | 0 output_tests/map/int8/string/types.go | 3 + .../float64 => map/string/bool}/json_test.go | 0 .../builtins => map}/string/bool/types.go | 0 .../int32 => map/string/byte}/json_test.go | 0 .../builtins => map}/string/byte/types.go | 0 .../int8 => map/string/float64}/json_test.go | 0 .../builtins => map}/string/float64/types.go | 0 .../map => map/string/int32}/json_test.go | 0 .../builtins => map}/string/int32/types.go | 0 .../string/map_string_string}/json_test.go | 0 .../string/map_string_string}/types.go | 0 .../string/ptr_bool}/json_test.go | 0 .../pointers => map}/string/ptr_bool/types.go | 0 .../string/ptr_float64}/json_test.go | 0 .../string/ptr_float64/types.go | 0 .../string/ptr_int32}/json_test.go | 0 .../string/ptr_int32/types.go | 0 .../ptr_map_string_string}/json_test.go | 0 .../map/string/ptr_map_string_string/types.go | 3 + .../string/ptr_slice_string}/json_test.go | 0 .../map/string/ptr_slice_string/types.go | 3 + .../string/ptr_string}/json_test.go | 0 .../string/ptr_string/types.go | 0 .../string/ptr_struct}/json_test.go | 0 .../int32 => map/string}/ptr_struct/types.go | 0 .../string/ptr_struct_various}/json_test.go | 0 .../string/ptr_struct_various}/types.go | 0 .../string/ptr_uint8}/json_test.go | 0 .../string/ptr_uint8/types.go | 0 .../string/slice_string}/json_test.go | 0 .../string/slice_string}/types.go | 0 .../int8 => map/string/string}/json_test.go | 0 .../builtins => map}/string/string/types.go | 0 .../string/string_alias}/json_test.go | 0 .../string/string_alias/types.go | 0 .../string/struct}/json_test.go | 0 .../int32 => map/string}/struct/types.go | 0 .../string/struct_empty}/json_test.go | 0 output_tests/map/string/struct_empty/types.go | 3 + .../string/struct_empty_alias}/json_test.go | 0 .../map/string/struct_empty_alias/types.go | 5 + .../string/struct_ptr_string}/json_test.go | 0 .../map/string/struct_ptr_string/types.go | 5 + .../string/struct_various}/json_test.go | 0 .../string/struct_various}/types.go | 4 +- .../string/uint8/json_test.go | 0 .../builtins => map}/string/uint8/types.go | 0 .../string_alias/string}/json_test.go | 0 .../string_alias/string/types.go | 0 .../string_alias/string_alias}/json_test.go | 0 .../string_alias/string_alias/types.go | 0 .../uint16/string}/json_test.go | 0 output_tests/map/uint16/string/types.go | 3 + .../uint32/string}/json_test.go | 0 output_tests/map/uint32/string/types.go | 3 + .../int32 => map/uint8/string}/json_test.go | 0 .../builtins => map}/uint8/string/types.go | 0 .../maps/builtins/int32/bool/types.go | 3 - .../maps/builtins/int32/byte/types.go | 3 - .../maps/builtins/int32/float32/types.go | 3 - .../maps/builtins/int32/float64/types.go | 3 - .../maps/builtins/int32/int32/types.go | 3 - .../maps/builtins/int32/int8/types.go | 3 - .../maps/builtins/int32/string_alias/types.go | 5 - .../maps/builtins/int32/uint8/types.go | 3 - .../maps/builtins/string/float32/types.go | 3 - .../maps/builtins/string/int8/types.go | 3 - .../maps/builtins/string/map/types.go | 3 - .../maps/builtins/string/slice/types.go | 3 - .../maps/builtins/string_alias/bool/types.go | 5 - .../maps/builtins/string_alias/byte/types.go | 5 - .../builtins/string_alias/float32/types.go | 5 - .../builtins/string_alias/float64/types.go | 5 - .../maps/builtins/string_alias/int32/types.go | 5 - .../builtins/string_alias/int8/json_test.go | 139 ------------------ .../maps/builtins/string_alias/int8/types.go | 5 - .../builtins/string_alias/map/json_test.go | 139 ------------------ .../maps/builtins/string_alias/map/types.go | 3 - .../string_alias/ptr_struct/json_test.go | 139 ------------------ .../builtins/string_alias/ptr_struct/types.go | 14 -- .../builtins/string_alias/slice/json_test.go | 139 ------------------ .../maps/builtins/string_alias/slice/types.go | 3 - .../builtins/string_alias/string/json_test.go | 139 ------------------ .../string_alias/string_alias/json_test.go | 139 ------------------ .../builtins/string_alias/struct/json_test.go | 139 ------------------ .../builtins/string_alias/struct/types.go | 14 -- .../builtins/string_alias/uint8/json_test.go | 139 ------------------ .../maps/builtins/string_alias/uint8/types.go | 5 - .../maps/builtins/uint8/bool/json_test.go | 139 ------------------ .../maps/builtins/uint8/bool/types.go | 3 - .../maps/builtins/uint8/byte/json_test.go | 139 ------------------ .../maps/builtins/uint8/byte/types.go | 3 - .../maps/builtins/uint8/float32/json_test.go | 139 ------------------ .../maps/builtins/uint8/float32/types.go | 3 - .../maps/builtins/uint8/float64/json_test.go | 139 ------------------ .../maps/builtins/uint8/float64/types.go | 3 - .../maps/builtins/uint8/int32/json_test.go | 139 ------------------ .../maps/builtins/uint8/int32/types.go | 3 - .../maps/builtins/uint8/int8/json_test.go | 139 ------------------ .../maps/builtins/uint8/int8/types.go | 3 - .../maps/builtins/uint8/map/json_test.go | 139 ------------------ output_tests/maps/builtins/uint8/map/types.go | 3 - .../builtins/uint8/ptr_struct/json_test.go | 139 ------------------ .../maps/builtins/uint8/ptr_struct/types.go | 14 -- .../maps/builtins/uint8/slice/json_test.go | 139 ------------------ .../maps/builtins/uint8/slice/types.go | 3 - .../maps/builtins/uint8/string/json_test.go | 139 ------------------ .../builtins/uint8/string_alias/json_test.go | 139 ------------------ .../maps/builtins/uint8/string_alias/types.go | 5 - .../maps/builtins/uint8/struct/json_test.go | 139 ------------------ .../maps/builtins/uint8/struct/types.go | 14 -- .../maps/builtins/uint8/uint8/json_test.go | 139 ------------------ .../maps/builtins/uint8/uint8/types.go | 3 - .../maps/pointers/int16/ptr_bool/json_test.go | 139 ------------------ .../maps/pointers/int16/ptr_bool/types.go | 3 - .../pointers/int16/ptr_float64/json_test.go | 139 ------------------ .../maps/pointers/int16/ptr_float64/types.go | 3 - .../pointers/int16/ptr_int32/json_test.go | 139 ------------------ .../maps/pointers/int16/ptr_int32/types.go | 3 - .../pointers/int16/ptr_string/json_test.go | 139 ------------------ .../maps/pointers/int16/ptr_string/types.go | 3 - .../pointers/int16/ptr_uint8/json_test.go | 139 ------------------ .../maps/pointers/int16/ptr_uint8/types.go | 3 - .../pointers/string/ptr_bool/json_test.go | 139 ------------------ .../pointers/string/ptr_float64/json_test.go | 139 ------------------ .../pointers/string/ptr_int32/json_test.go | 139 ------------------ .../pointers/string/ptr_string/json_test.go | 139 ------------------ .../pointers/string/ptr_uint8/json_test.go | 139 ------------------ .../pointers/uint16/ptr_bool/json_test.go | 139 ------------------ .../maps/pointers/uint16/ptr_bool/types.go | 3 - .../pointers/uint16/ptr_float64/json_test.go | 139 ------------------ .../maps/pointers/uint16/ptr_float64/types.go | 3 - .../pointers/uint16/ptr_int32/json_test.go | 139 ------------------ .../maps/pointers/uint16/ptr_int32/types.go | 3 - .../pointers/uint16/ptr_string/json_test.go | 139 ------------------ .../maps/pointers/uint16/ptr_string/types.go | 3 - .../pointers/uint16/ptr_uint8/json_test.go | 139 ------------------ .../maps/pointers/uint16/ptr_uint8/types.go | 3 - 143 files changed, 32 insertions(+), 5204 deletions(-) rename output_tests/{maps/builtins/int32/bool => map/int16/string}/json_test.go (100%) create mode 100644 output_tests/map/int16/string/types.go rename output_tests/{maps/builtins/int32/byte => map/int32/string}/json_test.go (100%) rename output_tests/{maps/builtins => map}/int32/string/types.go (100%) rename output_tests/{maps/builtins/int32/float32 => map/int8/string}/json_test.go (100%) create mode 100644 output_tests/map/int8/string/types.go rename output_tests/{maps/builtins/int32/float64 => map/string/bool}/json_test.go (100%) rename output_tests/{maps/builtins => map}/string/bool/types.go (100%) rename output_tests/{maps/builtins/int32/int32 => map/string/byte}/json_test.go (100%) rename output_tests/{maps/builtins => map}/string/byte/types.go (100%) rename output_tests/{maps/builtins/int32/int8 => map/string/float64}/json_test.go (100%) rename output_tests/{maps/builtins => map}/string/float64/types.go (100%) rename output_tests/{maps/builtins/int32/map => map/string/int32}/json_test.go (100%) rename output_tests/{maps/builtins => map}/string/int32/types.go (100%) rename output_tests/{maps/builtins/int32/ptr_struct => map/string/map_string_string}/json_test.go (100%) rename output_tests/{maps/builtins/int32/map => map/string/map_string_string}/types.go (100%) rename output_tests/{maps/builtins/int32/slice => map/string/ptr_bool}/json_test.go (100%) rename output_tests/{maps/pointers => map}/string/ptr_bool/types.go (100%) rename output_tests/{maps/builtins/int32/string => map/string/ptr_float64}/json_test.go (100%) rename output_tests/{maps/pointers => map}/string/ptr_float64/types.go (100%) rename output_tests/{maps/builtins/int32/string_alias => map/string/ptr_int32}/json_test.go (100%) rename output_tests/{maps/pointers => map}/string/ptr_int32/types.go (100%) rename output_tests/{maps/builtins/int32/struct => map/string/ptr_map_string_string}/json_test.go (100%) create mode 100644 output_tests/map/string/ptr_map_string_string/types.go rename output_tests/{maps/builtins/int32/uint8 => map/string/ptr_slice_string}/json_test.go (100%) create mode 100644 output_tests/map/string/ptr_slice_string/types.go rename output_tests/{maps/builtins/string/bool => map/string/ptr_string}/json_test.go (100%) rename output_tests/{maps/pointers => map}/string/ptr_string/types.go (100%) rename output_tests/{maps/builtins/string/byte => map/string/ptr_struct}/json_test.go (100%) rename output_tests/{maps/builtins/int32 => map/string}/ptr_struct/types.go (100%) rename output_tests/{maps/builtins/string/float32 => map/string/ptr_struct_various}/json_test.go (100%) rename output_tests/{maps/builtins/string/ptr_struct => map/string/ptr_struct_various}/types.go (100%) rename output_tests/{maps/builtins/string/float64 => map/string/ptr_uint8}/json_test.go (100%) rename output_tests/{maps/pointers => map}/string/ptr_uint8/types.go (100%) rename output_tests/{maps/builtins/string/int32 => map/string/slice_string}/json_test.go (100%) rename output_tests/{maps/builtins/int32/slice => map/string/slice_string}/types.go (100%) rename output_tests/{maps/builtins/string/int8 => map/string/string}/json_test.go (100%) rename output_tests/{maps/builtins => map}/string/string/types.go (100%) rename output_tests/{maps/builtins/string/map => map/string/string_alias}/json_test.go (100%) rename output_tests/{maps/builtins => map}/string/string_alias/types.go (100%) rename output_tests/{maps/builtins/string/ptr_struct => map/string/struct}/json_test.go (100%) rename output_tests/{maps/builtins/int32 => map/string}/struct/types.go (100%) rename output_tests/{maps/builtins/string/slice => map/string/struct_empty}/json_test.go (100%) create mode 100644 output_tests/map/string/struct_empty/types.go rename output_tests/{maps/builtins/string/string => map/string/struct_empty_alias}/json_test.go (100%) create mode 100644 output_tests/map/string/struct_empty_alias/types.go rename output_tests/{maps/builtins/string/string_alias => map/string/struct_ptr_string}/json_test.go (100%) create mode 100644 output_tests/map/string/struct_ptr_string/types.go rename output_tests/{maps/builtins/string/struct => map/string/struct_various}/json_test.go (100%) rename output_tests/{maps/builtins/string/struct => map/string/struct_various}/types.go (73%) rename output_tests/{maps/builtins => map}/string/uint8/json_test.go (100%) rename output_tests/{maps/builtins => map}/string/uint8/types.go (100%) rename output_tests/{maps/builtins/string_alias/bool => map/string_alias/string}/json_test.go (100%) rename output_tests/{maps/builtins => map}/string_alias/string/types.go (100%) rename output_tests/{maps/builtins/string_alias/byte => map/string_alias/string_alias}/json_test.go (100%) rename output_tests/{maps/builtins => map}/string_alias/string_alias/types.go (100%) rename output_tests/{maps/builtins/string_alias/float32 => map/uint16/string}/json_test.go (100%) create mode 100644 output_tests/map/uint16/string/types.go rename output_tests/{maps/builtins/string_alias/float64 => map/uint32/string}/json_test.go (100%) create mode 100644 output_tests/map/uint32/string/types.go rename output_tests/{maps/builtins/string_alias/int32 => map/uint8/string}/json_test.go (100%) rename output_tests/{maps/builtins => map}/uint8/string/types.go (100%) delete mode 100644 output_tests/maps/builtins/int32/bool/types.go delete mode 100644 output_tests/maps/builtins/int32/byte/types.go delete mode 100644 output_tests/maps/builtins/int32/float32/types.go delete mode 100644 output_tests/maps/builtins/int32/float64/types.go delete mode 100644 output_tests/maps/builtins/int32/int32/types.go delete mode 100644 output_tests/maps/builtins/int32/int8/types.go delete mode 100644 output_tests/maps/builtins/int32/string_alias/types.go delete mode 100644 output_tests/maps/builtins/int32/uint8/types.go delete mode 100644 output_tests/maps/builtins/string/float32/types.go delete mode 100644 output_tests/maps/builtins/string/int8/types.go delete mode 100644 output_tests/maps/builtins/string/map/types.go delete mode 100644 output_tests/maps/builtins/string/slice/types.go delete mode 100644 output_tests/maps/builtins/string_alias/bool/types.go delete mode 100644 output_tests/maps/builtins/string_alias/byte/types.go delete mode 100644 output_tests/maps/builtins/string_alias/float32/types.go delete mode 100644 output_tests/maps/builtins/string_alias/float64/types.go delete mode 100644 output_tests/maps/builtins/string_alias/int32/types.go delete mode 100644 output_tests/maps/builtins/string_alias/int8/json_test.go delete mode 100644 output_tests/maps/builtins/string_alias/int8/types.go delete mode 100644 output_tests/maps/builtins/string_alias/map/json_test.go delete mode 100644 output_tests/maps/builtins/string_alias/map/types.go delete mode 100644 output_tests/maps/builtins/string_alias/ptr_struct/json_test.go delete mode 100644 output_tests/maps/builtins/string_alias/ptr_struct/types.go delete mode 100644 output_tests/maps/builtins/string_alias/slice/json_test.go delete mode 100644 output_tests/maps/builtins/string_alias/slice/types.go delete mode 100644 output_tests/maps/builtins/string_alias/string/json_test.go delete mode 100644 output_tests/maps/builtins/string_alias/string_alias/json_test.go delete mode 100644 output_tests/maps/builtins/string_alias/struct/json_test.go delete mode 100644 output_tests/maps/builtins/string_alias/struct/types.go delete mode 100644 output_tests/maps/builtins/string_alias/uint8/json_test.go delete mode 100644 output_tests/maps/builtins/string_alias/uint8/types.go delete mode 100644 output_tests/maps/builtins/uint8/bool/json_test.go delete mode 100644 output_tests/maps/builtins/uint8/bool/types.go delete mode 100644 output_tests/maps/builtins/uint8/byte/json_test.go delete mode 100644 output_tests/maps/builtins/uint8/byte/types.go delete mode 100644 output_tests/maps/builtins/uint8/float32/json_test.go delete mode 100644 output_tests/maps/builtins/uint8/float32/types.go delete mode 100644 output_tests/maps/builtins/uint8/float64/json_test.go delete mode 100644 output_tests/maps/builtins/uint8/float64/types.go delete mode 100644 output_tests/maps/builtins/uint8/int32/json_test.go delete mode 100644 output_tests/maps/builtins/uint8/int32/types.go delete mode 100644 output_tests/maps/builtins/uint8/int8/json_test.go delete mode 100644 output_tests/maps/builtins/uint8/int8/types.go delete mode 100644 output_tests/maps/builtins/uint8/map/json_test.go delete mode 100644 output_tests/maps/builtins/uint8/map/types.go delete mode 100644 output_tests/maps/builtins/uint8/ptr_struct/json_test.go delete mode 100644 output_tests/maps/builtins/uint8/ptr_struct/types.go delete mode 100644 output_tests/maps/builtins/uint8/slice/json_test.go delete mode 100644 output_tests/maps/builtins/uint8/slice/types.go delete mode 100644 output_tests/maps/builtins/uint8/string/json_test.go delete mode 100644 output_tests/maps/builtins/uint8/string_alias/json_test.go delete mode 100644 output_tests/maps/builtins/uint8/string_alias/types.go delete mode 100644 output_tests/maps/builtins/uint8/struct/json_test.go delete mode 100644 output_tests/maps/builtins/uint8/struct/types.go delete mode 100644 output_tests/maps/builtins/uint8/uint8/json_test.go delete mode 100644 output_tests/maps/builtins/uint8/uint8/types.go delete mode 100644 output_tests/maps/pointers/int16/ptr_bool/json_test.go delete mode 100644 output_tests/maps/pointers/int16/ptr_bool/types.go delete mode 100644 output_tests/maps/pointers/int16/ptr_float64/json_test.go delete mode 100644 output_tests/maps/pointers/int16/ptr_float64/types.go delete mode 100644 output_tests/maps/pointers/int16/ptr_int32/json_test.go delete mode 100644 output_tests/maps/pointers/int16/ptr_int32/types.go delete mode 100644 output_tests/maps/pointers/int16/ptr_string/json_test.go delete mode 100644 output_tests/maps/pointers/int16/ptr_string/types.go delete mode 100644 output_tests/maps/pointers/int16/ptr_uint8/json_test.go delete mode 100644 output_tests/maps/pointers/int16/ptr_uint8/types.go delete mode 100644 output_tests/maps/pointers/string/ptr_bool/json_test.go delete mode 100644 output_tests/maps/pointers/string/ptr_float64/json_test.go delete mode 100644 output_tests/maps/pointers/string/ptr_int32/json_test.go delete mode 100644 output_tests/maps/pointers/string/ptr_string/json_test.go delete mode 100644 output_tests/maps/pointers/string/ptr_uint8/json_test.go delete mode 100644 output_tests/maps/pointers/uint16/ptr_bool/json_test.go delete mode 100644 output_tests/maps/pointers/uint16/ptr_bool/types.go delete mode 100644 output_tests/maps/pointers/uint16/ptr_float64/json_test.go delete mode 100644 output_tests/maps/pointers/uint16/ptr_float64/types.go delete mode 100644 output_tests/maps/pointers/uint16/ptr_int32/json_test.go delete mode 100644 output_tests/maps/pointers/uint16/ptr_int32/types.go delete mode 100644 output_tests/maps/pointers/uint16/ptr_string/json_test.go delete mode 100644 output_tests/maps/pointers/uint16/ptr_string/types.go delete mode 100644 output_tests/maps/pointers/uint16/ptr_uint8/json_test.go delete mode 100644 output_tests/maps/pointers/uint16/ptr_uint8/types.go diff --git a/output_tests/maps/builtins/int32/bool/json_test.go b/output_tests/map/int16/string/json_test.go similarity index 100% rename from output_tests/maps/builtins/int32/bool/json_test.go rename to output_tests/map/int16/string/json_test.go diff --git a/output_tests/map/int16/string/types.go b/output_tests/map/int16/string/types.go new file mode 100644 index 0000000..f4061d9 --- /dev/null +++ b/output_tests/map/int16/string/types.go @@ -0,0 +1,3 @@ +package test + +type T map[int16]string diff --git a/output_tests/maps/builtins/int32/byte/json_test.go b/output_tests/map/int32/string/json_test.go similarity index 100% rename from output_tests/maps/builtins/int32/byte/json_test.go rename to output_tests/map/int32/string/json_test.go diff --git a/output_tests/maps/builtins/int32/string/types.go b/output_tests/map/int32/string/types.go similarity index 100% rename from output_tests/maps/builtins/int32/string/types.go rename to output_tests/map/int32/string/types.go diff --git a/output_tests/maps/builtins/int32/float32/json_test.go b/output_tests/map/int8/string/json_test.go similarity index 100% rename from output_tests/maps/builtins/int32/float32/json_test.go rename to output_tests/map/int8/string/json_test.go diff --git a/output_tests/map/int8/string/types.go b/output_tests/map/int8/string/types.go new file mode 100644 index 0000000..6bf6054 --- /dev/null +++ b/output_tests/map/int8/string/types.go @@ -0,0 +1,3 @@ +package test + +type T map[int8]string diff --git a/output_tests/maps/builtins/int32/float64/json_test.go b/output_tests/map/string/bool/json_test.go similarity index 100% rename from output_tests/maps/builtins/int32/float64/json_test.go rename to output_tests/map/string/bool/json_test.go diff --git a/output_tests/maps/builtins/string/bool/types.go b/output_tests/map/string/bool/types.go similarity index 100% rename from output_tests/maps/builtins/string/bool/types.go rename to output_tests/map/string/bool/types.go diff --git a/output_tests/maps/builtins/int32/int32/json_test.go b/output_tests/map/string/byte/json_test.go similarity index 100% rename from output_tests/maps/builtins/int32/int32/json_test.go rename to output_tests/map/string/byte/json_test.go diff --git a/output_tests/maps/builtins/string/byte/types.go b/output_tests/map/string/byte/types.go similarity index 100% rename from output_tests/maps/builtins/string/byte/types.go rename to output_tests/map/string/byte/types.go diff --git a/output_tests/maps/builtins/int32/int8/json_test.go b/output_tests/map/string/float64/json_test.go similarity index 100% rename from output_tests/maps/builtins/int32/int8/json_test.go rename to output_tests/map/string/float64/json_test.go diff --git a/output_tests/maps/builtins/string/float64/types.go b/output_tests/map/string/float64/types.go similarity index 100% rename from output_tests/maps/builtins/string/float64/types.go rename to output_tests/map/string/float64/types.go diff --git a/output_tests/maps/builtins/int32/map/json_test.go b/output_tests/map/string/int32/json_test.go similarity index 100% rename from output_tests/maps/builtins/int32/map/json_test.go rename to output_tests/map/string/int32/json_test.go diff --git a/output_tests/maps/builtins/string/int32/types.go b/output_tests/map/string/int32/types.go similarity index 100% rename from output_tests/maps/builtins/string/int32/types.go rename to output_tests/map/string/int32/types.go diff --git a/output_tests/maps/builtins/int32/ptr_struct/json_test.go b/output_tests/map/string/map_string_string/json_test.go similarity index 100% rename from output_tests/maps/builtins/int32/ptr_struct/json_test.go rename to output_tests/map/string/map_string_string/json_test.go diff --git a/output_tests/maps/builtins/int32/map/types.go b/output_tests/map/string/map_string_string/types.go similarity index 100% rename from output_tests/maps/builtins/int32/map/types.go rename to output_tests/map/string/map_string_string/types.go diff --git a/output_tests/maps/builtins/int32/slice/json_test.go b/output_tests/map/string/ptr_bool/json_test.go similarity index 100% rename from output_tests/maps/builtins/int32/slice/json_test.go rename to output_tests/map/string/ptr_bool/json_test.go diff --git a/output_tests/maps/pointers/string/ptr_bool/types.go b/output_tests/map/string/ptr_bool/types.go similarity index 100% rename from output_tests/maps/pointers/string/ptr_bool/types.go rename to output_tests/map/string/ptr_bool/types.go diff --git a/output_tests/maps/builtins/int32/string/json_test.go b/output_tests/map/string/ptr_float64/json_test.go similarity index 100% rename from output_tests/maps/builtins/int32/string/json_test.go rename to output_tests/map/string/ptr_float64/json_test.go diff --git a/output_tests/maps/pointers/string/ptr_float64/types.go b/output_tests/map/string/ptr_float64/types.go similarity index 100% rename from output_tests/maps/pointers/string/ptr_float64/types.go rename to output_tests/map/string/ptr_float64/types.go diff --git a/output_tests/maps/builtins/int32/string_alias/json_test.go b/output_tests/map/string/ptr_int32/json_test.go similarity index 100% rename from output_tests/maps/builtins/int32/string_alias/json_test.go rename to output_tests/map/string/ptr_int32/json_test.go diff --git a/output_tests/maps/pointers/string/ptr_int32/types.go b/output_tests/map/string/ptr_int32/types.go similarity index 100% rename from output_tests/maps/pointers/string/ptr_int32/types.go rename to output_tests/map/string/ptr_int32/types.go diff --git a/output_tests/maps/builtins/int32/struct/json_test.go b/output_tests/map/string/ptr_map_string_string/json_test.go similarity index 100% rename from output_tests/maps/builtins/int32/struct/json_test.go rename to output_tests/map/string/ptr_map_string_string/json_test.go diff --git a/output_tests/map/string/ptr_map_string_string/types.go b/output_tests/map/string/ptr_map_string_string/types.go new file mode 100644 index 0000000..fb901b0 --- /dev/null +++ b/output_tests/map/string/ptr_map_string_string/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]*map[string]string diff --git a/output_tests/maps/builtins/int32/uint8/json_test.go b/output_tests/map/string/ptr_slice_string/json_test.go similarity index 100% rename from output_tests/maps/builtins/int32/uint8/json_test.go rename to output_tests/map/string/ptr_slice_string/json_test.go diff --git a/output_tests/map/string/ptr_slice_string/types.go b/output_tests/map/string/ptr_slice_string/types.go new file mode 100644 index 0000000..52cc262 --- /dev/null +++ b/output_tests/map/string/ptr_slice_string/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]*[]string diff --git a/output_tests/maps/builtins/string/bool/json_test.go b/output_tests/map/string/ptr_string/json_test.go similarity index 100% rename from output_tests/maps/builtins/string/bool/json_test.go rename to output_tests/map/string/ptr_string/json_test.go diff --git a/output_tests/maps/pointers/string/ptr_string/types.go b/output_tests/map/string/ptr_string/types.go similarity index 100% rename from output_tests/maps/pointers/string/ptr_string/types.go rename to output_tests/map/string/ptr_string/types.go diff --git a/output_tests/maps/builtins/string/byte/json_test.go b/output_tests/map/string/ptr_struct/json_test.go similarity index 100% rename from output_tests/maps/builtins/string/byte/json_test.go rename to output_tests/map/string/ptr_struct/json_test.go diff --git a/output_tests/maps/builtins/int32/ptr_struct/types.go b/output_tests/map/string/ptr_struct/types.go similarity index 100% rename from output_tests/maps/builtins/int32/ptr_struct/types.go rename to output_tests/map/string/ptr_struct/types.go diff --git a/output_tests/maps/builtins/string/float32/json_test.go b/output_tests/map/string/ptr_struct_various/json_test.go similarity index 100% rename from output_tests/maps/builtins/string/float32/json_test.go rename to output_tests/map/string/ptr_struct_various/json_test.go diff --git a/output_tests/maps/builtins/string/ptr_struct/types.go b/output_tests/map/string/ptr_struct_various/types.go similarity index 100% rename from output_tests/maps/builtins/string/ptr_struct/types.go rename to output_tests/map/string/ptr_struct_various/types.go diff --git a/output_tests/maps/builtins/string/float64/json_test.go b/output_tests/map/string/ptr_uint8/json_test.go similarity index 100% rename from output_tests/maps/builtins/string/float64/json_test.go rename to output_tests/map/string/ptr_uint8/json_test.go diff --git a/output_tests/maps/pointers/string/ptr_uint8/types.go b/output_tests/map/string/ptr_uint8/types.go similarity index 100% rename from output_tests/maps/pointers/string/ptr_uint8/types.go rename to output_tests/map/string/ptr_uint8/types.go diff --git a/output_tests/maps/builtins/string/int32/json_test.go b/output_tests/map/string/slice_string/json_test.go similarity index 100% rename from output_tests/maps/builtins/string/int32/json_test.go rename to output_tests/map/string/slice_string/json_test.go diff --git a/output_tests/maps/builtins/int32/slice/types.go b/output_tests/map/string/slice_string/types.go similarity index 100% rename from output_tests/maps/builtins/int32/slice/types.go rename to output_tests/map/string/slice_string/types.go diff --git a/output_tests/maps/builtins/string/int8/json_test.go b/output_tests/map/string/string/json_test.go similarity index 100% rename from output_tests/maps/builtins/string/int8/json_test.go rename to output_tests/map/string/string/json_test.go diff --git a/output_tests/maps/builtins/string/string/types.go b/output_tests/map/string/string/types.go similarity index 100% rename from output_tests/maps/builtins/string/string/types.go rename to output_tests/map/string/string/types.go diff --git a/output_tests/maps/builtins/string/map/json_test.go b/output_tests/map/string/string_alias/json_test.go similarity index 100% rename from output_tests/maps/builtins/string/map/json_test.go rename to output_tests/map/string/string_alias/json_test.go diff --git a/output_tests/maps/builtins/string/string_alias/types.go b/output_tests/map/string/string_alias/types.go similarity index 100% rename from output_tests/maps/builtins/string/string_alias/types.go rename to output_tests/map/string/string_alias/types.go diff --git a/output_tests/maps/builtins/string/ptr_struct/json_test.go b/output_tests/map/string/struct/json_test.go similarity index 100% rename from output_tests/maps/builtins/string/ptr_struct/json_test.go rename to output_tests/map/string/struct/json_test.go diff --git a/output_tests/maps/builtins/int32/struct/types.go b/output_tests/map/string/struct/types.go similarity index 100% rename from output_tests/maps/builtins/int32/struct/types.go rename to output_tests/map/string/struct/types.go diff --git a/output_tests/maps/builtins/string/slice/json_test.go b/output_tests/map/string/struct_empty/json_test.go similarity index 100% rename from output_tests/maps/builtins/string/slice/json_test.go rename to output_tests/map/string/struct_empty/json_test.go diff --git a/output_tests/map/string/struct_empty/types.go b/output_tests/map/string/struct_empty/types.go new file mode 100644 index 0000000..0cf025f --- /dev/null +++ b/output_tests/map/string/struct_empty/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]struct{} diff --git a/output_tests/maps/builtins/string/string/json_test.go b/output_tests/map/string/struct_empty_alias/json_test.go similarity index 100% rename from output_tests/maps/builtins/string/string/json_test.go rename to output_tests/map/string/struct_empty_alias/json_test.go diff --git a/output_tests/map/string/struct_empty_alias/types.go b/output_tests/map/string/struct_empty_alias/types.go new file mode 100644 index 0000000..7b60ced --- /dev/null +++ b/output_tests/map/string/struct_empty_alias/types.go @@ -0,0 +1,5 @@ +package test + +type A struct{} + +type T map[string]A diff --git a/output_tests/maps/builtins/string/string_alias/json_test.go b/output_tests/map/string/struct_ptr_string/json_test.go similarity index 100% rename from output_tests/maps/builtins/string/string_alias/json_test.go rename to output_tests/map/string/struct_ptr_string/json_test.go diff --git a/output_tests/map/string/struct_ptr_string/types.go b/output_tests/map/string/struct_ptr_string/types.go new file mode 100644 index 0000000..7516dfc --- /dev/null +++ b/output_tests/map/string/struct_ptr_string/types.go @@ -0,0 +1,5 @@ +package test + +type T map[string]struct { + F *string +} diff --git a/output_tests/maps/builtins/string/struct/json_test.go b/output_tests/map/string/struct_various/json_test.go similarity index 100% rename from output_tests/maps/builtins/string/struct/json_test.go rename to output_tests/map/string/struct_various/json_test.go diff --git a/output_tests/maps/builtins/string/struct/types.go b/output_tests/map/string/struct_various/types.go similarity index 73% rename from output_tests/maps/builtins/string/struct/types.go rename to output_tests/map/string/struct_various/types.go index 263d4a6..832322a 100644 --- a/output_tests/maps/builtins/string/struct/types.go +++ b/output_tests/map/string/struct_various/types.go @@ -1,6 +1,6 @@ package test -type Struct struct { +type T map[string]struct { String string Int int32 Float float64 @@ -10,5 +10,3 @@ type Struct struct { Slice []string Map map[string]string } - -type T map[string]Struct diff --git a/output_tests/maps/builtins/string/uint8/json_test.go b/output_tests/map/string/uint8/json_test.go similarity index 100% rename from output_tests/maps/builtins/string/uint8/json_test.go rename to output_tests/map/string/uint8/json_test.go diff --git a/output_tests/maps/builtins/string/uint8/types.go b/output_tests/map/string/uint8/types.go similarity index 100% rename from output_tests/maps/builtins/string/uint8/types.go rename to output_tests/map/string/uint8/types.go diff --git a/output_tests/maps/builtins/string_alias/bool/json_test.go b/output_tests/map/string_alias/string/json_test.go similarity index 100% rename from output_tests/maps/builtins/string_alias/bool/json_test.go rename to output_tests/map/string_alias/string/json_test.go diff --git a/output_tests/maps/builtins/string_alias/string/types.go b/output_tests/map/string_alias/string/types.go similarity index 100% rename from output_tests/maps/builtins/string_alias/string/types.go rename to output_tests/map/string_alias/string/types.go diff --git a/output_tests/maps/builtins/string_alias/byte/json_test.go b/output_tests/map/string_alias/string_alias/json_test.go similarity index 100% rename from output_tests/maps/builtins/string_alias/byte/json_test.go rename to output_tests/map/string_alias/string_alias/json_test.go diff --git a/output_tests/maps/builtins/string_alias/string_alias/types.go b/output_tests/map/string_alias/string_alias/types.go similarity index 100% rename from output_tests/maps/builtins/string_alias/string_alias/types.go rename to output_tests/map/string_alias/string_alias/types.go diff --git a/output_tests/maps/builtins/string_alias/float32/json_test.go b/output_tests/map/uint16/string/json_test.go similarity index 100% rename from output_tests/maps/builtins/string_alias/float32/json_test.go rename to output_tests/map/uint16/string/json_test.go diff --git a/output_tests/map/uint16/string/types.go b/output_tests/map/uint16/string/types.go new file mode 100644 index 0000000..cc32109 --- /dev/null +++ b/output_tests/map/uint16/string/types.go @@ -0,0 +1,3 @@ +package test + +type T map[uint16]string diff --git a/output_tests/maps/builtins/string_alias/float64/json_test.go b/output_tests/map/uint32/string/json_test.go similarity index 100% rename from output_tests/maps/builtins/string_alias/float64/json_test.go rename to output_tests/map/uint32/string/json_test.go diff --git a/output_tests/map/uint32/string/types.go b/output_tests/map/uint32/string/types.go new file mode 100644 index 0000000..0ee156a --- /dev/null +++ b/output_tests/map/uint32/string/types.go @@ -0,0 +1,3 @@ +package test + +type T map[uint32]string diff --git a/output_tests/maps/builtins/string_alias/int32/json_test.go b/output_tests/map/uint8/string/json_test.go similarity index 100% rename from output_tests/maps/builtins/string_alias/int32/json_test.go rename to output_tests/map/uint8/string/json_test.go diff --git a/output_tests/maps/builtins/uint8/string/types.go b/output_tests/map/uint8/string/types.go similarity index 100% rename from output_tests/maps/builtins/uint8/string/types.go rename to output_tests/map/uint8/string/types.go diff --git a/output_tests/maps/builtins/int32/bool/types.go b/output_tests/maps/builtins/int32/bool/types.go deleted file mode 100644 index 7f21229..0000000 --- a/output_tests/maps/builtins/int32/bool/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[int32]bool diff --git a/output_tests/maps/builtins/int32/byte/types.go b/output_tests/maps/builtins/int32/byte/types.go deleted file mode 100644 index 8190cba..0000000 --- a/output_tests/maps/builtins/int32/byte/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[int32]byte diff --git a/output_tests/maps/builtins/int32/float32/types.go b/output_tests/maps/builtins/int32/float32/types.go deleted file mode 100644 index be7c27d..0000000 --- a/output_tests/maps/builtins/int32/float32/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[int32]float32 diff --git a/output_tests/maps/builtins/int32/float64/types.go b/output_tests/maps/builtins/int32/float64/types.go deleted file mode 100644 index 5f597d7..0000000 --- a/output_tests/maps/builtins/int32/float64/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[int32]float64 diff --git a/output_tests/maps/builtins/int32/int32/types.go b/output_tests/maps/builtins/int32/int32/types.go deleted file mode 100644 index 94e8940..0000000 --- a/output_tests/maps/builtins/int32/int32/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[int32]int32 diff --git a/output_tests/maps/builtins/int32/int8/types.go b/output_tests/maps/builtins/int32/int8/types.go deleted file mode 100644 index e2f3708..0000000 --- a/output_tests/maps/builtins/int32/int8/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[int32]int8 diff --git a/output_tests/maps/builtins/int32/string_alias/types.go b/output_tests/maps/builtins/int32/string_alias/types.go deleted file mode 100644 index d4af66b..0000000 --- a/output_tests/maps/builtins/int32/string_alias/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type StringAlias string - -type T map[int32]StringAlias diff --git a/output_tests/maps/builtins/int32/uint8/types.go b/output_tests/maps/builtins/int32/uint8/types.go deleted file mode 100644 index e2948b2..0000000 --- a/output_tests/maps/builtins/int32/uint8/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[int32]uint8 diff --git a/output_tests/maps/builtins/string/float32/types.go b/output_tests/maps/builtins/string/float32/types.go deleted file mode 100644 index e019053..0000000 --- a/output_tests/maps/builtins/string/float32/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[string]float32 diff --git a/output_tests/maps/builtins/string/int8/types.go b/output_tests/maps/builtins/string/int8/types.go deleted file mode 100644 index 1843c77..0000000 --- a/output_tests/maps/builtins/string/int8/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[string]int8 diff --git a/output_tests/maps/builtins/string/map/types.go b/output_tests/maps/builtins/string/map/types.go deleted file mode 100644 index cd51eed..0000000 --- a/output_tests/maps/builtins/string/map/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[string]map[string]string diff --git a/output_tests/maps/builtins/string/slice/types.go b/output_tests/maps/builtins/string/slice/types.go deleted file mode 100644 index 1e12e7d..0000000 --- a/output_tests/maps/builtins/string/slice/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[string][]string diff --git a/output_tests/maps/builtins/string_alias/bool/types.go b/output_tests/maps/builtins/string_alias/bool/types.go deleted file mode 100644 index f385400..0000000 --- a/output_tests/maps/builtins/string_alias/bool/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type StringAlias string - -type T map[StringAlias]bool diff --git a/output_tests/maps/builtins/string_alias/byte/types.go b/output_tests/maps/builtins/string_alias/byte/types.go deleted file mode 100644 index 665339f..0000000 --- a/output_tests/maps/builtins/string_alias/byte/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type StringAlias string - -type T map[StringAlias]byte diff --git a/output_tests/maps/builtins/string_alias/float32/types.go b/output_tests/maps/builtins/string_alias/float32/types.go deleted file mode 100644 index 93ea708..0000000 --- a/output_tests/maps/builtins/string_alias/float32/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type StringAlias string - -type T map[StringAlias]float32 diff --git a/output_tests/maps/builtins/string_alias/float64/types.go b/output_tests/maps/builtins/string_alias/float64/types.go deleted file mode 100644 index 10e8dbe..0000000 --- a/output_tests/maps/builtins/string_alias/float64/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type StringAlias string - -type T map[StringAlias]float64 diff --git a/output_tests/maps/builtins/string_alias/int32/types.go b/output_tests/maps/builtins/string_alias/int32/types.go deleted file mode 100644 index c0b8c1b..0000000 --- a/output_tests/maps/builtins/string_alias/int32/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type StringAlias string - -type T map[StringAlias]int32 diff --git a/output_tests/maps/builtins/string_alias/int8/json_test.go b/output_tests/maps/builtins/string_alias/int8/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/string_alias/int8/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/string_alias/int8/types.go b/output_tests/maps/builtins/string_alias/int8/types.go deleted file mode 100644 index a0b7de3..0000000 --- a/output_tests/maps/builtins/string_alias/int8/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type StringAlias string - -type T map[StringAlias]int8 diff --git a/output_tests/maps/builtins/string_alias/map/json_test.go b/output_tests/maps/builtins/string_alias/map/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/string_alias/map/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/string_alias/map/types.go b/output_tests/maps/builtins/string_alias/map/types.go deleted file mode 100644 index cd51eed..0000000 --- a/output_tests/maps/builtins/string_alias/map/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[string]map[string]string diff --git a/output_tests/maps/builtins/string_alias/ptr_struct/json_test.go b/output_tests/maps/builtins/string_alias/ptr_struct/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/string_alias/ptr_struct/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/string_alias/ptr_struct/types.go b/output_tests/maps/builtins/string_alias/ptr_struct/types.go deleted file mode 100644 index 0a1c237..0000000 --- a/output_tests/maps/builtins/string_alias/ptr_struct/types.go +++ /dev/null @@ -1,14 +0,0 @@ -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 diff --git a/output_tests/maps/builtins/string_alias/slice/json_test.go b/output_tests/maps/builtins/string_alias/slice/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/string_alias/slice/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/string_alias/slice/types.go b/output_tests/maps/builtins/string_alias/slice/types.go deleted file mode 100644 index 1e12e7d..0000000 --- a/output_tests/maps/builtins/string_alias/slice/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[string][]string diff --git a/output_tests/maps/builtins/string_alias/string/json_test.go b/output_tests/maps/builtins/string_alias/string/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/string_alias/string/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/string_alias/string_alias/json_test.go b/output_tests/maps/builtins/string_alias/string_alias/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/string_alias/string_alias/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/string_alias/struct/json_test.go b/output_tests/maps/builtins/string_alias/struct/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/string_alias/struct/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/string_alias/struct/types.go b/output_tests/maps/builtins/string_alias/struct/types.go deleted file mode 100644 index 263d4a6..0000000 --- a/output_tests/maps/builtins/string_alias/struct/types.go +++ /dev/null @@ -1,14 +0,0 @@ -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 diff --git a/output_tests/maps/builtins/string_alias/uint8/json_test.go b/output_tests/maps/builtins/string_alias/uint8/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/string_alias/uint8/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/string_alias/uint8/types.go b/output_tests/maps/builtins/string_alias/uint8/types.go deleted file mode 100644 index ef37a71..0000000 --- a/output_tests/maps/builtins/string_alias/uint8/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type StringAlias string - -type T map[StringAlias]uint8 diff --git a/output_tests/maps/builtins/uint8/bool/json_test.go b/output_tests/maps/builtins/uint8/bool/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/uint8/bool/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/uint8/bool/types.go b/output_tests/maps/builtins/uint8/bool/types.go deleted file mode 100644 index 1c32ae2..0000000 --- a/output_tests/maps/builtins/uint8/bool/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[uint8]bool diff --git a/output_tests/maps/builtins/uint8/byte/json_test.go b/output_tests/maps/builtins/uint8/byte/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/uint8/byte/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/uint8/byte/types.go b/output_tests/maps/builtins/uint8/byte/types.go deleted file mode 100644 index bddd3d0..0000000 --- a/output_tests/maps/builtins/uint8/byte/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[uint8]byte diff --git a/output_tests/maps/builtins/uint8/float32/json_test.go b/output_tests/maps/builtins/uint8/float32/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/uint8/float32/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/uint8/float32/types.go b/output_tests/maps/builtins/uint8/float32/types.go deleted file mode 100644 index 4ab4270..0000000 --- a/output_tests/maps/builtins/uint8/float32/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[uint8]float32 diff --git a/output_tests/maps/builtins/uint8/float64/json_test.go b/output_tests/maps/builtins/uint8/float64/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/uint8/float64/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/uint8/float64/types.go b/output_tests/maps/builtins/uint8/float64/types.go deleted file mode 100644 index a429f7e..0000000 --- a/output_tests/maps/builtins/uint8/float64/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[uint8]float64 diff --git a/output_tests/maps/builtins/uint8/int32/json_test.go b/output_tests/maps/builtins/uint8/int32/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/uint8/int32/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/uint8/int32/types.go b/output_tests/maps/builtins/uint8/int32/types.go deleted file mode 100644 index c2ce4be..0000000 --- a/output_tests/maps/builtins/uint8/int32/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[uint8]int32 diff --git a/output_tests/maps/builtins/uint8/int8/json_test.go b/output_tests/maps/builtins/uint8/int8/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/uint8/int8/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/uint8/int8/types.go b/output_tests/maps/builtins/uint8/int8/types.go deleted file mode 100644 index 01fa4d3..0000000 --- a/output_tests/maps/builtins/uint8/int8/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[uint8]int8 diff --git a/output_tests/maps/builtins/uint8/map/json_test.go b/output_tests/maps/builtins/uint8/map/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/uint8/map/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/uint8/map/types.go b/output_tests/maps/builtins/uint8/map/types.go deleted file mode 100644 index cd51eed..0000000 --- a/output_tests/maps/builtins/uint8/map/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[string]map[string]string diff --git a/output_tests/maps/builtins/uint8/ptr_struct/json_test.go b/output_tests/maps/builtins/uint8/ptr_struct/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/uint8/ptr_struct/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/uint8/ptr_struct/types.go b/output_tests/maps/builtins/uint8/ptr_struct/types.go deleted file mode 100644 index 0a1c237..0000000 --- a/output_tests/maps/builtins/uint8/ptr_struct/types.go +++ /dev/null @@ -1,14 +0,0 @@ -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 diff --git a/output_tests/maps/builtins/uint8/slice/json_test.go b/output_tests/maps/builtins/uint8/slice/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/uint8/slice/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/uint8/slice/types.go b/output_tests/maps/builtins/uint8/slice/types.go deleted file mode 100644 index 1e12e7d..0000000 --- a/output_tests/maps/builtins/uint8/slice/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[string][]string diff --git a/output_tests/maps/builtins/uint8/string/json_test.go b/output_tests/maps/builtins/uint8/string/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/uint8/string/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/uint8/string_alias/json_test.go b/output_tests/maps/builtins/uint8/string_alias/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/uint8/string_alias/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/uint8/string_alias/types.go b/output_tests/maps/builtins/uint8/string_alias/types.go deleted file mode 100644 index d8e81f3..0000000 --- a/output_tests/maps/builtins/uint8/string_alias/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type StringAlias string - -type T map[uint8]StringAlias diff --git a/output_tests/maps/builtins/uint8/struct/json_test.go b/output_tests/maps/builtins/uint8/struct/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/uint8/struct/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/uint8/struct/types.go b/output_tests/maps/builtins/uint8/struct/types.go deleted file mode 100644 index 263d4a6..0000000 --- a/output_tests/maps/builtins/uint8/struct/types.go +++ /dev/null @@ -1,14 +0,0 @@ -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 diff --git a/output_tests/maps/builtins/uint8/uint8/json_test.go b/output_tests/maps/builtins/uint8/uint8/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/builtins/uint8/uint8/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/builtins/uint8/uint8/types.go b/output_tests/maps/builtins/uint8/uint8/types.go deleted file mode 100644 index ee7f109..0000000 --- a/output_tests/maps/builtins/uint8/uint8/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[uint8]uint8 diff --git a/output_tests/maps/pointers/int16/ptr_bool/json_test.go b/output_tests/maps/pointers/int16/ptr_bool/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/int16/ptr_bool/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/int16/ptr_bool/types.go b/output_tests/maps/pointers/int16/ptr_bool/types.go deleted file mode 100644 index f49ad1c..0000000 --- a/output_tests/maps/pointers/int16/ptr_bool/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[int16]*bool diff --git a/output_tests/maps/pointers/int16/ptr_float64/json_test.go b/output_tests/maps/pointers/int16/ptr_float64/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/int16/ptr_float64/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/int16/ptr_float64/types.go b/output_tests/maps/pointers/int16/ptr_float64/types.go deleted file mode 100644 index 7fc988e..0000000 --- a/output_tests/maps/pointers/int16/ptr_float64/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[int16]*float64 diff --git a/output_tests/maps/pointers/int16/ptr_int32/json_test.go b/output_tests/maps/pointers/int16/ptr_int32/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/int16/ptr_int32/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/int16/ptr_int32/types.go b/output_tests/maps/pointers/int16/ptr_int32/types.go deleted file mode 100644 index 1c9e438..0000000 --- a/output_tests/maps/pointers/int16/ptr_int32/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[int16]*int32 diff --git a/output_tests/maps/pointers/int16/ptr_string/json_test.go b/output_tests/maps/pointers/int16/ptr_string/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/int16/ptr_string/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/int16/ptr_string/types.go b/output_tests/maps/pointers/int16/ptr_string/types.go deleted file mode 100644 index 04bc953..0000000 --- a/output_tests/maps/pointers/int16/ptr_string/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[int16]*string diff --git a/output_tests/maps/pointers/int16/ptr_uint8/json_test.go b/output_tests/maps/pointers/int16/ptr_uint8/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/int16/ptr_uint8/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/int16/ptr_uint8/types.go b/output_tests/maps/pointers/int16/ptr_uint8/types.go deleted file mode 100644 index 2f9baed..0000000 --- a/output_tests/maps/pointers/int16/ptr_uint8/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[int16]*uint8 diff --git a/output_tests/maps/pointers/string/ptr_bool/json_test.go b/output_tests/maps/pointers/string/ptr_bool/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/string/ptr_bool/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/string/ptr_float64/json_test.go b/output_tests/maps/pointers/string/ptr_float64/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/string/ptr_float64/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/string/ptr_int32/json_test.go b/output_tests/maps/pointers/string/ptr_int32/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/string/ptr_int32/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/string/ptr_string/json_test.go b/output_tests/maps/pointers/string/ptr_string/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/string/ptr_string/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/string/ptr_uint8/json_test.go b/output_tests/maps/pointers/string/ptr_uint8/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/string/ptr_uint8/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/uint16/ptr_bool/json_test.go b/output_tests/maps/pointers/uint16/ptr_bool/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/uint16/ptr_bool/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/uint16/ptr_bool/types.go b/output_tests/maps/pointers/uint16/ptr_bool/types.go deleted file mode 100644 index 9cdc0c8..0000000 --- a/output_tests/maps/pointers/uint16/ptr_bool/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[uint16]*bool diff --git a/output_tests/maps/pointers/uint16/ptr_float64/json_test.go b/output_tests/maps/pointers/uint16/ptr_float64/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/uint16/ptr_float64/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/uint16/ptr_float64/types.go b/output_tests/maps/pointers/uint16/ptr_float64/types.go deleted file mode 100644 index cfd5772..0000000 --- a/output_tests/maps/pointers/uint16/ptr_float64/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[uint16]*float64 diff --git a/output_tests/maps/pointers/uint16/ptr_int32/json_test.go b/output_tests/maps/pointers/uint16/ptr_int32/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/uint16/ptr_int32/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/uint16/ptr_int32/types.go b/output_tests/maps/pointers/uint16/ptr_int32/types.go deleted file mode 100644 index b472630..0000000 --- a/output_tests/maps/pointers/uint16/ptr_int32/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[uint16]*int32 diff --git a/output_tests/maps/pointers/uint16/ptr_string/json_test.go b/output_tests/maps/pointers/uint16/ptr_string/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/uint16/ptr_string/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/uint16/ptr_string/types.go b/output_tests/maps/pointers/uint16/ptr_string/types.go deleted file mode 100644 index 2b56c01..0000000 --- a/output_tests/maps/pointers/uint16/ptr_string/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[uint16]*string diff --git a/output_tests/maps/pointers/uint16/ptr_uint8/json_test.go b/output_tests/maps/pointers/uint16/ptr_uint8/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/maps/pointers/uint16/ptr_uint8/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/maps/pointers/uint16/ptr_uint8/types.go b/output_tests/maps/pointers/uint16/ptr_uint8/types.go deleted file mode 100644 index 5517914..0000000 --- a/output_tests/maps/pointers/uint16/ptr_uint8/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T map[uint16]*uint8 From f09f778ca9a00c46943c27657d0f0e1d93c9b067 Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 19:21:17 +0100 Subject: [PATCH 07/18] Reorganize output_tests for slices As I added more and more cases, I found the dir structure hard to navigate. The new structure follows how you read a type: e.g. []*string -> slice/ptr_string This exposed some redundant cases and some missing cases, too. --- .../ptr_struct => slice/bool}/json_test.go | 0 .../{slices/builtins => slice}/bool/types.go | 0 .../string/struct => slice/byte}/json_test.go | 0 .../{slices/builtins => slice}/byte/types.go | 0 .../bool => slice/float64}/json_test.go | 0 .../builtins => slice}/float64/types.go | 0 .../byte => slice/int32}/json_test.go | 0 .../{slices/builtins => slice}/int32/types.go | 0 .../map/int32_string}/json_test.go | 0 output_tests/slice/map/int32_string/types.go | 3 + .../map/string_string}/json_test.go | 0 output_tests/slice/map/string_string/types.go | 3 + .../int32 => slice/ptr_bool}/json_test.go | 0 .../pointers/bool => slice/ptr_bool}/types.go | 0 .../int8 => slice/ptr_float64}/json_test.go | 0 .../float64 => slice/ptr_float64}/types.go | 0 .../string => slice/ptr_int32}/json_test.go | 0 .../int32 => slice/ptr_int32}/types.go | 0 .../ptr_map/int32_string}/json_test.go | 0 .../slice/ptr_map/int32_string/types.go | 3 + .../ptr_map/string_string}/json_test.go | 0 .../slice/ptr_map/string_string/types.go | 3 + .../ptr_slice/bool}/json_test.go | 0 output_tests/slice/ptr_slice/bool/types.go | 3 + .../ptr_slice/byte}/json_test.go | 0 output_tests/slice/ptr_slice/byte/types.go | 3 + .../ptr_slice/float64}/json_test.go | 0 output_tests/slice/ptr_slice/float64/types.go | 3 + .../ptr_slice/int32}/json_test.go | 0 output_tests/slice/ptr_slice/int32/types.go | 3 + .../ptr_slice/ptr_string}/json_test.go | 0 .../slice/ptr_slice/ptr_string/types.go | 3 + .../ptr_slice/string}/json_test.go | 0 output_tests/slice/ptr_slice/string/types.go | 3 + .../ptr_slice/uint8}/json_test.go | 0 output_tests/slice/ptr_slice/uint8/types.go | 3 + .../float64 => slice/ptr_string}/json_test.go | 0 .../string => slice/ptr_string}/types.go | 0 .../ptr_struct_various}/json_test.go | 0 .../ptr_struct_various}/types.go | 4 +- .../int8 => slice/ptr_uint8}/json_test.go | 0 output_tests/slice/ptr_uint8/types.go | 3 + .../slice/bool}/json_test.go | 0 .../slices => slice/slice}/bool/types.go | 0 .../string => slice/slice/byte}/json_test.go | 0 .../slices => slice/slice}/byte/types.go | 0 .../slice/float64}/json_test.go | 0 .../slices => slice/slice}/float64/types.go | 0 .../slice/int32}/json_test.go | 0 .../slices => slice/slice}/int32/types.go | 0 .../slice/ptr_string}/json_test.go | 0 .../slice}/ptr_string/types.go | 0 .../slice/string}/json_test.go | 0 .../slices => slice/slice}/string/types.go | 0 .../slice/uint8}/json_test.go | 0 output_tests/slice/slice/uint8/types.go | 3 + output_tests/slice/string/json_test.go | 139 ++++++++++++++++++ .../builtins => slice}/string/types.go | 0 output_tests/slice/struct_empty/json_test.go | 139 ++++++++++++++++++ output_tests/slice/struct_empty/types.go | 3 + .../slice/struct_empty_alias/json_test.go | 139 ++++++++++++++++++ .../slice/struct_empty_alias/types.go | 5 + .../slice/struct_ptr_string/json_test.go | 139 ++++++++++++++++++ output_tests/slice/struct_ptr_string/types.go | 5 + .../slice/struct_various/json_test.go | 139 ++++++++++++++++++ .../struct_various}/types.go | 4 +- output_tests/slice/uint8/json_test.go | 139 ++++++++++++++++++ .../{slices/builtins => slice}/uint8/types.go | 0 output_tests/slices/builtins/float32/types.go | 3 - output_tests/slices/builtins/int8/types.go | 3 - output_tests/slices/pointers/float32/types.go | 3 - output_tests/slices/pointers/int8/types.go | 3 - output_tests/slices/slices/int8/types.go | 3 - .../slices/slices/struct_empty/types.go | 3 - .../slices/slices/struct_ptr_string/types.go | 5 - .../slices/slices/struct_ptrs_string/types.go | 7 - .../slices/slices/struct_string/types.go | 5 - .../slices/slices/struct_strings/types.go | 7 - 78 files changed, 888 insertions(+), 48 deletions(-) rename output_tests/{map/string/ptr_struct => slice/bool}/json_test.go (100%) rename output_tests/{slices/builtins => slice}/bool/types.go (100%) rename output_tests/{map/string/struct => slice/byte}/json_test.go (100%) rename output_tests/{slices/builtins => slice}/byte/types.go (100%) rename output_tests/{slices/builtins/bool => slice/float64}/json_test.go (100%) rename output_tests/{slices/builtins => slice}/float64/types.go (100%) rename output_tests/{slices/builtins/byte => slice/int32}/json_test.go (100%) rename output_tests/{slices/builtins => slice}/int32/types.go (100%) rename output_tests/{slices/builtins/float32 => slice/map/int32_string}/json_test.go (100%) create mode 100644 output_tests/slice/map/int32_string/types.go rename output_tests/{slices/builtins/float64 => slice/map/string_string}/json_test.go (100%) create mode 100644 output_tests/slice/map/string_string/types.go rename output_tests/{slices/builtins/int32 => slice/ptr_bool}/json_test.go (100%) rename output_tests/{slices/pointers/bool => slice/ptr_bool}/types.go (100%) rename output_tests/{slices/builtins/int8 => slice/ptr_float64}/json_test.go (100%) rename output_tests/{slices/pointers/float64 => slice/ptr_float64}/types.go (100%) rename output_tests/{slices/builtins/string => slice/ptr_int32}/json_test.go (100%) rename output_tests/{slices/pointers/int32 => slice/ptr_int32}/types.go (100%) rename output_tests/{slices/builtins/uint8 => slice/ptr_map/int32_string}/json_test.go (100%) create mode 100644 output_tests/slice/ptr_map/int32_string/types.go rename output_tests/{slices/pointers/bool => slice/ptr_map/string_string}/json_test.go (100%) create mode 100644 output_tests/slice/ptr_map/string_string/types.go rename output_tests/{slices/pointers/float32 => slice/ptr_slice/bool}/json_test.go (100%) create mode 100644 output_tests/slice/ptr_slice/bool/types.go rename output_tests/{slices/pointers/float64 => slice/ptr_slice/byte}/json_test.go (100%) create mode 100644 output_tests/slice/ptr_slice/byte/types.go rename output_tests/{slices/pointers/int32 => slice/ptr_slice/float64}/json_test.go (100%) create mode 100644 output_tests/slice/ptr_slice/float64/types.go rename output_tests/{slices/pointers/int8 => slice/ptr_slice/int32}/json_test.go (100%) create mode 100644 output_tests/slice/ptr_slice/int32/types.go rename output_tests/{slices/pointers/string => slice/ptr_slice/ptr_string}/json_test.go (100%) create mode 100644 output_tests/slice/ptr_slice/ptr_string/types.go rename output_tests/{slices/slices/bool => slice/ptr_slice/string}/json_test.go (100%) create mode 100644 output_tests/slice/ptr_slice/string/types.go rename output_tests/{slices/slices/byte => slice/ptr_slice/uint8}/json_test.go (100%) create mode 100644 output_tests/slice/ptr_slice/uint8/types.go rename output_tests/{slices/slices/float64 => slice/ptr_string}/json_test.go (100%) rename output_tests/{slices/pointers/string => slice/ptr_string}/types.go (100%) rename output_tests/{slices/slices/int32 => slice/ptr_struct_various}/json_test.go (100%) rename output_tests/{map/string/struct => slice/ptr_struct_various}/types.go (73%) rename output_tests/{slices/slices/int8 => slice/ptr_uint8}/json_test.go (100%) create mode 100644 output_tests/slice/ptr_uint8/types.go rename output_tests/{slices/slices/ptr_string => slice/slice/bool}/json_test.go (100%) rename output_tests/{slices/slices => slice/slice}/bool/types.go (100%) rename output_tests/{slices/slices/string => slice/slice/byte}/json_test.go (100%) rename output_tests/{slices/slices => slice/slice}/byte/types.go (100%) rename output_tests/{slices/slices/struct_empty => slice/slice/float64}/json_test.go (100%) rename output_tests/{slices/slices => slice/slice}/float64/types.go (100%) rename output_tests/{slices/slices/struct_ptr_string => slice/slice/int32}/json_test.go (100%) rename output_tests/{slices/slices => slice/slice}/int32/types.go (100%) rename output_tests/{slices/slices/struct_ptrs_string => slice/slice/ptr_string}/json_test.go (100%) rename output_tests/{slices/slices => slice/slice}/ptr_string/types.go (100%) rename output_tests/{slices/slices/struct_string => slice/slice/string}/json_test.go (100%) rename output_tests/{slices/slices => slice/slice}/string/types.go (100%) rename output_tests/{slices/slices/struct_strings => slice/slice/uint8}/json_test.go (100%) create mode 100644 output_tests/slice/slice/uint8/types.go create mode 100644 output_tests/slice/string/json_test.go rename output_tests/{slices/builtins => slice}/string/types.go (100%) create mode 100644 output_tests/slice/struct_empty/json_test.go create mode 100644 output_tests/slice/struct_empty/types.go create mode 100644 output_tests/slice/struct_empty_alias/json_test.go create mode 100644 output_tests/slice/struct_empty_alias/types.go create mode 100644 output_tests/slice/struct_ptr_string/json_test.go create mode 100644 output_tests/slice/struct_ptr_string/types.go create mode 100644 output_tests/slice/struct_various/json_test.go rename output_tests/{map/string/ptr_struct => slice/struct_various}/types.go (73%) create mode 100644 output_tests/slice/uint8/json_test.go rename output_tests/{slices/builtins => slice}/uint8/types.go (100%) delete mode 100644 output_tests/slices/builtins/float32/types.go delete mode 100644 output_tests/slices/builtins/int8/types.go delete mode 100644 output_tests/slices/pointers/float32/types.go delete mode 100644 output_tests/slices/pointers/int8/types.go delete mode 100644 output_tests/slices/slices/int8/types.go delete mode 100644 output_tests/slices/slices/struct_empty/types.go delete mode 100644 output_tests/slices/slices/struct_ptr_string/types.go delete mode 100644 output_tests/slices/slices/struct_ptrs_string/types.go delete mode 100644 output_tests/slices/slices/struct_string/types.go delete mode 100644 output_tests/slices/slices/struct_strings/types.go diff --git a/output_tests/map/string/ptr_struct/json_test.go b/output_tests/slice/bool/json_test.go similarity index 100% rename from output_tests/map/string/ptr_struct/json_test.go rename to output_tests/slice/bool/json_test.go diff --git a/output_tests/slices/builtins/bool/types.go b/output_tests/slice/bool/types.go similarity index 100% rename from output_tests/slices/builtins/bool/types.go rename to output_tests/slice/bool/types.go diff --git a/output_tests/map/string/struct/json_test.go b/output_tests/slice/byte/json_test.go similarity index 100% rename from output_tests/map/string/struct/json_test.go rename to output_tests/slice/byte/json_test.go diff --git a/output_tests/slices/builtins/byte/types.go b/output_tests/slice/byte/types.go similarity index 100% rename from output_tests/slices/builtins/byte/types.go rename to output_tests/slice/byte/types.go diff --git a/output_tests/slices/builtins/bool/json_test.go b/output_tests/slice/float64/json_test.go similarity index 100% rename from output_tests/slices/builtins/bool/json_test.go rename to output_tests/slice/float64/json_test.go diff --git a/output_tests/slices/builtins/float64/types.go b/output_tests/slice/float64/types.go similarity index 100% rename from output_tests/slices/builtins/float64/types.go rename to output_tests/slice/float64/types.go diff --git a/output_tests/slices/builtins/byte/json_test.go b/output_tests/slice/int32/json_test.go similarity index 100% rename from output_tests/slices/builtins/byte/json_test.go rename to output_tests/slice/int32/json_test.go diff --git a/output_tests/slices/builtins/int32/types.go b/output_tests/slice/int32/types.go similarity index 100% rename from output_tests/slices/builtins/int32/types.go rename to output_tests/slice/int32/types.go diff --git a/output_tests/slices/builtins/float32/json_test.go b/output_tests/slice/map/int32_string/json_test.go similarity index 100% rename from output_tests/slices/builtins/float32/json_test.go rename to output_tests/slice/map/int32_string/json_test.go diff --git a/output_tests/slice/map/int32_string/types.go b/output_tests/slice/map/int32_string/types.go new file mode 100644 index 0000000..001f0ce --- /dev/null +++ b/output_tests/slice/map/int32_string/types.go @@ -0,0 +1,3 @@ +package test + +type T []map[int32]string diff --git a/output_tests/slices/builtins/float64/json_test.go b/output_tests/slice/map/string_string/json_test.go similarity index 100% rename from output_tests/slices/builtins/float64/json_test.go rename to output_tests/slice/map/string_string/json_test.go diff --git a/output_tests/slice/map/string_string/types.go b/output_tests/slice/map/string_string/types.go new file mode 100644 index 0000000..79a1e6c --- /dev/null +++ b/output_tests/slice/map/string_string/types.go @@ -0,0 +1,3 @@ +package test + +type T []map[string]string diff --git a/output_tests/slices/builtins/int32/json_test.go b/output_tests/slice/ptr_bool/json_test.go similarity index 100% rename from output_tests/slices/builtins/int32/json_test.go rename to output_tests/slice/ptr_bool/json_test.go diff --git a/output_tests/slices/pointers/bool/types.go b/output_tests/slice/ptr_bool/types.go similarity index 100% rename from output_tests/slices/pointers/bool/types.go rename to output_tests/slice/ptr_bool/types.go diff --git a/output_tests/slices/builtins/int8/json_test.go b/output_tests/slice/ptr_float64/json_test.go similarity index 100% rename from output_tests/slices/builtins/int8/json_test.go rename to output_tests/slice/ptr_float64/json_test.go diff --git a/output_tests/slices/pointers/float64/types.go b/output_tests/slice/ptr_float64/types.go similarity index 100% rename from output_tests/slices/pointers/float64/types.go rename to output_tests/slice/ptr_float64/types.go diff --git a/output_tests/slices/builtins/string/json_test.go b/output_tests/slice/ptr_int32/json_test.go similarity index 100% rename from output_tests/slices/builtins/string/json_test.go rename to output_tests/slice/ptr_int32/json_test.go diff --git a/output_tests/slices/pointers/int32/types.go b/output_tests/slice/ptr_int32/types.go similarity index 100% rename from output_tests/slices/pointers/int32/types.go rename to output_tests/slice/ptr_int32/types.go diff --git a/output_tests/slices/builtins/uint8/json_test.go b/output_tests/slice/ptr_map/int32_string/json_test.go similarity index 100% rename from output_tests/slices/builtins/uint8/json_test.go rename to output_tests/slice/ptr_map/int32_string/json_test.go diff --git a/output_tests/slice/ptr_map/int32_string/types.go b/output_tests/slice/ptr_map/int32_string/types.go new file mode 100644 index 0000000..90ad4ca --- /dev/null +++ b/output_tests/slice/ptr_map/int32_string/types.go @@ -0,0 +1,3 @@ +package test + +type T []*map[int32]string diff --git a/output_tests/slices/pointers/bool/json_test.go b/output_tests/slice/ptr_map/string_string/json_test.go similarity index 100% rename from output_tests/slices/pointers/bool/json_test.go rename to output_tests/slice/ptr_map/string_string/json_test.go diff --git a/output_tests/slice/ptr_map/string_string/types.go b/output_tests/slice/ptr_map/string_string/types.go new file mode 100644 index 0000000..f905206 --- /dev/null +++ b/output_tests/slice/ptr_map/string_string/types.go @@ -0,0 +1,3 @@ +package test + +type T []*map[string]string diff --git a/output_tests/slices/pointers/float32/json_test.go b/output_tests/slice/ptr_slice/bool/json_test.go similarity index 100% rename from output_tests/slices/pointers/float32/json_test.go rename to output_tests/slice/ptr_slice/bool/json_test.go diff --git a/output_tests/slice/ptr_slice/bool/types.go b/output_tests/slice/ptr_slice/bool/types.go new file mode 100644 index 0000000..83af382 --- /dev/null +++ b/output_tests/slice/ptr_slice/bool/types.go @@ -0,0 +1,3 @@ +package test + +type T []*[]bool diff --git a/output_tests/slices/pointers/float64/json_test.go b/output_tests/slice/ptr_slice/byte/json_test.go similarity index 100% rename from output_tests/slices/pointers/float64/json_test.go rename to output_tests/slice/ptr_slice/byte/json_test.go diff --git a/output_tests/slice/ptr_slice/byte/types.go b/output_tests/slice/ptr_slice/byte/types.go new file mode 100644 index 0000000..57a7010 --- /dev/null +++ b/output_tests/slice/ptr_slice/byte/types.go @@ -0,0 +1,3 @@ +package test + +type T []*[]byte diff --git a/output_tests/slices/pointers/int32/json_test.go b/output_tests/slice/ptr_slice/float64/json_test.go similarity index 100% rename from output_tests/slices/pointers/int32/json_test.go rename to output_tests/slice/ptr_slice/float64/json_test.go diff --git a/output_tests/slice/ptr_slice/float64/types.go b/output_tests/slice/ptr_slice/float64/types.go new file mode 100644 index 0000000..5ef1fc0 --- /dev/null +++ b/output_tests/slice/ptr_slice/float64/types.go @@ -0,0 +1,3 @@ +package test + +type T []*[]float64 diff --git a/output_tests/slices/pointers/int8/json_test.go b/output_tests/slice/ptr_slice/int32/json_test.go similarity index 100% rename from output_tests/slices/pointers/int8/json_test.go rename to output_tests/slice/ptr_slice/int32/json_test.go diff --git a/output_tests/slice/ptr_slice/int32/types.go b/output_tests/slice/ptr_slice/int32/types.go new file mode 100644 index 0000000..22ee72a --- /dev/null +++ b/output_tests/slice/ptr_slice/int32/types.go @@ -0,0 +1,3 @@ +package test + +type T []*[]int32 diff --git a/output_tests/slices/pointers/string/json_test.go b/output_tests/slice/ptr_slice/ptr_string/json_test.go similarity index 100% rename from output_tests/slices/pointers/string/json_test.go rename to output_tests/slice/ptr_slice/ptr_string/json_test.go diff --git a/output_tests/slice/ptr_slice/ptr_string/types.go b/output_tests/slice/ptr_slice/ptr_string/types.go new file mode 100644 index 0000000..5f9188e --- /dev/null +++ b/output_tests/slice/ptr_slice/ptr_string/types.go @@ -0,0 +1,3 @@ +package test + +type T []*[]*string diff --git a/output_tests/slices/slices/bool/json_test.go b/output_tests/slice/ptr_slice/string/json_test.go similarity index 100% rename from output_tests/slices/slices/bool/json_test.go rename to output_tests/slice/ptr_slice/string/json_test.go diff --git a/output_tests/slice/ptr_slice/string/types.go b/output_tests/slice/ptr_slice/string/types.go new file mode 100644 index 0000000..ac60616 --- /dev/null +++ b/output_tests/slice/ptr_slice/string/types.go @@ -0,0 +1,3 @@ +package test + +type T []*[]string diff --git a/output_tests/slices/slices/byte/json_test.go b/output_tests/slice/ptr_slice/uint8/json_test.go similarity index 100% rename from output_tests/slices/slices/byte/json_test.go rename to output_tests/slice/ptr_slice/uint8/json_test.go diff --git a/output_tests/slice/ptr_slice/uint8/types.go b/output_tests/slice/ptr_slice/uint8/types.go new file mode 100644 index 0000000..d036526 --- /dev/null +++ b/output_tests/slice/ptr_slice/uint8/types.go @@ -0,0 +1,3 @@ +package test + +type T []*[]uint8 diff --git a/output_tests/slices/slices/float64/json_test.go b/output_tests/slice/ptr_string/json_test.go similarity index 100% rename from output_tests/slices/slices/float64/json_test.go rename to output_tests/slice/ptr_string/json_test.go diff --git a/output_tests/slices/pointers/string/types.go b/output_tests/slice/ptr_string/types.go similarity index 100% rename from output_tests/slices/pointers/string/types.go rename to output_tests/slice/ptr_string/types.go diff --git a/output_tests/slices/slices/int32/json_test.go b/output_tests/slice/ptr_struct_various/json_test.go similarity index 100% rename from output_tests/slices/slices/int32/json_test.go rename to output_tests/slice/ptr_struct_various/json_test.go diff --git a/output_tests/map/string/struct/types.go b/output_tests/slice/ptr_struct_various/types.go similarity index 73% rename from output_tests/map/string/struct/types.go rename to output_tests/slice/ptr_struct_various/types.go index 263d4a6..7f2c5a0 100644 --- a/output_tests/map/string/struct/types.go +++ b/output_tests/slice/ptr_struct_various/types.go @@ -1,6 +1,6 @@ package test -type Struct struct { +type T []*struct { String string Int int32 Float float64 @@ -10,5 +10,3 @@ type Struct struct { Slice []string Map map[string]string } - -type T map[string]Struct diff --git a/output_tests/slices/slices/int8/json_test.go b/output_tests/slice/ptr_uint8/json_test.go similarity index 100% rename from output_tests/slices/slices/int8/json_test.go rename to output_tests/slice/ptr_uint8/json_test.go diff --git a/output_tests/slice/ptr_uint8/types.go b/output_tests/slice/ptr_uint8/types.go new file mode 100644 index 0000000..61ac629 --- /dev/null +++ b/output_tests/slice/ptr_uint8/types.go @@ -0,0 +1,3 @@ +package test + +type T []*uint8 diff --git a/output_tests/slices/slices/ptr_string/json_test.go b/output_tests/slice/slice/bool/json_test.go similarity index 100% rename from output_tests/slices/slices/ptr_string/json_test.go rename to output_tests/slice/slice/bool/json_test.go diff --git a/output_tests/slices/slices/bool/types.go b/output_tests/slice/slice/bool/types.go similarity index 100% rename from output_tests/slices/slices/bool/types.go rename to output_tests/slice/slice/bool/types.go diff --git a/output_tests/slices/slices/string/json_test.go b/output_tests/slice/slice/byte/json_test.go similarity index 100% rename from output_tests/slices/slices/string/json_test.go rename to output_tests/slice/slice/byte/json_test.go diff --git a/output_tests/slices/slices/byte/types.go b/output_tests/slice/slice/byte/types.go similarity index 100% rename from output_tests/slices/slices/byte/types.go rename to output_tests/slice/slice/byte/types.go diff --git a/output_tests/slices/slices/struct_empty/json_test.go b/output_tests/slice/slice/float64/json_test.go similarity index 100% rename from output_tests/slices/slices/struct_empty/json_test.go rename to output_tests/slice/slice/float64/json_test.go diff --git a/output_tests/slices/slices/float64/types.go b/output_tests/slice/slice/float64/types.go similarity index 100% rename from output_tests/slices/slices/float64/types.go rename to output_tests/slice/slice/float64/types.go diff --git a/output_tests/slices/slices/struct_ptr_string/json_test.go b/output_tests/slice/slice/int32/json_test.go similarity index 100% rename from output_tests/slices/slices/struct_ptr_string/json_test.go rename to output_tests/slice/slice/int32/json_test.go diff --git a/output_tests/slices/slices/int32/types.go b/output_tests/slice/slice/int32/types.go similarity index 100% rename from output_tests/slices/slices/int32/types.go rename to output_tests/slice/slice/int32/types.go diff --git a/output_tests/slices/slices/struct_ptrs_string/json_test.go b/output_tests/slice/slice/ptr_string/json_test.go similarity index 100% rename from output_tests/slices/slices/struct_ptrs_string/json_test.go rename to output_tests/slice/slice/ptr_string/json_test.go diff --git a/output_tests/slices/slices/ptr_string/types.go b/output_tests/slice/slice/ptr_string/types.go similarity index 100% rename from output_tests/slices/slices/ptr_string/types.go rename to output_tests/slice/slice/ptr_string/types.go diff --git a/output_tests/slices/slices/struct_string/json_test.go b/output_tests/slice/slice/string/json_test.go similarity index 100% rename from output_tests/slices/slices/struct_string/json_test.go rename to output_tests/slice/slice/string/json_test.go diff --git a/output_tests/slices/slices/string/types.go b/output_tests/slice/slice/string/types.go similarity index 100% rename from output_tests/slices/slices/string/types.go rename to output_tests/slice/slice/string/types.go diff --git a/output_tests/slices/slices/struct_strings/json_test.go b/output_tests/slice/slice/uint8/json_test.go similarity index 100% rename from output_tests/slices/slices/struct_strings/json_test.go rename to output_tests/slice/slice/uint8/json_test.go diff --git a/output_tests/slice/slice/uint8/types.go b/output_tests/slice/slice/uint8/types.go new file mode 100644 index 0000000..35db451 --- /dev/null +++ b/output_tests/slice/slice/uint8/types.go @@ -0,0 +1,3 @@ +package test + +type T [][]uint8 diff --git a/output_tests/slice/string/json_test.go b/output_tests/slice/string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slice/string/json_test.go @@ -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) +} diff --git a/output_tests/slices/builtins/string/types.go b/output_tests/slice/string/types.go similarity index 100% rename from output_tests/slices/builtins/string/types.go rename to output_tests/slice/string/types.go diff --git a/output_tests/slice/struct_empty/json_test.go b/output_tests/slice/struct_empty/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slice/struct_empty/json_test.go @@ -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) +} diff --git a/output_tests/slice/struct_empty/types.go b/output_tests/slice/struct_empty/types.go new file mode 100644 index 0000000..5ca1754 --- /dev/null +++ b/output_tests/slice/struct_empty/types.go @@ -0,0 +1,3 @@ +package test + +type T []struct{} diff --git a/output_tests/slice/struct_empty_alias/json_test.go b/output_tests/slice/struct_empty_alias/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slice/struct_empty_alias/json_test.go @@ -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) +} diff --git a/output_tests/slice/struct_empty_alias/types.go b/output_tests/slice/struct_empty_alias/types.go new file mode 100644 index 0000000..ecb5364 --- /dev/null +++ b/output_tests/slice/struct_empty_alias/types.go @@ -0,0 +1,5 @@ +package test + +type A struct{} + +type T []A diff --git a/output_tests/slice/struct_ptr_string/json_test.go b/output_tests/slice/struct_ptr_string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slice/struct_ptr_string/json_test.go @@ -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) +} diff --git a/output_tests/slice/struct_ptr_string/types.go b/output_tests/slice/struct_ptr_string/types.go new file mode 100644 index 0000000..d81f60f --- /dev/null +++ b/output_tests/slice/struct_ptr_string/types.go @@ -0,0 +1,5 @@ +package test + +type T []struct { + F *string +} diff --git a/output_tests/slice/struct_various/json_test.go b/output_tests/slice/struct_various/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slice/struct_various/json_test.go @@ -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) +} diff --git a/output_tests/map/string/ptr_struct/types.go b/output_tests/slice/struct_various/types.go similarity index 73% rename from output_tests/map/string/ptr_struct/types.go rename to output_tests/slice/struct_various/types.go index 0a1c237..e9653cf 100644 --- a/output_tests/map/string/ptr_struct/types.go +++ b/output_tests/slice/struct_various/types.go @@ -1,6 +1,6 @@ package test -type Struct struct { +type T []struct { String string Int int32 Float float64 @@ -10,5 +10,3 @@ type Struct struct { Slice []string Map map[string]string } - -type T map[string]*Struct diff --git a/output_tests/slice/uint8/json_test.go b/output_tests/slice/uint8/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/slice/uint8/json_test.go @@ -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) +} diff --git a/output_tests/slices/builtins/uint8/types.go b/output_tests/slice/uint8/types.go similarity index 100% rename from output_tests/slices/builtins/uint8/types.go rename to output_tests/slice/uint8/types.go diff --git a/output_tests/slices/builtins/float32/types.go b/output_tests/slices/builtins/float32/types.go deleted file mode 100644 index fba8cbe..0000000 --- a/output_tests/slices/builtins/float32/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T []float32 diff --git a/output_tests/slices/builtins/int8/types.go b/output_tests/slices/builtins/int8/types.go deleted file mode 100644 index 02ccbf2..0000000 --- a/output_tests/slices/builtins/int8/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T []int8 diff --git a/output_tests/slices/pointers/float32/types.go b/output_tests/slices/pointers/float32/types.go deleted file mode 100644 index 59207c2..0000000 --- a/output_tests/slices/pointers/float32/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T []*float32 diff --git a/output_tests/slices/pointers/int8/types.go b/output_tests/slices/pointers/int8/types.go deleted file mode 100644 index 4113c54..0000000 --- a/output_tests/slices/pointers/int8/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T []*int8 diff --git a/output_tests/slices/slices/int8/types.go b/output_tests/slices/slices/int8/types.go deleted file mode 100644 index 5027f30..0000000 --- a/output_tests/slices/slices/int8/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T [][]int8 diff --git a/output_tests/slices/slices/struct_empty/types.go b/output_tests/slices/slices/struct_empty/types.go deleted file mode 100644 index d454cb8..0000000 --- a/output_tests/slices/slices/struct_empty/types.go +++ /dev/null @@ -1,3 +0,0 @@ -package test - -type T [][]struct{} diff --git a/output_tests/slices/slices/struct_ptr_string/types.go b/output_tests/slices/slices/struct_ptr_string/types.go deleted file mode 100644 index 3ee04c7..0000000 --- a/output_tests/slices/slices/struct_ptr_string/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type T [][]struct { - F1 *string -} diff --git a/output_tests/slices/slices/struct_ptrs_string/types.go b/output_tests/slices/slices/struct_ptrs_string/types.go deleted file mode 100644 index c795d67..0000000 --- a/output_tests/slices/slices/struct_ptrs_string/types.go +++ /dev/null @@ -1,7 +0,0 @@ -package test - -type T [][]struct { - F1 *string - F2 *string - F3 *string -} diff --git a/output_tests/slices/slices/struct_string/types.go b/output_tests/slices/slices/struct_string/types.go deleted file mode 100644 index cb5fea9..0000000 --- a/output_tests/slices/slices/struct_string/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type T [][]struct { - F1 string -} diff --git a/output_tests/slices/slices/struct_strings/types.go b/output_tests/slices/slices/struct_strings/types.go deleted file mode 100644 index b9903d9..0000000 --- a/output_tests/slices/slices/struct_strings/types.go +++ /dev/null @@ -1,7 +0,0 @@ -package test - -type T [][]struct { - F1 string - F2 string - F3 string -} From 97ee4ad4a215715d3265275254dcabdf90be7bee Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 19:51:13 +0100 Subject: [PATCH 08/18] Reorganize output_tests for structs As I added more and more cases, I found the dir structure hard to navigate. The new structure follows how you read a type: e.g. struct { F *string } -> struct/ptr_string This exposed some redundant cases and some missing cases, too. --- .../builtins => struct}/alias/json_test.go | 0 .../builtins => struct}/alias/types.go | 0 .../everything => struct/empty}/json_test.go | 0 .../{structs => struct}/empty/types.go | 0 .../empty_alias}/json_test.go | 0 .../{structs => struct}/empty_alias/types.go | 0 .../everything}/json_test.go | 0 .../builtins => struct}/everything/types.go | 0 .../builtins => struct}/float64/json_test.go | 0 .../builtins => struct}/float64/types.go | 0 .../float64_alias/json_test.go | 0 .../float64_alias/types.go | 0 .../int32s => struct/float64s}/json_test.go | 0 output_tests/struct/float64s/types.go | 7 + .../float64s_alias}/json_test.go | 0 .../float64s_alias}/types.go | 2 +- .../int8 => struct/int32}/json_test.go | 0 .../pointers/int8 => struct/int32}/types.go | 2 +- .../int32_alias}/json_test.go | 0 .../int32_alias}/types.go | 2 +- .../string => struct/int32s}/json_test.go | 0 .../builtins => struct}/int32s/types.go | 0 .../int32s_alias}/json_test.go | 0 .../builtins => struct}/int32s_alias/types.go | 0 .../map/int32_ptr_string}/json_test.go | 0 .../map/int32_ptr_string}/types.go | 2 +- .../map/int32_string}/json_test.go | 0 .../map/int32_string}/types.go | 2 +- .../map/int32_struct_strings}/json_test.go | 0 .../struct/map/int32_struct_strings/types.go | 9 ++ .../map/string_ptr_string}/json_test.go | 0 .../map/string_ptr_string}/types.go | 0 .../map/string_string}/json_test.go | 0 .../map/string_string}/types.go | 0 .../map/string_struct_strings}/json_test.go | 0 .../map/string_struct_strings}/types.go | 0 .../ptr_float64}/json_test.go | 0 .../float64 => struct/ptr_float64}/types.go | 0 .../ptr_float64_alias}/json_test.go | 0 .../ptr_float64_alias}/types.go | 4 +- .../strings => struct/ptr_int32}/json_test.go | 0 .../int8 => struct/ptr_int32}/types.go | 2 +- .../ptr_int32_alias}/json_test.go | 0 .../ptr_int32_alias}/types.go | 0 .../ptr_ptr_struct_empty}/json_test.go | 0 .../ptr_ptr_struct_empty}/types.go | 0 .../ptr_ptr_struct_strings}/json_test.go | 0 .../ptr_ptr_struct_strings}/types.go | 0 .../ptr_string}/json_test.go | 0 .../string => struct/ptr_string}/types.go | 0 .../ptr_string_alias}/json_test.go | 0 .../ptr_string_alias}/types.go | 0 .../ptr_struct_empty}/json_test.go | 0 .../ptr_struct_empty}/types.go | 0 .../ptr_struct_strings}/json_test.go | 0 .../ptr_struct_strings}/types.go | 0 .../ptrs_float64}/json_test.go | 0 output_tests/struct/ptrs_float64/types.go | 7 + .../ptrs_int32}/json_test.go | 0 .../int32s => struct/ptrs_int32}/types.go | 0 .../ptrs_string}/json_test.go | 0 .../strings => struct/ptrs_string}/types.go | 0 .../slice/ptr_string}/json_test.go | 0 .../slice/ptr_string}/types.go | 0 .../slice/string}/json_test.go | 0 .../builtins => struct/slice}/string/types.go | 0 .../slice/string_alias}/json_test.go | 0 .../slice}/string_alias/types.go | 0 .../slice/strings}/json_test.go | 0 .../slice}/strings/types.go | 0 .../slice/struct_strings}/json_test.go | 0 .../slice/struct_strings}/types.go | 0 .../string}/json_test.go | 0 .../builtins => struct}/string/types.go | 0 .../string_alias}/json_test.go | 0 .../builtins => struct}/string_alias/types.go | 0 .../int8 => struct/strings}/json_test.go | 0 .../builtins => struct}/strings/types.go | 0 .../strings_alias}/json_test.go | 0 .../strings_alias/types.go | 0 .../struct/empties}/json_test.go | 0 .../struct}/empties/types.go | 0 .../struct/empty}/json_test.go | 0 .../structs => struct/struct}/empty/types.go | 0 .../struct/empty_alias}/json_test.go | 0 .../struct}/empty_alias/types.go | 0 .../struct/float32s}/json_test.go | 0 .../struct}/float32s/types.go | 0 .../struct/float64}/json_test.go | 0 .../struct}/float64/types.go | 0 .../struct/float64_alias}/json_test.go | 0 .../struct}/float64_alias/types.go | 0 .../struct/int32s}/json_test.go | 0 .../structs => struct/struct}/int32s/types.go | 0 .../struct/strings}/json_test.go | 0 .../struct}/strings/types.go | 0 .../struct/strings_alias}/json_test.go | 0 .../struct}/strings_alias/types.go | 0 .../structs/builtins/float32s/types.go | 7 - .../structs/maps/builtins/float32/types.go | 5 - .../maps/builtins/string_alias/types.go | 9 -- .../structs/maps/builtins/strings/types.go | 7 - .../structs/maps/pointers/float32/types.go | 5 - .../maps/pointers/string_alias/types.go | 9 -- .../structs/maps/pointers/strings/types.go | 7 - .../structs/maps/structs/empty/types.go | 5 - .../structs/maps/structs/float32s/types.go | 9 -- .../structs/maps/structs/int32s/types.go | 9 -- .../maps/structs/ptr_to_strings/types.go | 9 -- .../structs/pointers/everything/types.go | 18 --- .../pointers/everything_alias/types.go | 20 --- .../structs/pointers/float32s/types.go | 7 - .../structs/pointers/structs/float64/types.go | 7 - .../structs/pointers/structs/int32s/types.go | 9 -- .../structs/pointers/float64/types.go | 7 - .../pointers/structs/pointers/int32s/types.go | 9 -- .../pointers/structs/strings/json_test.go | 139 ------------------ .../slices/builtins/float32/json_test.go | 139 ------------------ .../structs/slices/builtins/float32/types.go | 5 - .../slices/builtins/int32/json_test.go | 139 ------------------ .../structs/slices/builtins/int32/types.go | 5 - .../slices/builtins/string/json_test.go | 139 ------------------ .../slices/builtins/string_alias/json_test.go | 139 ------------------ .../slices/builtins/strings/json_test.go | 139 ------------------ .../slices/pointers/float32/json_test.go | 139 ------------------ .../structs/slices/pointers/float32/types.go | 5 - .../slices/pointers/int32/json_test.go | 139 ------------------ .../structs/slices/pointers/int32/types.go | 5 - .../slices/pointers/string/json_test.go | 139 ------------------ .../slices/pointers/string_alias/json_test.go | 139 ------------------ .../slices/pointers/string_alias/types.go | 9 -- .../slices/pointers/strings/json_test.go | 139 ------------------ .../structs/slices/pointers/strings/types.go | 7 - .../structs/slices/structs/empty/json_test.go | 139 ------------------ .../structs/slices/structs/empty/types.go | 5 - .../slices/structs/float32s/json_test.go | 139 ------------------ .../structs/slices/structs/float32s/types.go | 9 -- .../slices/structs/int32s/json_test.go | 139 ------------------ .../structs/slices/structs/int32s/types.go | 9 -- .../structs/ptr_to_strings/json_test.go | 139 ------------------ .../slices/structs/ptr_to_strings/types.go | 9 -- .../slices/structs/strings/json_test.go | 139 ------------------ .../structs/structs/empties/json_test.go | 139 ------------------ .../structs/structs/empty/json_test.go | 139 ------------------ .../structs/structs/empty_alias/json_test.go | 139 ------------------ .../structs/structs/float32s/json_test.go | 139 ------------------ .../structs/structs/float64/json_test.go | 139 ------------------ .../structs/float64_alias/json_test.go | 139 ------------------ .../structs/structs/int32s/json_test.go | 139 ------------------ .../structs/structs/strings/json_test.go | 139 ------------------ .../structs/strings_alias/json_test.go | 139 ------------------ 151 files changed, 31 insertions(+), 3709 deletions(-) rename output_tests/{structs/builtins => struct}/alias/json_test.go (100%) rename output_tests/{structs/builtins => struct}/alias/types.go (100%) rename output_tests/{structs/builtins/everything => struct/empty}/json_test.go (100%) rename output_tests/{structs => struct}/empty/types.go (100%) rename output_tests/{structs/builtins/float32s => struct/empty_alias}/json_test.go (100%) rename output_tests/{structs => struct}/empty_alias/types.go (100%) rename output_tests/{structs/builtins/float32s_alias => struct/everything}/json_test.go (100%) rename output_tests/{structs/builtins => struct}/everything/types.go (100%) rename output_tests/{structs/builtins => struct}/float64/json_test.go (100%) rename output_tests/{structs/builtins => struct}/float64/types.go (100%) rename output_tests/{structs/builtins => struct}/float64_alias/json_test.go (100%) rename output_tests/{structs/builtins => struct}/float64_alias/types.go (100%) rename output_tests/{structs/builtins/int32s => struct/float64s}/json_test.go (100%) create mode 100644 output_tests/struct/float64s/types.go rename output_tests/{structs/builtins/int32s_alias => struct/float64s_alias}/json_test.go (100%) rename output_tests/{structs/builtins/float32s_alias => struct/float64s_alias}/types.go (77%) rename output_tests/{structs/builtins/int8 => struct/int32}/json_test.go (100%) rename output_tests/{structs/pointers/int8 => struct/int32}/types.go (78%) rename output_tests/{structs/builtins/int8_alias => struct/int32_alias}/json_test.go (100%) rename output_tests/{structs/builtins/int8_alias => struct/int32_alias}/types.go (74%) rename output_tests/{structs/builtins/string => struct/int32s}/json_test.go (100%) rename output_tests/{structs/builtins => struct}/int32s/types.go (100%) rename output_tests/{structs/builtins/string_alias => struct/int32s_alias}/json_test.go (100%) rename output_tests/{structs/builtins => struct}/int32s_alias/types.go (100%) rename output_tests/{structs/builtins/strings => struct/map/int32_ptr_string}/json_test.go (100%) rename output_tests/{structs/maps/pointers/int32 => struct/map/int32_ptr_string}/types.go (60%) rename output_tests/{structs/builtins/strings_alias => struct/map/int32_string}/json_test.go (100%) rename output_tests/{structs/maps/builtins/int32 => struct/map/int32_string}/types.go (61%) rename output_tests/{structs/empty => struct/map/int32_struct_strings}/json_test.go (100%) create mode 100644 output_tests/struct/map/int32_struct_strings/types.go rename output_tests/{structs/empty_alias => struct/map/string_ptr_string}/json_test.go (100%) rename output_tests/{structs/maps/pointers/string => struct/map/string_ptr_string}/types.go (100%) rename output_tests/{structs/maps/builtins/float32 => struct/map/string_string}/json_test.go (100%) rename output_tests/{structs/maps/builtins/string => struct/map/string_string}/types.go (100%) rename output_tests/{structs/maps/builtins/int32 => struct/map/string_struct_strings}/json_test.go (100%) rename output_tests/{structs/maps/structs/strings => struct/map/string_struct_strings}/types.go (100%) rename output_tests/{structs/maps/builtins/string => struct/ptr_float64}/json_test.go (100%) rename output_tests/{structs/pointers/float64 => struct/ptr_float64}/types.go (100%) rename output_tests/{structs/maps/builtins/string_alias => struct/ptr_float64_alias}/json_test.go (100%) rename output_tests/{structs/pointers/float32_alias => struct/ptr_float64_alias}/types.go (62%) rename output_tests/{structs/maps/builtins/strings => struct/ptr_int32}/json_test.go (100%) rename output_tests/{structs/builtins/int8 => struct/ptr_int32}/types.go (76%) rename output_tests/{structs/maps/pointers/float32 => struct/ptr_int32_alias}/json_test.go (100%) rename output_tests/{structs/pointers/int32_alias => struct/ptr_int32_alias}/types.go (100%) rename output_tests/{structs/maps/pointers/int32 => struct/ptr_ptr_struct_empty}/json_test.go (100%) rename output_tests/{structs/pointers/structs/pointers/empty => struct/ptr_ptr_struct_empty}/types.go (100%) rename output_tests/{structs/maps/pointers/string => struct/ptr_ptr_struct_strings}/json_test.go (100%) rename output_tests/{structs/pointers/structs/pointers/strings => struct/ptr_ptr_struct_strings}/types.go (100%) rename output_tests/{structs/maps/pointers/string_alias => struct/ptr_string}/json_test.go (100%) rename output_tests/{structs/pointers/string => struct/ptr_string}/types.go (100%) rename output_tests/{structs/maps/pointers/strings => struct/ptr_string_alias}/json_test.go (100%) rename output_tests/{structs/pointers/string_alias => struct/ptr_string_alias}/types.go (100%) rename output_tests/{structs/maps/structs/empty => struct/ptr_struct_empty}/json_test.go (100%) rename output_tests/{structs/pointers/structs/empty => struct/ptr_struct_empty}/types.go (100%) rename output_tests/{structs/maps/structs/float32s => struct/ptr_struct_strings}/json_test.go (100%) rename output_tests/{structs/pointers/structs/strings => struct/ptr_struct_strings}/types.go (100%) rename output_tests/{structs/maps/structs/int32s => struct/ptrs_float64}/json_test.go (100%) create mode 100644 output_tests/struct/ptrs_float64/types.go rename output_tests/{structs/maps/structs/ptr_to_strings => struct/ptrs_int32}/json_test.go (100%) rename output_tests/{structs/pointers/int32s => struct/ptrs_int32}/types.go (100%) rename output_tests/{structs/maps/structs/strings => struct/ptrs_string}/json_test.go (100%) rename output_tests/{structs/pointers/strings => struct/ptrs_string}/types.go (100%) rename output_tests/{structs/pointers/everything => struct/slice/ptr_string}/json_test.go (100%) rename output_tests/{structs/slices/pointers/string => struct/slice/ptr_string}/types.go (100%) rename output_tests/{structs/pointers/everything_alias => struct/slice/string}/json_test.go (100%) rename output_tests/{structs/slices/builtins => struct/slice}/string/types.go (100%) rename output_tests/{structs/pointers/float32_alias => struct/slice/string_alias}/json_test.go (100%) rename output_tests/{structs/slices/builtins => struct/slice}/string_alias/types.go (100%) rename output_tests/{structs/pointers/float32s => struct/slice/strings}/json_test.go (100%) rename output_tests/{structs/slices/builtins => struct/slice}/strings/types.go (100%) rename output_tests/{structs/pointers/float64 => struct/slice/struct_strings}/json_test.go (100%) rename output_tests/{structs/slices/structs/strings => struct/slice/struct_strings}/types.go (100%) rename output_tests/{structs/pointers/int32_alias => struct/string}/json_test.go (100%) rename output_tests/{structs/builtins => struct}/string/types.go (100%) rename output_tests/{structs/pointers/int32s => struct/string_alias}/json_test.go (100%) rename output_tests/{structs/builtins => struct}/string_alias/types.go (100%) rename output_tests/{structs/pointers/int8 => struct/strings}/json_test.go (100%) rename output_tests/{structs/builtins => struct}/strings/types.go (100%) rename output_tests/{structs/pointers/string => struct/strings_alias}/json_test.go (100%) rename output_tests/{structs/builtins => struct}/strings_alias/types.go (100%) rename output_tests/{structs/pointers/string_alias => struct/struct/empties}/json_test.go (100%) rename output_tests/{structs/structs => struct/struct}/empties/types.go (100%) rename output_tests/{structs/pointers/strings => struct/struct/empty}/json_test.go (100%) rename output_tests/{structs/structs => struct/struct}/empty/types.go (100%) rename output_tests/{structs/pointers/structs/empty => struct/struct/empty_alias}/json_test.go (100%) rename output_tests/{structs/structs => struct/struct}/empty_alias/types.go (100%) rename output_tests/{structs/pointers/structs/float64 => struct/struct/float32s}/json_test.go (100%) rename output_tests/{structs/structs => struct/struct}/float32s/types.go (100%) rename output_tests/{structs/pointers/structs/int32s => struct/struct/float64}/json_test.go (100%) rename output_tests/{structs/structs => struct/struct}/float64/types.go (100%) rename output_tests/{structs/pointers/structs/pointers/empty => struct/struct/float64_alias}/json_test.go (100%) rename output_tests/{structs/structs => struct/struct}/float64_alias/types.go (100%) rename output_tests/{structs/pointers/structs/pointers/float64 => struct/struct/int32s}/json_test.go (100%) rename output_tests/{structs/structs => struct/struct}/int32s/types.go (100%) rename output_tests/{structs/pointers/structs/pointers/int32s => struct/struct/strings}/json_test.go (100%) rename output_tests/{structs/structs => struct/struct}/strings/types.go (100%) rename output_tests/{structs/pointers/structs/pointers/strings => struct/struct/strings_alias}/json_test.go (100%) rename output_tests/{structs/structs => struct/struct}/strings_alias/types.go (100%) delete mode 100644 output_tests/structs/builtins/float32s/types.go delete mode 100644 output_tests/structs/maps/builtins/float32/types.go delete mode 100644 output_tests/structs/maps/builtins/string_alias/types.go delete mode 100644 output_tests/structs/maps/builtins/strings/types.go delete mode 100644 output_tests/structs/maps/pointers/float32/types.go delete mode 100644 output_tests/structs/maps/pointers/string_alias/types.go delete mode 100644 output_tests/structs/maps/pointers/strings/types.go delete mode 100644 output_tests/structs/maps/structs/empty/types.go delete mode 100644 output_tests/structs/maps/structs/float32s/types.go delete mode 100644 output_tests/structs/maps/structs/int32s/types.go delete mode 100644 output_tests/structs/maps/structs/ptr_to_strings/types.go delete mode 100644 output_tests/structs/pointers/everything/types.go delete mode 100644 output_tests/structs/pointers/everything_alias/types.go delete mode 100644 output_tests/structs/pointers/float32s/types.go delete mode 100644 output_tests/structs/pointers/structs/float64/types.go delete mode 100644 output_tests/structs/pointers/structs/int32s/types.go delete mode 100644 output_tests/structs/pointers/structs/pointers/float64/types.go delete mode 100644 output_tests/structs/pointers/structs/pointers/int32s/types.go delete mode 100644 output_tests/structs/pointers/structs/strings/json_test.go delete mode 100644 output_tests/structs/slices/builtins/float32/json_test.go delete mode 100644 output_tests/structs/slices/builtins/float32/types.go delete mode 100644 output_tests/structs/slices/builtins/int32/json_test.go delete mode 100644 output_tests/structs/slices/builtins/int32/types.go delete mode 100644 output_tests/structs/slices/builtins/string/json_test.go delete mode 100644 output_tests/structs/slices/builtins/string_alias/json_test.go delete mode 100644 output_tests/structs/slices/builtins/strings/json_test.go delete mode 100644 output_tests/structs/slices/pointers/float32/json_test.go delete mode 100644 output_tests/structs/slices/pointers/float32/types.go delete mode 100644 output_tests/structs/slices/pointers/int32/json_test.go delete mode 100644 output_tests/structs/slices/pointers/int32/types.go delete mode 100644 output_tests/structs/slices/pointers/string/json_test.go delete mode 100644 output_tests/structs/slices/pointers/string_alias/json_test.go delete mode 100644 output_tests/structs/slices/pointers/string_alias/types.go delete mode 100644 output_tests/structs/slices/pointers/strings/json_test.go delete mode 100644 output_tests/structs/slices/pointers/strings/types.go delete mode 100644 output_tests/structs/slices/structs/empty/json_test.go delete mode 100644 output_tests/structs/slices/structs/empty/types.go delete mode 100644 output_tests/structs/slices/structs/float32s/json_test.go delete mode 100644 output_tests/structs/slices/structs/float32s/types.go delete mode 100644 output_tests/structs/slices/structs/int32s/json_test.go delete mode 100644 output_tests/structs/slices/structs/int32s/types.go delete mode 100644 output_tests/structs/slices/structs/ptr_to_strings/json_test.go delete mode 100644 output_tests/structs/slices/structs/ptr_to_strings/types.go delete mode 100644 output_tests/structs/slices/structs/strings/json_test.go delete mode 100644 output_tests/structs/structs/empties/json_test.go delete mode 100644 output_tests/structs/structs/empty/json_test.go delete mode 100644 output_tests/structs/structs/empty_alias/json_test.go delete mode 100644 output_tests/structs/structs/float32s/json_test.go delete mode 100644 output_tests/structs/structs/float64/json_test.go delete mode 100644 output_tests/structs/structs/float64_alias/json_test.go delete mode 100644 output_tests/structs/structs/int32s/json_test.go delete mode 100644 output_tests/structs/structs/strings/json_test.go delete mode 100644 output_tests/structs/structs/strings_alias/json_test.go diff --git a/output_tests/structs/builtins/alias/json_test.go b/output_tests/struct/alias/json_test.go similarity index 100% rename from output_tests/structs/builtins/alias/json_test.go rename to output_tests/struct/alias/json_test.go diff --git a/output_tests/structs/builtins/alias/types.go b/output_tests/struct/alias/types.go similarity index 100% rename from output_tests/structs/builtins/alias/types.go rename to output_tests/struct/alias/types.go diff --git a/output_tests/structs/builtins/everything/json_test.go b/output_tests/struct/empty/json_test.go similarity index 100% rename from output_tests/structs/builtins/everything/json_test.go rename to output_tests/struct/empty/json_test.go diff --git a/output_tests/structs/empty/types.go b/output_tests/struct/empty/types.go similarity index 100% rename from output_tests/structs/empty/types.go rename to output_tests/struct/empty/types.go diff --git a/output_tests/structs/builtins/float32s/json_test.go b/output_tests/struct/empty_alias/json_test.go similarity index 100% rename from output_tests/structs/builtins/float32s/json_test.go rename to output_tests/struct/empty_alias/json_test.go diff --git a/output_tests/structs/empty_alias/types.go b/output_tests/struct/empty_alias/types.go similarity index 100% rename from output_tests/structs/empty_alias/types.go rename to output_tests/struct/empty_alias/types.go diff --git a/output_tests/structs/builtins/float32s_alias/json_test.go b/output_tests/struct/everything/json_test.go similarity index 100% rename from output_tests/structs/builtins/float32s_alias/json_test.go rename to output_tests/struct/everything/json_test.go diff --git a/output_tests/structs/builtins/everything/types.go b/output_tests/struct/everything/types.go similarity index 100% rename from output_tests/structs/builtins/everything/types.go rename to output_tests/struct/everything/types.go diff --git a/output_tests/structs/builtins/float64/json_test.go b/output_tests/struct/float64/json_test.go similarity index 100% rename from output_tests/structs/builtins/float64/json_test.go rename to output_tests/struct/float64/json_test.go diff --git a/output_tests/structs/builtins/float64/types.go b/output_tests/struct/float64/types.go similarity index 100% rename from output_tests/structs/builtins/float64/types.go rename to output_tests/struct/float64/types.go diff --git a/output_tests/structs/builtins/float64_alias/json_test.go b/output_tests/struct/float64_alias/json_test.go similarity index 100% rename from output_tests/structs/builtins/float64_alias/json_test.go rename to output_tests/struct/float64_alias/json_test.go diff --git a/output_tests/structs/builtins/float64_alias/types.go b/output_tests/struct/float64_alias/types.go similarity index 100% rename from output_tests/structs/builtins/float64_alias/types.go rename to output_tests/struct/float64_alias/types.go diff --git a/output_tests/structs/builtins/int32s/json_test.go b/output_tests/struct/float64s/json_test.go similarity index 100% rename from output_tests/structs/builtins/int32s/json_test.go rename to output_tests/struct/float64s/json_test.go diff --git a/output_tests/struct/float64s/types.go b/output_tests/struct/float64s/types.go new file mode 100644 index 0000000..e2766f3 --- /dev/null +++ b/output_tests/struct/float64s/types.go @@ -0,0 +1,7 @@ +package test + +type T struct { + F1 float64 + F2 float64 + F3 float64 +} diff --git a/output_tests/structs/builtins/int32s_alias/json_test.go b/output_tests/struct/float64s_alias/json_test.go similarity index 100% rename from output_tests/structs/builtins/int32s_alias/json_test.go rename to output_tests/struct/float64s_alias/json_test.go diff --git a/output_tests/structs/builtins/float32s_alias/types.go b/output_tests/struct/float64s_alias/types.go similarity index 77% rename from output_tests/structs/builtins/float32s_alias/types.go rename to output_tests/struct/float64s_alias/types.go index 6b0d6aa..175e4dc 100644 --- a/output_tests/structs/builtins/float32s_alias/types.go +++ b/output_tests/struct/float64s_alias/types.go @@ -1,6 +1,6 @@ package test -type A float32 +type A float64 type T struct { F1 A diff --git a/output_tests/structs/builtins/int8/json_test.go b/output_tests/struct/int32/json_test.go similarity index 100% rename from output_tests/structs/builtins/int8/json_test.go rename to output_tests/struct/int32/json_test.go diff --git a/output_tests/structs/pointers/int8/types.go b/output_tests/struct/int32/types.go similarity index 78% rename from output_tests/structs/pointers/int8/types.go rename to output_tests/struct/int32/types.go index 5f6c145..ecbe969 100644 --- a/output_tests/structs/pointers/int8/types.go +++ b/output_tests/struct/int32/types.go @@ -1,5 +1,5 @@ package test type T struct { - F *int8 + F int32 } diff --git a/output_tests/structs/builtins/int8_alias/json_test.go b/output_tests/struct/int32_alias/json_test.go similarity index 100% rename from output_tests/structs/builtins/int8_alias/json_test.go rename to output_tests/struct/int32_alias/json_test.go diff --git a/output_tests/structs/builtins/int8_alias/types.go b/output_tests/struct/int32_alias/types.go similarity index 74% rename from output_tests/structs/builtins/int8_alias/types.go rename to output_tests/struct/int32_alias/types.go index fcd0a9a..79b5b84 100644 --- a/output_tests/structs/builtins/int8_alias/types.go +++ b/output_tests/struct/int32_alias/types.go @@ -1,6 +1,6 @@ package test -type A int8 +type A int32 type T struct { F A diff --git a/output_tests/structs/builtins/string/json_test.go b/output_tests/struct/int32s/json_test.go similarity index 100% rename from output_tests/structs/builtins/string/json_test.go rename to output_tests/struct/int32s/json_test.go diff --git a/output_tests/structs/builtins/int32s/types.go b/output_tests/struct/int32s/types.go similarity index 100% rename from output_tests/structs/builtins/int32s/types.go rename to output_tests/struct/int32s/types.go diff --git a/output_tests/structs/builtins/string_alias/json_test.go b/output_tests/struct/int32s_alias/json_test.go similarity index 100% rename from output_tests/structs/builtins/string_alias/json_test.go rename to output_tests/struct/int32s_alias/json_test.go diff --git a/output_tests/structs/builtins/int32s_alias/types.go b/output_tests/struct/int32s_alias/types.go similarity index 100% rename from output_tests/structs/builtins/int32s_alias/types.go rename to output_tests/struct/int32s_alias/types.go diff --git a/output_tests/structs/builtins/strings/json_test.go b/output_tests/struct/map/int32_ptr_string/json_test.go similarity index 100% rename from output_tests/structs/builtins/strings/json_test.go rename to output_tests/struct/map/int32_ptr_string/json_test.go diff --git a/output_tests/structs/maps/pointers/int32/types.go b/output_tests/struct/map/int32_ptr_string/types.go similarity index 60% rename from output_tests/structs/maps/pointers/int32/types.go rename to output_tests/struct/map/int32_ptr_string/types.go index dab3575..3356165 100644 --- a/output_tests/structs/maps/pointers/int32/types.go +++ b/output_tests/struct/map/int32_ptr_string/types.go @@ -1,5 +1,5 @@ package test type T struct { - F map[string]*int32 + F map[int32]*string } diff --git a/output_tests/structs/builtins/strings_alias/json_test.go b/output_tests/struct/map/int32_string/json_test.go similarity index 100% rename from output_tests/structs/builtins/strings_alias/json_test.go rename to output_tests/struct/map/int32_string/json_test.go diff --git a/output_tests/structs/maps/builtins/int32/types.go b/output_tests/struct/map/int32_string/types.go similarity index 61% rename from output_tests/structs/maps/builtins/int32/types.go rename to output_tests/struct/map/int32_string/types.go index 9bdad18..f90fd53 100644 --- a/output_tests/structs/maps/builtins/int32/types.go +++ b/output_tests/struct/map/int32_string/types.go @@ -1,5 +1,5 @@ package test type T struct { - F map[string]int32 + F map[int32]string } diff --git a/output_tests/structs/empty/json_test.go b/output_tests/struct/map/int32_struct_strings/json_test.go similarity index 100% rename from output_tests/structs/empty/json_test.go rename to output_tests/struct/map/int32_struct_strings/json_test.go diff --git a/output_tests/struct/map/int32_struct_strings/types.go b/output_tests/struct/map/int32_struct_strings/types.go new file mode 100644 index 0000000..6d506a9 --- /dev/null +++ b/output_tests/struct/map/int32_struct_strings/types.go @@ -0,0 +1,9 @@ +package test + +type T struct { + F map[int32]struct { + F1 string + F2 string + F3 string + } +} diff --git a/output_tests/structs/empty_alias/json_test.go b/output_tests/struct/map/string_ptr_string/json_test.go similarity index 100% rename from output_tests/structs/empty_alias/json_test.go rename to output_tests/struct/map/string_ptr_string/json_test.go diff --git a/output_tests/structs/maps/pointers/string/types.go b/output_tests/struct/map/string_ptr_string/types.go similarity index 100% rename from output_tests/structs/maps/pointers/string/types.go rename to output_tests/struct/map/string_ptr_string/types.go diff --git a/output_tests/structs/maps/builtins/float32/json_test.go b/output_tests/struct/map/string_string/json_test.go similarity index 100% rename from output_tests/structs/maps/builtins/float32/json_test.go rename to output_tests/struct/map/string_string/json_test.go diff --git a/output_tests/structs/maps/builtins/string/types.go b/output_tests/struct/map/string_string/types.go similarity index 100% rename from output_tests/structs/maps/builtins/string/types.go rename to output_tests/struct/map/string_string/types.go diff --git a/output_tests/structs/maps/builtins/int32/json_test.go b/output_tests/struct/map/string_struct_strings/json_test.go similarity index 100% rename from output_tests/structs/maps/builtins/int32/json_test.go rename to output_tests/struct/map/string_struct_strings/json_test.go diff --git a/output_tests/structs/maps/structs/strings/types.go b/output_tests/struct/map/string_struct_strings/types.go similarity index 100% rename from output_tests/structs/maps/structs/strings/types.go rename to output_tests/struct/map/string_struct_strings/types.go diff --git a/output_tests/structs/maps/builtins/string/json_test.go b/output_tests/struct/ptr_float64/json_test.go similarity index 100% rename from output_tests/structs/maps/builtins/string/json_test.go rename to output_tests/struct/ptr_float64/json_test.go diff --git a/output_tests/structs/pointers/float64/types.go b/output_tests/struct/ptr_float64/types.go similarity index 100% rename from output_tests/structs/pointers/float64/types.go rename to output_tests/struct/ptr_float64/types.go diff --git a/output_tests/structs/maps/builtins/string_alias/json_test.go b/output_tests/struct/ptr_float64_alias/json_test.go similarity index 100% rename from output_tests/structs/maps/builtins/string_alias/json_test.go rename to output_tests/struct/ptr_float64_alias/json_test.go diff --git a/output_tests/structs/pointers/float32_alias/types.go b/output_tests/struct/ptr_float64_alias/types.go similarity index 62% rename from output_tests/structs/pointers/float32_alias/types.go rename to output_tests/struct/ptr_float64_alias/types.go index 5b27b47..aa21eb7 100644 --- a/output_tests/structs/pointers/float32_alias/types.go +++ b/output_tests/struct/ptr_float64_alias/types.go @@ -1,7 +1,7 @@ package test -type A1 float32 -type A2 *float32 +type A1 float64 +type A2 *float64 type T struct { F1 *A1 diff --git a/output_tests/structs/maps/builtins/strings/json_test.go b/output_tests/struct/ptr_int32/json_test.go similarity index 100% rename from output_tests/structs/maps/builtins/strings/json_test.go rename to output_tests/struct/ptr_int32/json_test.go diff --git a/output_tests/structs/builtins/int8/types.go b/output_tests/struct/ptr_int32/types.go similarity index 76% rename from output_tests/structs/builtins/int8/types.go rename to output_tests/struct/ptr_int32/types.go index 86940e0..9570bef 100644 --- a/output_tests/structs/builtins/int8/types.go +++ b/output_tests/struct/ptr_int32/types.go @@ -1,5 +1,5 @@ package test type T struct { - F int8 + F *int32 } diff --git a/output_tests/structs/maps/pointers/float32/json_test.go b/output_tests/struct/ptr_int32_alias/json_test.go similarity index 100% rename from output_tests/structs/maps/pointers/float32/json_test.go rename to output_tests/struct/ptr_int32_alias/json_test.go diff --git a/output_tests/structs/pointers/int32_alias/types.go b/output_tests/struct/ptr_int32_alias/types.go similarity index 100% rename from output_tests/structs/pointers/int32_alias/types.go rename to output_tests/struct/ptr_int32_alias/types.go diff --git a/output_tests/structs/maps/pointers/int32/json_test.go b/output_tests/struct/ptr_ptr_struct_empty/json_test.go similarity index 100% rename from output_tests/structs/maps/pointers/int32/json_test.go rename to output_tests/struct/ptr_ptr_struct_empty/json_test.go diff --git a/output_tests/structs/pointers/structs/pointers/empty/types.go b/output_tests/struct/ptr_ptr_struct_empty/types.go similarity index 100% rename from output_tests/structs/pointers/structs/pointers/empty/types.go rename to output_tests/struct/ptr_ptr_struct_empty/types.go diff --git a/output_tests/structs/maps/pointers/string/json_test.go b/output_tests/struct/ptr_ptr_struct_strings/json_test.go similarity index 100% rename from output_tests/structs/maps/pointers/string/json_test.go rename to output_tests/struct/ptr_ptr_struct_strings/json_test.go diff --git a/output_tests/structs/pointers/structs/pointers/strings/types.go b/output_tests/struct/ptr_ptr_struct_strings/types.go similarity index 100% rename from output_tests/structs/pointers/structs/pointers/strings/types.go rename to output_tests/struct/ptr_ptr_struct_strings/types.go diff --git a/output_tests/structs/maps/pointers/string_alias/json_test.go b/output_tests/struct/ptr_string/json_test.go similarity index 100% rename from output_tests/structs/maps/pointers/string_alias/json_test.go rename to output_tests/struct/ptr_string/json_test.go diff --git a/output_tests/structs/pointers/string/types.go b/output_tests/struct/ptr_string/types.go similarity index 100% rename from output_tests/structs/pointers/string/types.go rename to output_tests/struct/ptr_string/types.go diff --git a/output_tests/structs/maps/pointers/strings/json_test.go b/output_tests/struct/ptr_string_alias/json_test.go similarity index 100% rename from output_tests/structs/maps/pointers/strings/json_test.go rename to output_tests/struct/ptr_string_alias/json_test.go diff --git a/output_tests/structs/pointers/string_alias/types.go b/output_tests/struct/ptr_string_alias/types.go similarity index 100% rename from output_tests/structs/pointers/string_alias/types.go rename to output_tests/struct/ptr_string_alias/types.go diff --git a/output_tests/structs/maps/structs/empty/json_test.go b/output_tests/struct/ptr_struct_empty/json_test.go similarity index 100% rename from output_tests/structs/maps/structs/empty/json_test.go rename to output_tests/struct/ptr_struct_empty/json_test.go diff --git a/output_tests/structs/pointers/structs/empty/types.go b/output_tests/struct/ptr_struct_empty/types.go similarity index 100% rename from output_tests/structs/pointers/structs/empty/types.go rename to output_tests/struct/ptr_struct_empty/types.go diff --git a/output_tests/structs/maps/structs/float32s/json_test.go b/output_tests/struct/ptr_struct_strings/json_test.go similarity index 100% rename from output_tests/structs/maps/structs/float32s/json_test.go rename to output_tests/struct/ptr_struct_strings/json_test.go diff --git a/output_tests/structs/pointers/structs/strings/types.go b/output_tests/struct/ptr_struct_strings/types.go similarity index 100% rename from output_tests/structs/pointers/structs/strings/types.go rename to output_tests/struct/ptr_struct_strings/types.go diff --git a/output_tests/structs/maps/structs/int32s/json_test.go b/output_tests/struct/ptrs_float64/json_test.go similarity index 100% rename from output_tests/structs/maps/structs/int32s/json_test.go rename to output_tests/struct/ptrs_float64/json_test.go diff --git a/output_tests/struct/ptrs_float64/types.go b/output_tests/struct/ptrs_float64/types.go new file mode 100644 index 0000000..eb24c7f --- /dev/null +++ b/output_tests/struct/ptrs_float64/types.go @@ -0,0 +1,7 @@ +package test + +type T struct { + F1 *float64 + F2 *float64 + F3 *float64 +} diff --git a/output_tests/structs/maps/structs/ptr_to_strings/json_test.go b/output_tests/struct/ptrs_int32/json_test.go similarity index 100% rename from output_tests/structs/maps/structs/ptr_to_strings/json_test.go rename to output_tests/struct/ptrs_int32/json_test.go diff --git a/output_tests/structs/pointers/int32s/types.go b/output_tests/struct/ptrs_int32/types.go similarity index 100% rename from output_tests/structs/pointers/int32s/types.go rename to output_tests/struct/ptrs_int32/types.go diff --git a/output_tests/structs/maps/structs/strings/json_test.go b/output_tests/struct/ptrs_string/json_test.go similarity index 100% rename from output_tests/structs/maps/structs/strings/json_test.go rename to output_tests/struct/ptrs_string/json_test.go diff --git a/output_tests/structs/pointers/strings/types.go b/output_tests/struct/ptrs_string/types.go similarity index 100% rename from output_tests/structs/pointers/strings/types.go rename to output_tests/struct/ptrs_string/types.go diff --git a/output_tests/structs/pointers/everything/json_test.go b/output_tests/struct/slice/ptr_string/json_test.go similarity index 100% rename from output_tests/structs/pointers/everything/json_test.go rename to output_tests/struct/slice/ptr_string/json_test.go diff --git a/output_tests/structs/slices/pointers/string/types.go b/output_tests/struct/slice/ptr_string/types.go similarity index 100% rename from output_tests/structs/slices/pointers/string/types.go rename to output_tests/struct/slice/ptr_string/types.go diff --git a/output_tests/structs/pointers/everything_alias/json_test.go b/output_tests/struct/slice/string/json_test.go similarity index 100% rename from output_tests/structs/pointers/everything_alias/json_test.go rename to output_tests/struct/slice/string/json_test.go diff --git a/output_tests/structs/slices/builtins/string/types.go b/output_tests/struct/slice/string/types.go similarity index 100% rename from output_tests/structs/slices/builtins/string/types.go rename to output_tests/struct/slice/string/types.go diff --git a/output_tests/structs/pointers/float32_alias/json_test.go b/output_tests/struct/slice/string_alias/json_test.go similarity index 100% rename from output_tests/structs/pointers/float32_alias/json_test.go rename to output_tests/struct/slice/string_alias/json_test.go diff --git a/output_tests/structs/slices/builtins/string_alias/types.go b/output_tests/struct/slice/string_alias/types.go similarity index 100% rename from output_tests/structs/slices/builtins/string_alias/types.go rename to output_tests/struct/slice/string_alias/types.go diff --git a/output_tests/structs/pointers/float32s/json_test.go b/output_tests/struct/slice/strings/json_test.go similarity index 100% rename from output_tests/structs/pointers/float32s/json_test.go rename to output_tests/struct/slice/strings/json_test.go diff --git a/output_tests/structs/slices/builtins/strings/types.go b/output_tests/struct/slice/strings/types.go similarity index 100% rename from output_tests/structs/slices/builtins/strings/types.go rename to output_tests/struct/slice/strings/types.go diff --git a/output_tests/structs/pointers/float64/json_test.go b/output_tests/struct/slice/struct_strings/json_test.go similarity index 100% rename from output_tests/structs/pointers/float64/json_test.go rename to output_tests/struct/slice/struct_strings/json_test.go diff --git a/output_tests/structs/slices/structs/strings/types.go b/output_tests/struct/slice/struct_strings/types.go similarity index 100% rename from output_tests/structs/slices/structs/strings/types.go rename to output_tests/struct/slice/struct_strings/types.go diff --git a/output_tests/structs/pointers/int32_alias/json_test.go b/output_tests/struct/string/json_test.go similarity index 100% rename from output_tests/structs/pointers/int32_alias/json_test.go rename to output_tests/struct/string/json_test.go diff --git a/output_tests/structs/builtins/string/types.go b/output_tests/struct/string/types.go similarity index 100% rename from output_tests/structs/builtins/string/types.go rename to output_tests/struct/string/types.go diff --git a/output_tests/structs/pointers/int32s/json_test.go b/output_tests/struct/string_alias/json_test.go similarity index 100% rename from output_tests/structs/pointers/int32s/json_test.go rename to output_tests/struct/string_alias/json_test.go diff --git a/output_tests/structs/builtins/string_alias/types.go b/output_tests/struct/string_alias/types.go similarity index 100% rename from output_tests/structs/builtins/string_alias/types.go rename to output_tests/struct/string_alias/types.go diff --git a/output_tests/structs/pointers/int8/json_test.go b/output_tests/struct/strings/json_test.go similarity index 100% rename from output_tests/structs/pointers/int8/json_test.go rename to output_tests/struct/strings/json_test.go diff --git a/output_tests/structs/builtins/strings/types.go b/output_tests/struct/strings/types.go similarity index 100% rename from output_tests/structs/builtins/strings/types.go rename to output_tests/struct/strings/types.go diff --git a/output_tests/structs/pointers/string/json_test.go b/output_tests/struct/strings_alias/json_test.go similarity index 100% rename from output_tests/structs/pointers/string/json_test.go rename to output_tests/struct/strings_alias/json_test.go diff --git a/output_tests/structs/builtins/strings_alias/types.go b/output_tests/struct/strings_alias/types.go similarity index 100% rename from output_tests/structs/builtins/strings_alias/types.go rename to output_tests/struct/strings_alias/types.go diff --git a/output_tests/structs/pointers/string_alias/json_test.go b/output_tests/struct/struct/empties/json_test.go similarity index 100% rename from output_tests/structs/pointers/string_alias/json_test.go rename to output_tests/struct/struct/empties/json_test.go diff --git a/output_tests/structs/structs/empties/types.go b/output_tests/struct/struct/empties/types.go similarity index 100% rename from output_tests/structs/structs/empties/types.go rename to output_tests/struct/struct/empties/types.go diff --git a/output_tests/structs/pointers/strings/json_test.go b/output_tests/struct/struct/empty/json_test.go similarity index 100% rename from output_tests/structs/pointers/strings/json_test.go rename to output_tests/struct/struct/empty/json_test.go diff --git a/output_tests/structs/structs/empty/types.go b/output_tests/struct/struct/empty/types.go similarity index 100% rename from output_tests/structs/structs/empty/types.go rename to output_tests/struct/struct/empty/types.go diff --git a/output_tests/structs/pointers/structs/empty/json_test.go b/output_tests/struct/struct/empty_alias/json_test.go similarity index 100% rename from output_tests/structs/pointers/structs/empty/json_test.go rename to output_tests/struct/struct/empty_alias/json_test.go diff --git a/output_tests/structs/structs/empty_alias/types.go b/output_tests/struct/struct/empty_alias/types.go similarity index 100% rename from output_tests/structs/structs/empty_alias/types.go rename to output_tests/struct/struct/empty_alias/types.go diff --git a/output_tests/structs/pointers/structs/float64/json_test.go b/output_tests/struct/struct/float32s/json_test.go similarity index 100% rename from output_tests/structs/pointers/structs/float64/json_test.go rename to output_tests/struct/struct/float32s/json_test.go diff --git a/output_tests/structs/structs/float32s/types.go b/output_tests/struct/struct/float32s/types.go similarity index 100% rename from output_tests/structs/structs/float32s/types.go rename to output_tests/struct/struct/float32s/types.go diff --git a/output_tests/structs/pointers/structs/int32s/json_test.go b/output_tests/struct/struct/float64/json_test.go similarity index 100% rename from output_tests/structs/pointers/structs/int32s/json_test.go rename to output_tests/struct/struct/float64/json_test.go diff --git a/output_tests/structs/structs/float64/types.go b/output_tests/struct/struct/float64/types.go similarity index 100% rename from output_tests/structs/structs/float64/types.go rename to output_tests/struct/struct/float64/types.go diff --git a/output_tests/structs/pointers/structs/pointers/empty/json_test.go b/output_tests/struct/struct/float64_alias/json_test.go similarity index 100% rename from output_tests/structs/pointers/structs/pointers/empty/json_test.go rename to output_tests/struct/struct/float64_alias/json_test.go diff --git a/output_tests/structs/structs/float64_alias/types.go b/output_tests/struct/struct/float64_alias/types.go similarity index 100% rename from output_tests/structs/structs/float64_alias/types.go rename to output_tests/struct/struct/float64_alias/types.go diff --git a/output_tests/structs/pointers/structs/pointers/float64/json_test.go b/output_tests/struct/struct/int32s/json_test.go similarity index 100% rename from output_tests/structs/pointers/structs/pointers/float64/json_test.go rename to output_tests/struct/struct/int32s/json_test.go diff --git a/output_tests/structs/structs/int32s/types.go b/output_tests/struct/struct/int32s/types.go similarity index 100% rename from output_tests/structs/structs/int32s/types.go rename to output_tests/struct/struct/int32s/types.go diff --git a/output_tests/structs/pointers/structs/pointers/int32s/json_test.go b/output_tests/struct/struct/strings/json_test.go similarity index 100% rename from output_tests/structs/pointers/structs/pointers/int32s/json_test.go rename to output_tests/struct/struct/strings/json_test.go diff --git a/output_tests/structs/structs/strings/types.go b/output_tests/struct/struct/strings/types.go similarity index 100% rename from output_tests/structs/structs/strings/types.go rename to output_tests/struct/struct/strings/types.go diff --git a/output_tests/structs/pointers/structs/pointers/strings/json_test.go b/output_tests/struct/struct/strings_alias/json_test.go similarity index 100% rename from output_tests/structs/pointers/structs/pointers/strings/json_test.go rename to output_tests/struct/struct/strings_alias/json_test.go diff --git a/output_tests/structs/structs/strings_alias/types.go b/output_tests/struct/struct/strings_alias/types.go similarity index 100% rename from output_tests/structs/structs/strings_alias/types.go rename to output_tests/struct/struct/strings_alias/types.go diff --git a/output_tests/structs/builtins/float32s/types.go b/output_tests/structs/builtins/float32s/types.go deleted file mode 100644 index e6a31b6..0000000 --- a/output_tests/structs/builtins/float32s/types.go +++ /dev/null @@ -1,7 +0,0 @@ -package test - -type T struct { - F1 float32 - F2 float32 - F3 float32 -} diff --git a/output_tests/structs/maps/builtins/float32/types.go b/output_tests/structs/maps/builtins/float32/types.go deleted file mode 100644 index 4cf8288..0000000 --- a/output_tests/structs/maps/builtins/float32/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type T struct { - F map[string]float32 -} diff --git a/output_tests/structs/maps/builtins/string_alias/types.go b/output_tests/structs/maps/builtins/string_alias/types.go deleted file mode 100644 index e2ecc99..0000000 --- a/output_tests/structs/maps/builtins/string_alias/types.go +++ /dev/null @@ -1,9 +0,0 @@ -package test - -type A1 string -type A2 map[string]A1 - -type T struct { - F1 map[string]A1 - F2 A2 -} diff --git a/output_tests/structs/maps/builtins/strings/types.go b/output_tests/structs/maps/builtins/strings/types.go deleted file mode 100644 index 312dcc4..0000000 --- a/output_tests/structs/maps/builtins/strings/types.go +++ /dev/null @@ -1,7 +0,0 @@ -package test - -type T struct { - F1 map[string]string - F2 map[string]string - F3 map[string]string -} diff --git a/output_tests/structs/maps/pointers/float32/types.go b/output_tests/structs/maps/pointers/float32/types.go deleted file mode 100644 index 9e24661..0000000 --- a/output_tests/structs/maps/pointers/float32/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type T struct { - F map[string]*float32 -} diff --git a/output_tests/structs/maps/pointers/string_alias/types.go b/output_tests/structs/maps/pointers/string_alias/types.go deleted file mode 100644 index 537d59b..0000000 --- a/output_tests/structs/maps/pointers/string_alias/types.go +++ /dev/null @@ -1,9 +0,0 @@ -package test - -type A1 *string -type A2 map[string]*A1 - -type T struct { - F1 map[string]A1 - F2 A2 -} diff --git a/output_tests/structs/maps/pointers/strings/types.go b/output_tests/structs/maps/pointers/strings/types.go deleted file mode 100644 index 6e0f498..0000000 --- a/output_tests/structs/maps/pointers/strings/types.go +++ /dev/null @@ -1,7 +0,0 @@ -package test - -type T struct { - F1 map[string]*string - F2 map[string]*string - F3 map[string]*string -} diff --git a/output_tests/structs/maps/structs/empty/types.go b/output_tests/structs/maps/structs/empty/types.go deleted file mode 100644 index b52b62d..0000000 --- a/output_tests/structs/maps/structs/empty/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type T struct { - F map[string]struct{} -} diff --git a/output_tests/structs/maps/structs/float32s/types.go b/output_tests/structs/maps/structs/float32s/types.go deleted file mode 100644 index c79868c..0000000 --- a/output_tests/structs/maps/structs/float32s/types.go +++ /dev/null @@ -1,9 +0,0 @@ -package test - -type T struct { - F map[string]struct { - F1 float32 - F2 float32 - F3 float32 - } -} diff --git a/output_tests/structs/maps/structs/int32s/types.go b/output_tests/structs/maps/structs/int32s/types.go deleted file mode 100644 index 891595f..0000000 --- a/output_tests/structs/maps/structs/int32s/types.go +++ /dev/null @@ -1,9 +0,0 @@ -package test - -type T struct { - F map[string]struct { - F1 int32 - F2 int32 - F3 int32 - } -} diff --git a/output_tests/structs/maps/structs/ptr_to_strings/types.go b/output_tests/structs/maps/structs/ptr_to_strings/types.go deleted file mode 100644 index c537c2d..0000000 --- a/output_tests/structs/maps/structs/ptr_to_strings/types.go +++ /dev/null @@ -1,9 +0,0 @@ -package test - -type T struct { - F map[string]struct { - F1 *string - F2 *string - F3 *string - } -} diff --git a/output_tests/structs/pointers/everything/types.go b/output_tests/structs/pointers/everything/types.go deleted file mode 100644 index 8565a48..0000000 --- a/output_tests/structs/pointers/everything/types.go +++ /dev/null @@ -1,18 +0,0 @@ -package test - -type T struct { - Byte1 *byte - Byte2 *byte - Bool1 *bool - Bool2 *bool - Int8 *int8 - Int16 *int16 - Int32 *int32 - Uint8 *uint8 - Uint16 *uint16 - Uint32 *uint32 - Float32 *float32 - Float64 *float64 - String1 *string - String2 *string -} diff --git a/output_tests/structs/pointers/everything_alias/types.go b/output_tests/structs/pointers/everything_alias/types.go deleted file mode 100644 index a9c08fd..0000000 --- a/output_tests/structs/pointers/everything_alias/types.go +++ /dev/null @@ -1,20 +0,0 @@ -package test - -type A struct { - Byte1 *byte - Byte2 *byte - Bool1 *bool - Bool2 *bool - Int8 *int8 - Int16 *int16 - Int32 *int32 - Uint8 *uint8 - Uint16 *uint16 - Uint32 *uint32 - Float32 *float32 - Float64 *float64 - String1 *string - String2 *string -} - -type T A diff --git a/output_tests/structs/pointers/float32s/types.go b/output_tests/structs/pointers/float32s/types.go deleted file mode 100644 index a17108f..0000000 --- a/output_tests/structs/pointers/float32s/types.go +++ /dev/null @@ -1,7 +0,0 @@ -package test - -type T struct { - F1 *float32 - F2 *float32 - F3 *float32 -} diff --git a/output_tests/structs/pointers/structs/float64/types.go b/output_tests/structs/pointers/structs/float64/types.go deleted file mode 100644 index 113087a..0000000 --- a/output_tests/structs/pointers/structs/float64/types.go +++ /dev/null @@ -1,7 +0,0 @@ -package test - -type T struct { - F *struct { - F float32 - } -} diff --git a/output_tests/structs/pointers/structs/int32s/types.go b/output_tests/structs/pointers/structs/int32s/types.go deleted file mode 100644 index 78f41cb..0000000 --- a/output_tests/structs/pointers/structs/int32s/types.go +++ /dev/null @@ -1,9 +0,0 @@ -package test - -type T struct { - F *struct { - F1 int32 - F2 int32 - F3 int32 - } -} diff --git a/output_tests/structs/pointers/structs/pointers/float64/types.go b/output_tests/structs/pointers/structs/pointers/float64/types.go deleted file mode 100644 index 0f7d558..0000000 --- a/output_tests/structs/pointers/structs/pointers/float64/types.go +++ /dev/null @@ -1,7 +0,0 @@ -package test - -type T struct { - F **struct { - F float32 - } -} diff --git a/output_tests/structs/pointers/structs/pointers/int32s/types.go b/output_tests/structs/pointers/structs/pointers/int32s/types.go deleted file mode 100644 index f8b1a33..0000000 --- a/output_tests/structs/pointers/structs/pointers/int32s/types.go +++ /dev/null @@ -1,9 +0,0 @@ -package test - -type T struct { - F **struct { - F1 int32 - F2 int32 - F3 int32 - } -} diff --git a/output_tests/structs/pointers/structs/strings/json_test.go b/output_tests/structs/pointers/structs/strings/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/pointers/structs/strings/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/builtins/float32/json_test.go b/output_tests/structs/slices/builtins/float32/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/builtins/float32/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/builtins/float32/types.go b/output_tests/structs/slices/builtins/float32/types.go deleted file mode 100644 index 74ad37a..0000000 --- a/output_tests/structs/slices/builtins/float32/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type T struct { - F []float32 -} diff --git a/output_tests/structs/slices/builtins/int32/json_test.go b/output_tests/structs/slices/builtins/int32/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/builtins/int32/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/builtins/int32/types.go b/output_tests/structs/slices/builtins/int32/types.go deleted file mode 100644 index a5da597..0000000 --- a/output_tests/structs/slices/builtins/int32/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type T struct { - F []int32 -} diff --git a/output_tests/structs/slices/builtins/string/json_test.go b/output_tests/structs/slices/builtins/string/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/builtins/string/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/builtins/string_alias/json_test.go b/output_tests/structs/slices/builtins/string_alias/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/builtins/string_alias/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/builtins/strings/json_test.go b/output_tests/structs/slices/builtins/strings/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/builtins/strings/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/pointers/float32/json_test.go b/output_tests/structs/slices/pointers/float32/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/pointers/float32/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/pointers/float32/types.go b/output_tests/structs/slices/pointers/float32/types.go deleted file mode 100644 index b18535b..0000000 --- a/output_tests/structs/slices/pointers/float32/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type T struct { - F []*float32 -} diff --git a/output_tests/structs/slices/pointers/int32/json_test.go b/output_tests/structs/slices/pointers/int32/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/pointers/int32/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/pointers/int32/types.go b/output_tests/structs/slices/pointers/int32/types.go deleted file mode 100644 index e12c2e2..0000000 --- a/output_tests/structs/slices/pointers/int32/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type T struct { - F []*int32 -} diff --git a/output_tests/structs/slices/pointers/string/json_test.go b/output_tests/structs/slices/pointers/string/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/pointers/string/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/pointers/string_alias/json_test.go b/output_tests/structs/slices/pointers/string_alias/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/pointers/string_alias/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/pointers/string_alias/types.go b/output_tests/structs/slices/pointers/string_alias/types.go deleted file mode 100644 index f0e825a..0000000 --- a/output_tests/structs/slices/pointers/string_alias/types.go +++ /dev/null @@ -1,9 +0,0 @@ -package test - -type A1 *string -type A2 []*A1 - -type T struct { - F1 []A1 - F2 A2 -} diff --git a/output_tests/structs/slices/pointers/strings/json_test.go b/output_tests/structs/slices/pointers/strings/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/pointers/strings/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/pointers/strings/types.go b/output_tests/structs/slices/pointers/strings/types.go deleted file mode 100644 index adefc13..0000000 --- a/output_tests/structs/slices/pointers/strings/types.go +++ /dev/null @@ -1,7 +0,0 @@ -package test - -type T struct { - F1 []*string - F2 []*string - F3 []*string -} diff --git a/output_tests/structs/slices/structs/empty/json_test.go b/output_tests/structs/slices/structs/empty/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/structs/empty/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/structs/empty/types.go b/output_tests/structs/slices/structs/empty/types.go deleted file mode 100644 index cd2c828..0000000 --- a/output_tests/structs/slices/structs/empty/types.go +++ /dev/null @@ -1,5 +0,0 @@ -package test - -type T struct { - F []struct{} -} diff --git a/output_tests/structs/slices/structs/float32s/json_test.go b/output_tests/structs/slices/structs/float32s/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/structs/float32s/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/structs/float32s/types.go b/output_tests/structs/slices/structs/float32s/types.go deleted file mode 100644 index be5139c..0000000 --- a/output_tests/structs/slices/structs/float32s/types.go +++ /dev/null @@ -1,9 +0,0 @@ -package test - -type T struct { - F []struct { - F1 float32 - F2 float32 - F3 float32 - } -} diff --git a/output_tests/structs/slices/structs/int32s/json_test.go b/output_tests/structs/slices/structs/int32s/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/structs/int32s/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/structs/int32s/types.go b/output_tests/structs/slices/structs/int32s/types.go deleted file mode 100644 index cd4b948..0000000 --- a/output_tests/structs/slices/structs/int32s/types.go +++ /dev/null @@ -1,9 +0,0 @@ -package test - -type T struct { - F []struct { - F1 int32 - F2 int32 - F3 int32 - } -} diff --git a/output_tests/structs/slices/structs/ptr_to_strings/json_test.go b/output_tests/structs/slices/structs/ptr_to_strings/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/structs/ptr_to_strings/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/slices/structs/ptr_to_strings/types.go b/output_tests/structs/slices/structs/ptr_to_strings/types.go deleted file mode 100644 index 876d63a..0000000 --- a/output_tests/structs/slices/structs/ptr_to_strings/types.go +++ /dev/null @@ -1,9 +0,0 @@ -package test - -type T struct { - F []struct { - F1 *string - F2 *string - F3 *string - } -} diff --git a/output_tests/structs/slices/structs/strings/json_test.go b/output_tests/structs/slices/structs/strings/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/slices/structs/strings/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/structs/empties/json_test.go b/output_tests/structs/structs/empties/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/structs/empties/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/structs/empty/json_test.go b/output_tests/structs/structs/empty/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/structs/empty/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/structs/empty_alias/json_test.go b/output_tests/structs/structs/empty_alias/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/structs/empty_alias/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/structs/float32s/json_test.go b/output_tests/structs/structs/float32s/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/structs/float32s/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/structs/float64/json_test.go b/output_tests/structs/structs/float64/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/structs/float64/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/structs/float64_alias/json_test.go b/output_tests/structs/structs/float64_alias/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/structs/float64_alias/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/structs/int32s/json_test.go b/output_tests/structs/structs/int32s/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/structs/int32s/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/structs/strings/json_test.go b/output_tests/structs/structs/strings/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/structs/strings/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} diff --git a/output_tests/structs/structs/strings_alias/json_test.go b/output_tests/structs/structs/strings_alias/json_test.go deleted file mode 100644 index a7b1d0d..0000000 --- a/output_tests/structs/structs/strings_alias/json_test.go +++ /dev/null @@ -1,139 +0,0 @@ -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) -} From 1589ab2fd76f556daa0d4ccdd5951ee11cd2d5ac Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 20:04:14 +0100 Subject: [PATCH 09/18] Add output tests for omitempty --- .../struct_tags/omitempty/bool/json_test.go | 139 ++++++++++++++++++ .../struct_tags/omitempty/bool/types.go | 6 + .../omitempty/float32/json_test.go | 139 ++++++++++++++++++ .../struct_tags/omitempty/float32/types.go | 6 + .../struct_tags/omitempty/int32/json_test.go | 139 ++++++++++++++++++ .../struct_tags/omitempty/int32/types.go | 6 + .../omitempty/map_string_string/json_test.go | 139 ++++++++++++++++++ .../omitempty/map_string_string/types.go | 6 + .../omitempty/ptr_bool/json_test.go | 139 ++++++++++++++++++ .../struct_tags/omitempty/ptr_bool/types.go | 6 + .../omitempty/ptr_float32/json_test.go | 139 ++++++++++++++++++ .../omitempty/ptr_float32/types.go | 6 + .../omitempty/ptr_int32/json_test.go | 139 ++++++++++++++++++ .../struct_tags/omitempty/ptr_int32/types.go | 6 + .../ptr_map_string_string/json_test.go | 139 ++++++++++++++++++ .../omitempty/ptr_map_string_string/types.go | 6 + .../omitempty/ptr_slice_string/json_test.go | 139 ++++++++++++++++++ .../omitempty/ptr_slice_string/types.go | 6 + .../omitempty/ptr_string/json_test.go | 139 ++++++++++++++++++ .../omitempty/ptr_string/string/json_test.go | 139 ++++++++++++++++++ .../omitempty/ptr_string/string/types.go | 6 + .../struct_tags/omitempty/ptr_string/types.go | 6 + .../omitempty/ptr_uint32/json_test.go | 139 ++++++++++++++++++ .../struct_tags/omitempty/ptr_uint32/types.go | 6 + .../omitempty/slice_string/json_test.go | 139 ++++++++++++++++++ .../omitempty/slice_string/types.go | 6 + .../struct_tags/omitempty/string/json_test.go | 139 ++++++++++++++++++ .../struct_tags/omitempty/string/types.go | 6 + .../struct_tags/omitempty/uint32/json_test.go | 139 ++++++++++++++++++ .../struct_tags/omitempty/uint32/types.go | 6 + 30 files changed, 2175 insertions(+) create mode 100644 output_tests/struct_tags/omitempty/bool/json_test.go create mode 100644 output_tests/struct_tags/omitempty/bool/types.go create mode 100644 output_tests/struct_tags/omitempty/float32/json_test.go create mode 100644 output_tests/struct_tags/omitempty/float32/types.go create mode 100644 output_tests/struct_tags/omitempty/int32/json_test.go create mode 100644 output_tests/struct_tags/omitempty/int32/types.go create mode 100644 output_tests/struct_tags/omitempty/map_string_string/json_test.go create mode 100644 output_tests/struct_tags/omitempty/map_string_string/types.go create mode 100644 output_tests/struct_tags/omitempty/ptr_bool/json_test.go create mode 100644 output_tests/struct_tags/omitempty/ptr_bool/types.go create mode 100644 output_tests/struct_tags/omitempty/ptr_float32/json_test.go create mode 100644 output_tests/struct_tags/omitempty/ptr_float32/types.go create mode 100644 output_tests/struct_tags/omitempty/ptr_int32/json_test.go create mode 100644 output_tests/struct_tags/omitempty/ptr_int32/types.go create mode 100644 output_tests/struct_tags/omitempty/ptr_map_string_string/json_test.go create mode 100644 output_tests/struct_tags/omitempty/ptr_map_string_string/types.go create mode 100644 output_tests/struct_tags/omitempty/ptr_slice_string/json_test.go create mode 100644 output_tests/struct_tags/omitempty/ptr_slice_string/types.go create mode 100644 output_tests/struct_tags/omitempty/ptr_string/json_test.go create mode 100644 output_tests/struct_tags/omitempty/ptr_string/string/json_test.go create mode 100644 output_tests/struct_tags/omitempty/ptr_string/string/types.go create mode 100644 output_tests/struct_tags/omitempty/ptr_string/types.go create mode 100644 output_tests/struct_tags/omitempty/ptr_uint32/json_test.go create mode 100644 output_tests/struct_tags/omitempty/ptr_uint32/types.go create mode 100644 output_tests/struct_tags/omitempty/slice_string/json_test.go create mode 100644 output_tests/struct_tags/omitempty/slice_string/types.go create mode 100644 output_tests/struct_tags/omitempty/string/json_test.go create mode 100644 output_tests/struct_tags/omitempty/string/types.go create mode 100644 output_tests/struct_tags/omitempty/uint32/json_test.go create mode 100644 output_tests/struct_tags/omitempty/uint32/types.go diff --git a/output_tests/struct_tags/omitempty/bool/json_test.go b/output_tests/struct_tags/omitempty/bool/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/bool/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/bool/types.go b/output_tests/struct_tags/omitempty/bool/types.go new file mode 100644 index 0000000..cfdb1b7 --- /dev/null +++ b/output_tests/struct_tags/omitempty/bool/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 bool `json:"F1"` + F2 bool `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/float32/json_test.go b/output_tests/struct_tags/omitempty/float32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/float32/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/float32/types.go b/output_tests/struct_tags/omitempty/float32/types.go new file mode 100644 index 0000000..6e0fd26 --- /dev/null +++ b/output_tests/struct_tags/omitempty/float32/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 float32 `json:"F1"` + F2 float32 `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/int32/json_test.go b/output_tests/struct_tags/omitempty/int32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/int32/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/int32/types.go b/output_tests/struct_tags/omitempty/int32/types.go new file mode 100644 index 0000000..913e275 --- /dev/null +++ b/output_tests/struct_tags/omitempty/int32/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 int32 `json:"F1"` + F2 int32 `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/map_string_string/json_test.go b/output_tests/struct_tags/omitempty/map_string_string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/map_string_string/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/map_string_string/types.go b/output_tests/struct_tags/omitempty/map_string_string/types.go new file mode 100644 index 0000000..cdc9758 --- /dev/null +++ b/output_tests/struct_tags/omitempty/map_string_string/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 map[string]string `json:"F1"` + F2 map[string]string `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/ptr_bool/json_test.go b/output_tests/struct_tags/omitempty/ptr_bool/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_bool/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/ptr_bool/types.go b/output_tests/struct_tags/omitempty/ptr_bool/types.go new file mode 100644 index 0000000..c585ee4 --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_bool/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 *bool `json:"F1"` + F2 *bool `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/ptr_float32/json_test.go b/output_tests/struct_tags/omitempty/ptr_float32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_float32/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/ptr_float32/types.go b/output_tests/struct_tags/omitempty/ptr_float32/types.go new file mode 100644 index 0000000..5863d78 --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_float32/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 *float32 `json:"F1"` + F2 *float32 `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/ptr_int32/json_test.go b/output_tests/struct_tags/omitempty/ptr_int32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_int32/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/ptr_int32/types.go b/output_tests/struct_tags/omitempty/ptr_int32/types.go new file mode 100644 index 0000000..267ab59 --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_int32/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 *int32 `json:"F1"` + F2 *int32 `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/ptr_map_string_string/json_test.go b/output_tests/struct_tags/omitempty/ptr_map_string_string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_map_string_string/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/ptr_map_string_string/types.go b/output_tests/struct_tags/omitempty/ptr_map_string_string/types.go new file mode 100644 index 0000000..ad44be1 --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_map_string_string/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 *map[string]string `json:"F1"` + F2 *map[string]string `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/ptr_slice_string/json_test.go b/output_tests/struct_tags/omitempty/ptr_slice_string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_slice_string/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/ptr_slice_string/types.go b/output_tests/struct_tags/omitempty/ptr_slice_string/types.go new file mode 100644 index 0000000..0630914 --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_slice_string/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 *[]string `json:"F1"` + F2 *[]string `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/ptr_string/json_test.go b/output_tests/struct_tags/omitempty/ptr_string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_string/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/ptr_string/string/json_test.go b/output_tests/struct_tags/omitempty/ptr_string/string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_string/string/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/ptr_string/string/types.go b/output_tests/struct_tags/omitempty/ptr_string/string/types.go new file mode 100644 index 0000000..5d5ded8 --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_string/string/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 string `json:"F1"` + F2 string `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/ptr_string/types.go b/output_tests/struct_tags/omitempty/ptr_string/types.go new file mode 100644 index 0000000..d0d5e12 --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_string/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 *string `json:"F1"` + F2 *string `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/ptr_uint32/json_test.go b/output_tests/struct_tags/omitempty/ptr_uint32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_uint32/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/ptr_uint32/types.go b/output_tests/struct_tags/omitempty/ptr_uint32/types.go new file mode 100644 index 0000000..ae41dad --- /dev/null +++ b/output_tests/struct_tags/omitempty/ptr_uint32/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 *uint32 `json:"F1"` + F2 *uint32 `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/slice_string/json_test.go b/output_tests/struct_tags/omitempty/slice_string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/slice_string/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/slice_string/types.go b/output_tests/struct_tags/omitempty/slice_string/types.go new file mode 100644 index 0000000..8216011 --- /dev/null +++ b/output_tests/struct_tags/omitempty/slice_string/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 []string `json:"F1"` + F2 []string `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/string/json_test.go b/output_tests/struct_tags/omitempty/string/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/string/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/string/types.go b/output_tests/struct_tags/omitempty/string/types.go new file mode 100644 index 0000000..5d5ded8 --- /dev/null +++ b/output_tests/struct_tags/omitempty/string/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 string `json:"F1"` + F2 string `json:"F2,omitempty"` +} diff --git a/output_tests/struct_tags/omitempty/uint32/json_test.go b/output_tests/struct_tags/omitempty/uint32/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/omitempty/uint32/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/omitempty/uint32/types.go b/output_tests/struct_tags/omitempty/uint32/types.go new file mode 100644 index 0000000..cfdeab4 --- /dev/null +++ b/output_tests/struct_tags/omitempty/uint32/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 uint32 `json:"F1"` + F2 uint32 `json:"F2,omitempty"` +} From e40d614037cdcc3caf0f329a2fa38a4120bad55b Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 20:07:29 +0100 Subject: [PATCH 10/18] Add output test for json tag field names --- .../struct_tags/fieldname/json_test.go | 139 ++++++++++++++++++ output_tests/struct_tags/fieldname/types.go | 10 ++ 2 files changed, 149 insertions(+) create mode 100644 output_tests/struct_tags/fieldname/json_test.go create mode 100644 output_tests/struct_tags/fieldname/types.go diff --git a/output_tests/struct_tags/fieldname/json_test.go b/output_tests/struct_tags/fieldname/json_test.go new file mode 100644 index 0000000..a7b1d0d --- /dev/null +++ b/output_tests/struct_tags/fieldname/json_test.go @@ -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) +} diff --git a/output_tests/struct_tags/fieldname/types.go b/output_tests/struct_tags/fieldname/types.go new file mode 100644 index 0000000..3140950 --- /dev/null +++ b/output_tests/struct_tags/fieldname/types.go @@ -0,0 +1,10 @@ +package test + +type T struct { + F1 string `json:"F1"` + F2 string `json:"f2"` + F3 string `json:"-"` + F4 string `json:"-,"` + F5 string `json:","` + F6 string `json:""` +} From c2c9981062fd9fea7395262b862e3a3826500f8f Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 20:42:22 +0100 Subject: [PATCH 11/18] catch errors in output_tests --- output_tests/builtins/bool/json_test.go | 25 +++++++++++++------ output_tests/builtins/bool_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/byte/json_test.go | 25 +++++++++++++------ output_tests/builtins/byte_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/float32/json_test.go | 25 +++++++++++++------ .../builtins/float32_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/float64/json_test.go | 25 +++++++++++++------ .../builtins/float64_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/int16/json_test.go | 25 +++++++++++++------ .../builtins/int16_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/int32/json_test.go | 25 +++++++++++++------ .../builtins/int32_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/int8/json_test.go | 25 +++++++++++++------ output_tests/builtins/int8_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/string/json_test.go | 25 +++++++++++++------ .../builtins/string_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/uint16/json_test.go | 25 +++++++++++++------ .../builtins/uint16_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/uint32/json_test.go | 25 +++++++++++++------ .../builtins/uint32_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/uint8/json_test.go | 25 +++++++++++++------ .../builtins/uint8_alias/json_test.go | 25 +++++++++++++------ output_tests/map/int16/string/json_test.go | 25 +++++++++++++------ output_tests/map/int32/string/json_test.go | 25 +++++++++++++------ output_tests/map/int8/string/json_test.go | 25 +++++++++++++------ output_tests/map/string/bool/json_test.go | 25 +++++++++++++------ output_tests/map/string/byte/json_test.go | 25 +++++++++++++------ output_tests/map/string/float64/json_test.go | 25 +++++++++++++------ output_tests/map/string/int32/json_test.go | 25 +++++++++++++------ .../map/string/map_string_string/json_test.go | 25 +++++++++++++------ output_tests/map/string/ptr_bool/json_test.go | 25 +++++++++++++------ .../map/string/ptr_float64/json_test.go | 25 +++++++++++++------ .../map/string/ptr_int32/json_test.go | 25 +++++++++++++------ .../string/ptr_map_string_string/json_test.go | 25 +++++++++++++------ .../map/string/ptr_slice_string/json_test.go | 25 +++++++++++++------ .../map/string/ptr_string/json_test.go | 25 +++++++++++++------ .../string/ptr_struct_various/json_test.go | 25 +++++++++++++------ .../map/string/ptr_uint8/json_test.go | 25 +++++++++++++------ .../map/string/slice_string/json_test.go | 25 +++++++++++++------ output_tests/map/string/string/json_test.go | 25 +++++++++++++------ .../map/string/string_alias/json_test.go | 25 +++++++++++++------ .../map/string/struct_empty/json_test.go | 25 +++++++++++++------ .../string/struct_empty_alias/json_test.go | 25 +++++++++++++------ .../map/string/struct_ptr_string/json_test.go | 25 +++++++++++++------ .../map/string/struct_various/json_test.go | 25 +++++++++++++------ output_tests/map/string/uint8/json_test.go | 25 +++++++++++++------ .../map/string_alias/string/json_test.go | 25 +++++++++++++------ .../string_alias/string_alias/json_test.go | 25 +++++++++++++------ output_tests/map/uint16/string/json_test.go | 25 +++++++++++++------ output_tests/map/uint32/string/json_test.go | 25 +++++++++++++------ output_tests/map/uint8/string/json_test.go | 25 +++++++++++++------ output_tests/slice/bool/json_test.go | 25 +++++++++++++------ output_tests/slice/byte/json_test.go | 25 +++++++++++++------ output_tests/slice/float64/json_test.go | 25 +++++++++++++------ output_tests/slice/int32/json_test.go | 25 +++++++++++++------ .../slice/map/int32_string/json_test.go | 25 +++++++++++++------ .../slice/map/string_string/json_test.go | 25 +++++++++++++------ output_tests/slice/ptr_bool/json_test.go | 25 +++++++++++++------ output_tests/slice/ptr_float64/json_test.go | 25 +++++++++++++------ output_tests/slice/ptr_int32/json_test.go | 25 +++++++++++++------ .../slice/ptr_map/int32_string/json_test.go | 25 +++++++++++++------ .../slice/ptr_map/string_string/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/bool/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/byte/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/float64/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/int32/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/ptr_string/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/string/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/uint8/json_test.go | 25 +++++++++++++------ output_tests/slice/ptr_string/json_test.go | 25 +++++++++++++------ .../slice/ptr_struct_various/json_test.go | 25 +++++++++++++------ output_tests/slice/ptr_uint8/json_test.go | 25 +++++++++++++------ output_tests/slice/slice/bool/json_test.go | 25 +++++++++++++------ output_tests/slice/slice/byte/json_test.go | 25 +++++++++++++------ output_tests/slice/slice/float64/json_test.go | 25 +++++++++++++------ output_tests/slice/slice/int32/json_test.go | 25 +++++++++++++------ .../slice/slice/ptr_string/json_test.go | 25 +++++++++++++------ output_tests/slice/slice/string/json_test.go | 25 +++++++++++++------ output_tests/slice/slice/uint8/json_test.go | 25 +++++++++++++------ output_tests/slice/string/json_test.go | 25 +++++++++++++------ output_tests/slice/struct_empty/json_test.go | 25 +++++++++++++------ .../slice/struct_empty_alias/json_test.go | 25 +++++++++++++------ .../slice/struct_ptr_string/json_test.go | 25 +++++++++++++------ .../slice/struct_various/json_test.go | 25 +++++++++++++------ output_tests/slice/uint8/json_test.go | 25 +++++++++++++------ output_tests/struct/alias/json_test.go | 25 +++++++++++++------ output_tests/struct/empty/json_test.go | 25 +++++++++++++------ output_tests/struct/empty_alias/json_test.go | 25 +++++++++++++------ output_tests/struct/everything/json_test.go | 25 +++++++++++++------ output_tests/struct/float64/json_test.go | 25 +++++++++++++------ .../struct/float64_alias/json_test.go | 25 +++++++++++++------ output_tests/struct/float64s/json_test.go | 25 +++++++++++++------ .../struct/float64s_alias/json_test.go | 25 +++++++++++++------ output_tests/struct/int32/json_test.go | 25 +++++++++++++------ output_tests/struct/int32_alias/json_test.go | 25 +++++++++++++------ output_tests/struct/int32s/json_test.go | 25 +++++++++++++------ output_tests/struct/int32s_alias/json_test.go | 25 +++++++++++++------ .../struct/map/int32_ptr_string/json_test.go | 25 +++++++++++++------ .../struct/map/int32_string/json_test.go | 25 +++++++++++++------ .../map/int32_struct_strings/json_test.go | 25 +++++++++++++------ .../struct/map/string_ptr_string/json_test.go | 25 +++++++++++++------ .../struct/map/string_string/json_test.go | 25 +++++++++++++------ .../map/string_struct_strings/json_test.go | 25 +++++++++++++------ output_tests/struct/ptr_float64/json_test.go | 25 +++++++++++++------ .../struct/ptr_float64_alias/json_test.go | 25 +++++++++++++------ output_tests/struct/ptr_int32/json_test.go | 25 +++++++++++++------ .../struct/ptr_int32_alias/json_test.go | 25 +++++++++++++------ .../struct/ptr_ptr_struct_empty/json_test.go | 25 +++++++++++++------ .../ptr_ptr_struct_strings/json_test.go | 25 +++++++++++++------ output_tests/struct/ptr_string/json_test.go | 25 +++++++++++++------ .../struct/ptr_string_alias/json_test.go | 25 +++++++++++++------ .../struct/ptr_struct_empty/json_test.go | 25 +++++++++++++------ .../struct/ptr_struct_strings/json_test.go | 25 +++++++++++++------ output_tests/struct/ptrs_float64/json_test.go | 25 +++++++++++++------ output_tests/struct/ptrs_int32/json_test.go | 25 +++++++++++++------ output_tests/struct/ptrs_string/json_test.go | 25 +++++++++++++------ .../struct/slice/ptr_string/json_test.go | 25 +++++++++++++------ output_tests/struct/slice/string/json_test.go | 25 +++++++++++++------ .../struct/slice/string_alias/json_test.go | 25 +++++++++++++------ .../struct/slice/strings/json_test.go | 25 +++++++++++++------ .../struct/slice/struct_strings/json_test.go | 25 +++++++++++++------ output_tests/struct/string/json_test.go | 25 +++++++++++++------ output_tests/struct/string_alias/json_test.go | 25 +++++++++++++------ output_tests/struct/strings/json_test.go | 25 +++++++++++++------ .../struct/strings_alias/json_test.go | 25 +++++++++++++------ .../struct/struct/empties/json_test.go | 25 +++++++++++++------ output_tests/struct/struct/empty/json_test.go | 25 +++++++++++++------ .../struct/struct/empty_alias/json_test.go | 25 +++++++++++++------ .../struct/struct/float32s/json_test.go | 25 +++++++++++++------ .../struct/struct/float64/json_test.go | 25 +++++++++++++------ .../struct/struct/float64_alias/json_test.go | 25 +++++++++++++------ .../struct/struct/int32s/json_test.go | 25 +++++++++++++------ .../struct/struct/strings/json_test.go | 25 +++++++++++++------ .../struct/struct/strings_alias/json_test.go | 25 +++++++++++++------ .../struct_tags/fieldname/json_test.go | 25 +++++++++++++------ .../struct_tags/omitempty/bool/json_test.go | 25 +++++++++++++------ .../omitempty/float32/json_test.go | 25 +++++++++++++------ .../struct_tags/omitempty/int32/json_test.go | 25 +++++++++++++------ .../omitempty/map_string_string/json_test.go | 25 +++++++++++++------ .../omitempty/ptr_string/json_test.go | 25 +++++++++++++------ .../omitempty/slice_string/json_test.go | 25 +++++++++++++------ .../struct_tags/omitempty/string/json_test.go | 25 +++++++++++++------ .../struct_tags/omitempty/uint32/json_test.go | 25 +++++++++++++------ 143 files changed, 2574 insertions(+), 1001 deletions(-) diff --git a/output_tests/builtins/bool/json_test.go b/output_tests/builtins/bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/bool/json_test.go +++ b/output_tests/builtins/bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/bool_alias/json_test.go b/output_tests/builtins/bool_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/bool_alias/json_test.go +++ b/output_tests/builtins/bool_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/byte/json_test.go b/output_tests/builtins/byte/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/byte/json_test.go +++ b/output_tests/builtins/byte/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/byte_alias/json_test.go b/output_tests/builtins/byte_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/byte_alias/json_test.go +++ b/output_tests/builtins/byte_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/float32/json_test.go b/output_tests/builtins/float32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/float32/json_test.go +++ b/output_tests/builtins/float32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/float32_alias/json_test.go b/output_tests/builtins/float32_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/float32_alias/json_test.go +++ b/output_tests/builtins/float32_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/float64/json_test.go b/output_tests/builtins/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/float64/json_test.go +++ b/output_tests/builtins/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/float64_alias/json_test.go b/output_tests/builtins/float64_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/float64_alias/json_test.go +++ b/output_tests/builtins/float64_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/int16/json_test.go b/output_tests/builtins/int16/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/int16/json_test.go +++ b/output_tests/builtins/int16/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/int16_alias/json_test.go b/output_tests/builtins/int16_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/int16_alias/json_test.go +++ b/output_tests/builtins/int16_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/int32/json_test.go b/output_tests/builtins/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/int32/json_test.go +++ b/output_tests/builtins/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/int32_alias/json_test.go b/output_tests/builtins/int32_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/int32_alias/json_test.go +++ b/output_tests/builtins/int32_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/int8/json_test.go b/output_tests/builtins/int8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/int8/json_test.go +++ b/output_tests/builtins/int8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/int8_alias/json_test.go b/output_tests/builtins/int8_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/int8_alias/json_test.go +++ b/output_tests/builtins/int8_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/string/json_test.go b/output_tests/builtins/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/string/json_test.go +++ b/output_tests/builtins/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/string_alias/json_test.go b/output_tests/builtins/string_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/string_alias/json_test.go +++ b/output_tests/builtins/string_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/uint16/json_test.go b/output_tests/builtins/uint16/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/uint16/json_test.go +++ b/output_tests/builtins/uint16/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/uint16_alias/json_test.go b/output_tests/builtins/uint16_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/uint16_alias/json_test.go +++ b/output_tests/builtins/uint16_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/uint32/json_test.go b/output_tests/builtins/uint32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/uint32/json_test.go +++ b/output_tests/builtins/uint32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/uint32_alias/json_test.go b/output_tests/builtins/uint32_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/uint32_alias/json_test.go +++ b/output_tests/builtins/uint32_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/uint8/json_test.go b/output_tests/builtins/uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/uint8/json_test.go +++ b/output_tests/builtins/uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/uint8_alias/json_test.go b/output_tests/builtins/uint8_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/uint8_alias/json_test.go +++ b/output_tests/builtins/uint8_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/int16/string/json_test.go b/output_tests/map/int16/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/int16/string/json_test.go +++ b/output_tests/map/int16/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/int32/string/json_test.go b/output_tests/map/int32/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/int32/string/json_test.go +++ b/output_tests/map/int32/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/int8/string/json_test.go b/output_tests/map/int8/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/int8/string/json_test.go +++ b/output_tests/map/int8/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/bool/json_test.go b/output_tests/map/string/bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/bool/json_test.go +++ b/output_tests/map/string/bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/byte/json_test.go b/output_tests/map/string/byte/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/byte/json_test.go +++ b/output_tests/map/string/byte/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/float64/json_test.go b/output_tests/map/string/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/float64/json_test.go +++ b/output_tests/map/string/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/int32/json_test.go b/output_tests/map/string/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/int32/json_test.go +++ b/output_tests/map/string/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/map_string_string/json_test.go b/output_tests/map/string/map_string_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/map_string_string/json_test.go +++ b/output_tests/map/string/map_string_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_bool/json_test.go b/output_tests/map/string/ptr_bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_bool/json_test.go +++ b/output_tests/map/string/ptr_bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_float64/json_test.go b/output_tests/map/string/ptr_float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_float64/json_test.go +++ b/output_tests/map/string/ptr_float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_int32/json_test.go b/output_tests/map/string/ptr_int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_int32/json_test.go +++ b/output_tests/map/string/ptr_int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_map_string_string/json_test.go b/output_tests/map/string/ptr_map_string_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_map_string_string/json_test.go +++ b/output_tests/map/string/ptr_map_string_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_slice_string/json_test.go b/output_tests/map/string/ptr_slice_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_slice_string/json_test.go +++ b/output_tests/map/string/ptr_slice_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_string/json_test.go b/output_tests/map/string/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_string/json_test.go +++ b/output_tests/map/string/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_struct_various/json_test.go b/output_tests/map/string/ptr_struct_various/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_struct_various/json_test.go +++ b/output_tests/map/string/ptr_struct_various/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_uint8/json_test.go b/output_tests/map/string/ptr_uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_uint8/json_test.go +++ b/output_tests/map/string/ptr_uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/slice_string/json_test.go b/output_tests/map/string/slice_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/slice_string/json_test.go +++ b/output_tests/map/string/slice_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/string/json_test.go b/output_tests/map/string/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/string/json_test.go +++ b/output_tests/map/string/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/string_alias/json_test.go b/output_tests/map/string/string_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/string_alias/json_test.go +++ b/output_tests/map/string/string_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/struct_empty/json_test.go b/output_tests/map/string/struct_empty/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/struct_empty/json_test.go +++ b/output_tests/map/string/struct_empty/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/struct_empty_alias/json_test.go b/output_tests/map/string/struct_empty_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/struct_empty_alias/json_test.go +++ b/output_tests/map/string/struct_empty_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/struct_ptr_string/json_test.go b/output_tests/map/string/struct_ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/struct_ptr_string/json_test.go +++ b/output_tests/map/string/struct_ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/struct_various/json_test.go b/output_tests/map/string/struct_various/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/struct_various/json_test.go +++ b/output_tests/map/string/struct_various/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/uint8/json_test.go b/output_tests/map/string/uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/uint8/json_test.go +++ b/output_tests/map/string/uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string_alias/string/json_test.go b/output_tests/map/string_alias/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string_alias/string/json_test.go +++ b/output_tests/map/string_alias/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string_alias/string_alias/json_test.go b/output_tests/map/string_alias/string_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string_alias/string_alias/json_test.go +++ b/output_tests/map/string_alias/string_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/uint16/string/json_test.go b/output_tests/map/uint16/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/uint16/string/json_test.go +++ b/output_tests/map/uint16/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/uint32/string/json_test.go b/output_tests/map/uint32/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/uint32/string/json_test.go +++ b/output_tests/map/uint32/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/uint8/string/json_test.go b/output_tests/map/uint8/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/uint8/string/json_test.go +++ b/output_tests/map/uint8/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/bool/json_test.go b/output_tests/slice/bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/bool/json_test.go +++ b/output_tests/slice/bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/byte/json_test.go b/output_tests/slice/byte/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/byte/json_test.go +++ b/output_tests/slice/byte/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/float64/json_test.go b/output_tests/slice/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/float64/json_test.go +++ b/output_tests/slice/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/int32/json_test.go b/output_tests/slice/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/int32/json_test.go +++ b/output_tests/slice/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/map/int32_string/json_test.go b/output_tests/slice/map/int32_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/map/int32_string/json_test.go +++ b/output_tests/slice/map/int32_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/map/string_string/json_test.go b/output_tests/slice/map/string_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/map/string_string/json_test.go +++ b/output_tests/slice/map/string_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_bool/json_test.go b/output_tests/slice/ptr_bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_bool/json_test.go +++ b/output_tests/slice/ptr_bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_float64/json_test.go b/output_tests/slice/ptr_float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_float64/json_test.go +++ b/output_tests/slice/ptr_float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_int32/json_test.go b/output_tests/slice/ptr_int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_int32/json_test.go +++ b/output_tests/slice/ptr_int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_map/int32_string/json_test.go b/output_tests/slice/ptr_map/int32_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_map/int32_string/json_test.go +++ b/output_tests/slice/ptr_map/int32_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_map/string_string/json_test.go b/output_tests/slice/ptr_map/string_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_map/string_string/json_test.go +++ b/output_tests/slice/ptr_map/string_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/bool/json_test.go b/output_tests/slice/ptr_slice/bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/bool/json_test.go +++ b/output_tests/slice/ptr_slice/bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/byte/json_test.go b/output_tests/slice/ptr_slice/byte/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/byte/json_test.go +++ b/output_tests/slice/ptr_slice/byte/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/float64/json_test.go b/output_tests/slice/ptr_slice/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/float64/json_test.go +++ b/output_tests/slice/ptr_slice/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/int32/json_test.go b/output_tests/slice/ptr_slice/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/int32/json_test.go +++ b/output_tests/slice/ptr_slice/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/ptr_string/json_test.go b/output_tests/slice/ptr_slice/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/ptr_string/json_test.go +++ b/output_tests/slice/ptr_slice/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/string/json_test.go b/output_tests/slice/ptr_slice/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/string/json_test.go +++ b/output_tests/slice/ptr_slice/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/uint8/json_test.go b/output_tests/slice/ptr_slice/uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/uint8/json_test.go +++ b/output_tests/slice/ptr_slice/uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_string/json_test.go b/output_tests/slice/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_string/json_test.go +++ b/output_tests/slice/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_struct_various/json_test.go b/output_tests/slice/ptr_struct_various/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_struct_various/json_test.go +++ b/output_tests/slice/ptr_struct_various/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_uint8/json_test.go b/output_tests/slice/ptr_uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_uint8/json_test.go +++ b/output_tests/slice/ptr_uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/bool/json_test.go b/output_tests/slice/slice/bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/bool/json_test.go +++ b/output_tests/slice/slice/bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/byte/json_test.go b/output_tests/slice/slice/byte/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/byte/json_test.go +++ b/output_tests/slice/slice/byte/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/float64/json_test.go b/output_tests/slice/slice/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/float64/json_test.go +++ b/output_tests/slice/slice/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/int32/json_test.go b/output_tests/slice/slice/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/int32/json_test.go +++ b/output_tests/slice/slice/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/ptr_string/json_test.go b/output_tests/slice/slice/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/ptr_string/json_test.go +++ b/output_tests/slice/slice/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/string/json_test.go b/output_tests/slice/slice/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/string/json_test.go +++ b/output_tests/slice/slice/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/uint8/json_test.go b/output_tests/slice/slice/uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/uint8/json_test.go +++ b/output_tests/slice/slice/uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/string/json_test.go b/output_tests/slice/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/string/json_test.go +++ b/output_tests/slice/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/struct_empty/json_test.go b/output_tests/slice/struct_empty/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/struct_empty/json_test.go +++ b/output_tests/slice/struct_empty/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/struct_empty_alias/json_test.go b/output_tests/slice/struct_empty_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/struct_empty_alias/json_test.go +++ b/output_tests/slice/struct_empty_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/struct_ptr_string/json_test.go b/output_tests/slice/struct_ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/struct_ptr_string/json_test.go +++ b/output_tests/slice/struct_ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/struct_various/json_test.go b/output_tests/slice/struct_various/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/struct_various/json_test.go +++ b/output_tests/slice/struct_various/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/uint8/json_test.go b/output_tests/slice/uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/uint8/json_test.go +++ b/output_tests/slice/uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/alias/json_test.go b/output_tests/struct/alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/alias/json_test.go +++ b/output_tests/struct/alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/empty/json_test.go b/output_tests/struct/empty/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/empty/json_test.go +++ b/output_tests/struct/empty/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/empty_alias/json_test.go b/output_tests/struct/empty_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/empty_alias/json_test.go +++ b/output_tests/struct/empty_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/everything/json_test.go b/output_tests/struct/everything/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/everything/json_test.go +++ b/output_tests/struct/everything/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/float64/json_test.go b/output_tests/struct/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/float64/json_test.go +++ b/output_tests/struct/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/float64_alias/json_test.go b/output_tests/struct/float64_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/float64_alias/json_test.go +++ b/output_tests/struct/float64_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/float64s/json_test.go b/output_tests/struct/float64s/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/float64s/json_test.go +++ b/output_tests/struct/float64s/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/float64s_alias/json_test.go b/output_tests/struct/float64s_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/float64s_alias/json_test.go +++ b/output_tests/struct/float64s_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/int32/json_test.go b/output_tests/struct/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/int32/json_test.go +++ b/output_tests/struct/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/int32_alias/json_test.go b/output_tests/struct/int32_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/int32_alias/json_test.go +++ b/output_tests/struct/int32_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/int32s/json_test.go b/output_tests/struct/int32s/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/int32s/json_test.go +++ b/output_tests/struct/int32s/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/int32s_alias/json_test.go b/output_tests/struct/int32s_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/int32s_alias/json_test.go +++ b/output_tests/struct/int32s_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/map/int32_ptr_string/json_test.go b/output_tests/struct/map/int32_ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/map/int32_ptr_string/json_test.go +++ b/output_tests/struct/map/int32_ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/map/int32_string/json_test.go b/output_tests/struct/map/int32_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/map/int32_string/json_test.go +++ b/output_tests/struct/map/int32_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/map/int32_struct_strings/json_test.go b/output_tests/struct/map/int32_struct_strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/map/int32_struct_strings/json_test.go +++ b/output_tests/struct/map/int32_struct_strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/map/string_ptr_string/json_test.go b/output_tests/struct/map/string_ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/map/string_ptr_string/json_test.go +++ b/output_tests/struct/map/string_ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/map/string_string/json_test.go b/output_tests/struct/map/string_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/map/string_string/json_test.go +++ b/output_tests/struct/map/string_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/map/string_struct_strings/json_test.go b/output_tests/struct/map/string_struct_strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/map/string_struct_strings/json_test.go +++ b/output_tests/struct/map/string_struct_strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_float64/json_test.go b/output_tests/struct/ptr_float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_float64/json_test.go +++ b/output_tests/struct/ptr_float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_float64_alias/json_test.go b/output_tests/struct/ptr_float64_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_float64_alias/json_test.go +++ b/output_tests/struct/ptr_float64_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_int32/json_test.go b/output_tests/struct/ptr_int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_int32/json_test.go +++ b/output_tests/struct/ptr_int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_int32_alias/json_test.go b/output_tests/struct/ptr_int32_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_int32_alias/json_test.go +++ b/output_tests/struct/ptr_int32_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_ptr_struct_empty/json_test.go b/output_tests/struct/ptr_ptr_struct_empty/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_ptr_struct_empty/json_test.go +++ b/output_tests/struct/ptr_ptr_struct_empty/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_ptr_struct_strings/json_test.go b/output_tests/struct/ptr_ptr_struct_strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_ptr_struct_strings/json_test.go +++ b/output_tests/struct/ptr_ptr_struct_strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_string/json_test.go b/output_tests/struct/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_string/json_test.go +++ b/output_tests/struct/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_string_alias/json_test.go b/output_tests/struct/ptr_string_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_string_alias/json_test.go +++ b/output_tests/struct/ptr_string_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_struct_empty/json_test.go b/output_tests/struct/ptr_struct_empty/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_struct_empty/json_test.go +++ b/output_tests/struct/ptr_struct_empty/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_struct_strings/json_test.go b/output_tests/struct/ptr_struct_strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_struct_strings/json_test.go +++ b/output_tests/struct/ptr_struct_strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptrs_float64/json_test.go b/output_tests/struct/ptrs_float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptrs_float64/json_test.go +++ b/output_tests/struct/ptrs_float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptrs_int32/json_test.go b/output_tests/struct/ptrs_int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptrs_int32/json_test.go +++ b/output_tests/struct/ptrs_int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptrs_string/json_test.go b/output_tests/struct/ptrs_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptrs_string/json_test.go +++ b/output_tests/struct/ptrs_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/slice/ptr_string/json_test.go b/output_tests/struct/slice/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/slice/ptr_string/json_test.go +++ b/output_tests/struct/slice/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/slice/string/json_test.go b/output_tests/struct/slice/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/slice/string/json_test.go +++ b/output_tests/struct/slice/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/slice/string_alias/json_test.go b/output_tests/struct/slice/string_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/slice/string_alias/json_test.go +++ b/output_tests/struct/slice/string_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/slice/strings/json_test.go b/output_tests/struct/slice/strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/slice/strings/json_test.go +++ b/output_tests/struct/slice/strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/slice/struct_strings/json_test.go b/output_tests/struct/slice/struct_strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/slice/struct_strings/json_test.go +++ b/output_tests/struct/slice/struct_strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/string/json_test.go b/output_tests/struct/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/string/json_test.go +++ b/output_tests/struct/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/string_alias/json_test.go b/output_tests/struct/string_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/string_alias/json_test.go +++ b/output_tests/struct/string_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/strings/json_test.go b/output_tests/struct/strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/strings/json_test.go +++ b/output_tests/struct/strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/strings_alias/json_test.go b/output_tests/struct/strings_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/strings_alias/json_test.go +++ b/output_tests/struct/strings_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/empties/json_test.go b/output_tests/struct/struct/empties/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/empties/json_test.go +++ b/output_tests/struct/struct/empties/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/empty/json_test.go b/output_tests/struct/struct/empty/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/empty/json_test.go +++ b/output_tests/struct/struct/empty/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/empty_alias/json_test.go b/output_tests/struct/struct/empty_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/empty_alias/json_test.go +++ b/output_tests/struct/struct/empty_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/float32s/json_test.go b/output_tests/struct/struct/float32s/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/float32s/json_test.go +++ b/output_tests/struct/struct/float32s/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/float64/json_test.go b/output_tests/struct/struct/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/float64/json_test.go +++ b/output_tests/struct/struct/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/float64_alias/json_test.go b/output_tests/struct/struct/float64_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/float64_alias/json_test.go +++ b/output_tests/struct/struct/float64_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/int32s/json_test.go b/output_tests/struct/struct/int32s/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/int32s/json_test.go +++ b/output_tests/struct/struct/int32s/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/strings/json_test.go b/output_tests/struct/struct/strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/strings/json_test.go +++ b/output_tests/struct/struct/strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/strings_alias/json_test.go b/output_tests/struct/struct/strings_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/strings_alias/json_test.go +++ b/output_tests/struct/struct/strings_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/fieldname/json_test.go b/output_tests/struct_tags/fieldname/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/fieldname/json_test.go +++ b/output_tests/struct_tags/fieldname/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/bool/json_test.go b/output_tests/struct_tags/omitempty/bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/bool/json_test.go +++ b/output_tests/struct_tags/omitempty/bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/float32/json_test.go b/output_tests/struct_tags/omitempty/float32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/float32/json_test.go +++ b/output_tests/struct_tags/omitempty/float32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/int32/json_test.go b/output_tests/struct_tags/omitempty/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/int32/json_test.go +++ b/output_tests/struct_tags/omitempty/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/map_string_string/json_test.go b/output_tests/struct_tags/omitempty/map_string_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/map_string_string/json_test.go +++ b/output_tests/struct_tags/omitempty/map_string_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/ptr_string/json_test.go b/output_tests/struct_tags/omitempty/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/ptr_string/json_test.go +++ b/output_tests/struct_tags/omitempty/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/slice_string/json_test.go b/output_tests/struct_tags/omitempty/slice_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/slice_string/json_test.go +++ b/output_tests/struct_tags/omitempty/slice_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/string/json_test.go b/output_tests/struct_tags/omitempty/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/string/json_test.go +++ b/output_tests/struct_tags/omitempty/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/uint32/json_test.go b/output_tests/struct_tags/omitempty/uint32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/uint32/json_test.go +++ b/output_tests/struct_tags/omitempty/uint32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("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) + t.Fatalf("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) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } From 5bb7a1f7afefe67e8aa7041e4ed2085df82207bb Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 20:42:39 +0100 Subject: [PATCH 12/18] Add output test for 'string' tag --- .../struct_tags/string/bool/json_test.go | 150 ++++++++++++++++++ output_tests/struct_tags/string/bool/types.go | 6 + .../struct_tags/string/byte/json_test.go | 150 ++++++++++++++++++ output_tests/struct_tags/string/byte/types.go | 6 + .../struct_tags/string/float32/json_test.go | 150 ++++++++++++++++++ .../struct_tags/string/float32/types.go | 6 + .../struct_tags/string/float64/json_test.go | 150 ++++++++++++++++++ .../struct_tags/string/float64/types.go | 6 + .../struct_tags/string/int16/json_test.go | 150 ++++++++++++++++++ .../struct_tags/string/int16/types.go | 6 + .../struct_tags/string/int32/json_test.go | 150 ++++++++++++++++++ .../struct_tags/string/int32/types.go | 6 + .../struct_tags/string/int8/json_test.go | 150 ++++++++++++++++++ output_tests/struct_tags/string/int8/types.go | 6 + .../struct_tags/string/string/json_test.go | 150 ++++++++++++++++++ .../struct_tags/string/string/types.go | 6 + .../struct_tags/string/uint16/json_test.go | 150 ++++++++++++++++++ .../struct_tags/string/uint16/types.go | 6 + .../struct_tags/string/uint32/json_test.go | 150 ++++++++++++++++++ .../struct_tags/string/uint32/types.go | 6 + .../struct_tags/string/uint8/json_test.go | 150 ++++++++++++++++++ .../struct_tags/string/uint8/types.go | 6 + 22 files changed, 1716 insertions(+) create mode 100644 output_tests/struct_tags/string/bool/json_test.go create mode 100644 output_tests/struct_tags/string/bool/types.go create mode 100644 output_tests/struct_tags/string/byte/json_test.go create mode 100644 output_tests/struct_tags/string/byte/types.go create mode 100644 output_tests/struct_tags/string/float32/json_test.go create mode 100644 output_tests/struct_tags/string/float32/types.go create mode 100644 output_tests/struct_tags/string/float64/json_test.go create mode 100644 output_tests/struct_tags/string/float64/types.go create mode 100644 output_tests/struct_tags/string/int16/json_test.go create mode 100644 output_tests/struct_tags/string/int16/types.go create mode 100644 output_tests/struct_tags/string/int32/json_test.go create mode 100644 output_tests/struct_tags/string/int32/types.go create mode 100644 output_tests/struct_tags/string/int8/json_test.go create mode 100644 output_tests/struct_tags/string/int8/types.go create mode 100644 output_tests/struct_tags/string/string/json_test.go create mode 100644 output_tests/struct_tags/string/string/types.go create mode 100644 output_tests/struct_tags/string/uint16/json_test.go create mode 100644 output_tests/struct_tags/string/uint16/types.go create mode 100644 output_tests/struct_tags/string/uint32/json_test.go create mode 100644 output_tests/struct_tags/string/uint32/types.go create mode 100644 output_tests/struct_tags/string/uint8/json_test.go create mode 100644 output_tests/struct_tags/string/uint8/types.go diff --git a/output_tests/struct_tags/string/bool/json_test.go b/output_tests/struct_tags/string/bool/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/struct_tags/string/bool/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct_tags/string/bool/types.go b/output_tests/struct_tags/string/bool/types.go new file mode 100644 index 0000000..2a62243 --- /dev/null +++ b/output_tests/struct_tags/string/bool/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 bool `json:"F1"` + F2 bool `json:"F2,string"` +} diff --git a/output_tests/struct_tags/string/byte/json_test.go b/output_tests/struct_tags/string/byte/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/struct_tags/string/byte/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct_tags/string/byte/types.go b/output_tests/struct_tags/string/byte/types.go new file mode 100644 index 0000000..5b7132d --- /dev/null +++ b/output_tests/struct_tags/string/byte/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 byte `json:"F1"` + F2 byte `json:"F2,string"` +} diff --git a/output_tests/struct_tags/string/float32/json_test.go b/output_tests/struct_tags/string/float32/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/struct_tags/string/float32/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct_tags/string/float32/types.go b/output_tests/struct_tags/string/float32/types.go new file mode 100644 index 0000000..d49696b --- /dev/null +++ b/output_tests/struct_tags/string/float32/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 float32 `json:"F1"` + F2 float32 `json:"F2,string"` +} diff --git a/output_tests/struct_tags/string/float64/json_test.go b/output_tests/struct_tags/string/float64/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/struct_tags/string/float64/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct_tags/string/float64/types.go b/output_tests/struct_tags/string/float64/types.go new file mode 100644 index 0000000..073436f --- /dev/null +++ b/output_tests/struct_tags/string/float64/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 float64 `json:"F1"` + F2 float64 `json:"F2,string"` +} diff --git a/output_tests/struct_tags/string/int16/json_test.go b/output_tests/struct_tags/string/int16/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/struct_tags/string/int16/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct_tags/string/int16/types.go b/output_tests/struct_tags/string/int16/types.go new file mode 100644 index 0000000..5e291e9 --- /dev/null +++ b/output_tests/struct_tags/string/int16/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 int16 `json:"F1"` + F2 int16 `json:"F2,string"` +} diff --git a/output_tests/struct_tags/string/int32/json_test.go b/output_tests/struct_tags/string/int32/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/struct_tags/string/int32/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct_tags/string/int32/types.go b/output_tests/struct_tags/string/int32/types.go new file mode 100644 index 0000000..406f9c0 --- /dev/null +++ b/output_tests/struct_tags/string/int32/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 int32 `json:"F1"` + F2 int32 `json:"F2,string"` +} diff --git a/output_tests/struct_tags/string/int8/json_test.go b/output_tests/struct_tags/string/int8/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/struct_tags/string/int8/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct_tags/string/int8/types.go b/output_tests/struct_tags/string/int8/types.go new file mode 100644 index 0000000..bd16a4e --- /dev/null +++ b/output_tests/struct_tags/string/int8/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 int8 `json:"F1"` + F2 int8 `json:"F2,string"` +} diff --git a/output_tests/struct_tags/string/string/json_test.go b/output_tests/struct_tags/string/string/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/struct_tags/string/string/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct_tags/string/string/types.go b/output_tests/struct_tags/string/string/types.go new file mode 100644 index 0000000..4d1a646 --- /dev/null +++ b/output_tests/struct_tags/string/string/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 string `json:"F1"` + F2 string `json:"F2,string"` +} diff --git a/output_tests/struct_tags/string/uint16/json_test.go b/output_tests/struct_tags/string/uint16/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/struct_tags/string/uint16/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct_tags/string/uint16/types.go b/output_tests/struct_tags/string/uint16/types.go new file mode 100644 index 0000000..a338d54 --- /dev/null +++ b/output_tests/struct_tags/string/uint16/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 uint16 `json:"F1"` + F2 uint16 `json:"F2,string"` +} diff --git a/output_tests/struct_tags/string/uint32/json_test.go b/output_tests/struct_tags/string/uint32/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/struct_tags/string/uint32/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct_tags/string/uint32/types.go b/output_tests/struct_tags/string/uint32/types.go new file mode 100644 index 0000000..1bdd7aa --- /dev/null +++ b/output_tests/struct_tags/string/uint32/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 uint32 `json:"F1"` + F2 uint32 `json:"F2,string"` +} diff --git a/output_tests/struct_tags/string/uint8/json_test.go b/output_tests/struct_tags/string/uint8/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/struct_tags/string/uint8/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct_tags/string/uint8/types.go b/output_tests/struct_tags/string/uint8/types.go new file mode 100644 index 0000000..01f16c4 --- /dev/null +++ b/output_tests/struct_tags/string/uint8/types.go @@ -0,0 +1,6 @@ +package test + +type T struct { + F1 uint8 `json:"F1"` + F2 uint8 `json:"F2,string"` +} From 628fedf63cff8f7d9a1920043a558f7b166d9a1f Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 20:54:18 +0100 Subject: [PATCH 13/18] Add output tests for map keys with TextMarshal --- .../string_alias/json_test.go | 150 ++++++++++++++++++ .../string_alias/types.go | 22 +++ .../map_key_text_marshal/struct/json_test.go | 150 ++++++++++++++++++ .../map_key_text_marshal/struct/types.go | 24 +++ .../struct_alias/json_test.go | 150 ++++++++++++++++++ .../struct_alias/types.go | 26 +++ 6 files changed, 522 insertions(+) create mode 100644 output_tests/map_key_text_marshal/string_alias/json_test.go create mode 100644 output_tests/map_key_text_marshal/string_alias/types.go create mode 100644 output_tests/map_key_text_marshal/struct/json_test.go create mode 100644 output_tests/map_key_text_marshal/struct/types.go create mode 100644 output_tests/map_key_text_marshal/struct_alias/json_test.go create mode 100644 output_tests/map_key_text_marshal/struct_alias/types.go diff --git a/output_tests/map_key_text_marshal/string_alias/json_test.go b/output_tests/map_key_text_marshal/string_alias/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/map_key_text_marshal/string_alias/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/map_key_text_marshal/string_alias/types.go b/output_tests/map_key_text_marshal/string_alias/types.go new file mode 100644 index 0000000..af41fe2 --- /dev/null +++ b/output_tests/map_key_text_marshal/string_alias/types.go @@ -0,0 +1,22 @@ +package test + +import ( + "encoding" + "strings" +) + +type KeyType string + +func (k KeyType) MarshalText() ([]byte, error) { + return []byte("MANUAL__" + k), nil +} + +func (k *KeyType) UnmarshalText(text []byte) error { + *k = KeyType(strings.TrimPrefix(string(text), "MANUAL__")) + return nil +} + +var _ encoding.TextMarshaler = KeyType("") +var _ encoding.TextUnmarshaler = new(KeyType) + +type T map[KeyType]string diff --git a/output_tests/map_key_text_marshal/struct/json_test.go b/output_tests/map_key_text_marshal/struct/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/map_key_text_marshal/struct/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/map_key_text_marshal/struct/types.go b/output_tests/map_key_text_marshal/struct/types.go new file mode 100644 index 0000000..360ebe8 --- /dev/null +++ b/output_tests/map_key_text_marshal/struct/types.go @@ -0,0 +1,24 @@ +package test + +import ( + "encoding" + "strings" +) + +type KeyType struct { + X string +} + +func (k KeyType) MarshalText() ([]byte, error) { + return []byte("MANUAL__" + k.X), nil +} + +func (k *KeyType) UnmarshalText(text []byte) error { + k.X = strings.TrimPrefix(string(text), "MANUAL__") + return nil +} + +var _ encoding.TextMarshaler = KeyType{} +var _ encoding.TextUnmarshaler = &KeyType{} + +type T map[KeyType]string diff --git a/output_tests/map_key_text_marshal/struct_alias/json_test.go b/output_tests/map_key_text_marshal/struct_alias/json_test.go new file mode 100644 index 0000000..196f98d --- /dev/null +++ b/output_tests/map_key_text_marshal/struct_alias/json_test.go @@ -0,0 +1,150 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v", err) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v", err) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/map_key_text_marshal/struct_alias/types.go b/output_tests/map_key_text_marshal/struct_alias/types.go new file mode 100644 index 0000000..30d61f2 --- /dev/null +++ b/output_tests/map_key_text_marshal/struct_alias/types.go @@ -0,0 +1,26 @@ +package test + +import ( + "encoding" + "strings" +) + +type KeyType struct { + X string +} + +func (k KeyType) MarshalText() ([]byte, error) { + return []byte("MANUAL__" + k.X), nil +} + +func (k *KeyType) UnmarshalText(text []byte) error { + k.X = strings.TrimPrefix(string(text), "MANUAL__") + return nil +} + +var _ encoding.TextMarshaler = KeyType{} +var _ encoding.TextUnmarshaler = &KeyType{} + +type A KeyType + +type T map[A]string From d6ef711c182a4491e9f4d48c82045c74c1008596 Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 21:09:08 +0100 Subject: [PATCH 14/18] Better errors in output_tests --- output_tests/builtins/bool/json_test.go | 6 ++++-- output_tests/builtins/bool_alias/json_test.go | 6 ++++-- output_tests/builtins/byte/json_test.go | 6 ++++-- output_tests/builtins/byte_alias/json_test.go | 6 ++++-- output_tests/builtins/float32/json_test.go | 6 ++++-- output_tests/builtins/float32_alias/json_test.go | 6 ++++-- output_tests/builtins/float64/json_test.go | 6 ++++-- output_tests/builtins/float64_alias/json_test.go | 6 ++++-- output_tests/builtins/int16/json_test.go | 6 ++++-- output_tests/builtins/int16_alias/json_test.go | 6 ++++-- output_tests/builtins/int32/json_test.go | 6 ++++-- output_tests/builtins/int32_alias/json_test.go | 6 ++++-- output_tests/builtins/int8/json_test.go | 6 ++++-- output_tests/builtins/int8_alias/json_test.go | 6 ++++-- output_tests/builtins/string/json_test.go | 6 ++++-- output_tests/builtins/string_alias/json_test.go | 6 ++++-- output_tests/builtins/uint16/json_test.go | 6 ++++-- output_tests/builtins/uint16_alias/json_test.go | 6 ++++-- output_tests/builtins/uint32/json_test.go | 6 ++++-- output_tests/builtins/uint32_alias/json_test.go | 6 ++++-- output_tests/builtins/uint8/json_test.go | 6 ++++-- output_tests/builtins/uint8_alias/json_test.go | 6 ++++-- output_tests/map/int16/string/json_test.go | 6 ++++-- output_tests/map/int32/string/json_test.go | 6 ++++-- output_tests/map/int8/string/json_test.go | 6 ++++-- output_tests/map/string/bool/json_test.go | 6 ++++-- output_tests/map/string/byte/json_test.go | 6 ++++-- output_tests/map/string/float64/json_test.go | 6 ++++-- output_tests/map/string/int32/json_test.go | 6 ++++-- output_tests/map/string/map_string_string/json_test.go | 6 ++++-- output_tests/map/string/ptr_bool/json_test.go | 6 ++++-- output_tests/map/string/ptr_float64/json_test.go | 6 ++++-- output_tests/map/string/ptr_int32/json_test.go | 6 ++++-- output_tests/map/string/ptr_map_string_string/json_test.go | 6 ++++-- output_tests/map/string/ptr_slice_string/json_test.go | 6 ++++-- output_tests/map/string/ptr_string/json_test.go | 6 ++++-- output_tests/map/string/ptr_struct_various/json_test.go | 6 ++++-- output_tests/map/string/ptr_uint8/json_test.go | 6 ++++-- output_tests/map/string/slice_string/json_test.go | 6 ++++-- output_tests/map/string/string/json_test.go | 6 ++++-- output_tests/map/string/string_alias/json_test.go | 6 ++++-- output_tests/map/string/struct_empty/json_test.go | 6 ++++-- output_tests/map/string/struct_empty_alias/json_test.go | 6 ++++-- output_tests/map/string/struct_ptr_string/json_test.go | 6 ++++-- output_tests/map/string/struct_various/json_test.go | 6 ++++-- output_tests/map/string/uint8/json_test.go | 6 ++++-- output_tests/map/string_alias/string/json_test.go | 6 ++++-- output_tests/map/string_alias/string_alias/json_test.go | 6 ++++-- output_tests/map/uint16/string/json_test.go | 6 ++++-- output_tests/map/uint32/string/json_test.go | 6 ++++-- output_tests/map/uint8/string/json_test.go | 6 ++++-- output_tests/map_key_text_marshal/string_alias/json_test.go | 6 ++++-- output_tests/map_key_text_marshal/struct/json_test.go | 6 ++++-- output_tests/map_key_text_marshal/struct_alias/json_test.go | 6 ++++-- output_tests/slice/bool/json_test.go | 6 ++++-- output_tests/slice/byte/json_test.go | 6 ++++-- output_tests/slice/float64/json_test.go | 6 ++++-- output_tests/slice/int32/json_test.go | 6 ++++-- output_tests/slice/map/int32_string/json_test.go | 6 ++++-- output_tests/slice/map/string_string/json_test.go | 6 ++++-- output_tests/slice/ptr_bool/json_test.go | 6 ++++-- output_tests/slice/ptr_float64/json_test.go | 6 ++++-- output_tests/slice/ptr_int32/json_test.go | 6 ++++-- output_tests/slice/ptr_map/int32_string/json_test.go | 6 ++++-- output_tests/slice/ptr_map/string_string/json_test.go | 6 ++++-- output_tests/slice/ptr_slice/bool/json_test.go | 6 ++++-- output_tests/slice/ptr_slice/byte/json_test.go | 6 ++++-- output_tests/slice/ptr_slice/float64/json_test.go | 6 ++++-- output_tests/slice/ptr_slice/int32/json_test.go | 6 ++++-- output_tests/slice/ptr_slice/ptr_string/json_test.go | 6 ++++-- output_tests/slice/ptr_slice/string/json_test.go | 6 ++++-- output_tests/slice/ptr_slice/uint8/json_test.go | 6 ++++-- output_tests/slice/ptr_string/json_test.go | 6 ++++-- output_tests/slice/ptr_struct_various/json_test.go | 6 ++++-- output_tests/slice/ptr_uint8/json_test.go | 6 ++++-- output_tests/slice/slice/bool/json_test.go | 6 ++++-- output_tests/slice/slice/byte/json_test.go | 6 ++++-- output_tests/slice/slice/float64/json_test.go | 6 ++++-- output_tests/slice/slice/int32/json_test.go | 6 ++++-- output_tests/slice/slice/ptr_string/json_test.go | 6 ++++-- output_tests/slice/slice/string/json_test.go | 6 ++++-- output_tests/slice/slice/uint8/json_test.go | 6 ++++-- output_tests/slice/string/json_test.go | 6 ++++-- output_tests/slice/struct_empty/json_test.go | 6 ++++-- output_tests/slice/struct_empty_alias/json_test.go | 6 ++++-- output_tests/slice/struct_ptr_string/json_test.go | 6 ++++-- output_tests/slice/struct_various/json_test.go | 6 ++++-- output_tests/slice/uint8/json_test.go | 6 ++++-- output_tests/struct/alias/json_test.go | 6 ++++-- output_tests/struct/empty/json_test.go | 6 ++++-- output_tests/struct/empty_alias/json_test.go | 6 ++++-- output_tests/struct/everything/json_test.go | 6 ++++-- output_tests/struct/float64/json_test.go | 6 ++++-- output_tests/struct/float64_alias/json_test.go | 6 ++++-- output_tests/struct/float64s/json_test.go | 6 ++++-- output_tests/struct/float64s_alias/json_test.go | 6 ++++-- output_tests/struct/int32/json_test.go | 6 ++++-- output_tests/struct/int32_alias/json_test.go | 6 ++++-- output_tests/struct/int32s/json_test.go | 6 ++++-- output_tests/struct/int32s_alias/json_test.go | 6 ++++-- output_tests/struct/map/int32_ptr_string/json_test.go | 6 ++++-- output_tests/struct/map/int32_string/json_test.go | 6 ++++-- output_tests/struct/map/int32_struct_strings/json_test.go | 6 ++++-- output_tests/struct/map/string_ptr_string/json_test.go | 6 ++++-- output_tests/struct/map/string_string/json_test.go | 6 ++++-- output_tests/struct/map/string_struct_strings/json_test.go | 6 ++++-- output_tests/struct/ptr_float64/json_test.go | 6 ++++-- output_tests/struct/ptr_float64_alias/json_test.go | 6 ++++-- output_tests/struct/ptr_int32/json_test.go | 6 ++++-- output_tests/struct/ptr_int32_alias/json_test.go | 6 ++++-- output_tests/struct/ptr_ptr_struct_empty/json_test.go | 6 ++++-- output_tests/struct/ptr_ptr_struct_strings/json_test.go | 6 ++++-- output_tests/struct/ptr_string/json_test.go | 6 ++++-- output_tests/struct/ptr_string_alias/json_test.go | 6 ++++-- output_tests/struct/ptr_struct_empty/json_test.go | 6 ++++-- output_tests/struct/ptr_struct_strings/json_test.go | 6 ++++-- output_tests/struct/ptrs_float64/json_test.go | 6 ++++-- output_tests/struct/ptrs_int32/json_test.go | 6 ++++-- output_tests/struct/ptrs_string/json_test.go | 6 ++++-- output_tests/struct/slice/ptr_string/json_test.go | 6 ++++-- output_tests/struct/slice/string/json_test.go | 6 ++++-- output_tests/struct/slice/string_alias/json_test.go | 6 ++++-- output_tests/struct/slice/strings/json_test.go | 6 ++++-- output_tests/struct/slice/struct_strings/json_test.go | 6 ++++-- output_tests/struct/string/json_test.go | 6 ++++-- output_tests/struct/string_alias/json_test.go | 6 ++++-- output_tests/struct/strings/json_test.go | 6 ++++-- output_tests/struct/strings_alias/json_test.go | 6 ++++-- output_tests/struct/struct/empties/json_test.go | 6 ++++-- output_tests/struct/struct/empty/json_test.go | 6 ++++-- output_tests/struct/struct/empty_alias/json_test.go | 6 ++++-- output_tests/struct/struct/float32s/json_test.go | 6 ++++-- output_tests/struct/struct/float64/json_test.go | 6 ++++-- output_tests/struct/struct/float64_alias/json_test.go | 6 ++++-- output_tests/struct/struct/int32s/json_test.go | 6 ++++-- output_tests/struct/struct/strings/json_test.go | 6 ++++-- output_tests/struct/struct/strings_alias/json_test.go | 6 ++++-- output_tests/struct_tags/fieldname/json_test.go | 6 ++++-- output_tests/struct_tags/omitempty/bool/json_test.go | 6 ++++-- output_tests/struct_tags/omitempty/float32/json_test.go | 6 ++++-- output_tests/struct_tags/omitempty/int32/json_test.go | 6 ++++-- .../struct_tags/omitempty/map_string_string/json_test.go | 6 ++++-- output_tests/struct_tags/omitempty/ptr_string/json_test.go | 6 ++++-- .../struct_tags/omitempty/slice_string/json_test.go | 6 ++++-- output_tests/struct_tags/omitempty/string/json_test.go | 6 ++++-- output_tests/struct_tags/omitempty/uint32/json_test.go | 6 ++++-- output_tests/struct_tags/string/bool/json_test.go | 6 ++++-- output_tests/struct_tags/string/byte/json_test.go | 6 ++++-- output_tests/struct_tags/string/float32/json_test.go | 6 ++++-- output_tests/struct_tags/string/float64/json_test.go | 6 ++++-- output_tests/struct_tags/string/int16/json_test.go | 6 ++++-- output_tests/struct_tags/string/int32/json_test.go | 6 ++++-- output_tests/struct_tags/string/int8/json_test.go | 6 ++++-- output_tests/struct_tags/string/string/json_test.go | 6 ++++-- output_tests/struct_tags/string/uint16/json_test.go | 6 ++++-- output_tests/struct_tags/string/uint32/json_test.go | 6 ++++-- output_tests/struct_tags/string/uint8/json_test.go | 6 ++++-- 157 files changed, 628 insertions(+), 314 deletions(-) diff --git a/output_tests/builtins/bool/json_test.go b/output_tests/builtins/bool/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/bool/json_test.go +++ b/output_tests/builtins/bool/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/bool_alias/json_test.go b/output_tests/builtins/bool_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/bool_alias/json_test.go +++ b/output_tests/builtins/bool_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/byte/json_test.go b/output_tests/builtins/byte/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/byte/json_test.go +++ b/output_tests/builtins/byte/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/byte_alias/json_test.go b/output_tests/builtins/byte_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/byte_alias/json_test.go +++ b/output_tests/builtins/byte_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/float32/json_test.go b/output_tests/builtins/float32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/float32/json_test.go +++ b/output_tests/builtins/float32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/float32_alias/json_test.go b/output_tests/builtins/float32_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/float32_alias/json_test.go +++ b/output_tests/builtins/float32_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/float64/json_test.go b/output_tests/builtins/float64/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/float64/json_test.go +++ b/output_tests/builtins/float64/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/float64_alias/json_test.go b/output_tests/builtins/float64_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/float64_alias/json_test.go +++ b/output_tests/builtins/float64_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/int16/json_test.go b/output_tests/builtins/int16/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/int16/json_test.go +++ b/output_tests/builtins/int16/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/int16_alias/json_test.go b/output_tests/builtins/int16_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/int16_alias/json_test.go +++ b/output_tests/builtins/int16_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/int32/json_test.go b/output_tests/builtins/int32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/int32/json_test.go +++ b/output_tests/builtins/int32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/int32_alias/json_test.go b/output_tests/builtins/int32_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/int32_alias/json_test.go +++ b/output_tests/builtins/int32_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/int8/json_test.go b/output_tests/builtins/int8/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/int8/json_test.go +++ b/output_tests/builtins/int8/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/int8_alias/json_test.go b/output_tests/builtins/int8_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/int8_alias/json_test.go +++ b/output_tests/builtins/int8_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/string/json_test.go b/output_tests/builtins/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/string/json_test.go +++ b/output_tests/builtins/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/string_alias/json_test.go b/output_tests/builtins/string_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/string_alias/json_test.go +++ b/output_tests/builtins/string_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/uint16/json_test.go b/output_tests/builtins/uint16/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/uint16/json_test.go +++ b/output_tests/builtins/uint16/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/uint16_alias/json_test.go b/output_tests/builtins/uint16_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/uint16_alias/json_test.go +++ b/output_tests/builtins/uint16_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/uint32/json_test.go b/output_tests/builtins/uint32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/uint32/json_test.go +++ b/output_tests/builtins/uint32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/uint32_alias/json_test.go b/output_tests/builtins/uint32_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/uint32_alias/json_test.go +++ b/output_tests/builtins/uint32_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/uint8/json_test.go b/output_tests/builtins/uint8/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/uint8/json_test.go +++ b/output_tests/builtins/uint8/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/builtins/uint8_alias/json_test.go b/output_tests/builtins/uint8_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/builtins/uint8_alias/json_test.go +++ b/output_tests/builtins/uint8_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/int16/string/json_test.go b/output_tests/map/int16/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/int16/string/json_test.go +++ b/output_tests/map/int16/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/int32/string/json_test.go b/output_tests/map/int32/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/int32/string/json_test.go +++ b/output_tests/map/int32/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/int8/string/json_test.go b/output_tests/map/int8/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/int8/string/json_test.go +++ b/output_tests/map/int8/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/bool/json_test.go b/output_tests/map/string/bool/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/bool/json_test.go +++ b/output_tests/map/string/bool/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/byte/json_test.go b/output_tests/map/string/byte/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/byte/json_test.go +++ b/output_tests/map/string/byte/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/float64/json_test.go b/output_tests/map/string/float64/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/float64/json_test.go +++ b/output_tests/map/string/float64/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/int32/json_test.go b/output_tests/map/string/int32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/int32/json_test.go +++ b/output_tests/map/string/int32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/map_string_string/json_test.go b/output_tests/map/string/map_string_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/map_string_string/json_test.go +++ b/output_tests/map/string/map_string_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/ptr_bool/json_test.go b/output_tests/map/string/ptr_bool/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/ptr_bool/json_test.go +++ b/output_tests/map/string/ptr_bool/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/ptr_float64/json_test.go b/output_tests/map/string/ptr_float64/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/ptr_float64/json_test.go +++ b/output_tests/map/string/ptr_float64/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/ptr_int32/json_test.go b/output_tests/map/string/ptr_int32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/ptr_int32/json_test.go +++ b/output_tests/map/string/ptr_int32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/ptr_map_string_string/json_test.go b/output_tests/map/string/ptr_map_string_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/ptr_map_string_string/json_test.go +++ b/output_tests/map/string/ptr_map_string_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/ptr_slice_string/json_test.go b/output_tests/map/string/ptr_slice_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/ptr_slice_string/json_test.go +++ b/output_tests/map/string/ptr_slice_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/ptr_string/json_test.go b/output_tests/map/string/ptr_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/ptr_string/json_test.go +++ b/output_tests/map/string/ptr_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/ptr_struct_various/json_test.go b/output_tests/map/string/ptr_struct_various/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/ptr_struct_various/json_test.go +++ b/output_tests/map/string/ptr_struct_various/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/ptr_uint8/json_test.go b/output_tests/map/string/ptr_uint8/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/ptr_uint8/json_test.go +++ b/output_tests/map/string/ptr_uint8/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/slice_string/json_test.go b/output_tests/map/string/slice_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/slice_string/json_test.go +++ b/output_tests/map/string/slice_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/string/json_test.go b/output_tests/map/string/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/string/json_test.go +++ b/output_tests/map/string/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/string_alias/json_test.go b/output_tests/map/string/string_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/string_alias/json_test.go +++ b/output_tests/map/string/string_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/struct_empty/json_test.go b/output_tests/map/string/struct_empty/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/struct_empty/json_test.go +++ b/output_tests/map/string/struct_empty/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/struct_empty_alias/json_test.go b/output_tests/map/string/struct_empty_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/struct_empty_alias/json_test.go +++ b/output_tests/map/string/struct_empty_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/struct_ptr_string/json_test.go b/output_tests/map/string/struct_ptr_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/struct_ptr_string/json_test.go +++ b/output_tests/map/string/struct_ptr_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/struct_various/json_test.go b/output_tests/map/string/struct_various/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/struct_various/json_test.go +++ b/output_tests/map/string/struct_various/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string/uint8/json_test.go b/output_tests/map/string/uint8/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string/uint8/json_test.go +++ b/output_tests/map/string/uint8/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string_alias/string/json_test.go b/output_tests/map/string_alias/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string_alias/string/json_test.go +++ b/output_tests/map/string_alias/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/string_alias/string_alias/json_test.go b/output_tests/map/string_alias/string_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/string_alias/string_alias/json_test.go +++ b/output_tests/map/string_alias/string_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/uint16/string/json_test.go b/output_tests/map/uint16/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/uint16/string/json_test.go +++ b/output_tests/map/uint16/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/uint32/string/json_test.go b/output_tests/map/uint32/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/uint32/string/json_test.go +++ b/output_tests/map/uint32/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map/uint8/string/json_test.go b/output_tests/map/uint8/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map/uint8/string/json_test.go +++ b/output_tests/map/uint8/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map_key_text_marshal/string_alias/json_test.go b/output_tests/map_key_text_marshal/string_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map_key_text_marshal/string_alias/json_test.go +++ b/output_tests/map_key_text_marshal/string_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map_key_text_marshal/struct/json_test.go b/output_tests/map_key_text_marshal/struct/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map_key_text_marshal/struct/json_test.go +++ b/output_tests/map_key_text_marshal/struct/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/map_key_text_marshal/struct_alias/json_test.go b/output_tests/map_key_text_marshal/struct_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/map_key_text_marshal/struct_alias/json_test.go +++ b/output_tests/map_key_text_marshal/struct_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/bool/json_test.go b/output_tests/slice/bool/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/bool/json_test.go +++ b/output_tests/slice/bool/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/byte/json_test.go b/output_tests/slice/byte/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/byte/json_test.go +++ b/output_tests/slice/byte/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/float64/json_test.go b/output_tests/slice/float64/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/float64/json_test.go +++ b/output_tests/slice/float64/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/int32/json_test.go b/output_tests/slice/int32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/int32/json_test.go +++ b/output_tests/slice/int32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/map/int32_string/json_test.go b/output_tests/slice/map/int32_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/map/int32_string/json_test.go +++ b/output_tests/slice/map/int32_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/map/string_string/json_test.go b/output_tests/slice/map/string_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/map/string_string/json_test.go +++ b/output_tests/slice/map/string_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_bool/json_test.go b/output_tests/slice/ptr_bool/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_bool/json_test.go +++ b/output_tests/slice/ptr_bool/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_float64/json_test.go b/output_tests/slice/ptr_float64/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_float64/json_test.go +++ b/output_tests/slice/ptr_float64/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_int32/json_test.go b/output_tests/slice/ptr_int32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_int32/json_test.go +++ b/output_tests/slice/ptr_int32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_map/int32_string/json_test.go b/output_tests/slice/ptr_map/int32_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_map/int32_string/json_test.go +++ b/output_tests/slice/ptr_map/int32_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_map/string_string/json_test.go b/output_tests/slice/ptr_map/string_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_map/string_string/json_test.go +++ b/output_tests/slice/ptr_map/string_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_slice/bool/json_test.go b/output_tests/slice/ptr_slice/bool/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_slice/bool/json_test.go +++ b/output_tests/slice/ptr_slice/bool/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_slice/byte/json_test.go b/output_tests/slice/ptr_slice/byte/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_slice/byte/json_test.go +++ b/output_tests/slice/ptr_slice/byte/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_slice/float64/json_test.go b/output_tests/slice/ptr_slice/float64/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_slice/float64/json_test.go +++ b/output_tests/slice/ptr_slice/float64/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_slice/int32/json_test.go b/output_tests/slice/ptr_slice/int32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_slice/int32/json_test.go +++ b/output_tests/slice/ptr_slice/int32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_slice/ptr_string/json_test.go b/output_tests/slice/ptr_slice/ptr_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_slice/ptr_string/json_test.go +++ b/output_tests/slice/ptr_slice/ptr_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_slice/string/json_test.go b/output_tests/slice/ptr_slice/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_slice/string/json_test.go +++ b/output_tests/slice/ptr_slice/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_slice/uint8/json_test.go b/output_tests/slice/ptr_slice/uint8/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_slice/uint8/json_test.go +++ b/output_tests/slice/ptr_slice/uint8/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_string/json_test.go b/output_tests/slice/ptr_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_string/json_test.go +++ b/output_tests/slice/ptr_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_struct_various/json_test.go b/output_tests/slice/ptr_struct_various/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_struct_various/json_test.go +++ b/output_tests/slice/ptr_struct_various/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/ptr_uint8/json_test.go b/output_tests/slice/ptr_uint8/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/ptr_uint8/json_test.go +++ b/output_tests/slice/ptr_uint8/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/slice/bool/json_test.go b/output_tests/slice/slice/bool/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/slice/bool/json_test.go +++ b/output_tests/slice/slice/bool/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/slice/byte/json_test.go b/output_tests/slice/slice/byte/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/slice/byte/json_test.go +++ b/output_tests/slice/slice/byte/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/slice/float64/json_test.go b/output_tests/slice/slice/float64/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/slice/float64/json_test.go +++ b/output_tests/slice/slice/float64/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/slice/int32/json_test.go b/output_tests/slice/slice/int32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/slice/int32/json_test.go +++ b/output_tests/slice/slice/int32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/slice/ptr_string/json_test.go b/output_tests/slice/slice/ptr_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/slice/ptr_string/json_test.go +++ b/output_tests/slice/slice/ptr_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/slice/string/json_test.go b/output_tests/slice/slice/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/slice/string/json_test.go +++ b/output_tests/slice/slice/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/slice/uint8/json_test.go b/output_tests/slice/slice/uint8/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/slice/uint8/json_test.go +++ b/output_tests/slice/slice/uint8/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/string/json_test.go b/output_tests/slice/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/string/json_test.go +++ b/output_tests/slice/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/struct_empty/json_test.go b/output_tests/slice/struct_empty/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/struct_empty/json_test.go +++ b/output_tests/slice/struct_empty/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/struct_empty_alias/json_test.go b/output_tests/slice/struct_empty_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/struct_empty_alias/json_test.go +++ b/output_tests/slice/struct_empty_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/struct_ptr_string/json_test.go b/output_tests/slice/struct_ptr_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/struct_ptr_string/json_test.go +++ b/output_tests/slice/struct_ptr_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/struct_various/json_test.go b/output_tests/slice/struct_various/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/struct_various/json_test.go +++ b/output_tests/slice/struct_various/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/slice/uint8/json_test.go b/output_tests/slice/uint8/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/slice/uint8/json_test.go +++ b/output_tests/slice/uint8/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/alias/json_test.go b/output_tests/struct/alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/alias/json_test.go +++ b/output_tests/struct/alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/empty/json_test.go b/output_tests/struct/empty/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/empty/json_test.go +++ b/output_tests/struct/empty/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/empty_alias/json_test.go b/output_tests/struct/empty_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/empty_alias/json_test.go +++ b/output_tests/struct/empty_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/everything/json_test.go b/output_tests/struct/everything/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/everything/json_test.go +++ b/output_tests/struct/everything/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/float64/json_test.go b/output_tests/struct/float64/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/float64/json_test.go +++ b/output_tests/struct/float64/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/float64_alias/json_test.go b/output_tests/struct/float64_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/float64_alias/json_test.go +++ b/output_tests/struct/float64_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/float64s/json_test.go b/output_tests/struct/float64s/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/float64s/json_test.go +++ b/output_tests/struct/float64s/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/float64s_alias/json_test.go b/output_tests/struct/float64s_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/float64s_alias/json_test.go +++ b/output_tests/struct/float64s_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/int32/json_test.go b/output_tests/struct/int32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/int32/json_test.go +++ b/output_tests/struct/int32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/int32_alias/json_test.go b/output_tests/struct/int32_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/int32_alias/json_test.go +++ b/output_tests/struct/int32_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/int32s/json_test.go b/output_tests/struct/int32s/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/int32s/json_test.go +++ b/output_tests/struct/int32s/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/int32s_alias/json_test.go b/output_tests/struct/int32s_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/int32s_alias/json_test.go +++ b/output_tests/struct/int32s_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/map/int32_ptr_string/json_test.go b/output_tests/struct/map/int32_ptr_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/map/int32_ptr_string/json_test.go +++ b/output_tests/struct/map/int32_ptr_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/map/int32_string/json_test.go b/output_tests/struct/map/int32_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/map/int32_string/json_test.go +++ b/output_tests/struct/map/int32_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/map/int32_struct_strings/json_test.go b/output_tests/struct/map/int32_struct_strings/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/map/int32_struct_strings/json_test.go +++ b/output_tests/struct/map/int32_struct_strings/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/map/string_ptr_string/json_test.go b/output_tests/struct/map/string_ptr_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/map/string_ptr_string/json_test.go +++ b/output_tests/struct/map/string_ptr_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/map/string_string/json_test.go b/output_tests/struct/map/string_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/map/string_string/json_test.go +++ b/output_tests/struct/map/string_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/map/string_struct_strings/json_test.go b/output_tests/struct/map/string_struct_strings/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/map/string_struct_strings/json_test.go +++ b/output_tests/struct/map/string_struct_strings/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/ptr_float64/json_test.go b/output_tests/struct/ptr_float64/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/ptr_float64/json_test.go +++ b/output_tests/struct/ptr_float64/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/ptr_float64_alias/json_test.go b/output_tests/struct/ptr_float64_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/ptr_float64_alias/json_test.go +++ b/output_tests/struct/ptr_float64_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/ptr_int32/json_test.go b/output_tests/struct/ptr_int32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/ptr_int32/json_test.go +++ b/output_tests/struct/ptr_int32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/ptr_int32_alias/json_test.go b/output_tests/struct/ptr_int32_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/ptr_int32_alias/json_test.go +++ b/output_tests/struct/ptr_int32_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/ptr_ptr_struct_empty/json_test.go b/output_tests/struct/ptr_ptr_struct_empty/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/ptr_ptr_struct_empty/json_test.go +++ b/output_tests/struct/ptr_ptr_struct_empty/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/ptr_ptr_struct_strings/json_test.go b/output_tests/struct/ptr_ptr_struct_strings/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/ptr_ptr_struct_strings/json_test.go +++ b/output_tests/struct/ptr_ptr_struct_strings/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/ptr_string/json_test.go b/output_tests/struct/ptr_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/ptr_string/json_test.go +++ b/output_tests/struct/ptr_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/ptr_string_alias/json_test.go b/output_tests/struct/ptr_string_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/ptr_string_alias/json_test.go +++ b/output_tests/struct/ptr_string_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/ptr_struct_empty/json_test.go b/output_tests/struct/ptr_struct_empty/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/ptr_struct_empty/json_test.go +++ b/output_tests/struct/ptr_struct_empty/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/ptr_struct_strings/json_test.go b/output_tests/struct/ptr_struct_strings/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/ptr_struct_strings/json_test.go +++ b/output_tests/struct/ptr_struct_strings/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/ptrs_float64/json_test.go b/output_tests/struct/ptrs_float64/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/ptrs_float64/json_test.go +++ b/output_tests/struct/ptrs_float64/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/ptrs_int32/json_test.go b/output_tests/struct/ptrs_int32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/ptrs_int32/json_test.go +++ b/output_tests/struct/ptrs_int32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/ptrs_string/json_test.go b/output_tests/struct/ptrs_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/ptrs_string/json_test.go +++ b/output_tests/struct/ptrs_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/slice/ptr_string/json_test.go b/output_tests/struct/slice/ptr_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/slice/ptr_string/json_test.go +++ b/output_tests/struct/slice/ptr_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/slice/string/json_test.go b/output_tests/struct/slice/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/slice/string/json_test.go +++ b/output_tests/struct/slice/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/slice/string_alias/json_test.go b/output_tests/struct/slice/string_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/slice/string_alias/json_test.go +++ b/output_tests/struct/slice/string_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/slice/strings/json_test.go b/output_tests/struct/slice/strings/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/slice/strings/json_test.go +++ b/output_tests/struct/slice/strings/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/slice/struct_strings/json_test.go b/output_tests/struct/slice/struct_strings/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/slice/struct_strings/json_test.go +++ b/output_tests/struct/slice/struct_strings/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/string/json_test.go b/output_tests/struct/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/string/json_test.go +++ b/output_tests/struct/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/string_alias/json_test.go b/output_tests/struct/string_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/string_alias/json_test.go +++ b/output_tests/struct/string_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/strings/json_test.go b/output_tests/struct/strings/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/strings/json_test.go +++ b/output_tests/struct/strings/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/strings_alias/json_test.go b/output_tests/struct/strings_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/strings_alias/json_test.go +++ b/output_tests/struct/strings_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/struct/empties/json_test.go b/output_tests/struct/struct/empties/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/struct/empties/json_test.go +++ b/output_tests/struct/struct/empties/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/struct/empty/json_test.go b/output_tests/struct/struct/empty/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/struct/empty/json_test.go +++ b/output_tests/struct/struct/empty/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/struct/empty_alias/json_test.go b/output_tests/struct/struct/empty_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/struct/empty_alias/json_test.go +++ b/output_tests/struct/struct/empty_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/struct/float32s/json_test.go b/output_tests/struct/struct/float32s/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/struct/float32s/json_test.go +++ b/output_tests/struct/struct/float32s/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/struct/float64/json_test.go b/output_tests/struct/struct/float64/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/struct/float64/json_test.go +++ b/output_tests/struct/struct/float64/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/struct/float64_alias/json_test.go b/output_tests/struct/struct/float64_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/struct/float64_alias/json_test.go +++ b/output_tests/struct/struct/float64_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/struct/int32s/json_test.go b/output_tests/struct/struct/int32s/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/struct/int32s/json_test.go +++ b/output_tests/struct/struct/int32s/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/struct/strings/json_test.go b/output_tests/struct/struct/strings/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/struct/strings/json_test.go +++ b/output_tests/struct/struct/strings/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct/struct/strings_alias/json_test.go b/output_tests/struct/struct/strings_alias/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct/struct/strings_alias/json_test.go +++ b/output_tests/struct/struct/strings_alias/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/fieldname/json_test.go b/output_tests/struct_tags/fieldname/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/fieldname/json_test.go +++ b/output_tests/struct_tags/fieldname/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/omitempty/bool/json_test.go b/output_tests/struct_tags/omitempty/bool/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/omitempty/bool/json_test.go +++ b/output_tests/struct_tags/omitempty/bool/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/omitempty/float32/json_test.go b/output_tests/struct_tags/omitempty/float32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/omitempty/float32/json_test.go +++ b/output_tests/struct_tags/omitempty/float32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/omitempty/int32/json_test.go b/output_tests/struct_tags/omitempty/int32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/omitempty/int32/json_test.go +++ b/output_tests/struct_tags/omitempty/int32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/omitempty/map_string_string/json_test.go b/output_tests/struct_tags/omitempty/map_string_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/omitempty/map_string_string/json_test.go +++ b/output_tests/struct_tags/omitempty/map_string_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/omitempty/ptr_string/json_test.go b/output_tests/struct_tags/omitempty/ptr_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/omitempty/ptr_string/json_test.go +++ b/output_tests/struct_tags/omitempty/ptr_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/omitempty/slice_string/json_test.go b/output_tests/struct_tags/omitempty/slice_string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/omitempty/slice_string/json_test.go +++ b/output_tests/struct_tags/omitempty/slice_string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/omitempty/string/json_test.go b/output_tests/struct_tags/omitempty/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/omitempty/string/json_test.go +++ b/output_tests/struct_tags/omitempty/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/omitempty/uint32/json_test.go b/output_tests/struct_tags/omitempty/uint32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/omitempty/uint32/json_test.go +++ b/output_tests/struct_tags/omitempty/uint32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/string/bool/json_test.go b/output_tests/struct_tags/string/bool/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/string/bool/json_test.go +++ b/output_tests/struct_tags/string/bool/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/string/byte/json_test.go b/output_tests/struct_tags/string/byte/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/string/byte/json_test.go +++ b/output_tests/struct_tags/string/byte/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/string/float32/json_test.go b/output_tests/struct_tags/string/float32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/string/float32/json_test.go +++ b/output_tests/struct_tags/string/float32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/string/float64/json_test.go b/output_tests/struct_tags/string/float64/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/string/float64/json_test.go +++ b/output_tests/struct_tags/string/float64/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/string/int16/json_test.go b/output_tests/struct_tags/string/int16/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/string/int16/json_test.go +++ b/output_tests/struct_tags/string/int16/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/string/int32/json_test.go b/output_tests/struct_tags/string/int32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/string/int32/json_test.go +++ b/output_tests/struct_tags/string/int32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/string/int8/json_test.go b/output_tests/struct_tags/string/int8/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/string/int8/json_test.go +++ b/output_tests/struct_tags/string/int8/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/string/string/json_test.go b/output_tests/struct_tags/string/string/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/string/string/json_test.go +++ b/output_tests/struct_tags/string/string/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/string/uint16/json_test.go b/output_tests/struct_tags/string/uint16/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/string/uint16/json_test.go +++ b/output_tests/struct_tags/string/uint16/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/string/uint32/json_test.go b/output_tests/struct_tags/string/uint32/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/string/uint32/json_test.go +++ b/output_tests/struct_tags/string/uint32/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", diff --git a/output_tests/struct_tags/string/uint8/json_test.go b/output_tests/struct_tags/string/uint8/json_test.go index 196f98d..8c7d795 100644 --- a/output_tests/struct_tags/string/uint8/json_test.go +++ b/output_tests/struct_tags/string/uint8/json_test.go @@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) { var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Fatalf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Fatalf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) } if fingerprint(afterStd) != fingerprint(afterIter) { t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", From 0db2d74de8eca35d091efe4738013489c9608636 Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 21:09:54 +0100 Subject: [PATCH 15/18] Add output test for manual json marshalers --- .../json_marshal/string_alias/json_test.go | 152 ++++++++++++++++++ .../json_marshal/string_alias/types.go | 50 ++++++ output_tests/json_marshal/struct/json_test.go | 152 ++++++++++++++++++ output_tests/json_marshal/struct/types.go | 52 ++++++ .../json_marshal/struct_alias/json_test.go | 152 ++++++++++++++++++ .../json_marshal/struct_alias/types.go | 54 +++++++ .../json_marshal/struct_field/json_test.go | 152 ++++++++++++++++++ .../json_marshal/struct_field/types.go | 56 +++++++ .../struct_field_alias/json_test.go | 152 ++++++++++++++++++ .../json_marshal/struct_field_alias/types.go | 58 +++++++ 10 files changed, 1030 insertions(+) create mode 100644 output_tests/json_marshal/string_alias/json_test.go create mode 100644 output_tests/json_marshal/string_alias/types.go create mode 100644 output_tests/json_marshal/struct/json_test.go create mode 100644 output_tests/json_marshal/struct/types.go create mode 100644 output_tests/json_marshal/struct_alias/json_test.go create mode 100644 output_tests/json_marshal/struct_alias/types.go create mode 100644 output_tests/json_marshal/struct_field/json_test.go create mode 100644 output_tests/json_marshal/struct_field/types.go create mode 100644 output_tests/json_marshal/struct_field_alias/json_test.go create mode 100644 output_tests/json_marshal/struct_field_alias/types.go diff --git a/output_tests/json_marshal/string_alias/json_test.go b/output_tests/json_marshal/string_alias/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/json_marshal/string_alias/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/json_marshal/string_alias/types.go b/output_tests/json_marshal/string_alias/types.go new file mode 100644 index 0000000..cbe8143 --- /dev/null +++ b/output_tests/json_marshal/string_alias/types.go @@ -0,0 +1,50 @@ +package test + +import ( + "bytes" + "encoding/base64" + "encoding/json" + "strings" +) + +type Marshaler string + +func encode(str string) string { + buf := bytes.Buffer{} + b64 := base64.NewEncoder(base64.StdEncoding, &buf) + if _, err := b64.Write([]byte(str)); err != nil { + panic(err) + } + if err := b64.Close(); err != nil { + panic(err) + } + return buf.String() +} + +func decode(str string) string { + if len(str) == 0 { + return "" + } + b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str)) + bs := make([]byte, len(str)) + if n, err := b64.Read(bs); err != nil { + panic(err) + } else { + bs = bs[:n] + } + return string(bs) +} + +func (m Marshaler) MarshalJSON() ([]byte, error) { + return []byte(`"MANUAL__` + encode(string(m)) + `"`), nil +} + +func (m *Marshaler) UnmarshalJSON(text []byte) error { + *m = Marshaler(decode(strings.TrimPrefix(strings.Trim(string(text), `"`), "MANUAL__"))) + return nil +} + +var _ json.Marshaler = *new(Marshaler) +var _ json.Unmarshaler = new(Marshaler) + +type T Marshaler diff --git a/output_tests/json_marshal/struct/json_test.go b/output_tests/json_marshal/struct/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/json_marshal/struct/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/json_marshal/struct/types.go b/output_tests/json_marshal/struct/types.go new file mode 100644 index 0000000..f556b05 --- /dev/null +++ b/output_tests/json_marshal/struct/types.go @@ -0,0 +1,52 @@ +package test + +import ( + "bytes" + "encoding/base64" + "encoding/json" + "strings" +) + +type Marshaler struct { + X string +} + +func encode(str string) string { + buf := bytes.Buffer{} + b64 := base64.NewEncoder(base64.StdEncoding, &buf) + if _, err := b64.Write([]byte(str)); err != nil { + panic(err) + } + if err := b64.Close(); err != nil { + panic(err) + } + return buf.String() +} + +func decode(str string) string { + if len(str) == 0 { + return "" + } + b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str)) + bs := make([]byte, len(str)) + if n, err := b64.Read(bs); err != nil { + panic(err) + } else { + bs = bs[:n] + } + return string(bs) +} + +func (m Marshaler) MarshalJSON() ([]byte, error) { + return []byte(`"MANUAL__` + encode(m.X) + `"`), nil +} + +func (m *Marshaler) UnmarshalJSON(text []byte) error { + m.X = decode(strings.TrimPrefix(strings.Trim(string(text), `"`), "MANUAL__")) + return nil +} + +var _ json.Marshaler = Marshaler{} +var _ json.Unmarshaler = &Marshaler{} + +type T Marshaler diff --git a/output_tests/json_marshal/struct_alias/json_test.go b/output_tests/json_marshal/struct_alias/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/json_marshal/struct_alias/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/json_marshal/struct_alias/types.go b/output_tests/json_marshal/struct_alias/types.go new file mode 100644 index 0000000..f1c7b97 --- /dev/null +++ b/output_tests/json_marshal/struct_alias/types.go @@ -0,0 +1,54 @@ +package test + +import ( + "bytes" + "encoding/base64" + "encoding/json" + "strings" +) + +type Marshaler struct { + X string +} + +func encode(str string) string { + buf := bytes.Buffer{} + b64 := base64.NewEncoder(base64.StdEncoding, &buf) + if _, err := b64.Write([]byte(str)); err != nil { + panic(err) + } + if err := b64.Close(); err != nil { + panic(err) + } + return buf.String() +} + +func decode(str string) string { + if len(str) == 0 { + return "" + } + b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str)) + bs := make([]byte, len(str)) + if n, err := b64.Read(bs); err != nil { + panic(err) + } else { + bs = bs[:n] + } + return string(bs) +} + +func (m Marshaler) MarshalJSON() ([]byte, error) { + return []byte(`"MANUAL__` + encode(m.X) + `"`), nil +} + +func (m *Marshaler) UnmarshalJSON(text []byte) error { + m.X = decode(strings.TrimPrefix(strings.Trim(string(text), `"`), "MANUAL__")) + return nil +} + +var _ json.Marshaler = Marshaler{} +var _ json.Unmarshaler = &Marshaler{} + +type A Marshaler + +type T A diff --git a/output_tests/json_marshal/struct_field/json_test.go b/output_tests/json_marshal/struct_field/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/json_marshal/struct_field/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/json_marshal/struct_field/types.go b/output_tests/json_marshal/struct_field/types.go new file mode 100644 index 0000000..517b0cd --- /dev/null +++ b/output_tests/json_marshal/struct_field/types.go @@ -0,0 +1,56 @@ +package test + +import ( + "bytes" + "encoding/base64" + "encoding/json" + "strings" +) + +type Marshaler struct { + X string +} + +func encode(str string) string { + buf := bytes.Buffer{} + b64 := base64.NewEncoder(base64.StdEncoding, &buf) + if _, err := b64.Write([]byte(str)); err != nil { + panic(err) + } + if err := b64.Close(); err != nil { + panic(err) + } + return buf.String() +} + +func decode(str string) string { + if len(str) == 0 { + return "" + } + b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str)) + bs := make([]byte, len(str)) + if n, err := b64.Read(bs); err != nil { + panic(err) + } else { + bs = bs[:n] + } + return string(bs) +} + +func (m Marshaler) MarshalJSON() ([]byte, error) { + return []byte(`"MANUAL__` + encode(m.X) + `"`), nil +} + +func (m *Marshaler) UnmarshalJSON(text []byte) error { + m.X = decode(strings.TrimPrefix(strings.Trim(string(text), `"`), "MANUAL__")) + return nil +} + +var _ json.Marshaler = Marshaler{} +var _ json.Unmarshaler = &Marshaler{} + +type T struct { + S string + M Marshaler + I int8 +} diff --git a/output_tests/json_marshal/struct_field_alias/json_test.go b/output_tests/json_marshal/struct_field_alias/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/json_marshal/struct_field_alias/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/json_marshal/struct_field_alias/types.go b/output_tests/json_marshal/struct_field_alias/types.go new file mode 100644 index 0000000..ada9135 --- /dev/null +++ b/output_tests/json_marshal/struct_field_alias/types.go @@ -0,0 +1,58 @@ +package test + +import ( + "bytes" + "encoding/base64" + "encoding/json" + "strings" +) + +type Marshaler struct { + X string +} + +func encode(str string) string { + buf := bytes.Buffer{} + b64 := base64.NewEncoder(base64.StdEncoding, &buf) + if _, err := b64.Write([]byte(str)); err != nil { + panic(err) + } + if err := b64.Close(); err != nil { + panic(err) + } + return buf.String() +} + +func decode(str string) string { + if len(str) == 0 { + return "" + } + b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str)) + bs := make([]byte, len(str)) + if n, err := b64.Read(bs); err != nil { + panic(err) + } else { + bs = bs[:n] + } + return string(bs) +} + +func (m Marshaler) MarshalJSON() ([]byte, error) { + return []byte(`"MANUAL__` + encode(m.X) + `"`), nil +} + +func (m *Marshaler) UnmarshalJSON(text []byte) error { + m.X = decode(strings.TrimPrefix(strings.Trim(string(text), `"`), "MANUAL__")) + return nil +} + +var _ json.Marshaler = Marshaler{} +var _ json.Unmarshaler = &Marshaler{} + +type A Marshaler + +type T struct { + S string + M A + I int8 +} From 8a9f2b91790a6ddb0f6a766f2748ded6ce902031 Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 21:16:10 +0100 Subject: [PATCH 16/18] Add output test for manual text marshalers --- .../text_marshal/string_alias/json_test.go | 152 ++++++++++++++++++ .../text_marshal/string_alias/types.go | 50 ++++++ output_tests/text_marshal/struct/json_test.go | 152 ++++++++++++++++++ output_tests/text_marshal/struct/types.go | 52 ++++++ .../text_marshal/struct_alias/json_test.go | 152 ++++++++++++++++++ .../text_marshal/struct_alias/types.go | 54 +++++++ .../text_marshal/struct_field/json_test.go | 152 ++++++++++++++++++ .../text_marshal/struct_field/types.go | 56 +++++++ .../struct_field_alias/json_test.go | 152 ++++++++++++++++++ .../text_marshal/struct_field_alias/types.go | 58 +++++++ 10 files changed, 1030 insertions(+) create mode 100644 output_tests/text_marshal/string_alias/json_test.go create mode 100644 output_tests/text_marshal/string_alias/types.go create mode 100644 output_tests/text_marshal/struct/json_test.go create mode 100644 output_tests/text_marshal/struct/types.go create mode 100644 output_tests/text_marshal/struct_alias/json_test.go create mode 100644 output_tests/text_marshal/struct_alias/types.go create mode 100644 output_tests/text_marshal/struct_field/json_test.go create mode 100644 output_tests/text_marshal/struct_field/types.go create mode 100644 output_tests/text_marshal/struct_field_alias/json_test.go create mode 100644 output_tests/text_marshal/struct_field_alias/types.go diff --git a/output_tests/text_marshal/string_alias/json_test.go b/output_tests/text_marshal/string_alias/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/text_marshal/string_alias/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/text_marshal/string_alias/types.go b/output_tests/text_marshal/string_alias/types.go new file mode 100644 index 0000000..6351f30 --- /dev/null +++ b/output_tests/text_marshal/string_alias/types.go @@ -0,0 +1,50 @@ +package test + +import ( + "bytes" + "encoding" + "encoding/base64" + "strings" +) + +type Marshaler string + +func encode(str string) string { + buf := bytes.Buffer{} + b64 := base64.NewEncoder(base64.StdEncoding, &buf) + if _, err := b64.Write([]byte(str)); err != nil { + panic(err) + } + if err := b64.Close(); err != nil { + panic(err) + } + return buf.String() +} + +func decode(str string) string { + if len(str) == 0 { + return "" + } + b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str)) + bs := make([]byte, len(str)) + if n, err := b64.Read(bs); err != nil { + panic(err) + } else { + bs = bs[:n] + } + return string(bs) +} + +func (m Marshaler) MarshalText() ([]byte, error) { + return []byte(`MANUAL__` + encode(string(m))), nil +} + +func (m *Marshaler) UnmarshalText(text []byte) error { + *m = Marshaler(decode(strings.TrimPrefix(string(text), "MANUAL__"))) + return nil +} + +var _ encoding.TextMarshaler = *new(Marshaler) +var _ encoding.TextUnmarshaler = new(Marshaler) + +type T Marshaler diff --git a/output_tests/text_marshal/struct/json_test.go b/output_tests/text_marshal/struct/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/text_marshal/struct/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/text_marshal/struct/types.go b/output_tests/text_marshal/struct/types.go new file mode 100644 index 0000000..40f140b --- /dev/null +++ b/output_tests/text_marshal/struct/types.go @@ -0,0 +1,52 @@ +package test + +import ( + "bytes" + "encoding" + "encoding/base64" + "strings" +) + +type Marshaler struct { + X string +} + +func encode(str string) string { + buf := bytes.Buffer{} + b64 := base64.NewEncoder(base64.StdEncoding, &buf) + if _, err := b64.Write([]byte(str)); err != nil { + panic(err) + } + if err := b64.Close(); err != nil { + panic(err) + } + return buf.String() +} + +func decode(str string) string { + if len(str) == 0 { + return "" + } + b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str)) + bs := make([]byte, len(str)) + if n, err := b64.Read(bs); err != nil { + panic(err) + } else { + bs = bs[:n] + } + return string(bs) +} + +func (m Marshaler) MarshalText() ([]byte, error) { + return []byte(`MANUAL__` + encode(m.X)), nil +} + +func (m *Marshaler) UnmarshalText(text []byte) error { + m.X = decode(strings.TrimPrefix(string(text), "MANUAL__")) + return nil +} + +var _ encoding.TextMarshaler = Marshaler{} +var _ encoding.TextUnmarshaler = &Marshaler{} + +type T Marshaler diff --git a/output_tests/text_marshal/struct_alias/json_test.go b/output_tests/text_marshal/struct_alias/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/text_marshal/struct_alias/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/text_marshal/struct_alias/types.go b/output_tests/text_marshal/struct_alias/types.go new file mode 100644 index 0000000..1e3122d --- /dev/null +++ b/output_tests/text_marshal/struct_alias/types.go @@ -0,0 +1,54 @@ +package test + +import ( + "bytes" + "encoding" + "encoding/base64" + "strings" +) + +type Marshaler struct { + X string +} + +func encode(str string) string { + buf := bytes.Buffer{} + b64 := base64.NewEncoder(base64.StdEncoding, &buf) + if _, err := b64.Write([]byte(str)); err != nil { + panic(err) + } + if err := b64.Close(); err != nil { + panic(err) + } + return buf.String() +} + +func decode(str string) string { + if len(str) == 0 { + return "" + } + b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str)) + bs := make([]byte, len(str)) + if n, err := b64.Read(bs); err != nil { + panic(err) + } else { + bs = bs[:n] + } + return string(bs) +} + +func (m Marshaler) MarshalText() ([]byte, error) { + return []byte(`MANUAL__` + encode(m.X)), nil +} + +func (m *Marshaler) UnmarshalText(text []byte) error { + m.X = decode(strings.TrimPrefix(string(text), "MANUAL__")) + return nil +} + +var _ encoding.TextMarshaler = Marshaler{} +var _ encoding.TextUnmarshaler = &Marshaler{} + +type A Marshaler + +type T A diff --git a/output_tests/text_marshal/struct_field/json_test.go b/output_tests/text_marshal/struct_field/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/text_marshal/struct_field/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/text_marshal/struct_field/types.go b/output_tests/text_marshal/struct_field/types.go new file mode 100644 index 0000000..b811e32 --- /dev/null +++ b/output_tests/text_marshal/struct_field/types.go @@ -0,0 +1,56 @@ +package test + +import ( + "bytes" + "encoding" + "encoding/base64" + "strings" +) + +type Marshaler struct { + X string +} + +func encode(str string) string { + buf := bytes.Buffer{} + b64 := base64.NewEncoder(base64.StdEncoding, &buf) + if _, err := b64.Write([]byte(str)); err != nil { + panic(err) + } + if err := b64.Close(); err != nil { + panic(err) + } + return buf.String() +} + +func decode(str string) string { + if len(str) == 0 { + return "" + } + b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str)) + bs := make([]byte, len(str)) + if n, err := b64.Read(bs); err != nil { + panic(err) + } else { + bs = bs[:n] + } + return string(bs) +} + +func (m Marshaler) MarshalText() ([]byte, error) { + return []byte(`MANUAL__` + encode(m.X)), nil +} + +func (m *Marshaler) UnmarshalText(text []byte) error { + m.X = decode(strings.TrimPrefix(string(text), "MANUAL__")) + return nil +} + +var _ encoding.TextMarshaler = Marshaler{} +var _ encoding.TextUnmarshaler = &Marshaler{} + +type T struct { + S string + M Marshaler + I int8 +} diff --git a/output_tests/text_marshal/struct_field_alias/json_test.go b/output_tests/text_marshal/struct_field_alias/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/text_marshal/struct_field_alias/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/text_marshal/struct_field_alias/types.go b/output_tests/text_marshal/struct_field_alias/types.go new file mode 100644 index 0000000..1b6718a --- /dev/null +++ b/output_tests/text_marshal/struct_field_alias/types.go @@ -0,0 +1,58 @@ +package test + +import ( + "bytes" + "encoding" + "encoding/base64" + "strings" +) + +type Marshaler struct { + X string +} + +func encode(str string) string { + buf := bytes.Buffer{} + b64 := base64.NewEncoder(base64.StdEncoding, &buf) + if _, err := b64.Write([]byte(str)); err != nil { + panic(err) + } + if err := b64.Close(); err != nil { + panic(err) + } + return buf.String() +} + +func decode(str string) string { + if len(str) == 0 { + return "" + } + b64 := base64.NewDecoder(base64.StdEncoding, strings.NewReader(str)) + bs := make([]byte, len(str)) + if n, err := b64.Read(bs); err != nil { + panic(err) + } else { + bs = bs[:n] + } + return string(bs) +} + +func (m Marshaler) MarshalText() ([]byte, error) { + return []byte(`MANUAL__` + encode(m.X)), nil +} + +func (m *Marshaler) UnmarshalText(text []byte) error { + m.X = decode(strings.TrimPrefix(string(text), "MANUAL__")) + return nil +} + +var _ encoding.TextMarshaler = Marshaler{} +var _ encoding.TextUnmarshaler = &Marshaler{} + +type A Marshaler + +type T struct { + S string + M A + I int8 +} From 4652ac6cc2f497df09c439ac4223a8324d7884b9 Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 21:57:47 +0100 Subject: [PATCH 17/18] Add output tests for embedded types --- .../anonymous/no_overlap/float64/json_test.go | 152 ++++++++++++++++++ .../anonymous/no_overlap/float64/types.go | 7 + .../anonymous/no_overlap/int32/json_test.go | 152 ++++++++++++++++++ .../anonymous/no_overlap/int32/types.go | 7 + .../no_overlap/map_string_string/json_test.go | 152 ++++++++++++++++++ .../no_overlap/map_string_string/types.go | 7 + .../no_overlap/ptr_float64/json_test.go | 152 ++++++++++++++++++ .../anonymous/no_overlap/ptr_float64/types.go | 7 + .../no_overlap/ptr_int32/json_test.go | 152 ++++++++++++++++++ .../anonymous/no_overlap/ptr_int32/types.go | 7 + .../ptr_map_string_string/json_test.go | 152 ++++++++++++++++++ .../no_overlap/ptr_map_string_string/types.go | 7 + .../no_overlap/ptr_slice_string/json_test.go | 152 ++++++++++++++++++ .../no_overlap/ptr_slice_string/types.go | 7 + .../no_overlap/ptr_string/json_test.go | 152 ++++++++++++++++++ .../anonymous/no_overlap/ptr_string/types.go | 7 + .../ptr_struct_various/json_test.go | 152 ++++++++++++++++++ .../no_overlap/ptr_struct_various/types.go | 16 ++ .../no_overlap/slice_string/json_test.go | 152 ++++++++++++++++++ .../no_overlap/slice_string/types.go | 7 + .../anonymous/no_overlap/string/json_test.go | 152 ++++++++++++++++++ .../anonymous/no_overlap/string/types.go | 7 + .../no_overlap/string_with_tag/json_test.go | 152 ++++++++++++++++++ .../no_overlap/string_with_tag/types.go | 7 + .../no_overlap/struct_various/json_test.go | 152 ++++++++++++++++++ .../no_overlap/struct_various/types.go | 16 ++ .../overlap/different_levels/json_test.go | 152 ++++++++++++++++++ .../overlap/different_levels/types.go | 10 ++ .../overlap/ignore_deeper_level/json_test.go | 152 ++++++++++++++++++ .../overlap/ignore_deeper_level/types.go | 20 +++ .../same_level_1_both_tagged/json_test.go | 152 ++++++++++++++++++ .../overlap/same_level_1_both_tagged/types.go | 14 ++ .../overlap/same_level_1_no_tags/json_test.go | 152 ++++++++++++++++++ .../overlap/same_level_1_no_tags/types.go | 14 ++ .../overlap/same_level_1_tagged/json_test.go | 152 ++++++++++++++++++ .../overlap/same_level_1_tagged/types.go | 14 ++ .../same_level_2_both_tagged/json_test.go | 152 ++++++++++++++++++ .../overlap/same_level_2_both_tagged/types.go | 22 +++ .../overlap/same_level_2_no_tags/json_test.go | 152 ++++++++++++++++++ .../overlap/same_level_2_no_tags/types.go | 22 +++ .../overlap/same_level_2_tagged/json_test.go | 152 ++++++++++++++++++ .../overlap/same_level_2_tagged/types.go | 22 +++ 42 files changed, 3439 insertions(+) create mode 100644 output_tests/struct/anonymous/no_overlap/float64/json_test.go create mode 100644 output_tests/struct/anonymous/no_overlap/float64/types.go create mode 100644 output_tests/struct/anonymous/no_overlap/int32/json_test.go create mode 100644 output_tests/struct/anonymous/no_overlap/int32/types.go create mode 100644 output_tests/struct/anonymous/no_overlap/map_string_string/json_test.go create mode 100644 output_tests/struct/anonymous/no_overlap/map_string_string/types.go create mode 100644 output_tests/struct/anonymous/no_overlap/ptr_float64/json_test.go create mode 100644 output_tests/struct/anonymous/no_overlap/ptr_float64/types.go create mode 100644 output_tests/struct/anonymous/no_overlap/ptr_int32/json_test.go create mode 100644 output_tests/struct/anonymous/no_overlap/ptr_int32/types.go create mode 100644 output_tests/struct/anonymous/no_overlap/ptr_map_string_string/json_test.go create mode 100644 output_tests/struct/anonymous/no_overlap/ptr_map_string_string/types.go create mode 100644 output_tests/struct/anonymous/no_overlap/ptr_slice_string/json_test.go create mode 100644 output_tests/struct/anonymous/no_overlap/ptr_slice_string/types.go create mode 100644 output_tests/struct/anonymous/no_overlap/ptr_string/json_test.go create mode 100644 output_tests/struct/anonymous/no_overlap/ptr_string/types.go create mode 100644 output_tests/struct/anonymous/no_overlap/ptr_struct_various/json_test.go create mode 100644 output_tests/struct/anonymous/no_overlap/ptr_struct_various/types.go create mode 100644 output_tests/struct/anonymous/no_overlap/slice_string/json_test.go create mode 100644 output_tests/struct/anonymous/no_overlap/slice_string/types.go create mode 100644 output_tests/struct/anonymous/no_overlap/string/json_test.go create mode 100644 output_tests/struct/anonymous/no_overlap/string/types.go create mode 100644 output_tests/struct/anonymous/no_overlap/string_with_tag/json_test.go create mode 100644 output_tests/struct/anonymous/no_overlap/string_with_tag/types.go create mode 100644 output_tests/struct/anonymous/no_overlap/struct_various/json_test.go create mode 100644 output_tests/struct/anonymous/no_overlap/struct_various/types.go create mode 100644 output_tests/struct/anonymous/overlap/different_levels/json_test.go create mode 100644 output_tests/struct/anonymous/overlap/different_levels/types.go create mode 100644 output_tests/struct/anonymous/overlap/ignore_deeper_level/json_test.go create mode 100644 output_tests/struct/anonymous/overlap/ignore_deeper_level/types.go create mode 100644 output_tests/struct/anonymous/overlap/same_level_1_both_tagged/json_test.go create mode 100644 output_tests/struct/anonymous/overlap/same_level_1_both_tagged/types.go create mode 100644 output_tests/struct/anonymous/overlap/same_level_1_no_tags/json_test.go create mode 100644 output_tests/struct/anonymous/overlap/same_level_1_no_tags/types.go create mode 100644 output_tests/struct/anonymous/overlap/same_level_1_tagged/json_test.go create mode 100644 output_tests/struct/anonymous/overlap/same_level_1_tagged/types.go create mode 100644 output_tests/struct/anonymous/overlap/same_level_2_both_tagged/json_test.go create mode 100644 output_tests/struct/anonymous/overlap/same_level_2_both_tagged/types.go create mode 100644 output_tests/struct/anonymous/overlap/same_level_2_no_tags/json_test.go create mode 100644 output_tests/struct/anonymous/overlap/same_level_2_no_tags/types.go create mode 100644 output_tests/struct/anonymous/overlap/same_level_2_tagged/json_test.go create mode 100644 output_tests/struct/anonymous/overlap/same_level_2_tagged/types.go diff --git a/output_tests/struct/anonymous/no_overlap/float64/json_test.go b/output_tests/struct/anonymous/no_overlap/float64/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/float64/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/no_overlap/float64/types.go b/output_tests/struct/anonymous/no_overlap/float64/types.go new file mode 100644 index 0000000..e057f15 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/float64/types.go @@ -0,0 +1,7 @@ +package test + +type Embedded float64 + +type T struct { + Embedded +} diff --git a/output_tests/struct/anonymous/no_overlap/int32/json_test.go b/output_tests/struct/anonymous/no_overlap/int32/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/int32/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/no_overlap/int32/types.go b/output_tests/struct/anonymous/no_overlap/int32/types.go new file mode 100644 index 0000000..2733f97 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/int32/types.go @@ -0,0 +1,7 @@ +package test + +type Embedded int32 + +type T struct { + Embedded +} diff --git a/output_tests/struct/anonymous/no_overlap/map_string_string/json_test.go b/output_tests/struct/anonymous/no_overlap/map_string_string/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/map_string_string/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/no_overlap/map_string_string/types.go b/output_tests/struct/anonymous/no_overlap/map_string_string/types.go new file mode 100644 index 0000000..1330737 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/map_string_string/types.go @@ -0,0 +1,7 @@ +package test + +type Embedded map[string]string + +type T struct { + Embedded +} diff --git a/output_tests/struct/anonymous/no_overlap/ptr_float64/json_test.go b/output_tests/struct/anonymous/no_overlap/ptr_float64/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/ptr_float64/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/no_overlap/ptr_float64/types.go b/output_tests/struct/anonymous/no_overlap/ptr_float64/types.go new file mode 100644 index 0000000..827ffef --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/ptr_float64/types.go @@ -0,0 +1,7 @@ +package test + +type Embedded float64 + +type T struct { + *Embedded +} diff --git a/output_tests/struct/anonymous/no_overlap/ptr_int32/json_test.go b/output_tests/struct/anonymous/no_overlap/ptr_int32/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/ptr_int32/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/no_overlap/ptr_int32/types.go b/output_tests/struct/anonymous/no_overlap/ptr_int32/types.go new file mode 100644 index 0000000..e9d208b --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/ptr_int32/types.go @@ -0,0 +1,7 @@ +package test + +type Embedded int32 + +type T struct { + *Embedded +} diff --git a/output_tests/struct/anonymous/no_overlap/ptr_map_string_string/json_test.go b/output_tests/struct/anonymous/no_overlap/ptr_map_string_string/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/ptr_map_string_string/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/no_overlap/ptr_map_string_string/types.go b/output_tests/struct/anonymous/no_overlap/ptr_map_string_string/types.go new file mode 100644 index 0000000..58d8ef2 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/ptr_map_string_string/types.go @@ -0,0 +1,7 @@ +package test + +type Embedded map[string]string + +type T struct { + *Embedded +} diff --git a/output_tests/struct/anonymous/no_overlap/ptr_slice_string/json_test.go b/output_tests/struct/anonymous/no_overlap/ptr_slice_string/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/ptr_slice_string/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/no_overlap/ptr_slice_string/types.go b/output_tests/struct/anonymous/no_overlap/ptr_slice_string/types.go new file mode 100644 index 0000000..4c4294d --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/ptr_slice_string/types.go @@ -0,0 +1,7 @@ +package test + +type Embedded []string + +type T struct { + *Embedded +} diff --git a/output_tests/struct/anonymous/no_overlap/ptr_string/json_test.go b/output_tests/struct/anonymous/no_overlap/ptr_string/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/ptr_string/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/no_overlap/ptr_string/types.go b/output_tests/struct/anonymous/no_overlap/ptr_string/types.go new file mode 100644 index 0000000..1286763 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/ptr_string/types.go @@ -0,0 +1,7 @@ +package test + +type Embedded string + +type T struct { + *Embedded +} diff --git a/output_tests/struct/anonymous/no_overlap/ptr_struct_various/json_test.go b/output_tests/struct/anonymous/no_overlap/ptr_struct_various/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/ptr_struct_various/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/no_overlap/ptr_struct_various/types.go b/output_tests/struct/anonymous/no_overlap/ptr_struct_various/types.go new file mode 100644 index 0000000..f025afe --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/ptr_struct_various/types.go @@ -0,0 +1,16 @@ +package test + +type Embedded struct { + String string + Int int32 + Float float64 + Struct struct { + X string + } + Slice []string + Map map[string]string +} + +type T struct { + *Embedded +} diff --git a/output_tests/struct/anonymous/no_overlap/slice_string/json_test.go b/output_tests/struct/anonymous/no_overlap/slice_string/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/slice_string/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/no_overlap/slice_string/types.go b/output_tests/struct/anonymous/no_overlap/slice_string/types.go new file mode 100644 index 0000000..0e59e70 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/slice_string/types.go @@ -0,0 +1,7 @@ +package test + +type Embedded []string + +type T struct { + Embedded +} diff --git a/output_tests/struct/anonymous/no_overlap/string/json_test.go b/output_tests/struct/anonymous/no_overlap/string/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/string/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/no_overlap/string/types.go b/output_tests/struct/anonymous/no_overlap/string/types.go new file mode 100644 index 0000000..008f903 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/string/types.go @@ -0,0 +1,7 @@ +package test + +type Embedded string + +type T struct { + Embedded +} diff --git a/output_tests/struct/anonymous/no_overlap/string_with_tag/json_test.go b/output_tests/struct/anonymous/no_overlap/string_with_tag/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/string_with_tag/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/no_overlap/string_with_tag/types.go b/output_tests/struct/anonymous/no_overlap/string_with_tag/types.go new file mode 100644 index 0000000..b7e01bd --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/string_with_tag/types.go @@ -0,0 +1,7 @@ +package test + +type Embedded string + +type T struct { + Embedded `json:"othername"` +} diff --git a/output_tests/struct/anonymous/no_overlap/struct_various/json_test.go b/output_tests/struct/anonymous/no_overlap/struct_various/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/struct_various/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/no_overlap/struct_various/types.go b/output_tests/struct/anonymous/no_overlap/struct_various/types.go new file mode 100644 index 0000000..19d7328 --- /dev/null +++ b/output_tests/struct/anonymous/no_overlap/struct_various/types.go @@ -0,0 +1,16 @@ +package test + +type Embedded struct { + String string + Int int32 + Float float64 + Struct struct { + X string + } + Slice []string + Map map[string]string +} + +type T struct { + Embedded +} diff --git a/output_tests/struct/anonymous/overlap/different_levels/json_test.go b/output_tests/struct/anonymous/overlap/different_levels/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/overlap/different_levels/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/overlap/different_levels/types.go b/output_tests/struct/anonymous/overlap/different_levels/types.go new file mode 100644 index 0000000..400441d --- /dev/null +++ b/output_tests/struct/anonymous/overlap/different_levels/types.go @@ -0,0 +1,10 @@ +package test + +type Embedded struct { + F1 int32 +} + +type T struct { + F1 string + Embedded +} diff --git a/output_tests/struct/anonymous/overlap/ignore_deeper_level/json_test.go b/output_tests/struct/anonymous/overlap/ignore_deeper_level/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/overlap/ignore_deeper_level/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/overlap/ignore_deeper_level/types.go b/output_tests/struct/anonymous/overlap/ignore_deeper_level/types.go new file mode 100644 index 0000000..5417bb3 --- /dev/null +++ b/output_tests/struct/anonymous/overlap/ignore_deeper_level/types.go @@ -0,0 +1,20 @@ +package test + +type DoubleEmbedded struct { + F1 int32 `json:"F1"` +} + +type Embedded1 struct { + DoubleEmbedded + F1 int32 +} + +type Embedded2 struct { + F1 int32 `json:"F1"` + DoubleEmbedded +} + +type T struct { + Embedded1 + Embedded2 +} diff --git a/output_tests/struct/anonymous/overlap/same_level_1_both_tagged/json_test.go b/output_tests/struct/anonymous/overlap/same_level_1_both_tagged/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/overlap/same_level_1_both_tagged/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/overlap/same_level_1_both_tagged/types.go b/output_tests/struct/anonymous/overlap/same_level_1_both_tagged/types.go new file mode 100644 index 0000000..d93fd3c --- /dev/null +++ b/output_tests/struct/anonymous/overlap/same_level_1_both_tagged/types.go @@ -0,0 +1,14 @@ +package test + +type Embedded1 struct { + F1 int32 `json:"F1"` +} + +type Embedded2 struct { + F1 int32 `json:"F1"` +} + +type T struct { + Embedded1 + Embedded2 +} diff --git a/output_tests/struct/anonymous/overlap/same_level_1_no_tags/json_test.go b/output_tests/struct/anonymous/overlap/same_level_1_no_tags/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/overlap/same_level_1_no_tags/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/overlap/same_level_1_no_tags/types.go b/output_tests/struct/anonymous/overlap/same_level_1_no_tags/types.go new file mode 100644 index 0000000..2a0036f --- /dev/null +++ b/output_tests/struct/anonymous/overlap/same_level_1_no_tags/types.go @@ -0,0 +1,14 @@ +package test + +type Embedded1 struct { + F1 int32 +} + +type Embedded2 struct { + F1 int32 +} + +type T struct { + Embedded1 + Embedded2 +} diff --git a/output_tests/struct/anonymous/overlap/same_level_1_tagged/json_test.go b/output_tests/struct/anonymous/overlap/same_level_1_tagged/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/overlap/same_level_1_tagged/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/overlap/same_level_1_tagged/types.go b/output_tests/struct/anonymous/overlap/same_level_1_tagged/types.go new file mode 100644 index 0000000..e4cf42f --- /dev/null +++ b/output_tests/struct/anonymous/overlap/same_level_1_tagged/types.go @@ -0,0 +1,14 @@ +package test + +type Embedded1 struct { + F1 int32 +} + +type Embedded2 struct { + F1 int32 `json:"F1"` +} + +type T struct { + Embedded1 + Embedded2 +} diff --git a/output_tests/struct/anonymous/overlap/same_level_2_both_tagged/json_test.go b/output_tests/struct/anonymous/overlap/same_level_2_both_tagged/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/overlap/same_level_2_both_tagged/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/overlap/same_level_2_both_tagged/types.go b/output_tests/struct/anonymous/overlap/same_level_2_both_tagged/types.go new file mode 100644 index 0000000..f434c5d --- /dev/null +++ b/output_tests/struct/anonymous/overlap/same_level_2_both_tagged/types.go @@ -0,0 +1,22 @@ +package test + +type DoubleEmbedded1 struct { + F1 int32 `json:"F1"` +} + +type Embedded1 struct { + DoubleEmbedded1 +} + +type DoubleEmbedded2 struct { + F1 int32 `json:"F1"` +} + +type Embedded2 struct { + DoubleEmbedded2 +} + +type T struct { + Embedded1 + Embedded2 +} diff --git a/output_tests/struct/anonymous/overlap/same_level_2_no_tags/json_test.go b/output_tests/struct/anonymous/overlap/same_level_2_no_tags/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/overlap/same_level_2_no_tags/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/overlap/same_level_2_no_tags/types.go b/output_tests/struct/anonymous/overlap/same_level_2_no_tags/types.go new file mode 100644 index 0000000..e19a1be --- /dev/null +++ b/output_tests/struct/anonymous/overlap/same_level_2_no_tags/types.go @@ -0,0 +1,22 @@ +package test + +type DoubleEmbedded1 struct { + F1 int32 +} + +type Embedded1 struct { + DoubleEmbedded1 +} + +type DoubleEmbedded2 struct { + F1 int32 +} + +type Embedded2 struct { + DoubleEmbedded2 +} + +type T struct { + Embedded1 + Embedded2 +} diff --git a/output_tests/struct/anonymous/overlap/same_level_2_tagged/json_test.go b/output_tests/struct/anonymous/overlap/same_level_2_tagged/json_test.go new file mode 100644 index 0000000..8c7d795 --- /dev/null +++ b/output_tests/struct/anonymous/overlap/same_level_2_tagged/json_test.go @@ -0,0 +1,152 @@ +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "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.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("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.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + 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) +} diff --git a/output_tests/struct/anonymous/overlap/same_level_2_tagged/types.go b/output_tests/struct/anonymous/overlap/same_level_2_tagged/types.go new file mode 100644 index 0000000..eebd291 --- /dev/null +++ b/output_tests/struct/anonymous/overlap/same_level_2_tagged/types.go @@ -0,0 +1,22 @@ +package test + +type DoubleEmbedded1 struct { + F1 int32 +} + +type Embedded1 struct { + DoubleEmbedded1 +} + +type DoubleEmbedded2 struct { + F1 int32 `json:"F1"` +} + +type Embedded2 struct { + DoubleEmbedded2 +} + +type T struct { + Embedded1 + Embedded2 +} From 03a2daaeeeaefbd2d1df0dc9cefb528d34efb5ec Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 22:06:13 +0100 Subject: [PATCH 18/18] Add a test for caseless unmarshal --- .../caseless_unmarshal/caseless_test.go | 84 +++++++++++++++++++ output_tests/caseless_unmarshal/types.go | 9 ++ 2 files changed, 93 insertions(+) create mode 100644 output_tests/caseless_unmarshal/caseless_test.go create mode 100644 output_tests/caseless_unmarshal/types.go diff --git a/output_tests/caseless_unmarshal/caseless_test.go b/output_tests/caseless_unmarshal/caseless_test.go new file mode 100644 index 0000000..d9049d8 --- /dev/null +++ b/output_tests/caseless_unmarshal/caseless_test.go @@ -0,0 +1,84 @@ +// NOTE: This test is different than most of the other JSON roundtrip tests. +package test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "testing" + + "github.com/davecgh/go-spew/spew" + fuzz "github.com/google/gofuzz" + jsoniter "github.com/json-iterator/go" +) + +func Test_CaselessUnmarshal(t *testing.T) { + fz := fuzz.New().MaxDepth(10).NilChance(0.3) + for i := 0; i < 1000; i++ { + var before T1 + fz.Fuzz(&before) + + jbStd, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") + } + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") + } + if string(jbStd) != string(jbIter) { + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + indent(jbStd, " "), indent(jbIter, " "), dump(before)) + } + + var afterStd T2 + err = json.Unmarshal(jbIter, &afterStd) + if err != nil { + t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + var afterIter T2 + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) + if err != nil { + t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", + err, indent(jbIter, " ")) + } + if fingerprint(afterStd) != fingerprint(afterIter) { + t.Fatalf("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 + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } + return buf.String() +} diff --git a/output_tests/caseless_unmarshal/types.go b/output_tests/caseless_unmarshal/types.go new file mode 100644 index 0000000..8ad454e --- /dev/null +++ b/output_tests/caseless_unmarshal/types.go @@ -0,0 +1,9 @@ +package test + +type T1 struct { + Field string +} + +type T2 struct { + FIELD string +}