From 9215b3c5085f74d82f7dad63be633ba21435e486 Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Sun, 11 Jun 2017 21:04:59 -0700 Subject: [PATCH 1/2] Add output tests for builtin types This fuzzes a type, marshals it with stdlib and json-iterator, compares, then unmarshals with stdlib and json-iterator and compares. This is checking for literal, byte-for-byte compatibility. In every case the test is exactly the same. It also include benchmark functions to compare stdlib vs json-iterator. This depends on a couple PRs to be merged in gofuzz. --- output_tests/builtins/bool/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/bool/types.go | 3 + output_tests/builtins/bool_alias/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/bool_alias/types.go | 3 + output_tests/builtins/byte/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/byte/types.go | 3 + output_tests/builtins/byte_alias/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/byte_alias/types.go | 3 + output_tests/builtins/float32/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/float32/types.go | 3 + .../builtins/float32_alias/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/float32_alias/types.go | 3 + output_tests/builtins/float64/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/float64/types.go | 3 + .../builtins/float64_alias/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/float64_alias/types.go | 3 + output_tests/builtins/int16/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/int16/types.go | 3 + .../builtins/int16_alias/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/int16_alias/types.go | 3 + output_tests/builtins/int32/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/int32/types.go | 3 + .../builtins/int32_alias/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/int32_alias/types.go | 3 + output_tests/builtins/int8/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/int8/types.go | 3 + output_tests/builtins/int8_alias/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/int8_alias/types.go | 3 + output_tests/builtins/string/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/string/types.go | 3 + .../builtins/string_alias/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/string_alias/types.go | 3 + output_tests/builtins/uint16/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/uint16/types.go | 3 + .../builtins/uint16_alias/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/uint16_alias/types.go | 3 + output_tests/builtins/uint32/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/uint32/types.go | 3 + .../builtins/uint32_alias/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/uint32_alias/types.go | 3 + output_tests/builtins/uint8/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/uint8/types.go | 3 + .../builtins/uint8_alias/json_test.go | 144 ++++++++++++++++++ output_tests/builtins/uint8_alias/types.go | 3 + 44 files changed, 3234 insertions(+) create mode 100644 output_tests/builtins/bool/json_test.go create mode 100644 output_tests/builtins/bool/types.go create mode 100644 output_tests/builtins/bool_alias/json_test.go create mode 100644 output_tests/builtins/bool_alias/types.go create mode 100644 output_tests/builtins/byte/json_test.go create mode 100644 output_tests/builtins/byte/types.go create mode 100644 output_tests/builtins/byte_alias/json_test.go create mode 100644 output_tests/builtins/byte_alias/types.go create mode 100644 output_tests/builtins/float32/json_test.go create mode 100644 output_tests/builtins/float32/types.go create mode 100644 output_tests/builtins/float32_alias/json_test.go create mode 100644 output_tests/builtins/float32_alias/types.go create mode 100644 output_tests/builtins/float64/json_test.go create mode 100644 output_tests/builtins/float64/types.go create mode 100644 output_tests/builtins/float64_alias/json_test.go create mode 100644 output_tests/builtins/float64_alias/types.go create mode 100644 output_tests/builtins/int16/json_test.go create mode 100644 output_tests/builtins/int16/types.go create mode 100644 output_tests/builtins/int16_alias/json_test.go create mode 100644 output_tests/builtins/int16_alias/types.go create mode 100644 output_tests/builtins/int32/json_test.go create mode 100644 output_tests/builtins/int32/types.go create mode 100644 output_tests/builtins/int32_alias/json_test.go create mode 100644 output_tests/builtins/int32_alias/types.go create mode 100644 output_tests/builtins/int8/json_test.go create mode 100644 output_tests/builtins/int8/types.go create mode 100644 output_tests/builtins/int8_alias/json_test.go create mode 100644 output_tests/builtins/int8_alias/types.go create mode 100644 output_tests/builtins/string/json_test.go create mode 100644 output_tests/builtins/string/types.go create mode 100644 output_tests/builtins/string_alias/json_test.go create mode 100644 output_tests/builtins/string_alias/types.go create mode 100644 output_tests/builtins/uint16/json_test.go create mode 100644 output_tests/builtins/uint16/types.go create mode 100644 output_tests/builtins/uint16_alias/json_test.go create mode 100644 output_tests/builtins/uint16_alias/types.go create mode 100644 output_tests/builtins/uint32/json_test.go create mode 100644 output_tests/builtins/uint32/types.go create mode 100644 output_tests/builtins/uint32_alias/json_test.go create mode 100644 output_tests/builtins/uint32_alias/types.go create mode 100644 output_tests/builtins/uint8/json_test.go create mode 100644 output_tests/builtins/uint8/types.go create mode 100644 output_tests/builtins/uint8_alias/json_test.go create mode 100644 output_tests/builtins/uint8_alias/types.go diff --git a/output_tests/builtins/bool/json_test.go b/output_tests/builtins/bool/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/bool/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/bool/types.go b/output_tests/builtins/bool/types.go new file mode 100644 index 0000000..1256227 --- /dev/null +++ b/output_tests/builtins/bool/types.go @@ -0,0 +1,3 @@ +package test + +type T bool diff --git a/output_tests/builtins/bool_alias/json_test.go b/output_tests/builtins/bool_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/bool_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/bool_alias/types.go b/output_tests/builtins/bool_alias/types.go new file mode 100644 index 0000000..1256227 --- /dev/null +++ b/output_tests/builtins/bool_alias/types.go @@ -0,0 +1,3 @@ +package test + +type T bool diff --git a/output_tests/builtins/byte/json_test.go b/output_tests/builtins/byte/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/byte/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/byte/types.go b/output_tests/builtins/byte/types.go new file mode 100644 index 0000000..cfe3f49 --- /dev/null +++ b/output_tests/builtins/byte/types.go @@ -0,0 +1,3 @@ +package test + +type T byte diff --git a/output_tests/builtins/byte_alias/json_test.go b/output_tests/builtins/byte_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/byte_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/byte_alias/types.go b/output_tests/builtins/byte_alias/types.go new file mode 100644 index 0000000..cfe3f49 --- /dev/null +++ b/output_tests/builtins/byte_alias/types.go @@ -0,0 +1,3 @@ +package test + +type T byte diff --git a/output_tests/builtins/float32/json_test.go b/output_tests/builtins/float32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/float32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/float32/types.go b/output_tests/builtins/float32/types.go new file mode 100644 index 0000000..4d63a9d --- /dev/null +++ b/output_tests/builtins/float32/types.go @@ -0,0 +1,3 @@ +package test + +type T float32 diff --git a/output_tests/builtins/float32_alias/json_test.go b/output_tests/builtins/float32_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/float32_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/float32_alias/types.go b/output_tests/builtins/float32_alias/types.go new file mode 100644 index 0000000..4d63a9d --- /dev/null +++ b/output_tests/builtins/float32_alias/types.go @@ -0,0 +1,3 @@ +package test + +type T float32 diff --git a/output_tests/builtins/float64/json_test.go b/output_tests/builtins/float64/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/float64/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/float64/types.go b/output_tests/builtins/float64/types.go new file mode 100644 index 0000000..841b79d --- /dev/null +++ b/output_tests/builtins/float64/types.go @@ -0,0 +1,3 @@ +package test + +type T float64 diff --git a/output_tests/builtins/float64_alias/json_test.go b/output_tests/builtins/float64_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/float64_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/float64_alias/types.go b/output_tests/builtins/float64_alias/types.go new file mode 100644 index 0000000..841b79d --- /dev/null +++ b/output_tests/builtins/float64_alias/types.go @@ -0,0 +1,3 @@ +package test + +type T float64 diff --git a/output_tests/builtins/int16/json_test.go b/output_tests/builtins/int16/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/int16/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/int16/types.go b/output_tests/builtins/int16/types.go new file mode 100644 index 0000000..2c815fe --- /dev/null +++ b/output_tests/builtins/int16/types.go @@ -0,0 +1,3 @@ +package test + +type T int16 diff --git a/output_tests/builtins/int16_alias/json_test.go b/output_tests/builtins/int16_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/int16_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/int16_alias/types.go b/output_tests/builtins/int16_alias/types.go new file mode 100644 index 0000000..2c815fe --- /dev/null +++ b/output_tests/builtins/int16_alias/types.go @@ -0,0 +1,3 @@ +package test + +type T int16 diff --git a/output_tests/builtins/int32/json_test.go b/output_tests/builtins/int32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/int32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/int32/types.go b/output_tests/builtins/int32/types.go new file mode 100644 index 0000000..ab2c0cc --- /dev/null +++ b/output_tests/builtins/int32/types.go @@ -0,0 +1,3 @@ +package test + +type T int32 diff --git a/output_tests/builtins/int32_alias/json_test.go b/output_tests/builtins/int32_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/int32_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/int32_alias/types.go b/output_tests/builtins/int32_alias/types.go new file mode 100644 index 0000000..ab2c0cc --- /dev/null +++ b/output_tests/builtins/int32_alias/types.go @@ -0,0 +1,3 @@ +package test + +type T int32 diff --git a/output_tests/builtins/int8/json_test.go b/output_tests/builtins/int8/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/int8/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/int8/types.go b/output_tests/builtins/int8/types.go new file mode 100644 index 0000000..9701529 --- /dev/null +++ b/output_tests/builtins/int8/types.go @@ -0,0 +1,3 @@ +package test + +type T int8 diff --git a/output_tests/builtins/int8_alias/json_test.go b/output_tests/builtins/int8_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/int8_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/int8_alias/types.go b/output_tests/builtins/int8_alias/types.go new file mode 100644 index 0000000..9701529 --- /dev/null +++ b/output_tests/builtins/int8_alias/types.go @@ -0,0 +1,3 @@ +package test + +type T int8 diff --git a/output_tests/builtins/string/json_test.go b/output_tests/builtins/string/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/string/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/string/types.go b/output_tests/builtins/string/types.go new file mode 100644 index 0000000..e453633 --- /dev/null +++ b/output_tests/builtins/string/types.go @@ -0,0 +1,3 @@ +package test + +type T string diff --git a/output_tests/builtins/string_alias/json_test.go b/output_tests/builtins/string_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/string_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/string_alias/types.go b/output_tests/builtins/string_alias/types.go new file mode 100644 index 0000000..e453633 --- /dev/null +++ b/output_tests/builtins/string_alias/types.go @@ -0,0 +1,3 @@ +package test + +type T string diff --git a/output_tests/builtins/uint16/json_test.go b/output_tests/builtins/uint16/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/uint16/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/uint16/types.go b/output_tests/builtins/uint16/types.go new file mode 100644 index 0000000..2b8ef0c --- /dev/null +++ b/output_tests/builtins/uint16/types.go @@ -0,0 +1,3 @@ +package test + +type T uint16 diff --git a/output_tests/builtins/uint16_alias/json_test.go b/output_tests/builtins/uint16_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/uint16_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/uint16_alias/types.go b/output_tests/builtins/uint16_alias/types.go new file mode 100644 index 0000000..2b8ef0c --- /dev/null +++ b/output_tests/builtins/uint16_alias/types.go @@ -0,0 +1,3 @@ +package test + +type T uint16 diff --git a/output_tests/builtins/uint32/json_test.go b/output_tests/builtins/uint32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/uint32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/uint32/types.go b/output_tests/builtins/uint32/types.go new file mode 100644 index 0000000..7b97339 --- /dev/null +++ b/output_tests/builtins/uint32/types.go @@ -0,0 +1,3 @@ +package test + +type T uint32 diff --git a/output_tests/builtins/uint32_alias/json_test.go b/output_tests/builtins/uint32_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/uint32_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/uint32_alias/types.go b/output_tests/builtins/uint32_alias/types.go new file mode 100644 index 0000000..7b97339 --- /dev/null +++ b/output_tests/builtins/uint32_alias/types.go @@ -0,0 +1,3 @@ +package test + +type T uint32 diff --git a/output_tests/builtins/uint8/json_test.go b/output_tests/builtins/uint8/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/uint8/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/uint8/types.go b/output_tests/builtins/uint8/types.go new file mode 100644 index 0000000..3e34e87 --- /dev/null +++ b/output_tests/builtins/uint8/types.go @@ -0,0 +1,3 @@ +package test + +type T uint8 diff --git a/output_tests/builtins/uint8_alias/json_test.go b/output_tests/builtins/uint8_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/builtins/uint8_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/builtins/uint8_alias/types.go b/output_tests/builtins/uint8_alias/types.go new file mode 100644 index 0000000..3e34e87 --- /dev/null +++ b/output_tests/builtins/uint8_alias/types.go @@ -0,0 +1,3 @@ +package test + +type T uint8 From 7480e41836d4a0a2fc442e61ff2a766024775963 Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Sun, 11 Jun 2017 21:09:56 -0700 Subject: [PATCH 2/2] Add output tests for maps of builtins This tests for exact stdlib compatibility. --- .../maps/builtins/int32/bool/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/int32/bool/types.go | 3 + .../maps/builtins/int32/byte/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/int32/byte/types.go | 3 + .../maps/builtins/int32/float32/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/int32/float32/types.go | 3 + .../maps/builtins/int32/float64/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/int32/float64/types.go | 3 + .../maps/builtins/int32/int32/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/int32/int32/types.go | 3 + .../maps/builtins/int32/int8/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/int32/int8/types.go | 3 + .../maps/builtins/int32/string/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/int32/string/types.go | 3 + .../builtins/int32/string_alias/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/int32/string_alias/types.go | 5 + .../maps/builtins/int32/uint8/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/int32/uint8/types.go | 3 + .../maps/builtins/string/bool/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/string/bool/types.go | 3 + .../maps/builtins/string/byte/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/string/byte/types.go | 3 + .../maps/builtins/string/float32/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/string/float32/types.go | 3 + .../maps/builtins/string/float64/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/string/float64/types.go | 3 + .../maps/builtins/string/int32/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/string/int32/types.go | 3 + .../maps/builtins/string/int8/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/string/int8/types.go | 3 + .../maps/builtins/string/string/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/string/string/types.go | 3 + .../builtins/string/string_alias/json_test.go | 144 ++++++++++++++++++ .../builtins/string/string_alias/types.go | 5 + .../maps/builtins/string/uint8/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/string/uint8/types.go | 3 + .../builtins/string_alias/bool/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/string_alias/bool/types.go | 5 + .../builtins/string_alias/byte/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/string_alias/byte/types.go | 5 + .../string_alias/float32/json_test.go | 144 ++++++++++++++++++ .../builtins/string_alias/float32/types.go | 5 + .../string_alias/float64/json_test.go | 144 ++++++++++++++++++ .../builtins/string_alias/float64/types.go | 5 + .../builtins/string_alias/int32/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/string_alias/int32/types.go | 5 + .../builtins/string_alias/int8/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/string_alias/int8/types.go | 5 + .../builtins/string_alias/string/json_test.go | 144 ++++++++++++++++++ .../builtins/string_alias/string/types.go | 5 + .../string_alias/string_alias/json_test.go | 144 ++++++++++++++++++ .../string_alias/string_alias/types.go | 5 + .../builtins/string_alias/uint8/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/string_alias/uint8/types.go | 5 + .../maps/builtins/uint8/bool/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/uint8/bool/types.go | 3 + .../maps/builtins/uint8/byte/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/uint8/byte/types.go | 3 + .../maps/builtins/uint8/float32/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/uint8/float32/types.go | 3 + .../maps/builtins/uint8/float64/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/uint8/float64/types.go | 3 + .../maps/builtins/uint8/int32/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/uint8/int32/types.go | 3 + .../maps/builtins/uint8/int8/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/uint8/int8/types.go | 3 + .../maps/builtins/uint8/string/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/uint8/string/types.go | 3 + .../builtins/uint8/string_alias/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/uint8/string_alias/types.go | 5 + .../maps/builtins/uint8/uint8/json_test.go | 144 ++++++++++++++++++ .../maps/builtins/uint8/uint8/types.go | 3 + .../maps/pointers/int16/ptr_bool/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/int16/ptr_bool/types.go | 3 + .../pointers/int16/ptr_float64/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/int16/ptr_float64/types.go | 3 + .../pointers/int16/ptr_int32/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/int16/ptr_int32/types.go | 3 + .../pointers/int16/ptr_string/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/int16/ptr_string/types.go | 3 + .../pointers/int16/ptr_uint8/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/int16/ptr_uint8/types.go | 3 + .../pointers/string/ptr_bool/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/string/ptr_bool/types.go | 3 + .../pointers/string/ptr_float64/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/string/ptr_float64/types.go | 3 + .../pointers/string/ptr_int32/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/string/ptr_int32/types.go | 3 + .../pointers/string/ptr_string/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/string/ptr_string/types.go | 3 + .../pointers/string/ptr_uint8/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/string/ptr_uint8/types.go | 3 + .../pointers/uint16/ptr_bool/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/uint16/ptr_bool/types.go | 3 + .../pointers/uint16/ptr_float64/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/uint16/ptr_float64/types.go | 3 + .../pointers/uint16/ptr_int32/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/uint16/ptr_int32/types.go | 3 + .../pointers/uint16/ptr_string/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/uint16/ptr_string/types.go | 3 + .../pointers/uint16/ptr_uint8/json_test.go | 144 ++++++++++++++++++ .../maps/pointers/uint16/ptr_uint8/types.go | 3 + 102 files changed, 7521 insertions(+) create mode 100644 output_tests/maps/builtins/int32/bool/json_test.go create mode 100644 output_tests/maps/builtins/int32/bool/types.go create mode 100644 output_tests/maps/builtins/int32/byte/json_test.go create mode 100644 output_tests/maps/builtins/int32/byte/types.go create mode 100644 output_tests/maps/builtins/int32/float32/json_test.go create mode 100644 output_tests/maps/builtins/int32/float32/types.go create mode 100644 output_tests/maps/builtins/int32/float64/json_test.go create mode 100644 output_tests/maps/builtins/int32/float64/types.go create mode 100644 output_tests/maps/builtins/int32/int32/json_test.go create mode 100644 output_tests/maps/builtins/int32/int32/types.go create mode 100644 output_tests/maps/builtins/int32/int8/json_test.go create mode 100644 output_tests/maps/builtins/int32/int8/types.go create mode 100644 output_tests/maps/builtins/int32/string/json_test.go create mode 100644 output_tests/maps/builtins/int32/string/types.go create mode 100644 output_tests/maps/builtins/int32/string_alias/json_test.go create mode 100644 output_tests/maps/builtins/int32/string_alias/types.go create mode 100644 output_tests/maps/builtins/int32/uint8/json_test.go create mode 100644 output_tests/maps/builtins/int32/uint8/types.go create mode 100644 output_tests/maps/builtins/string/bool/json_test.go create mode 100644 output_tests/maps/builtins/string/bool/types.go create mode 100644 output_tests/maps/builtins/string/byte/json_test.go create mode 100644 output_tests/maps/builtins/string/byte/types.go create mode 100644 output_tests/maps/builtins/string/float32/json_test.go create mode 100644 output_tests/maps/builtins/string/float32/types.go create mode 100644 output_tests/maps/builtins/string/float64/json_test.go create mode 100644 output_tests/maps/builtins/string/float64/types.go create mode 100644 output_tests/maps/builtins/string/int32/json_test.go create mode 100644 output_tests/maps/builtins/string/int32/types.go create mode 100644 output_tests/maps/builtins/string/int8/json_test.go create mode 100644 output_tests/maps/builtins/string/int8/types.go create mode 100644 output_tests/maps/builtins/string/string/json_test.go create mode 100644 output_tests/maps/builtins/string/string/types.go create mode 100644 output_tests/maps/builtins/string/string_alias/json_test.go create mode 100644 output_tests/maps/builtins/string/string_alias/types.go create mode 100644 output_tests/maps/builtins/string/uint8/json_test.go create mode 100644 output_tests/maps/builtins/string/uint8/types.go create mode 100644 output_tests/maps/builtins/string_alias/bool/json_test.go create mode 100644 output_tests/maps/builtins/string_alias/bool/types.go create mode 100644 output_tests/maps/builtins/string_alias/byte/json_test.go create mode 100644 output_tests/maps/builtins/string_alias/byte/types.go create mode 100644 output_tests/maps/builtins/string_alias/float32/json_test.go create mode 100644 output_tests/maps/builtins/string_alias/float32/types.go create mode 100644 output_tests/maps/builtins/string_alias/float64/json_test.go create mode 100644 output_tests/maps/builtins/string_alias/float64/types.go create mode 100644 output_tests/maps/builtins/string_alias/int32/json_test.go create mode 100644 output_tests/maps/builtins/string_alias/int32/types.go create mode 100644 output_tests/maps/builtins/string_alias/int8/json_test.go create mode 100644 output_tests/maps/builtins/string_alias/int8/types.go create mode 100644 output_tests/maps/builtins/string_alias/string/json_test.go create mode 100644 output_tests/maps/builtins/string_alias/string/types.go create mode 100644 output_tests/maps/builtins/string_alias/string_alias/json_test.go create mode 100644 output_tests/maps/builtins/string_alias/string_alias/types.go create mode 100644 output_tests/maps/builtins/string_alias/uint8/json_test.go create mode 100644 output_tests/maps/builtins/string_alias/uint8/types.go create mode 100644 output_tests/maps/builtins/uint8/bool/json_test.go create mode 100644 output_tests/maps/builtins/uint8/bool/types.go create mode 100644 output_tests/maps/builtins/uint8/byte/json_test.go create mode 100644 output_tests/maps/builtins/uint8/byte/types.go create mode 100644 output_tests/maps/builtins/uint8/float32/json_test.go create mode 100644 output_tests/maps/builtins/uint8/float32/types.go create mode 100644 output_tests/maps/builtins/uint8/float64/json_test.go create mode 100644 output_tests/maps/builtins/uint8/float64/types.go create mode 100644 output_tests/maps/builtins/uint8/int32/json_test.go create mode 100644 output_tests/maps/builtins/uint8/int32/types.go create mode 100644 output_tests/maps/builtins/uint8/int8/json_test.go create mode 100644 output_tests/maps/builtins/uint8/int8/types.go create mode 100644 output_tests/maps/builtins/uint8/string/json_test.go create mode 100644 output_tests/maps/builtins/uint8/string/types.go create mode 100644 output_tests/maps/builtins/uint8/string_alias/json_test.go create mode 100644 output_tests/maps/builtins/uint8/string_alias/types.go create mode 100644 output_tests/maps/builtins/uint8/uint8/json_test.go create mode 100644 output_tests/maps/builtins/uint8/uint8/types.go create mode 100644 output_tests/maps/pointers/int16/ptr_bool/json_test.go create mode 100644 output_tests/maps/pointers/int16/ptr_bool/types.go create mode 100644 output_tests/maps/pointers/int16/ptr_float64/json_test.go create mode 100644 output_tests/maps/pointers/int16/ptr_float64/types.go create mode 100644 output_tests/maps/pointers/int16/ptr_int32/json_test.go create mode 100644 output_tests/maps/pointers/int16/ptr_int32/types.go create mode 100644 output_tests/maps/pointers/int16/ptr_string/json_test.go create mode 100644 output_tests/maps/pointers/int16/ptr_string/types.go create mode 100644 output_tests/maps/pointers/int16/ptr_uint8/json_test.go create mode 100644 output_tests/maps/pointers/int16/ptr_uint8/types.go create mode 100644 output_tests/maps/pointers/string/ptr_bool/json_test.go create mode 100644 output_tests/maps/pointers/string/ptr_bool/types.go create mode 100644 output_tests/maps/pointers/string/ptr_float64/json_test.go create mode 100644 output_tests/maps/pointers/string/ptr_float64/types.go create mode 100644 output_tests/maps/pointers/string/ptr_int32/json_test.go create mode 100644 output_tests/maps/pointers/string/ptr_int32/types.go create mode 100644 output_tests/maps/pointers/string/ptr_string/json_test.go create mode 100644 output_tests/maps/pointers/string/ptr_string/types.go create mode 100644 output_tests/maps/pointers/string/ptr_uint8/json_test.go create mode 100644 output_tests/maps/pointers/string/ptr_uint8/types.go create mode 100644 output_tests/maps/pointers/uint16/ptr_bool/json_test.go create mode 100644 output_tests/maps/pointers/uint16/ptr_bool/types.go create mode 100644 output_tests/maps/pointers/uint16/ptr_float64/json_test.go create mode 100644 output_tests/maps/pointers/uint16/ptr_float64/types.go create mode 100644 output_tests/maps/pointers/uint16/ptr_int32/json_test.go create mode 100644 output_tests/maps/pointers/uint16/ptr_int32/types.go create mode 100644 output_tests/maps/pointers/uint16/ptr_string/json_test.go create mode 100644 output_tests/maps/pointers/uint16/ptr_string/types.go create mode 100644 output_tests/maps/pointers/uint16/ptr_uint8/json_test.go create 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/maps/builtins/int32/bool/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/int32/bool/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/int32/bool/types.go b/output_tests/maps/builtins/int32/bool/types.go new file mode 100644 index 0000000..7f21229 --- /dev/null +++ b/output_tests/maps/builtins/int32/bool/types.go @@ -0,0 +1,3 @@ +package test + +type T map[int32]bool diff --git a/output_tests/maps/builtins/int32/byte/json_test.go b/output_tests/maps/builtins/int32/byte/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/int32/byte/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/int32/byte/types.go b/output_tests/maps/builtins/int32/byte/types.go new file mode 100644 index 0000000..8190cba --- /dev/null +++ b/output_tests/maps/builtins/int32/byte/types.go @@ -0,0 +1,3 @@ +package test + +type T map[int32]byte diff --git a/output_tests/maps/builtins/int32/float32/json_test.go b/output_tests/maps/builtins/int32/float32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/int32/float32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/int32/float32/types.go b/output_tests/maps/builtins/int32/float32/types.go new file mode 100644 index 0000000..be7c27d --- /dev/null +++ b/output_tests/maps/builtins/int32/float32/types.go @@ -0,0 +1,3 @@ +package test + +type T map[int32]float32 diff --git a/output_tests/maps/builtins/int32/float64/json_test.go b/output_tests/maps/builtins/int32/float64/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/int32/float64/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/int32/float64/types.go b/output_tests/maps/builtins/int32/float64/types.go new file mode 100644 index 0000000..5f597d7 --- /dev/null +++ b/output_tests/maps/builtins/int32/float64/types.go @@ -0,0 +1,3 @@ +package test + +type T map[int32]float64 diff --git a/output_tests/maps/builtins/int32/int32/json_test.go b/output_tests/maps/builtins/int32/int32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/int32/int32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/int32/int32/types.go b/output_tests/maps/builtins/int32/int32/types.go new file mode 100644 index 0000000..94e8940 --- /dev/null +++ b/output_tests/maps/builtins/int32/int32/types.go @@ -0,0 +1,3 @@ +package test + +type T map[int32]int32 diff --git a/output_tests/maps/builtins/int32/int8/json_test.go b/output_tests/maps/builtins/int32/int8/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/int32/int8/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/int32/int8/types.go b/output_tests/maps/builtins/int32/int8/types.go new file mode 100644 index 0000000..e2f3708 --- /dev/null +++ b/output_tests/maps/builtins/int32/int8/types.go @@ -0,0 +1,3 @@ +package test + +type T map[int32]int8 diff --git a/output_tests/maps/builtins/int32/string/json_test.go b/output_tests/maps/builtins/int32/string/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/int32/string/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/int32/string/types.go b/output_tests/maps/builtins/int32/string/types.go new file mode 100644 index 0000000..0bc11de --- /dev/null +++ b/output_tests/maps/builtins/int32/string/types.go @@ -0,0 +1,3 @@ +package test + +type T map[int32]string diff --git a/output_tests/maps/builtins/int32/string_alias/json_test.go b/output_tests/maps/builtins/int32/string_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/int32/string_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/int32/string_alias/types.go b/output_tests/maps/builtins/int32/string_alias/types.go new file mode 100644 index 0000000..d4af66b --- /dev/null +++ b/output_tests/maps/builtins/int32/string_alias/types.go @@ -0,0 +1,5 @@ +package test + +type StringAlias string + +type T map[int32]StringAlias diff --git a/output_tests/maps/builtins/int32/uint8/json_test.go b/output_tests/maps/builtins/int32/uint8/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/int32/uint8/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/int32/uint8/types.go b/output_tests/maps/builtins/int32/uint8/types.go new file mode 100644 index 0000000..e2948b2 --- /dev/null +++ b/output_tests/maps/builtins/int32/uint8/types.go @@ -0,0 +1,3 @@ +package test + +type T map[int32]uint8 diff --git a/output_tests/maps/builtins/string/bool/json_test.go b/output_tests/maps/builtins/string/bool/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string/bool/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string/bool/types.go b/output_tests/maps/builtins/string/bool/types.go new file mode 100644 index 0000000..29e96ad --- /dev/null +++ b/output_tests/maps/builtins/string/bool/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]bool diff --git a/output_tests/maps/builtins/string/byte/json_test.go b/output_tests/maps/builtins/string/byte/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string/byte/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string/byte/types.go b/output_tests/maps/builtins/string/byte/types.go new file mode 100644 index 0000000..f3c4543 --- /dev/null +++ b/output_tests/maps/builtins/string/byte/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]byte diff --git a/output_tests/maps/builtins/string/float32/json_test.go b/output_tests/maps/builtins/string/float32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string/float32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string/float32/types.go b/output_tests/maps/builtins/string/float32/types.go new file mode 100644 index 0000000..e019053 --- /dev/null +++ b/output_tests/maps/builtins/string/float32/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]float32 diff --git a/output_tests/maps/builtins/string/float64/json_test.go b/output_tests/maps/builtins/string/float64/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string/float64/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string/float64/types.go b/output_tests/maps/builtins/string/float64/types.go new file mode 100644 index 0000000..f038307 --- /dev/null +++ b/output_tests/maps/builtins/string/float64/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]float64 diff --git a/output_tests/maps/builtins/string/int32/json_test.go b/output_tests/maps/builtins/string/int32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string/int32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string/int32/types.go b/output_tests/maps/builtins/string/int32/types.go new file mode 100644 index 0000000..5024937 --- /dev/null +++ b/output_tests/maps/builtins/string/int32/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]int32 diff --git a/output_tests/maps/builtins/string/int8/json_test.go b/output_tests/maps/builtins/string/int8/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string/int8/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string/int8/types.go b/output_tests/maps/builtins/string/int8/types.go new file mode 100644 index 0000000..1843c77 --- /dev/null +++ b/output_tests/maps/builtins/string/int8/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]int8 diff --git a/output_tests/maps/builtins/string/string/json_test.go b/output_tests/maps/builtins/string/string/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string/string/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string/string/types.go b/output_tests/maps/builtins/string/string/types.go new file mode 100644 index 0000000..e3eeca5 --- /dev/null +++ b/output_tests/maps/builtins/string/string/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]string diff --git a/output_tests/maps/builtins/string/string_alias/json_test.go b/output_tests/maps/builtins/string/string_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string/string_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string/string_alias/types.go b/output_tests/maps/builtins/string/string_alias/types.go new file mode 100644 index 0000000..af97195 --- /dev/null +++ b/output_tests/maps/builtins/string/string_alias/types.go @@ -0,0 +1,5 @@ +package test + +type StringAlias string + +type T map[string]StringAlias diff --git a/output_tests/maps/builtins/string/uint8/json_test.go b/output_tests/maps/builtins/string/uint8/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string/uint8/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string/uint8/types.go b/output_tests/maps/builtins/string/uint8/types.go new file mode 100644 index 0000000..295c8f9 --- /dev/null +++ b/output_tests/maps/builtins/string/uint8/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]uint8 diff --git a/output_tests/maps/builtins/string_alias/bool/json_test.go b/output_tests/maps/builtins/string_alias/bool/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/bool/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string_alias/bool/types.go b/output_tests/maps/builtins/string_alias/bool/types.go new file mode 100644 index 0000000..f385400 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/bool/types.go @@ -0,0 +1,5 @@ +package test + +type StringAlias string + +type T map[StringAlias]bool diff --git a/output_tests/maps/builtins/string_alias/byte/json_test.go b/output_tests/maps/builtins/string_alias/byte/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/byte/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string_alias/byte/types.go b/output_tests/maps/builtins/string_alias/byte/types.go new file mode 100644 index 0000000..665339f --- /dev/null +++ b/output_tests/maps/builtins/string_alias/byte/types.go @@ -0,0 +1,5 @@ +package test + +type StringAlias string + +type T map[StringAlias]byte diff --git a/output_tests/maps/builtins/string_alias/float32/json_test.go b/output_tests/maps/builtins/string_alias/float32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/float32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string_alias/float32/types.go b/output_tests/maps/builtins/string_alias/float32/types.go new file mode 100644 index 0000000..93ea708 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/float32/types.go @@ -0,0 +1,5 @@ +package test + +type StringAlias string + +type T map[StringAlias]float32 diff --git a/output_tests/maps/builtins/string_alias/float64/json_test.go b/output_tests/maps/builtins/string_alias/float64/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/float64/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string_alias/float64/types.go b/output_tests/maps/builtins/string_alias/float64/types.go new file mode 100644 index 0000000..10e8dbe --- /dev/null +++ b/output_tests/maps/builtins/string_alias/float64/types.go @@ -0,0 +1,5 @@ +package test + +type StringAlias string + +type T map[StringAlias]float64 diff --git a/output_tests/maps/builtins/string_alias/int32/json_test.go b/output_tests/maps/builtins/string_alias/int32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/int32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string_alias/int32/types.go b/output_tests/maps/builtins/string_alias/int32/types.go new file mode 100644 index 0000000..c0b8c1b --- /dev/null +++ b/output_tests/maps/builtins/string_alias/int32/types.go @@ -0,0 +1,5 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/int8/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string_alias/int8/types.go b/output_tests/maps/builtins/string_alias/int8/types.go new file mode 100644 index 0000000..a0b7de3 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/int8/types.go @@ -0,0 +1,5 @@ +package test + +type StringAlias string + +type T map[StringAlias]int8 diff --git a/output_tests/maps/builtins/string_alias/string/json_test.go b/output_tests/maps/builtins/string_alias/string/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/string/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string_alias/string/types.go b/output_tests/maps/builtins/string_alias/string/types.go new file mode 100644 index 0000000..890064d --- /dev/null +++ b/output_tests/maps/builtins/string_alias/string/types.go @@ -0,0 +1,5 @@ +package test + +type StringAlias string + +type T map[StringAlias]string 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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/string_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string_alias/string_alias/types.go b/output_tests/maps/builtins/string_alias/string_alias/types.go new file mode 100644 index 0000000..6abab0e --- /dev/null +++ b/output_tests/maps/builtins/string_alias/string_alias/types.go @@ -0,0 +1,5 @@ +package test + +type StringAlias string + +type T map[StringAlias]StringAlias diff --git a/output_tests/maps/builtins/string_alias/uint8/json_test.go b/output_tests/maps/builtins/string_alias/uint8/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/uint8/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/string_alias/uint8/types.go b/output_tests/maps/builtins/string_alias/uint8/types.go new file mode 100644 index 0000000..ef37a71 --- /dev/null +++ b/output_tests/maps/builtins/string_alias/uint8/types.go @@ -0,0 +1,5 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/uint8/bool/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/uint8/bool/types.go b/output_tests/maps/builtins/uint8/bool/types.go new file mode 100644 index 0000000..1c32ae2 --- /dev/null +++ b/output_tests/maps/builtins/uint8/bool/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/uint8/byte/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/uint8/byte/types.go b/output_tests/maps/builtins/uint8/byte/types.go new file mode 100644 index 0000000..bddd3d0 --- /dev/null +++ b/output_tests/maps/builtins/uint8/byte/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/uint8/float32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/uint8/float32/types.go b/output_tests/maps/builtins/uint8/float32/types.go new file mode 100644 index 0000000..4ab4270 --- /dev/null +++ b/output_tests/maps/builtins/uint8/float32/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/uint8/float64/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/uint8/float64/types.go b/output_tests/maps/builtins/uint8/float64/types.go new file mode 100644 index 0000000..a429f7e --- /dev/null +++ b/output_tests/maps/builtins/uint8/float64/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/uint8/int32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/uint8/int32/types.go b/output_tests/maps/builtins/uint8/int32/types.go new file mode 100644 index 0000000..c2ce4be --- /dev/null +++ b/output_tests/maps/builtins/uint8/int32/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/uint8/int8/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/uint8/int8/types.go b/output_tests/maps/builtins/uint8/int8/types.go new file mode 100644 index 0000000..01fa4d3 --- /dev/null +++ b/output_tests/maps/builtins/uint8/int8/types.go @@ -0,0 +1,3 @@ +package test + +type T map[uint8]int8 diff --git a/output_tests/maps/builtins/uint8/string/json_test.go b/output_tests/maps/builtins/uint8/string/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/uint8/string/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/uint8/string/types.go b/output_tests/maps/builtins/uint8/string/types.go new file mode 100644 index 0000000..97c774a --- /dev/null +++ b/output_tests/maps/builtins/uint8/string/types.go @@ -0,0 +1,3 @@ +package test + +type T map[uint8]string diff --git a/output_tests/maps/builtins/uint8/string_alias/json_test.go b/output_tests/maps/builtins/uint8/string_alias/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/uint8/string_alias/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/uint8/string_alias/types.go b/output_tests/maps/builtins/uint8/string_alias/types.go new file mode 100644 index 0000000..d8e81f3 --- /dev/null +++ b/output_tests/maps/builtins/uint8/string_alias/types.go @@ -0,0 +1,5 @@ +package test + +type StringAlias string + +type T map[uint8]StringAlias diff --git a/output_tests/maps/builtins/uint8/uint8/json_test.go b/output_tests/maps/builtins/uint8/uint8/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/builtins/uint8/uint8/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/builtins/uint8/uint8/types.go b/output_tests/maps/builtins/uint8/uint8/types.go new file mode 100644 index 0000000..ee7f109 --- /dev/null +++ b/output_tests/maps/builtins/uint8/uint8/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/int16/ptr_bool/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/int16/ptr_bool/types.go b/output_tests/maps/pointers/int16/ptr_bool/types.go new file mode 100644 index 0000000..f49ad1c --- /dev/null +++ b/output_tests/maps/pointers/int16/ptr_bool/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/int16/ptr_float64/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/int16/ptr_float64/types.go b/output_tests/maps/pointers/int16/ptr_float64/types.go new file mode 100644 index 0000000..7fc988e --- /dev/null +++ b/output_tests/maps/pointers/int16/ptr_float64/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/int16/ptr_int32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/int16/ptr_int32/types.go b/output_tests/maps/pointers/int16/ptr_int32/types.go new file mode 100644 index 0000000..1c9e438 --- /dev/null +++ b/output_tests/maps/pointers/int16/ptr_int32/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/int16/ptr_string/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/int16/ptr_string/types.go b/output_tests/maps/pointers/int16/ptr_string/types.go new file mode 100644 index 0000000..04bc953 --- /dev/null +++ b/output_tests/maps/pointers/int16/ptr_string/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/int16/ptr_uint8/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/int16/ptr_uint8/types.go b/output_tests/maps/pointers/int16/ptr_uint8/types.go new file mode 100644 index 0000000..2f9baed --- /dev/null +++ b/output_tests/maps/pointers/int16/ptr_uint8/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/string/ptr_bool/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/string/ptr_bool/types.go b/output_tests/maps/pointers/string/ptr_bool/types.go new file mode 100644 index 0000000..e31fb56 --- /dev/null +++ b/output_tests/maps/pointers/string/ptr_bool/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]*bool diff --git a/output_tests/maps/pointers/string/ptr_float64/json_test.go b/output_tests/maps/pointers/string/ptr_float64/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/string/ptr_float64/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/string/ptr_float64/types.go b/output_tests/maps/pointers/string/ptr_float64/types.go new file mode 100644 index 0000000..3f19528 --- /dev/null +++ b/output_tests/maps/pointers/string/ptr_float64/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]*float64 diff --git a/output_tests/maps/pointers/string/ptr_int32/json_test.go b/output_tests/maps/pointers/string/ptr_int32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/string/ptr_int32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/string/ptr_int32/types.go b/output_tests/maps/pointers/string/ptr_int32/types.go new file mode 100644 index 0000000..d9516ca --- /dev/null +++ b/output_tests/maps/pointers/string/ptr_int32/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]*int32 diff --git a/output_tests/maps/pointers/string/ptr_string/json_test.go b/output_tests/maps/pointers/string/ptr_string/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/string/ptr_string/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/string/ptr_string/types.go b/output_tests/maps/pointers/string/ptr_string/types.go new file mode 100644 index 0000000..11262f7 --- /dev/null +++ b/output_tests/maps/pointers/string/ptr_string/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]*string diff --git a/output_tests/maps/pointers/string/ptr_uint8/json_test.go b/output_tests/maps/pointers/string/ptr_uint8/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/string/ptr_uint8/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/string/ptr_uint8/types.go b/output_tests/maps/pointers/string/ptr_uint8/types.go new file mode 100644 index 0000000..ef560ee --- /dev/null +++ b/output_tests/maps/pointers/string/ptr_uint8/types.go @@ -0,0 +1,3 @@ +package test + +type T map[string]*uint8 diff --git a/output_tests/maps/pointers/uint16/ptr_bool/json_test.go b/output_tests/maps/pointers/uint16/ptr_bool/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/uint16/ptr_bool/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/uint16/ptr_bool/types.go b/output_tests/maps/pointers/uint16/ptr_bool/types.go new file mode 100644 index 0000000..9cdc0c8 --- /dev/null +++ b/output_tests/maps/pointers/uint16/ptr_bool/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/uint16/ptr_float64/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/uint16/ptr_float64/types.go b/output_tests/maps/pointers/uint16/ptr_float64/types.go new file mode 100644 index 0000000..cfd5772 --- /dev/null +++ b/output_tests/maps/pointers/uint16/ptr_float64/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/uint16/ptr_int32/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/uint16/ptr_int32/types.go b/output_tests/maps/pointers/uint16/ptr_int32/types.go new file mode 100644 index 0000000..b472630 --- /dev/null +++ b/output_tests/maps/pointers/uint16/ptr_int32/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/uint16/ptr_string/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/uint16/ptr_string/types.go b/output_tests/maps/pointers/uint16/ptr_string/types.go new file mode 100644 index 0000000..2b56c01 --- /dev/null +++ b/output_tests/maps/pointers/uint16/ptr_string/types.go @@ -0,0 +1,3 @@ +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 new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/maps/pointers/uint16/ptr_uint8/json_test.go @@ -0,0 +1,144 @@ +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.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.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 BenchmarkStandardMarshal(t *testing.B) { + 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 := json.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkStandardUnmarshal(t *testing.B) { + 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 = json.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} + +func BenchmarkJSONIterMarshal(t *testing.B) { + 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 := jsoniter.Marshal(obj) + if err != nil { + t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + } + _ = jb + } +} + +func BenchmarkJSONIterUnmarshal(t *testing.B) { + 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 = jsoniter.Unmarshal(jb, &after) + if err != nil { + t.Fatalf("failed to unmarshal:\n input: %q\n error: %v", string(jb), err) + } + } +} diff --git a/output_tests/maps/pointers/uint16/ptr_uint8/types.go b/output_tests/maps/pointers/uint16/ptr_uint8/types.go new file mode 100644 index 0000000..5517914 --- /dev/null +++ b/output_tests/maps/pointers/uint16/ptr_uint8/types.go @@ -0,0 +1,3 @@ +package test + +type T map[uint16]*uint8