Better errors in output_tests

output_tests/builtins/bool/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/bool_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/byte/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/byte_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/float32/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/float32_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/float64/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/float64_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/int16/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/int16_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/int32/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/int32_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/int8/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/int8_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/string_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/uint16/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/uint16_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/uint32/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/uint32_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/uint8/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/builtins/uint8_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/int16/string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/int32/string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/int8/string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/bool/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/byte/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/float64/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/int32/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/map_string_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/ptr_bool/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/ptr_float64/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/ptr_int32/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/ptr_map_string_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/ptr_slice_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/ptr_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/ptr_struct_various/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/ptr_uint8/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/slice_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/string_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/struct_empty/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/struct_empty_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/struct_ptr_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/struct_various/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string/uint8/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string_alias/string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/string_alias/string_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/uint16/string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/uint32/string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map/uint8/string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map_key_text_marshal/string_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map_key_text_marshal/struct/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/map_key_text_marshal/struct_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/bool/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/byte/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/float64/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/int32/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/map/int32_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/map/string_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_bool/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_float64/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_int32/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_map/int32_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_map/string_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_slice/bool/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_slice/byte/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_slice/float64/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_slice/int32/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_slice/ptr_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_slice/string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_slice/uint8/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_struct_various/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/ptr_uint8/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/slice/bool/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/slice/byte/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/slice/float64/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/slice/int32/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/slice/ptr_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/slice/string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/slice/uint8/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/struct_empty/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/struct_empty_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/struct_ptr_string/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/struct_various/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/slice/uint8/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/struct/alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/struct/empty/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/struct/empty_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/struct/everything/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/struct/float64/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/struct/float64_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/struct/float64s/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/struct/float64s_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/struct/int32/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/struct/int32_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/struct/int32s/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",

output_tests/struct/int32s_alias/json_test.go

@@ -40,12 +40,14 @@ func Test_Roundtrip(t *testing.T) {
 		var afterStd T
 		err = json.Unmarshal(jbIter, &afterStd)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with stdlib: %v", err)
+			t.Fatalf("failed to unmarshal with stdlib: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		var afterIter T
 		err = jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(jbIter, &afterIter)
 		if err != nil {
-			t.Fatalf("failed to unmarshal with jsoniter: %v", err)
+			t.Fatalf("failed to unmarshal with jsoniter: %v\nvia:\n    %s",
+				err, indent(jbIter, "    "))
 		}
 		if fingerprint(afterStd) != fingerprint(afterIter) {
 			t.Fatalf("unmarshal expected:\n    %s\ngot:\n    %s\nvia:\n    %s",