From c2c9981062fd9fea7395262b862e3a3826500f8f Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Tue, 27 Jun 2017 20:42:22 +0100 Subject: [PATCH] catch errors in output_tests --- output_tests/builtins/bool/json_test.go | 25 +++++++++++++------ output_tests/builtins/bool_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/byte/json_test.go | 25 +++++++++++++------ output_tests/builtins/byte_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/float32/json_test.go | 25 +++++++++++++------ .../builtins/float32_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/float64/json_test.go | 25 +++++++++++++------ .../builtins/float64_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/int16/json_test.go | 25 +++++++++++++------ .../builtins/int16_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/int32/json_test.go | 25 +++++++++++++------ .../builtins/int32_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/int8/json_test.go | 25 +++++++++++++------ output_tests/builtins/int8_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/string/json_test.go | 25 +++++++++++++------ .../builtins/string_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/uint16/json_test.go | 25 +++++++++++++------ .../builtins/uint16_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/uint32/json_test.go | 25 +++++++++++++------ .../builtins/uint32_alias/json_test.go | 25 +++++++++++++------ output_tests/builtins/uint8/json_test.go | 25 +++++++++++++------ .../builtins/uint8_alias/json_test.go | 25 +++++++++++++------ output_tests/map/int16/string/json_test.go | 25 +++++++++++++------ output_tests/map/int32/string/json_test.go | 25 +++++++++++++------ output_tests/map/int8/string/json_test.go | 25 +++++++++++++------ output_tests/map/string/bool/json_test.go | 25 +++++++++++++------ output_tests/map/string/byte/json_test.go | 25 +++++++++++++------ output_tests/map/string/float64/json_test.go | 25 +++++++++++++------ output_tests/map/string/int32/json_test.go | 25 +++++++++++++------ .../map/string/map_string_string/json_test.go | 25 +++++++++++++------ output_tests/map/string/ptr_bool/json_test.go | 25 +++++++++++++------ .../map/string/ptr_float64/json_test.go | 25 +++++++++++++------ .../map/string/ptr_int32/json_test.go | 25 +++++++++++++------ .../string/ptr_map_string_string/json_test.go | 25 +++++++++++++------ .../map/string/ptr_slice_string/json_test.go | 25 +++++++++++++------ .../map/string/ptr_string/json_test.go | 25 +++++++++++++------ .../string/ptr_struct_various/json_test.go | 25 +++++++++++++------ .../map/string/ptr_uint8/json_test.go | 25 +++++++++++++------ .../map/string/slice_string/json_test.go | 25 +++++++++++++------ output_tests/map/string/string/json_test.go | 25 +++++++++++++------ .../map/string/string_alias/json_test.go | 25 +++++++++++++------ .../map/string/struct_empty/json_test.go | 25 +++++++++++++------ .../string/struct_empty_alias/json_test.go | 25 +++++++++++++------ .../map/string/struct_ptr_string/json_test.go | 25 +++++++++++++------ .../map/string/struct_various/json_test.go | 25 +++++++++++++------ output_tests/map/string/uint8/json_test.go | 25 +++++++++++++------ .../map/string_alias/string/json_test.go | 25 +++++++++++++------ .../string_alias/string_alias/json_test.go | 25 +++++++++++++------ output_tests/map/uint16/string/json_test.go | 25 +++++++++++++------ output_tests/map/uint32/string/json_test.go | 25 +++++++++++++------ output_tests/map/uint8/string/json_test.go | 25 +++++++++++++------ output_tests/slice/bool/json_test.go | 25 +++++++++++++------ output_tests/slice/byte/json_test.go | 25 +++++++++++++------ output_tests/slice/float64/json_test.go | 25 +++++++++++++------ output_tests/slice/int32/json_test.go | 25 +++++++++++++------ .../slice/map/int32_string/json_test.go | 25 +++++++++++++------ .../slice/map/string_string/json_test.go | 25 +++++++++++++------ output_tests/slice/ptr_bool/json_test.go | 25 +++++++++++++------ output_tests/slice/ptr_float64/json_test.go | 25 +++++++++++++------ output_tests/slice/ptr_int32/json_test.go | 25 +++++++++++++------ .../slice/ptr_map/int32_string/json_test.go | 25 +++++++++++++------ .../slice/ptr_map/string_string/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/bool/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/byte/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/float64/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/int32/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/ptr_string/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/string/json_test.go | 25 +++++++++++++------ .../slice/ptr_slice/uint8/json_test.go | 25 +++++++++++++------ output_tests/slice/ptr_string/json_test.go | 25 +++++++++++++------ .../slice/ptr_struct_various/json_test.go | 25 +++++++++++++------ output_tests/slice/ptr_uint8/json_test.go | 25 +++++++++++++------ output_tests/slice/slice/bool/json_test.go | 25 +++++++++++++------ output_tests/slice/slice/byte/json_test.go | 25 +++++++++++++------ output_tests/slice/slice/float64/json_test.go | 25 +++++++++++++------ output_tests/slice/slice/int32/json_test.go | 25 +++++++++++++------ .../slice/slice/ptr_string/json_test.go | 25 +++++++++++++------ output_tests/slice/slice/string/json_test.go | 25 +++++++++++++------ output_tests/slice/slice/uint8/json_test.go | 25 +++++++++++++------ output_tests/slice/string/json_test.go | 25 +++++++++++++------ output_tests/slice/struct_empty/json_test.go | 25 +++++++++++++------ .../slice/struct_empty_alias/json_test.go | 25 +++++++++++++------ .../slice/struct_ptr_string/json_test.go | 25 +++++++++++++------ .../slice/struct_various/json_test.go | 25 +++++++++++++------ output_tests/slice/uint8/json_test.go | 25 +++++++++++++------ output_tests/struct/alias/json_test.go | 25 +++++++++++++------ output_tests/struct/empty/json_test.go | 25 +++++++++++++------ output_tests/struct/empty_alias/json_test.go | 25 +++++++++++++------ output_tests/struct/everything/json_test.go | 25 +++++++++++++------ output_tests/struct/float64/json_test.go | 25 +++++++++++++------ .../struct/float64_alias/json_test.go | 25 +++++++++++++------ output_tests/struct/float64s/json_test.go | 25 +++++++++++++------ .../struct/float64s_alias/json_test.go | 25 +++++++++++++------ output_tests/struct/int32/json_test.go | 25 +++++++++++++------ output_tests/struct/int32_alias/json_test.go | 25 +++++++++++++------ output_tests/struct/int32s/json_test.go | 25 +++++++++++++------ output_tests/struct/int32s_alias/json_test.go | 25 +++++++++++++------ .../struct/map/int32_ptr_string/json_test.go | 25 +++++++++++++------ .../struct/map/int32_string/json_test.go | 25 +++++++++++++------ .../map/int32_struct_strings/json_test.go | 25 +++++++++++++------ .../struct/map/string_ptr_string/json_test.go | 25 +++++++++++++------ .../struct/map/string_string/json_test.go | 25 +++++++++++++------ .../map/string_struct_strings/json_test.go | 25 +++++++++++++------ output_tests/struct/ptr_float64/json_test.go | 25 +++++++++++++------ .../struct/ptr_float64_alias/json_test.go | 25 +++++++++++++------ output_tests/struct/ptr_int32/json_test.go | 25 +++++++++++++------ .../struct/ptr_int32_alias/json_test.go | 25 +++++++++++++------ .../struct/ptr_ptr_struct_empty/json_test.go | 25 +++++++++++++------ .../ptr_ptr_struct_strings/json_test.go | 25 +++++++++++++------ output_tests/struct/ptr_string/json_test.go | 25 +++++++++++++------ .../struct/ptr_string_alias/json_test.go | 25 +++++++++++++------ .../struct/ptr_struct_empty/json_test.go | 25 +++++++++++++------ .../struct/ptr_struct_strings/json_test.go | 25 +++++++++++++------ output_tests/struct/ptrs_float64/json_test.go | 25 +++++++++++++------ output_tests/struct/ptrs_int32/json_test.go | 25 +++++++++++++------ output_tests/struct/ptrs_string/json_test.go | 25 +++++++++++++------ .../struct/slice/ptr_string/json_test.go | 25 +++++++++++++------ output_tests/struct/slice/string/json_test.go | 25 +++++++++++++------ .../struct/slice/string_alias/json_test.go | 25 +++++++++++++------ .../struct/slice/strings/json_test.go | 25 +++++++++++++------ .../struct/slice/struct_strings/json_test.go | 25 +++++++++++++------ output_tests/struct/string/json_test.go | 25 +++++++++++++------ output_tests/struct/string_alias/json_test.go | 25 +++++++++++++------ output_tests/struct/strings/json_test.go | 25 +++++++++++++------ .../struct/strings_alias/json_test.go | 25 +++++++++++++------ .../struct/struct/empties/json_test.go | 25 +++++++++++++------ output_tests/struct/struct/empty/json_test.go | 25 +++++++++++++------ .../struct/struct/empty_alias/json_test.go | 25 +++++++++++++------ .../struct/struct/float32s/json_test.go | 25 +++++++++++++------ .../struct/struct/float64/json_test.go | 25 +++++++++++++------ .../struct/struct/float64_alias/json_test.go | 25 +++++++++++++------ .../struct/struct/int32s/json_test.go | 25 +++++++++++++------ .../struct/struct/strings/json_test.go | 25 +++++++++++++------ .../struct/struct/strings_alias/json_test.go | 25 +++++++++++++------ .../struct_tags/fieldname/json_test.go | 25 +++++++++++++------ .../struct_tags/omitempty/bool/json_test.go | 25 +++++++++++++------ .../omitempty/float32/json_test.go | 25 +++++++++++++------ .../struct_tags/omitempty/int32/json_test.go | 25 +++++++++++++------ .../omitempty/map_string_string/json_test.go | 25 +++++++++++++------ .../omitempty/ptr_string/json_test.go | 25 +++++++++++++------ .../omitempty/slice_string/json_test.go | 25 +++++++++++++------ .../struct_tags/omitempty/string/json_test.go | 25 +++++++++++++------ .../struct_tags/omitempty/uint32/json_test.go | 25 +++++++++++++------ 143 files changed, 2574 insertions(+), 1001 deletions(-) diff --git a/output_tests/builtins/bool/json_test.go b/output_tests/builtins/bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/bool/json_test.go +++ b/output_tests/builtins/bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/bool_alias/json_test.go b/output_tests/builtins/bool_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/bool_alias/json_test.go +++ b/output_tests/builtins/bool_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/byte/json_test.go b/output_tests/builtins/byte/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/byte/json_test.go +++ b/output_tests/builtins/byte/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/byte_alias/json_test.go b/output_tests/builtins/byte_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/byte_alias/json_test.go +++ b/output_tests/builtins/byte_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/float32/json_test.go b/output_tests/builtins/float32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/float32/json_test.go +++ b/output_tests/builtins/float32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/float32_alias/json_test.go b/output_tests/builtins/float32_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/float32_alias/json_test.go +++ b/output_tests/builtins/float32_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/float64/json_test.go b/output_tests/builtins/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/float64/json_test.go +++ b/output_tests/builtins/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/float64_alias/json_test.go b/output_tests/builtins/float64_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/float64_alias/json_test.go +++ b/output_tests/builtins/float64_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/int16/json_test.go b/output_tests/builtins/int16/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/int16/json_test.go +++ b/output_tests/builtins/int16/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/int16_alias/json_test.go b/output_tests/builtins/int16_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/int16_alias/json_test.go +++ b/output_tests/builtins/int16_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/int32/json_test.go b/output_tests/builtins/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/int32/json_test.go +++ b/output_tests/builtins/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/int32_alias/json_test.go b/output_tests/builtins/int32_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/int32_alias/json_test.go +++ b/output_tests/builtins/int32_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/int8/json_test.go b/output_tests/builtins/int8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/int8/json_test.go +++ b/output_tests/builtins/int8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/int8_alias/json_test.go b/output_tests/builtins/int8_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/int8_alias/json_test.go +++ b/output_tests/builtins/int8_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/string/json_test.go b/output_tests/builtins/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/string/json_test.go +++ b/output_tests/builtins/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/string_alias/json_test.go b/output_tests/builtins/string_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/string_alias/json_test.go +++ b/output_tests/builtins/string_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/uint16/json_test.go b/output_tests/builtins/uint16/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/uint16/json_test.go +++ b/output_tests/builtins/uint16/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/uint16_alias/json_test.go b/output_tests/builtins/uint16_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/uint16_alias/json_test.go +++ b/output_tests/builtins/uint16_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/uint32/json_test.go b/output_tests/builtins/uint32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/uint32/json_test.go +++ b/output_tests/builtins/uint32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/uint32_alias/json_test.go b/output_tests/builtins/uint32_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/uint32_alias/json_test.go +++ b/output_tests/builtins/uint32_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/uint8/json_test.go b/output_tests/builtins/uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/uint8/json_test.go +++ b/output_tests/builtins/uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/builtins/uint8_alias/json_test.go b/output_tests/builtins/uint8_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/builtins/uint8_alias/json_test.go +++ b/output_tests/builtins/uint8_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/int16/string/json_test.go b/output_tests/map/int16/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/int16/string/json_test.go +++ b/output_tests/map/int16/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/int32/string/json_test.go b/output_tests/map/int32/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/int32/string/json_test.go +++ b/output_tests/map/int32/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/int8/string/json_test.go b/output_tests/map/int8/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/int8/string/json_test.go +++ b/output_tests/map/int8/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/bool/json_test.go b/output_tests/map/string/bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/bool/json_test.go +++ b/output_tests/map/string/bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/byte/json_test.go b/output_tests/map/string/byte/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/byte/json_test.go +++ b/output_tests/map/string/byte/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/float64/json_test.go b/output_tests/map/string/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/float64/json_test.go +++ b/output_tests/map/string/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/int32/json_test.go b/output_tests/map/string/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/int32/json_test.go +++ b/output_tests/map/string/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/map_string_string/json_test.go b/output_tests/map/string/map_string_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/map_string_string/json_test.go +++ b/output_tests/map/string/map_string_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_bool/json_test.go b/output_tests/map/string/ptr_bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_bool/json_test.go +++ b/output_tests/map/string/ptr_bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_float64/json_test.go b/output_tests/map/string/ptr_float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_float64/json_test.go +++ b/output_tests/map/string/ptr_float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_int32/json_test.go b/output_tests/map/string/ptr_int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_int32/json_test.go +++ b/output_tests/map/string/ptr_int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_map_string_string/json_test.go b/output_tests/map/string/ptr_map_string_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_map_string_string/json_test.go +++ b/output_tests/map/string/ptr_map_string_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_slice_string/json_test.go b/output_tests/map/string/ptr_slice_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_slice_string/json_test.go +++ b/output_tests/map/string/ptr_slice_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_string/json_test.go b/output_tests/map/string/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_string/json_test.go +++ b/output_tests/map/string/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_struct_various/json_test.go b/output_tests/map/string/ptr_struct_various/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_struct_various/json_test.go +++ b/output_tests/map/string/ptr_struct_various/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/ptr_uint8/json_test.go b/output_tests/map/string/ptr_uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/ptr_uint8/json_test.go +++ b/output_tests/map/string/ptr_uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/slice_string/json_test.go b/output_tests/map/string/slice_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/slice_string/json_test.go +++ b/output_tests/map/string/slice_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/string/json_test.go b/output_tests/map/string/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/string/json_test.go +++ b/output_tests/map/string/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/string_alias/json_test.go b/output_tests/map/string/string_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/string_alias/json_test.go +++ b/output_tests/map/string/string_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/struct_empty/json_test.go b/output_tests/map/string/struct_empty/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/struct_empty/json_test.go +++ b/output_tests/map/string/struct_empty/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/struct_empty_alias/json_test.go b/output_tests/map/string/struct_empty_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/struct_empty_alias/json_test.go +++ b/output_tests/map/string/struct_empty_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/struct_ptr_string/json_test.go b/output_tests/map/string/struct_ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/struct_ptr_string/json_test.go +++ b/output_tests/map/string/struct_ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/struct_various/json_test.go b/output_tests/map/string/struct_various/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/struct_various/json_test.go +++ b/output_tests/map/string/struct_various/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string/uint8/json_test.go b/output_tests/map/string/uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string/uint8/json_test.go +++ b/output_tests/map/string/uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string_alias/string/json_test.go b/output_tests/map/string_alias/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string_alias/string/json_test.go +++ b/output_tests/map/string_alias/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/string_alias/string_alias/json_test.go b/output_tests/map/string_alias/string_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/string_alias/string_alias/json_test.go +++ b/output_tests/map/string_alias/string_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/uint16/string/json_test.go b/output_tests/map/uint16/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/uint16/string/json_test.go +++ b/output_tests/map/uint16/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/uint32/string/json_test.go b/output_tests/map/uint32/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/uint32/string/json_test.go +++ b/output_tests/map/uint32/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/map/uint8/string/json_test.go b/output_tests/map/uint8/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/map/uint8/string/json_test.go +++ b/output_tests/map/uint8/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/bool/json_test.go b/output_tests/slice/bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/bool/json_test.go +++ b/output_tests/slice/bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/byte/json_test.go b/output_tests/slice/byte/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/byte/json_test.go +++ b/output_tests/slice/byte/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/float64/json_test.go b/output_tests/slice/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/float64/json_test.go +++ b/output_tests/slice/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/int32/json_test.go b/output_tests/slice/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/int32/json_test.go +++ b/output_tests/slice/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/map/int32_string/json_test.go b/output_tests/slice/map/int32_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/map/int32_string/json_test.go +++ b/output_tests/slice/map/int32_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/map/string_string/json_test.go b/output_tests/slice/map/string_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/map/string_string/json_test.go +++ b/output_tests/slice/map/string_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_bool/json_test.go b/output_tests/slice/ptr_bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_bool/json_test.go +++ b/output_tests/slice/ptr_bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_float64/json_test.go b/output_tests/slice/ptr_float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_float64/json_test.go +++ b/output_tests/slice/ptr_float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_int32/json_test.go b/output_tests/slice/ptr_int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_int32/json_test.go +++ b/output_tests/slice/ptr_int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_map/int32_string/json_test.go b/output_tests/slice/ptr_map/int32_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_map/int32_string/json_test.go +++ b/output_tests/slice/ptr_map/int32_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_map/string_string/json_test.go b/output_tests/slice/ptr_map/string_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_map/string_string/json_test.go +++ b/output_tests/slice/ptr_map/string_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/bool/json_test.go b/output_tests/slice/ptr_slice/bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/bool/json_test.go +++ b/output_tests/slice/ptr_slice/bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/byte/json_test.go b/output_tests/slice/ptr_slice/byte/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/byte/json_test.go +++ b/output_tests/slice/ptr_slice/byte/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/float64/json_test.go b/output_tests/slice/ptr_slice/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/float64/json_test.go +++ b/output_tests/slice/ptr_slice/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/int32/json_test.go b/output_tests/slice/ptr_slice/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/int32/json_test.go +++ b/output_tests/slice/ptr_slice/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/ptr_string/json_test.go b/output_tests/slice/ptr_slice/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/ptr_string/json_test.go +++ b/output_tests/slice/ptr_slice/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/string/json_test.go b/output_tests/slice/ptr_slice/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/string/json_test.go +++ b/output_tests/slice/ptr_slice/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_slice/uint8/json_test.go b/output_tests/slice/ptr_slice/uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_slice/uint8/json_test.go +++ b/output_tests/slice/ptr_slice/uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_string/json_test.go b/output_tests/slice/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_string/json_test.go +++ b/output_tests/slice/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_struct_various/json_test.go b/output_tests/slice/ptr_struct_various/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_struct_various/json_test.go +++ b/output_tests/slice/ptr_struct_various/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/ptr_uint8/json_test.go b/output_tests/slice/ptr_uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/ptr_uint8/json_test.go +++ b/output_tests/slice/ptr_uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/bool/json_test.go b/output_tests/slice/slice/bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/bool/json_test.go +++ b/output_tests/slice/slice/bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/byte/json_test.go b/output_tests/slice/slice/byte/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/byte/json_test.go +++ b/output_tests/slice/slice/byte/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/float64/json_test.go b/output_tests/slice/slice/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/float64/json_test.go +++ b/output_tests/slice/slice/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/int32/json_test.go b/output_tests/slice/slice/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/int32/json_test.go +++ b/output_tests/slice/slice/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/ptr_string/json_test.go b/output_tests/slice/slice/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/ptr_string/json_test.go +++ b/output_tests/slice/slice/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/string/json_test.go b/output_tests/slice/slice/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/string/json_test.go +++ b/output_tests/slice/slice/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/slice/uint8/json_test.go b/output_tests/slice/slice/uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/slice/uint8/json_test.go +++ b/output_tests/slice/slice/uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/string/json_test.go b/output_tests/slice/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/string/json_test.go +++ b/output_tests/slice/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/struct_empty/json_test.go b/output_tests/slice/struct_empty/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/struct_empty/json_test.go +++ b/output_tests/slice/struct_empty/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/struct_empty_alias/json_test.go b/output_tests/slice/struct_empty_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/struct_empty_alias/json_test.go +++ b/output_tests/slice/struct_empty_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/struct_ptr_string/json_test.go b/output_tests/slice/struct_ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/struct_ptr_string/json_test.go +++ b/output_tests/slice/struct_ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/struct_various/json_test.go b/output_tests/slice/struct_various/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/struct_various/json_test.go +++ b/output_tests/slice/struct_various/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/slice/uint8/json_test.go b/output_tests/slice/uint8/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/slice/uint8/json_test.go +++ b/output_tests/slice/uint8/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/alias/json_test.go b/output_tests/struct/alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/alias/json_test.go +++ b/output_tests/struct/alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/empty/json_test.go b/output_tests/struct/empty/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/empty/json_test.go +++ b/output_tests/struct/empty/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/empty_alias/json_test.go b/output_tests/struct/empty_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/empty_alias/json_test.go +++ b/output_tests/struct/empty_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/everything/json_test.go b/output_tests/struct/everything/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/everything/json_test.go +++ b/output_tests/struct/everything/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/float64/json_test.go b/output_tests/struct/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/float64/json_test.go +++ b/output_tests/struct/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/float64_alias/json_test.go b/output_tests/struct/float64_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/float64_alias/json_test.go +++ b/output_tests/struct/float64_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/float64s/json_test.go b/output_tests/struct/float64s/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/float64s/json_test.go +++ b/output_tests/struct/float64s/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/float64s_alias/json_test.go b/output_tests/struct/float64s_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/float64s_alias/json_test.go +++ b/output_tests/struct/float64s_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/int32/json_test.go b/output_tests/struct/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/int32/json_test.go +++ b/output_tests/struct/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/int32_alias/json_test.go b/output_tests/struct/int32_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/int32_alias/json_test.go +++ b/output_tests/struct/int32_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/int32s/json_test.go b/output_tests/struct/int32s/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/int32s/json_test.go +++ b/output_tests/struct/int32s/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/int32s_alias/json_test.go b/output_tests/struct/int32s_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/int32s_alias/json_test.go +++ b/output_tests/struct/int32s_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/map/int32_ptr_string/json_test.go b/output_tests/struct/map/int32_ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/map/int32_ptr_string/json_test.go +++ b/output_tests/struct/map/int32_ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/map/int32_string/json_test.go b/output_tests/struct/map/int32_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/map/int32_string/json_test.go +++ b/output_tests/struct/map/int32_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/map/int32_struct_strings/json_test.go b/output_tests/struct/map/int32_struct_strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/map/int32_struct_strings/json_test.go +++ b/output_tests/struct/map/int32_struct_strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/map/string_ptr_string/json_test.go b/output_tests/struct/map/string_ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/map/string_ptr_string/json_test.go +++ b/output_tests/struct/map/string_ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/map/string_string/json_test.go b/output_tests/struct/map/string_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/map/string_string/json_test.go +++ b/output_tests/struct/map/string_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/map/string_struct_strings/json_test.go b/output_tests/struct/map/string_struct_strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/map/string_struct_strings/json_test.go +++ b/output_tests/struct/map/string_struct_strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_float64/json_test.go b/output_tests/struct/ptr_float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_float64/json_test.go +++ b/output_tests/struct/ptr_float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_float64_alias/json_test.go b/output_tests/struct/ptr_float64_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_float64_alias/json_test.go +++ b/output_tests/struct/ptr_float64_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_int32/json_test.go b/output_tests/struct/ptr_int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_int32/json_test.go +++ b/output_tests/struct/ptr_int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_int32_alias/json_test.go b/output_tests/struct/ptr_int32_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_int32_alias/json_test.go +++ b/output_tests/struct/ptr_int32_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_ptr_struct_empty/json_test.go b/output_tests/struct/ptr_ptr_struct_empty/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_ptr_struct_empty/json_test.go +++ b/output_tests/struct/ptr_ptr_struct_empty/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_ptr_struct_strings/json_test.go b/output_tests/struct/ptr_ptr_struct_strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_ptr_struct_strings/json_test.go +++ b/output_tests/struct/ptr_ptr_struct_strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_string/json_test.go b/output_tests/struct/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_string/json_test.go +++ b/output_tests/struct/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_string_alias/json_test.go b/output_tests/struct/ptr_string_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_string_alias/json_test.go +++ b/output_tests/struct/ptr_string_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_struct_empty/json_test.go b/output_tests/struct/ptr_struct_empty/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_struct_empty/json_test.go +++ b/output_tests/struct/ptr_struct_empty/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptr_struct_strings/json_test.go b/output_tests/struct/ptr_struct_strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptr_struct_strings/json_test.go +++ b/output_tests/struct/ptr_struct_strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptrs_float64/json_test.go b/output_tests/struct/ptrs_float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptrs_float64/json_test.go +++ b/output_tests/struct/ptrs_float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptrs_int32/json_test.go b/output_tests/struct/ptrs_int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptrs_int32/json_test.go +++ b/output_tests/struct/ptrs_int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/ptrs_string/json_test.go b/output_tests/struct/ptrs_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/ptrs_string/json_test.go +++ b/output_tests/struct/ptrs_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/slice/ptr_string/json_test.go b/output_tests/struct/slice/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/slice/ptr_string/json_test.go +++ b/output_tests/struct/slice/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/slice/string/json_test.go b/output_tests/struct/slice/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/slice/string/json_test.go +++ b/output_tests/struct/slice/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/slice/string_alias/json_test.go b/output_tests/struct/slice/string_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/slice/string_alias/json_test.go +++ b/output_tests/struct/slice/string_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/slice/strings/json_test.go b/output_tests/struct/slice/strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/slice/strings/json_test.go +++ b/output_tests/struct/slice/strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/slice/struct_strings/json_test.go b/output_tests/struct/slice/struct_strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/slice/struct_strings/json_test.go +++ b/output_tests/struct/slice/struct_strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/string/json_test.go b/output_tests/struct/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/string/json_test.go +++ b/output_tests/struct/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/string_alias/json_test.go b/output_tests/struct/string_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/string_alias/json_test.go +++ b/output_tests/struct/string_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/strings/json_test.go b/output_tests/struct/strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/strings/json_test.go +++ b/output_tests/struct/strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/strings_alias/json_test.go b/output_tests/struct/strings_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/strings_alias/json_test.go +++ b/output_tests/struct/strings_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/empties/json_test.go b/output_tests/struct/struct/empties/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/empties/json_test.go +++ b/output_tests/struct/struct/empties/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/empty/json_test.go b/output_tests/struct/struct/empty/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/empty/json_test.go +++ b/output_tests/struct/struct/empty/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/empty_alias/json_test.go b/output_tests/struct/struct/empty_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/empty_alias/json_test.go +++ b/output_tests/struct/struct/empty_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/float32s/json_test.go b/output_tests/struct/struct/float32s/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/float32s/json_test.go +++ b/output_tests/struct/struct/float32s/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/float64/json_test.go b/output_tests/struct/struct/float64/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/float64/json_test.go +++ b/output_tests/struct/struct/float64/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/float64_alias/json_test.go b/output_tests/struct/struct/float64_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/float64_alias/json_test.go +++ b/output_tests/struct/struct/float64_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/int32s/json_test.go b/output_tests/struct/struct/int32s/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/int32s/json_test.go +++ b/output_tests/struct/struct/int32s/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/strings/json_test.go b/output_tests/struct/struct/strings/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/strings/json_test.go +++ b/output_tests/struct/struct/strings/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct/struct/strings_alias/json_test.go b/output_tests/struct/struct/strings_alias/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct/struct/strings_alias/json_test.go +++ b/output_tests/struct/struct/strings_alias/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/fieldname/json_test.go b/output_tests/struct_tags/fieldname/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/fieldname/json_test.go +++ b/output_tests/struct_tags/fieldname/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/bool/json_test.go b/output_tests/struct_tags/omitempty/bool/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/bool/json_test.go +++ b/output_tests/struct_tags/omitempty/bool/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/float32/json_test.go b/output_tests/struct_tags/omitempty/float32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/float32/json_test.go +++ b/output_tests/struct_tags/omitempty/float32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/int32/json_test.go b/output_tests/struct_tags/omitempty/int32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/int32/json_test.go +++ b/output_tests/struct_tags/omitempty/int32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/map_string_string/json_test.go b/output_tests/struct_tags/omitempty/map_string_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/map_string_string/json_test.go +++ b/output_tests/struct_tags/omitempty/map_string_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/ptr_string/json_test.go b/output_tests/struct_tags/omitempty/ptr_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/ptr_string/json_test.go +++ b/output_tests/struct_tags/omitempty/ptr_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/slice_string/json_test.go b/output_tests/struct_tags/omitempty/slice_string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/slice_string/json_test.go +++ b/output_tests/struct_tags/omitempty/slice_string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/string/json_test.go b/output_tests/struct_tags/omitempty/string/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/string/json_test.go +++ b/output_tests/struct_tags/omitempty/string/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() } diff --git a/output_tests/struct_tags/omitempty/uint32/json_test.go b/output_tests/struct_tags/omitempty/uint32/json_test.go index a7b1d0d..196f98d 100644 --- a/output_tests/struct_tags/omitempty/uint32/json_test.go +++ b/output_tests/struct_tags/omitempty/uint32/json_test.go @@ -3,6 +3,8 @@ package test import ( "bytes" "encoding/json" + "fmt" + "strings" "testing" "github.com/davecgh/go-spew/spew" @@ -18,29 +20,35 @@ func Test_Roundtrip(t *testing.T) { jbStd, err := json.Marshal(before) if err != nil { - t.Errorf("failed to marshal with stdlib: %v", err) + t.Fatalf("failed to marshal with stdlib: %v", err) + } + if len(strings.TrimSpace(string(jbStd))) == 0 { + t.Fatal("stdlib marshal produced empty result and no error") } jbIter, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(before) if err != nil { - t.Errorf("failed to marshal with jsoniter: %v", err) + t.Fatalf("failed to marshal with jsoniter: %v", err) + } + if len(strings.TrimSpace(string(jbIter))) == 0 { + t.Fatal("jsoniter marshal produced empty result and no error") } if string(jbStd) != string(jbIter) { - t.Errorf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", + t.Fatalf("marshal expected:\n %s\ngot:\n %s\nobj:\n %s", indent(jbStd, " "), indent(jbIter, " "), dump(before)) } var afterStd T err = json.Unmarshal(jbIter, &afterStd) if err != nil { - t.Errorf("failed to unmarshal with stdlib: %v", err) + t.Fatalf("failed to unmarshal with stdlib: %v", err) } var afterIter T err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter) if err != nil { - t.Errorf("failed to unmarshal with jsoniter: %v", err) + t.Fatalf("failed to unmarshal with jsoniter: %v", err) } if fingerprint(afterStd) != fingerprint(afterIter) { - t.Errorf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", + t.Fatalf("unmarshal expected:\n %s\ngot:\n %s\nvia:\n %s", dump(afterStd), dump(afterIter), indent(jbIter, " ")) } } @@ -65,7 +73,10 @@ func dump(obj interface{}) string { func indent(src []byte, prefix string) string { var buf bytes.Buffer - json.Indent(&buf, src, prefix, indentStr) + err := json.Indent(&buf, src, prefix, indentStr) + if err != nil { + return fmt.Sprintf("!!! %v", err) + } return buf.String() }