cleaner go test -v output

Uses ensureNoPanic test helper function so there is no need to write
the test case name prior to executing code that might cause a panic.

ensure_test.go

@@ -0,0 +1,85 @@
+package goavro
+
+// NOTE: This file was copied from https://github.com/karrick/gorill
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func ensureBuffer(tb testing.TB, buf []byte, n int, want string) {
+	tb.Helper()
+	if got, want := n, len(want); got != want {
+		tb.Fatalf("GOT: %v; WANT: %v", got, want)
+	}
+	if got, want := string(buf[:n]), want; got != want {
+		tb.Errorf("GOT: %v; WANT: %v", got, want)
+	}
+}
+
+func ensureError(tb testing.TB, err error, contains ...string) {
+	tb.Helper()
+	if len(contains) == 0 {
+		if err != nil {
+			tb.Errorf("GOT: %v; WANT: %v", err, contains)
+		}
+	} else if err == nil {
+		tb.Errorf("GOT: %v; WANT: %v", err, contains)
+	} else {
+		for _, stub := range contains {
+			if !strings.Contains(err.Error(), stub) {
+				tb.Errorf("GOT: %v; WANT: %v", err, stub)
+			}
+		}
+	}
+}
+
+func ensurePanic(tb testing.TB, want string, callback func()) {
+	tb.Helper()
+	defer func() {
+		r := recover()
+		if r == nil {
+			tb.Fatalf("GOT: %v; WANT: %v", r, want)
+			return
+		}
+		if got := fmt.Sprintf("%v", r); got != want {
+			tb.Fatalf("GOT: %v; WANT: %v", got, want)
+		}
+	}()
+	callback()
+}
+
+// ensureNoPanic prettifies the output so one knows which test case caused a
+// panic.
+func ensureNoPanic(tb testing.TB, test string, callback func()) {
+	tb.Helper()
+	defer func() {
+		if r := recover(); r != nil {
+			tb.Fatalf("TEST: %s: GOT: %v", test, r)
+		}
+	}()
+	callback()
+}
+
+func ensureStringSlicesMatch(tb testing.TB, actual, expected []string) {
+	tb.Helper()
+	if got, want := len(actual), len(expected); got != want {
+		tb.Errorf("GOT: %v; WANT: %v", got, want)
+	}
+	la := len(actual)
+	le := len(expected)
+	for i := 0; i < la || i < le; i++ {
+		if i < la {
+			if i < le {
+				if got, want := actual[i], expected[i]; got != want {
+					tb.Errorf("GOT: %q; WANT: %q", got, want)
+				}
+			} else {
+				tb.Errorf("GOT: %q (extra)", actual[i])
+			}
+		} else if i < le {
+			tb.Errorf("WANT: %q (missing)", expected[i])
+		}
+	}
+}

fuzz_test.go

@@ -40,8 +40,9 @@ func TestCrashers_OCFReader(t *testing.T) {
 	}
 
 	for testName, f := range crashers {
-		t.Logf("Testing: %s", testName)
-		_, _ = NewOCFReader(strings.NewReader(f)) // looking for panic rather than an error
+		ensureNoPanic(t, testName, func() {
+			_, _ = NewOCFReader(strings.NewReader(f)) // ensure does not panic
+		})
 	}
 }
 
@@ -382,32 +383,34 @@ func TestCrashers_OCF_e2e(t *testing.T) {
 	}
 
 	for testName, f := range crashers {
-		t.Logf("Testing: %s", testName)
-
-		// TODO: replace this with a call out to the e2e Fuzz function
-		ocfr, err := NewOCFReader(strings.NewReader(f))
-		if err != nil {
-			continue
-		}
+		ensureNoPanic(t, testName, func() {
+			// TODO: replace this with a call out to the e2e Fuzz function
+			ocfr, err := NewOCFReader(strings.NewReader(f))
+			if err != nil {
+				// We want the library to catch the erroneous condition and
+				// return an error rather than causing a panic.
+				return
+			}
 
-		var datums []interface{}
-		for ocfr.Scan() {
-			if datum, err := ocfr.Read(); err == nil {
-				datums = append(datums, datum)
+			var datums []interface{}
+			for ocfr.Scan() {
+				if datum, err := ocfr.Read(); err == nil {
+					datums = append(datums, datum)
+				}
 			}
-		}
 
-		b := new(bytes.Buffer)
-		ocfw, err := NewOCFWriter(
-			OCFConfig{
-				W:      b,
-				Schema: ocfr.Codec().Schema(),
-			})
-		if err != nil {
-			panic(err)
-		}
-		if err := ocfw.Append(datums); err != nil {
-			panic(err)
-		}
+			b := new(bytes.Buffer)
+			ocfw, err := NewOCFWriter(
+				OCFConfig{
+					W:      b,
+					Schema: ocfr.Codec().Schema(),
+				})
+			if err != nil {
+				t.Fatalf("GOT: %v; WANT: %v", err, nil)
+			}
+			if err := ocfw.Append(datums); err != nil {
+				t.Fatalf("GOT: %v; WANT: %v", err, nil)
+			}
+		})
 	}
 }

helpers_test.go

@@ -12,12 +12,12 @@ package goavro
 import (
 	"io"
 	"runtime"
-	"strings"
 	"sync"
 	"testing"
 )
 
 func benchmarkLowAndHigh(b *testing.B, callback func()) {
+	b.Helper()
 	// Run test case in parallel at relative low concurrency
 	b.Run("Low", func(b *testing.B) {
 		b.ResetTimer()
@@ -49,33 +49,6 @@ func benchmarkLowAndHigh(b *testing.B, callback func()) {
 	})
 }
 
-func ensureEqual(t *testing.T, actual, expected interface{}) {
-	if actual != expected {
-		_, file, line, ok := runtime.Caller(1)
-		if !ok {
-			t.Errorf("Actual: %#v; Expected: %#v", actual, expected)
-		} else {
-			if index := strings.LastIndex(file, "/"); index != -1 {
-				file = file[index+1:]
-			}
-			t.Errorf("Actual: %#v; Expected: %#v; %s:%d", actual, expected, file, line)
-		}
-	}
-}
-
-// ensure code under test returns error containing specified string
-func ensureError(tb testing.TB, err error, contains ...string) {
-	if err == nil {
-		tb.Errorf("GOT: %v; WANT: %#v", err, contains)
-		return
-	}
-	for _, stub := range contains {
-		if !strings.Contains(err.Error(), stub) {
-			tb.Errorf("GOT: %v; WANT: %#v", err, contains)
-		}
-	}
-}
-
 // ShortWriter returns a structure that wraps an io.Writer, but returns
 // io.ErrShortWrite when the number of bytes to write exceeds a preset limit.
 //