Use custom byte dumper for equality errors.

Author: rzajac

pkg/check/equal.go

@@ -267,30 +267,32 @@ func equalError(want, have any, opts ...Option) *notice.Notice {
 	}
 
 	ops := DefaultOptions(opts...)
-	msg := notice.New("expected values to be equal").
-		Trail(ops.Trail)
-
-	if b, ok := want.(byte); ok && isPrintableChar(b) {
-		_ = msg.Want("%#v ('%s')", want, string(b))
-	} else {
-		_ = msg.Want("%s", ops.Dumper.Any(want))
+	if _, ok := ops.Dumper.Dumpers[typByte]; !ok {
+		ops.Dumper.Dumpers[typByte] = dumpByte
 	}
 
-	if b, ok := have.(byte); ok && isPrintableChar(b) {
-		_ = msg.Have("%#v ('%s')", have, string(b))
-	} else {
-		_ = msg.Have("%s", ops.Dumper.Any(have))
-	}
+	msg := notice.New("expected values to be equal").
+		Trail(ops.Trail).
+		Want("%s", ops.Dumper.Any(want)).
+		Have("%s", ops.Dumper.Any(have))
 
 	if wTyp != "" {
-		// nolint: govet
 		_ = msg.
 			Append("want type", "%s", wTyp).
 			Append("have type", "%s", hTyp)
 	}
 	return msg
 }
 
-func dumpByte(dnp dump.Dump, lvl int, val reflect.Value) string {
-	return ""
+// dumpByte is a custom bumper for bytes.
+func dumpByte(dmp dump.Dump, lvl int, val reflect.Value) string {
+	v := val.Interface().(byte) // nolint: forcetypeassert
+	var str string
+	if isPrintableChar(v) {
+		str = fmt.Sprintf("0x%02x ('%s')", v, string(v))
+	} else {
+		str = fmt.Sprintf("0x%02x", v)
+	}
+	prn := dump.NewPrinter(dmp)
+	return prn.Tab(dmp.Indent + lvl).Write(str).String()
 }

pkg/check/equal_test.go

@@ -3,12 +3,14 @@ package check
 import (
 	"errors"
 	"fmt"
+	"reflect"
 	"testing"
 	"time"
 
 	"github.com/ctx42/testing/internal/affirm"
 	"github.com/ctx42/testing/internal/cases"
 	"github.com/ctx42/testing/internal/types"
+	"github.com/ctx42/testing/pkg/dump"
 	"github.com/ctx42/testing/pkg/must"
 )
 
@@ -1297,6 +1299,23 @@ func Test_equalError(t *testing.T) {
 		affirm.Equal(t, wMsg, err.Error())
 	})
 
+	t.Run("does not override already set byte dumper", func(t *testing.T) {
+		// --- Given ---
+		w := byte('A')
+		h := byte('B')
+		fn := func(_ dump.Dump, _ int, _ reflect.Value) string { return "abc" }
+		ops := DefaultOptions(WithDumper(dump.WithDumper(byte(0), fn)))
+
+		// --- When ---
+		err := equalError(w, h, WithOptions(ops))
+
+		// --- Then ---
+		wMsg := "expected values to be equal:\n" +
+			"  want: abc\n" +
+			"  have: abc"
+		affirm.Equal(t, wMsg, err.Error())
+	})
+
 	t.Run("different types", func(t *testing.T) {
 		// --- Given ---
 		w := byte('A')
@@ -1315,3 +1334,41 @@ func Test_equalError(t *testing.T) {
 		affirm.Equal(t, wMsg, err.Error())
 	})
 }
+
+func Test_dumpByte(t *testing.T) {
+	t.Run("success printable", func(t *testing.T) {
+		// --- Given ---
+		dmp := dump.New()
+		val := reflect.ValueOf(byte(42))
+
+		// --- When ---
+		have := dumpByte(dmp, 0, val)
+
+		// --- Then ---
+		affirm.Equal(t, "0x2a ('*')", have)
+	})
+
+	t.Run("success not printable", func(t *testing.T) {
+		// --- Given ---
+		dmp := dump.New()
+		val := reflect.ValueOf(byte(1))
+
+		// --- When ---
+		have := dumpByte(dmp, 0, val)
+
+		// --- Then ---
+		affirm.Equal(t, "0x01", have)
+	})
+
+	t.Run("uses indent and level", func(t *testing.T) {
+		// --- Given ---
+		dmp := dump.New(dump.WithIndent(2))
+		val := reflect.ValueOf(byte(1))
+
+		// --- When ---
+		have := dumpByte(dmp, 1, val)
+
+		// --- Then ---
+		affirm.Equal(t, "      0x01", have)
+	})
+}

pkg/check/helpers.go

@@ -20,6 +20,7 @@ var (
 	typTime       = reflect.TypeOf(time.Time{})
 	typTimeLoc    = reflect.TypeOf(time.Location{})
 	typTimeLocPtr = reflect.TypeOf(&time.Location{})
+	typByte       = reflect.TypeOf(byte(0))
 )
 
 // typeString returns type of the value as a string.