go/json-iterator
1
0
Fork 0
mirror of https://github.com/json-iterator/go.git synced 2025-03-23 21:09:11 +02:00
Code Issues Releases Activity

fix golint: do not export test types

Browse Source
This commit is contained in:
Tao Wen 2017-07-09 11:33:03 +08:00
parent 9ecb1fd36d
commit ad20f12c34
47 changed files with 163 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
feature_reflect_map.go
View File

@ -136,7 +136,7 @@ func encodeMapKey(key reflect.Value, stream *Stream) {
stream.writeByte('"') stream.writeByte('"')
return return
} }
stream.Error = &json.UnsupportedTypeError{Type:key.Type()} stream.Error = &json.UnsupportedTypeError{Type: key.Type()}
} }
func (encoder *mapEncoder) EncodeInterface(val interface{}, stream *Stream) { func (encoder *mapEncoder) EncodeInterface(val interface{}, stream *Stream) {
@ -216,7 +216,7 @@ func (w *reflectWithString) resolve() error {
w.s = strconv.FormatUint(w.v.Uint(), 10) w.s = strconv.FormatUint(w.v.Uint(), 10)
return nil return nil
} }
return &json.UnsupportedTypeError{Type:w.v.Type()} return &json.UnsupportedTypeError{Type: w.v.Type()}
} }
func (sv stringValues) Len() int { return len(sv) } func (sv stringValues) Len() int { return len(sv) }

12
output_tests/builtins/bool/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/bool/types.go
View File

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

12
output_tests/builtins/bool_alias/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/bool_alias/types.go
View File

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

12
output_tests/builtins/byte/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/byte/types.go
View File

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

12
output_tests/builtins/byte_alias/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/byte_alias/types.go
View File

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

12
output_tests/builtins/float32/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/float32/types.go
View File

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

12
output_tests/builtins/float32_alias/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/float32_alias/types.go
View File

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

12
output_tests/builtins/float64/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/float64/types.go
View File

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

12
output_tests/builtins/float64_alias/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/float64_alias/types.go
View File

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

12
output_tests/builtins/int16/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/int16/types.go
View File

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

12
output_tests/builtins/int16_alias/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/int16_alias/types.go
View File

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

12
output_tests/builtins/int32/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/int32/types.go
View File

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

12
output_tests/builtins/int32_alias/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/int32_alias/types.go
View File

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

12
output_tests/builtins/int8/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/int8/types.go
View File

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

12
output_tests/builtins/int8_alias/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

3
output_tests/builtins/int8_alias/types.go
View File

@ -1,4 +1,3 @@
package test package test
// Only used in test type typeForTest int8
type T int8

12
output_tests/builtins/string/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/string/types.go
View File

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

12
output_tests/builtins/string_alias/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/string_alias/types.go
View File

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

12
output_tests/builtins/uint16/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/uint16/types.go
View File

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

12
output_tests/builtins/uint16_alias/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/uint16_alias/types.go
View File

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

12
output_tests/builtins/uint32/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/uint32/types.go
View File

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

12
output_tests/builtins/uint32_alias/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/uint32_alias/types.go
View File

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

12
output_tests/builtins/uint8/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/uint8/types.go
View File

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

12
output_tests/builtins/uint8_alias/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/uint8_alias/types.go
View File

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

12
output_tests/builtins/uintptr/json_test.go
View File

@ -15,7 +15,7 @@ import (
func Test_Roundtrip(t *testing.T) { func Test_Roundtrip(t *testing.T) {
fz := fuzz.New().MaxDepth(10).NilChance(0.3) fz := fuzz.New().MaxDepth(10).NilChance(0.3)
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
var before T var before typeForTest
fz.Fuzz(&before) fz.Fuzz(&before)
jbStd, err := json.Marshal(before) jbStd, err := json.Marshal(before)
@ -37,13 +37,13 @@ func Test_Roundtrip(t *testing.T) {
indent(jbStd, " "), indent(jbIter, " "), dump(before)) indent(jbStd, " "), indent(jbIter, " "), dump(before))
} }
var afterStd T var afterStd typeForTest
err = json.Unmarshal(jbIter, &afterStd) err = json.Unmarshal(jbIter, &afterStd)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n %s",
err, indent(jbIter, " ")) err, indent(jbIter, " "))
} }
var afterIter T var afterIter typeForTest
err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
if err != nil { if err != nil {
t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s", t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n %s",
@ -86,7 +86,7 @@ func benchmarkMarshal(t *testing.B, name string, fn func(interface{}) ([]byte, e
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var obj T var obj typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&obj) fz.Fuzz(&obj)
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
@ -102,7 +102,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
t.ReportAllocs() t.ReportAllocs()
t.ResetTimer() t.ResetTimer()
var before T var before typeForTest
fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3) fz := fuzz.NewWithSeed(0).MaxDepth(10).NilChance(0.3)
fz.Fuzz(&before) fz.Fuzz(&before)
jb, err := json.Marshal(before) jb, err := json.Marshal(before)
@ -111,7 +111,7 @@ func benchmarkUnmarshal(t *testing.B, name string, fn func(data []byte, v interf
} }
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
var after T var after typeForTest
err = fn(jb, &after) err = fn(jb, &after)
if err != nil { if err != nil {
t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err) t.Fatalf("%s failed to unmarshal:\n input: %q\n error: %v", name, string(jb), err)

2
output_tests/builtins/uintptr/types.go
View File

@ -1,3 +1,3 @@
package test package test
type T uintptr type typeForTest uintptr