Revert "WIP: Tests to compare against stdlib"

output_tests/builtins/bool/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/bool/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T bool

output_tests/builtins/bool_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/bool_alias/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T bool

output_tests/builtins/byte/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/byte/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T byte

output_tests/builtins/byte_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/byte_alias/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T byte

output_tests/builtins/float32/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/float32/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T float32

output_tests/builtins/float32_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/float32_alias/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T float32

output_tests/builtins/float64/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/float64/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T float64

output_tests/builtins/float64_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/float64_alias/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T float64

output_tests/builtins/int16/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/int16/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T int16

output_tests/builtins/int16_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/int16_alias/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T int16

output_tests/builtins/int32/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/int32/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T int32

output_tests/builtins/int32_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/int32_alias/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T int32

output_tests/builtins/int8/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/int8/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T int8

output_tests/builtins/int8_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/int8_alias/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T int8

output_tests/builtins/string/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/string/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T string

output_tests/builtins/string_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/string_alias/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T string

output_tests/builtins/uint16/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/uint16/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T uint16

output_tests/builtins/uint16_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/uint16_alias/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T uint16

output_tests/builtins/uint32/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/uint32/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T uint32

output_tests/builtins/uint32_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/uint32_alias/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T uint32

output_tests/builtins/uint8/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/uint8/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T uint8

output_tests/builtins/uint8_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/builtins/uint8_alias/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T uint8

output_tests/maps/builtins/int32/bool/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/int32/bool/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[int32]bool

output_tests/maps/builtins/int32/byte/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/int32/byte/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[int32]byte

output_tests/maps/builtins/int32/float32/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/int32/float32/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[int32]float32

output_tests/maps/builtins/int32/float64/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/int32/float64/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[int32]float64

output_tests/maps/builtins/int32/int32/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/int32/int32/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[int32]int32

output_tests/maps/builtins/int32/int8/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/int32/int8/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[int32]int8

output_tests/maps/builtins/int32/string/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/int32/string/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[int32]string

output_tests/maps/builtins/int32/string_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/int32/string_alias/types.go

@@ -1,5 +0,0 @@
-package test
-
-type StringAlias string
-
-type T map[int32]StringAlias

output_tests/maps/builtins/int32/uint8/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/int32/uint8/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[int32]uint8

output_tests/maps/builtins/string/bool/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string/bool/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[string]bool

output_tests/maps/builtins/string/byte/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string/byte/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[string]byte

output_tests/maps/builtins/string/float32/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string/float32/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[string]float32

output_tests/maps/builtins/string/float64/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string/float64/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[string]float64

output_tests/maps/builtins/string/int32/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string/int32/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[string]int32

output_tests/maps/builtins/string/int8/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string/int8/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[string]int8

output_tests/maps/builtins/string/string/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string/string/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[string]string

output_tests/maps/builtins/string/string_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string/string_alias/types.go

@@ -1,5 +0,0 @@
-package test
-
-type StringAlias string
-
-type T map[string]StringAlias

output_tests/maps/builtins/string/uint8/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string/uint8/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[string]uint8

output_tests/maps/builtins/string_alias/bool/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string_alias/bool/types.go

@@ -1,5 +0,0 @@
-package test
-
-type StringAlias string
-
-type T map[StringAlias]bool

output_tests/maps/builtins/string_alias/byte/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string_alias/byte/types.go

@@ -1,5 +0,0 @@
-package test
-
-type StringAlias string
-
-type T map[StringAlias]byte

output_tests/maps/builtins/string_alias/float32/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string_alias/float32/types.go

@@ -1,5 +0,0 @@
-package test
-
-type StringAlias string
-
-type T map[StringAlias]float32

output_tests/maps/builtins/string_alias/float64/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string_alias/float64/types.go

@@ -1,5 +0,0 @@
-package test
-
-type StringAlias string
-
-type T map[StringAlias]float64

output_tests/maps/builtins/string_alias/int32/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string_alias/int32/types.go

@@ -1,5 +0,0 @@
-package test
-
-type StringAlias string
-
-type T map[StringAlias]int32

output_tests/maps/builtins/string_alias/int8/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string_alias/int8/types.go

@@ -1,5 +0,0 @@
-package test
-
-type StringAlias string
-
-type T map[StringAlias]int8

output_tests/maps/builtins/string_alias/string/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string_alias/string/types.go

@@ -1,5 +0,0 @@
-package test
-
-type StringAlias string
-
-type T map[StringAlias]string

output_tests/maps/builtins/string_alias/string_alias/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string_alias/string_alias/types.go

@@ -1,5 +0,0 @@
-package test
-
-type StringAlias string
-
-type T map[StringAlias]StringAlias

output_tests/maps/builtins/string_alias/uint8/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/string_alias/uint8/types.go

@@ -1,5 +0,0 @@
-package test
-
-type StringAlias string
-
-type T map[StringAlias]uint8

output_tests/maps/builtins/uint8/bool/json_test.go

@@ -1,144 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	fuzz "github.com/google/gofuzz"
-	jsoniter "github.com/json-iterator/go"
-)
-
-func Test_Roundtrip(t *testing.T) {
-	fz := fuzz.New().MaxDepth(10).NilChance(0.3)
-	for i := 0; i < 1000; i++ {
-		var before T
-		fz.Fuzz(&before)
-
-		jbStd, err := json.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with stdlib: %v", err)
-		}
-		jbIter, err := jsoniter.Marshal(before)
-		if err != nil {
-			t.Errorf("failed to marshal with jsoniter: %v", err)
-		}
-		if string(jbStd) != string(jbIter) {
-			t.Errorf("marshal expected:\n    %s\ngot:\n    %s\nobj:\n    %s",
-				indent(jbStd, "    "), indent(jbIter, "    "), dump(before))
-		}
-
-		var 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)
-		}
-	}
-}

output_tests/maps/builtins/uint8/bool/types.go

@@ -1,3 +0,0 @@
-package test
-
-type T map[uint8]bool