From 5d3508979f1dc1b50f8c488c59466594f7179e3c Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Mon, 12 Jun 2017 12:46:49 -0700 Subject: [PATCH 1/2] Add output tests for slices of builtins --- .../slices/builtins/bool/json_test.go | 144 ++++++++++++++++++ output_tests/slices/builtins/bool/types.go | 3 + .../slices/builtins/byte/json_test.go | 144 ++++++++++++++++++ output_tests/slices/builtins/byte/types.go | 3 + .../slices/builtins/float32/json_test.go | 144 ++++++++++++++++++ output_tests/slices/builtins/float32/types.go | 3 + .../slices/builtins/float64/json_test.go | 144 ++++++++++++++++++ output_tests/slices/builtins/float64/types.go | 3 + .../slices/builtins/int32/json_test.go | 144 ++++++++++++++++++ output_tests/slices/builtins/int32/types.go | 3 + .../slices/builtins/int8/json_test.go | 144 ++++++++++++++++++ output_tests/slices/builtins/int8/types.go | 3 + .../slices/builtins/string/json_test.go | 144 ++++++++++++++++++ output_tests/slices/builtins/string/types.go | 3 + .../slices/builtins/uint8/json_test.go | 144 ++++++++++++++++++ output_tests/slices/builtins/uint8/types.go | 3 + .../slices/pointers/bool/json_test.go | 144 ++++++++++++++++++ output_tests/slices/pointers/bool/types.go | 3 + .../slices/pointers/float32/json_test.go | 144 ++++++++++++++++++ output_tests/slices/pointers/float32/types.go | 3 + .../slices/pointers/float64/json_test.go | 144 ++++++++++++++++++ output_tests/slices/pointers/float64/types.go | 3 + .../slices/pointers/int32/json_test.go | 144 ++++++++++++++++++ output_tests/slices/pointers/int32/types.go | 3 + .../slices/pointers/int8/json_test.go | 144 ++++++++++++++++++ output_tests/slices/pointers/int8/types.go | 3 + .../slices/pointers/string/json_test.go | 144 ++++++++++++++++++ output_tests/slices/pointers/string/types.go | 3 + 28 files changed, 2058 insertions(+) create mode 100644 output_tests/slices/builtins/bool/json_test.go create mode 100644 output_tests/slices/builtins/bool/types.go create mode 100644 output_tests/slices/builtins/byte/json_test.go create mode 100644 output_tests/slices/builtins/byte/types.go create mode 100644 output_tests/slices/builtins/float32/json_test.go create mode 100644 output_tests/slices/builtins/float32/types.go create mode 100644 output_tests/slices/builtins/float64/json_test.go create mode 100644 output_tests/slices/builtins/float64/types.go create mode 100644 output_tests/slices/builtins/int32/json_test.go create mode 100644 output_tests/slices/builtins/int32/types.go create mode 100644 output_tests/slices/builtins/int8/json_test.go create mode 100644 output_tests/slices/builtins/int8/types.go create mode 100644 output_tests/slices/builtins/string/json_test.go create mode 100644 output_tests/slices/builtins/string/types.go create mode 100644 output_tests/slices/builtins/uint8/json_test.go create mode 100644 output_tests/slices/builtins/uint8/types.go create mode 100644 output_tests/slices/pointers/bool/json_test.go create mode 100644 output_tests/slices/pointers/bool/types.go create mode 100644 output_tests/slices/pointers/float32/json_test.go create mode 100644 output_tests/slices/pointers/float32/types.go create mode 100644 output_tests/slices/pointers/float64/json_test.go create mode 100644 output_tests/slices/pointers/float64/types.go create mode 100644 output_tests/slices/pointers/int32/json_test.go create mode 100644 output_tests/slices/pointers/int32/types.go create mode 100644 output_tests/slices/pointers/int8/json_test.go create mode 100644 output_tests/slices/pointers/int8/types.go create mode 100644 output_tests/slices/pointers/string/json_test.go create mode 100644 output_tests/slices/pointers/string/types.go diff --git a/output_tests/slices/builtins/bool/json_test.go b/output_tests/slices/builtins/bool/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/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/slices/builtins/bool/types.go b/output_tests/slices/builtins/bool/types.go new file mode 100644 index 0000000..38cedf1 --- /dev/null +++ b/output_tests/slices/builtins/bool/types.go @@ -0,0 +1,3 @@ +package test + +type T []bool diff --git a/output_tests/slices/builtins/byte/json_test.go b/output_tests/slices/builtins/byte/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/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/slices/builtins/byte/types.go b/output_tests/slices/builtins/byte/types.go new file mode 100644 index 0000000..e88324d --- /dev/null +++ b/output_tests/slices/builtins/byte/types.go @@ -0,0 +1,3 @@ +package test + +type T []byte diff --git a/output_tests/slices/builtins/float32/json_test.go b/output_tests/slices/builtins/float32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/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/slices/builtins/float32/types.go b/output_tests/slices/builtins/float32/types.go new file mode 100644 index 0000000..fba8cbe --- /dev/null +++ b/output_tests/slices/builtins/float32/types.go @@ -0,0 +1,3 @@ +package test + +type T []float32 diff --git a/output_tests/slices/builtins/float64/json_test.go b/output_tests/slices/builtins/float64/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/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/slices/builtins/float64/types.go b/output_tests/slices/builtins/float64/types.go new file mode 100644 index 0000000..5013457 --- /dev/null +++ b/output_tests/slices/builtins/float64/types.go @@ -0,0 +1,3 @@ +package test + +type T []float64 diff --git a/output_tests/slices/builtins/int32/json_test.go b/output_tests/slices/builtins/int32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/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/slices/builtins/int32/types.go b/output_tests/slices/builtins/int32/types.go new file mode 100644 index 0000000..98b8139 --- /dev/null +++ b/output_tests/slices/builtins/int32/types.go @@ -0,0 +1,3 @@ +package test + +type T []int32 diff --git a/output_tests/slices/builtins/int8/json_test.go b/output_tests/slices/builtins/int8/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/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/slices/builtins/int8/types.go b/output_tests/slices/builtins/int8/types.go new file mode 100644 index 0000000..02ccbf2 --- /dev/null +++ b/output_tests/slices/builtins/int8/types.go @@ -0,0 +1,3 @@ +package test + +type T []int8 diff --git a/output_tests/slices/builtins/string/json_test.go b/output_tests/slices/builtins/string/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/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/slices/builtins/string/types.go b/output_tests/slices/builtins/string/types.go new file mode 100644 index 0000000..75fb74d --- /dev/null +++ b/output_tests/slices/builtins/string/types.go @@ -0,0 +1,3 @@ +package test + +type T []string diff --git a/output_tests/slices/builtins/uint8/json_test.go b/output_tests/slices/builtins/uint8/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/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/slices/builtins/uint8/types.go b/output_tests/slices/builtins/uint8/types.go new file mode 100644 index 0000000..4f37131 --- /dev/null +++ b/output_tests/slices/builtins/uint8/types.go @@ -0,0 +1,3 @@ +package test + +type T []uint8 diff --git a/output_tests/slices/pointers/bool/json_test.go b/output_tests/slices/pointers/bool/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/pointers/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/slices/pointers/bool/types.go b/output_tests/slices/pointers/bool/types.go new file mode 100644 index 0000000..9791cf2 --- /dev/null +++ b/output_tests/slices/pointers/bool/types.go @@ -0,0 +1,3 @@ +package test + +type T []*bool diff --git a/output_tests/slices/pointers/float32/json_test.go b/output_tests/slices/pointers/float32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/pointers/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/slices/pointers/float32/types.go b/output_tests/slices/pointers/float32/types.go new file mode 100644 index 0000000..59207c2 --- /dev/null +++ b/output_tests/slices/pointers/float32/types.go @@ -0,0 +1,3 @@ +package test + +type T []*float32 diff --git a/output_tests/slices/pointers/float64/json_test.go b/output_tests/slices/pointers/float64/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/pointers/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/slices/pointers/float64/types.go b/output_tests/slices/pointers/float64/types.go new file mode 100644 index 0000000..a3dfea9 --- /dev/null +++ b/output_tests/slices/pointers/float64/types.go @@ -0,0 +1,3 @@ +package test + +type T []*float64 diff --git a/output_tests/slices/pointers/int32/json_test.go b/output_tests/slices/pointers/int32/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/pointers/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/slices/pointers/int32/types.go b/output_tests/slices/pointers/int32/types.go new file mode 100644 index 0000000..195c224 --- /dev/null +++ b/output_tests/slices/pointers/int32/types.go @@ -0,0 +1,3 @@ +package test + +type T []*int32 diff --git a/output_tests/slices/pointers/int8/json_test.go b/output_tests/slices/pointers/int8/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/pointers/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/slices/pointers/int8/types.go b/output_tests/slices/pointers/int8/types.go new file mode 100644 index 0000000..4113c54 --- /dev/null +++ b/output_tests/slices/pointers/int8/types.go @@ -0,0 +1,3 @@ +package test + +type T []*int8 diff --git a/output_tests/slices/pointers/string/json_test.go b/output_tests/slices/pointers/string/json_test.go new file mode 100644 index 0000000..f678ec9 --- /dev/null +++ b/output_tests/slices/pointers/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/slices/pointers/string/types.go b/output_tests/slices/pointers/string/types.go new file mode 100644 index 0000000..99f4129 --- /dev/null +++ b/output_tests/slices/pointers/string/types.go @@ -0,0 +1,3 @@ +package test + +type T []*string From 8f3de9c412ff23a854b4f3f84cae4903aa813b72 Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Sun, 25 Jun 2017 10:29:48 -0700 Subject: [PATCH 2/2] Adapt tests to use new Config structs the unit test uses compatible mode. The benchmarks measure compat, default, and fastest. This still fails for strings and slices and maps all over the place. --- output_tests/builtins/bool/json_test.go | 107 +++++++++--------- output_tests/builtins/bool_alias/json_test.go | 107 +++++++++--------- output_tests/builtins/byte/json_test.go | 107 +++++++++--------- output_tests/builtins/byte_alias/json_test.go | 107 +++++++++--------- output_tests/builtins/float32/json_test.go | 107 +++++++++--------- .../builtins/float32_alias/json_test.go | 107 +++++++++--------- output_tests/builtins/float64/json_test.go | 107 +++++++++--------- .../builtins/float64_alias/json_test.go | 107 +++++++++--------- output_tests/builtins/int16/json_test.go | 107 +++++++++--------- .../builtins/int16_alias/json_test.go | 107 +++++++++--------- output_tests/builtins/int32/json_test.go | 107 +++++++++--------- .../builtins/int32_alias/json_test.go | 107 +++++++++--------- output_tests/builtins/int8/json_test.go | 107 +++++++++--------- output_tests/builtins/int8_alias/json_test.go | 107 +++++++++--------- output_tests/builtins/string/json_test.go | 107 +++++++++--------- .../builtins/string_alias/json_test.go | 107 +++++++++--------- output_tests/builtins/uint16/json_test.go | 107 +++++++++--------- .../builtins/uint16_alias/json_test.go | 107 +++++++++--------- output_tests/builtins/uint32/json_test.go | 107 +++++++++--------- .../builtins/uint32_alias/json_test.go | 107 +++++++++--------- output_tests/builtins/uint8/json_test.go | 107 +++++++++--------- .../builtins/uint8_alias/json_test.go | 107 +++++++++--------- .../maps/builtins/int32/bool/json_test.go | 107 +++++++++--------- .../maps/builtins/int32/byte/json_test.go | 107 +++++++++--------- .../maps/builtins/int32/float32/json_test.go | 107 +++++++++--------- .../maps/builtins/int32/float64/json_test.go | 107 +++++++++--------- .../maps/builtins/int32/int32/json_test.go | 107 +++++++++--------- .../maps/builtins/int32/int8/json_test.go | 107 +++++++++--------- .../maps/builtins/int32/string/json_test.go | 107 +++++++++--------- .../builtins/int32/string_alias/json_test.go | 107 +++++++++--------- .../maps/builtins/int32/uint8/json_test.go | 107 +++++++++--------- .../maps/builtins/string/bool/json_test.go | 107 +++++++++--------- .../maps/builtins/string/byte/json_test.go | 107 +++++++++--------- .../maps/builtins/string/float32/json_test.go | 107 +++++++++--------- .../maps/builtins/string/float64/json_test.go | 107 +++++++++--------- .../maps/builtins/string/int32/json_test.go | 107 +++++++++--------- .../maps/builtins/string/int8/json_test.go | 107 +++++++++--------- .../maps/builtins/string/string/json_test.go | 107 +++++++++--------- .../builtins/string/string_alias/json_test.go | 107 +++++++++--------- .../maps/builtins/string/uint8/json_test.go | 107 +++++++++--------- .../builtins/string_alias/bool/json_test.go | 107 +++++++++--------- .../builtins/string_alias/byte/json_test.go | 107 +++++++++--------- .../string_alias/float32/json_test.go | 107 +++++++++--------- .../string_alias/float64/json_test.go | 107 +++++++++--------- .../builtins/string_alias/int32/json_test.go | 107 +++++++++--------- .../builtins/string_alias/int8/json_test.go | 107 +++++++++--------- .../builtins/string_alias/string/json_test.go | 107 +++++++++--------- .../string_alias/string_alias/json_test.go | 107 +++++++++--------- .../builtins/string_alias/uint8/json_test.go | 107 +++++++++--------- .../maps/builtins/uint8/bool/json_test.go | 107 +++++++++--------- .../maps/builtins/uint8/byte/json_test.go | 107 +++++++++--------- .../maps/builtins/uint8/float32/json_test.go | 107 +++++++++--------- .../maps/builtins/uint8/float64/json_test.go | 107 +++++++++--------- .../maps/builtins/uint8/int32/json_test.go | 107 +++++++++--------- .../maps/builtins/uint8/int8/json_test.go | 107 +++++++++--------- .../maps/builtins/uint8/string/json_test.go | 107 +++++++++--------- .../builtins/uint8/string_alias/json_test.go | 107 +++++++++--------- .../maps/builtins/uint8/uint8/json_test.go | 107 +++++++++--------- .../maps/pointers/int16/ptr_bool/json_test.go | 107 +++++++++--------- .../pointers/int16/ptr_float64/json_test.go | 107 +++++++++--------- .../pointers/int16/ptr_int32/json_test.go | 107 +++++++++--------- .../pointers/int16/ptr_string/json_test.go | 107 +++++++++--------- .../pointers/int16/ptr_uint8/json_test.go | 107 +++++++++--------- .../pointers/string/ptr_bool/json_test.go | 107 +++++++++--------- .../pointers/string/ptr_float64/json_test.go | 107 +++++++++--------- .../pointers/string/ptr_int32/json_test.go | 107 +++++++++--------- .../pointers/string/ptr_string/json_test.go | 107 +++++++++--------- .../pointers/string/ptr_uint8/json_test.go | 107 +++++++++--------- .../pointers/uint16/ptr_bool/json_test.go | 107 +++++++++--------- .../pointers/uint16/ptr_float64/json_test.go | 107 +++++++++--------- .../pointers/uint16/ptr_int32/json_test.go | 107 +++++++++--------- .../pointers/uint16/ptr_string/json_test.go | 107 +++++++++--------- .../pointers/uint16/ptr_uint8/json_test.go | 107 +++++++++--------- .../slices/builtins/bool/json_test.go | 107 +++++++++--------- .../slices/builtins/byte/json_test.go | 107 +++++++++--------- .../slices/builtins/float32/json_test.go | 107 +++++++++--------- .../slices/builtins/float64/json_test.go | 107 +++++++++--------- .../slices/builtins/int32/json_test.go | 107 +++++++++--------- .../slices/builtins/int8/json_test.go | 107 +++++++++--------- .../slices/builtins/string/json_test.go | 107 +++++++++--------- .../slices/builtins/uint8/json_test.go | 107 +++++++++--------- .../slices/pointers/bool/json_test.go | 107 +++++++++--------- .../slices/pointers/float32/json_test.go | 107 +++++++++--------- .../slices/pointers/float64/json_test.go | 107 +++++++++--------- .../slices/pointers/int32/json_test.go | 107 +++++++++--------- .../slices/pointers/int8/json_test.go | 107 +++++++++--------- .../slices/pointers/string/json_test.go | 107 +++++++++--------- 87 files changed, 4437 insertions(+), 4872 deletions(-) diff --git a/output_tests/builtins/bool/json_test.go b/output_tests/builtins/bool/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/bool/json_test.go +++ b/output_tests/builtins/bool/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/bool_alias/json_test.go b/output_tests/builtins/bool_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/bool_alias/json_test.go +++ b/output_tests/builtins/bool_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/byte/json_test.go b/output_tests/builtins/byte/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/byte/json_test.go +++ b/output_tests/builtins/byte/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/byte_alias/json_test.go b/output_tests/builtins/byte_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/byte_alias/json_test.go +++ b/output_tests/builtins/byte_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/float32/json_test.go b/output_tests/builtins/float32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/float32/json_test.go +++ b/output_tests/builtins/float32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/float32_alias/json_test.go b/output_tests/builtins/float32_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/float32_alias/json_test.go +++ b/output_tests/builtins/float32_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/float64/json_test.go b/output_tests/builtins/float64/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/float64/json_test.go +++ b/output_tests/builtins/float64/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/float64_alias/json_test.go b/output_tests/builtins/float64_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/float64_alias/json_test.go +++ b/output_tests/builtins/float64_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/int16/json_test.go b/output_tests/builtins/int16/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/int16/json_test.go +++ b/output_tests/builtins/int16/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/int16_alias/json_test.go b/output_tests/builtins/int16_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/int16_alias/json_test.go +++ b/output_tests/builtins/int16_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/int32/json_test.go b/output_tests/builtins/int32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/int32/json_test.go +++ b/output_tests/builtins/int32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/int32_alias/json_test.go b/output_tests/builtins/int32_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/int32_alias/json_test.go +++ b/output_tests/builtins/int32_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/int8/json_test.go b/output_tests/builtins/int8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/int8/json_test.go +++ b/output_tests/builtins/int8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/int8_alias/json_test.go b/output_tests/builtins/int8_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/int8_alias/json_test.go +++ b/output_tests/builtins/int8_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/string/json_test.go b/output_tests/builtins/string/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/string/json_test.go +++ b/output_tests/builtins/string/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/string_alias/json_test.go b/output_tests/builtins/string_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/string_alias/json_test.go +++ b/output_tests/builtins/string_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/uint16/json_test.go b/output_tests/builtins/uint16/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/uint16/json_test.go +++ b/output_tests/builtins/uint16/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/uint16_alias/json_test.go b/output_tests/builtins/uint16_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/uint16_alias/json_test.go +++ b/output_tests/builtins/uint16_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/uint32/json_test.go b/output_tests/builtins/uint32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/uint32/json_test.go +++ b/output_tests/builtins/uint32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/uint32_alias/json_test.go b/output_tests/builtins/uint32_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/uint32_alias/json_test.go +++ b/output_tests/builtins/uint32_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/uint8/json_test.go b/output_tests/builtins/uint8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/uint8/json_test.go +++ b/output_tests/builtins/uint8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/builtins/uint8_alias/json_test.go b/output_tests/builtins/uint8_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/builtins/uint8_alias/json_test.go +++ b/output_tests/builtins/uint8_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/int32/bool/json_test.go b/output_tests/maps/builtins/int32/bool/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/int32/bool/json_test.go +++ b/output_tests/maps/builtins/int32/bool/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/int32/byte/json_test.go b/output_tests/maps/builtins/int32/byte/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/int32/byte/json_test.go +++ b/output_tests/maps/builtins/int32/byte/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/int32/float32/json_test.go b/output_tests/maps/builtins/int32/float32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/int32/float32/json_test.go +++ b/output_tests/maps/builtins/int32/float32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/int32/float64/json_test.go b/output_tests/maps/builtins/int32/float64/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/int32/float64/json_test.go +++ b/output_tests/maps/builtins/int32/float64/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/int32/int32/json_test.go b/output_tests/maps/builtins/int32/int32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/int32/int32/json_test.go +++ b/output_tests/maps/builtins/int32/int32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/int32/int8/json_test.go b/output_tests/maps/builtins/int32/int8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/int32/int8/json_test.go +++ b/output_tests/maps/builtins/int32/int8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/int32/string/json_test.go b/output_tests/maps/builtins/int32/string/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/int32/string/json_test.go +++ b/output_tests/maps/builtins/int32/string/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/int32/string_alias/json_test.go b/output_tests/maps/builtins/int32/string_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/int32/string_alias/json_test.go +++ b/output_tests/maps/builtins/int32/string_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/int32/uint8/json_test.go b/output_tests/maps/builtins/int32/uint8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/int32/uint8/json_test.go +++ b/output_tests/maps/builtins/int32/uint8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string/bool/json_test.go b/output_tests/maps/builtins/string/bool/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string/bool/json_test.go +++ b/output_tests/maps/builtins/string/bool/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string/byte/json_test.go b/output_tests/maps/builtins/string/byte/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string/byte/json_test.go +++ b/output_tests/maps/builtins/string/byte/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string/float32/json_test.go b/output_tests/maps/builtins/string/float32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string/float32/json_test.go +++ b/output_tests/maps/builtins/string/float32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string/float64/json_test.go b/output_tests/maps/builtins/string/float64/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string/float64/json_test.go +++ b/output_tests/maps/builtins/string/float64/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string/int32/json_test.go b/output_tests/maps/builtins/string/int32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string/int32/json_test.go +++ b/output_tests/maps/builtins/string/int32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string/int8/json_test.go b/output_tests/maps/builtins/string/int8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string/int8/json_test.go +++ b/output_tests/maps/builtins/string/int8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string/string/json_test.go b/output_tests/maps/builtins/string/string/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string/string/json_test.go +++ b/output_tests/maps/builtins/string/string/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string/string_alias/json_test.go b/output_tests/maps/builtins/string/string_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string/string_alias/json_test.go +++ b/output_tests/maps/builtins/string/string_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string/uint8/json_test.go b/output_tests/maps/builtins/string/uint8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string/uint8/json_test.go +++ b/output_tests/maps/builtins/string/uint8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string_alias/bool/json_test.go b/output_tests/maps/builtins/string_alias/bool/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string_alias/bool/json_test.go +++ b/output_tests/maps/builtins/string_alias/bool/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string_alias/byte/json_test.go b/output_tests/maps/builtins/string_alias/byte/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string_alias/byte/json_test.go +++ b/output_tests/maps/builtins/string_alias/byte/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string_alias/float32/json_test.go b/output_tests/maps/builtins/string_alias/float32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string_alias/float32/json_test.go +++ b/output_tests/maps/builtins/string_alias/float32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string_alias/float64/json_test.go b/output_tests/maps/builtins/string_alias/float64/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string_alias/float64/json_test.go +++ b/output_tests/maps/builtins/string_alias/float64/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string_alias/int32/json_test.go b/output_tests/maps/builtins/string_alias/int32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string_alias/int32/json_test.go +++ b/output_tests/maps/builtins/string_alias/int32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string_alias/int8/json_test.go b/output_tests/maps/builtins/string_alias/int8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string_alias/int8/json_test.go +++ b/output_tests/maps/builtins/string_alias/int8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string_alias/string/json_test.go b/output_tests/maps/builtins/string_alias/string/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string_alias/string/json_test.go +++ b/output_tests/maps/builtins/string_alias/string/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string_alias/string_alias/json_test.go b/output_tests/maps/builtins/string_alias/string_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string_alias/string_alias/json_test.go +++ b/output_tests/maps/builtins/string_alias/string_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/string_alias/uint8/json_test.go b/output_tests/maps/builtins/string_alias/uint8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/string_alias/uint8/json_test.go +++ b/output_tests/maps/builtins/string_alias/uint8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/uint8/bool/json_test.go b/output_tests/maps/builtins/uint8/bool/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/uint8/bool/json_test.go +++ b/output_tests/maps/builtins/uint8/bool/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/uint8/byte/json_test.go b/output_tests/maps/builtins/uint8/byte/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/uint8/byte/json_test.go +++ b/output_tests/maps/builtins/uint8/byte/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/uint8/float32/json_test.go b/output_tests/maps/builtins/uint8/float32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/uint8/float32/json_test.go +++ b/output_tests/maps/builtins/uint8/float32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/uint8/float64/json_test.go b/output_tests/maps/builtins/uint8/float64/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/uint8/float64/json_test.go +++ b/output_tests/maps/builtins/uint8/float64/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/uint8/int32/json_test.go b/output_tests/maps/builtins/uint8/int32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/uint8/int32/json_test.go +++ b/output_tests/maps/builtins/uint8/int32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/uint8/int8/json_test.go b/output_tests/maps/builtins/uint8/int8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/uint8/int8/json_test.go +++ b/output_tests/maps/builtins/uint8/int8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/uint8/string/json_test.go b/output_tests/maps/builtins/uint8/string/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/uint8/string/json_test.go +++ b/output_tests/maps/builtins/uint8/string/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/uint8/string_alias/json_test.go b/output_tests/maps/builtins/uint8/string_alias/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/uint8/string_alias/json_test.go +++ b/output_tests/maps/builtins/uint8/string_alias/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/builtins/uint8/uint8/json_test.go b/output_tests/maps/builtins/uint8/uint8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/builtins/uint8/uint8/json_test.go +++ b/output_tests/maps/builtins/uint8/uint8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/int16/ptr_bool/json_test.go b/output_tests/maps/pointers/int16/ptr_bool/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/int16/ptr_bool/json_test.go +++ b/output_tests/maps/pointers/int16/ptr_bool/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/int16/ptr_float64/json_test.go b/output_tests/maps/pointers/int16/ptr_float64/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/int16/ptr_float64/json_test.go +++ b/output_tests/maps/pointers/int16/ptr_float64/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/int16/ptr_int32/json_test.go b/output_tests/maps/pointers/int16/ptr_int32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/int16/ptr_int32/json_test.go +++ b/output_tests/maps/pointers/int16/ptr_int32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/int16/ptr_string/json_test.go b/output_tests/maps/pointers/int16/ptr_string/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/int16/ptr_string/json_test.go +++ b/output_tests/maps/pointers/int16/ptr_string/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/int16/ptr_uint8/json_test.go b/output_tests/maps/pointers/int16/ptr_uint8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/int16/ptr_uint8/json_test.go +++ b/output_tests/maps/pointers/int16/ptr_uint8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/string/ptr_bool/json_test.go b/output_tests/maps/pointers/string/ptr_bool/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/string/ptr_bool/json_test.go +++ b/output_tests/maps/pointers/string/ptr_bool/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/string/ptr_float64/json_test.go b/output_tests/maps/pointers/string/ptr_float64/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/string/ptr_float64/json_test.go +++ b/output_tests/maps/pointers/string/ptr_float64/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/string/ptr_int32/json_test.go b/output_tests/maps/pointers/string/ptr_int32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/string/ptr_int32/json_test.go +++ b/output_tests/maps/pointers/string/ptr_int32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/string/ptr_string/json_test.go b/output_tests/maps/pointers/string/ptr_string/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/string/ptr_string/json_test.go +++ b/output_tests/maps/pointers/string/ptr_string/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/string/ptr_uint8/json_test.go b/output_tests/maps/pointers/string/ptr_uint8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/string/ptr_uint8/json_test.go +++ b/output_tests/maps/pointers/string/ptr_uint8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/uint16/ptr_bool/json_test.go b/output_tests/maps/pointers/uint16/ptr_bool/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/uint16/ptr_bool/json_test.go +++ b/output_tests/maps/pointers/uint16/ptr_bool/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/uint16/ptr_float64/json_test.go b/output_tests/maps/pointers/uint16/ptr_float64/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/uint16/ptr_float64/json_test.go +++ b/output_tests/maps/pointers/uint16/ptr_float64/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/uint16/ptr_int32/json_test.go b/output_tests/maps/pointers/uint16/ptr_int32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/uint16/ptr_int32/json_test.go +++ b/output_tests/maps/pointers/uint16/ptr_int32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/uint16/ptr_string/json_test.go b/output_tests/maps/pointers/uint16/ptr_string/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/uint16/ptr_string/json_test.go +++ b/output_tests/maps/pointers/uint16/ptr_string/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/maps/pointers/uint16/ptr_uint8/json_test.go b/output_tests/maps/pointers/uint16/ptr_uint8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/maps/pointers/uint16/ptr_uint8/json_test.go +++ b/output_tests/maps/pointers/uint16/ptr_uint8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/builtins/bool/json_test.go b/output_tests/slices/builtins/bool/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/builtins/bool/json_test.go +++ b/output_tests/slices/builtins/bool/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/builtins/byte/json_test.go b/output_tests/slices/builtins/byte/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/builtins/byte/json_test.go +++ b/output_tests/slices/builtins/byte/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/builtins/float32/json_test.go b/output_tests/slices/builtins/float32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/builtins/float32/json_test.go +++ b/output_tests/slices/builtins/float32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/builtins/float64/json_test.go b/output_tests/slices/builtins/float64/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/builtins/float64/json_test.go +++ b/output_tests/slices/builtins/float64/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/builtins/int32/json_test.go b/output_tests/slices/builtins/int32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/builtins/int32/json_test.go +++ b/output_tests/slices/builtins/int32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/builtins/int8/json_test.go b/output_tests/slices/builtins/int8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/builtins/int8/json_test.go +++ b/output_tests/slices/builtins/int8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/builtins/string/json_test.go b/output_tests/slices/builtins/string/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/builtins/string/json_test.go +++ b/output_tests/slices/builtins/string/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/builtins/uint8/json_test.go b/output_tests/slices/builtins/uint8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/builtins/uint8/json_test.go +++ b/output_tests/slices/builtins/uint8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/pointers/bool/json_test.go b/output_tests/slices/pointers/bool/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/pointers/bool/json_test.go +++ b/output_tests/slices/pointers/bool/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/pointers/float32/json_test.go b/output_tests/slices/pointers/float32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/pointers/float32/json_test.go +++ b/output_tests/slices/pointers/float32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/pointers/float64/json_test.go b/output_tests/slices/pointers/float64/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/pointers/float64/json_test.go +++ b/output_tests/slices/pointers/float64/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/pointers/int32/json_test.go b/output_tests/slices/pointers/int32/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/pointers/int32/json_test.go +++ b/output_tests/slices/pointers/int32/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/pointers/int8/json_test.go b/output_tests/slices/pointers/int8/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/pointers/int8/json_test.go +++ b/output_tests/slices/pointers/int8/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) } diff --git a/output_tests/slices/pointers/string/json_test.go b/output_tests/slices/pointers/string/json_test.go index f678ec9..a7b1d0d 100644 --- a/output_tests/slices/pointers/string/json_test.go +++ b/output_tests/slices/pointers/string/json_test.go @@ -20,7 +20,7 @@ func Test_Roundtrip(t *testing.T) { if err != nil { t.Errorf("failed to marshal with stdlib: %v", err) } - jbIter, err := jsoniter.Marshal(before) + jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { t.Errorf("failed to marshal with jsoniter: %v", err) } @@ -35,7 +35,7 @@ func Test_Roundtrip(t *testing.T) { t.Errorf("failed to unmarshal with stdlib: %v", err) } var afterIter T - err = jsoniter.Unmarshal(jbIter, &afterIter) + err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { t.Errorf("failed to unmarshal with jsoniter: %v", err) } @@ -69,7 +69,7 @@ func indent(src []byte, prefix string) string { return buf.String() } -func BenchmarkStandardMarshal(t *testing.B) { +func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, error)) { t.ReportAllocs() t.ResetTimer() @@ -77,68 +77,63 @@ func BenchmarkStandardMarshal(t *testing.B) { fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz.Fuzz(&obj) for i := 0; i < t.N; i++ { - jb, err := json.Marshal(obj) + jb, err := fn(obj) if err != nil { - t.Fatalf("failed to marshal:\n input: %s\n error: %v", dump(obj), err) + t.Fatalf("%s failed to marshal:\n input: %s\n error: %v", name, dump(obj), err) } _ = jb } } +func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interface{}) error) { + t.ReportAllocs() + t.ResetTimer() + + var before T + fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) + fz.Fuzz(&before) + jb, err := json.Marshal(before) + if err != nil { + t.Fatalf("failed to marshal: %v", err) + } + + for i := 0; i < t.N; i++ { + var after T + err = fn(jb, &after) + if err != nil { + t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) + } + } +} + +func BenchmarkStandardMarshal(t *testing.B) { + benchmarkMarshal(t, "stdlib", json.Marshal) +} + func BenchmarkStandardUnmarshal(t *testing.B) { - t.ReportAllocs() - t.ResetTimer() - - var before T - fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) - fz.Fuzz(&before) - jb, err := 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) - } - } + benchmarkUnmarshal(t, "stdlib", json.Unmarshal) } -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 BenchmarkJSONIterMarshalFastest(t *testing.B) { + benchmarkMarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Marshal) } -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) - } - } +func BenchmarkJSONIterUnmarshalFastest(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-fastest", jsoniter.ConfigFastest.Unmarshal) +} + +func BenchmarkJSONIterMarshalDefault(t *testing.B) { + benchmarkMarshal(t, "jsoniter-default", jsoniter.Marshal) +} + +func BenchmarkJSONIterUnmarshalDefault(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-default", jsoniter.Unmarshal) +} + +func BenchmarkJSONIterMarshalCompatible(t *testing.B) { + benchmarkMarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Marshal) +} + +func BenchmarkJSONIterUnmarshalCompatible(t *testing.B) { + benchmarkUnmarshal(t, "jsoniter-compat", jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal) }