test: add ZeroValue and NotZeroValue assertions

examples_test.go

@@ -681,6 +681,26 @@ func ExampleOne() {
 	// Output:
 }
 
+func ExampleZeroValue() {
+	ZeroValue(t, 0)
+	ZeroValue(t, "")
+	ZeroValue(t, false)
+	ZeroValue(t, struct{}{})
+	ZeroValue(t, time.Time{})
+	ZeroValue(t, time.Time{}.Local())
+	// Output:
+}
+
+func ExampleNotZeroValue() {
+	NotZeroValue(t, 42)
+	NotZeroValue(t, "hello")
+	NotZeroValue(t, true)
+	NotZeroValue(t, struct{ a int }{a: 1})
+	NotZeroValue(t, time.Now())
+	NotZeroValue(t, time.Time{} != time.Time{}.Local())
+	// Output:
+}
+
 func ExamplePositive() {
 	Positive(t, 42)
 	// Output:

internal/assertions/assertions.go

@@ -624,6 +624,40 @@ func NonZero[N interfaces.Number](value N) (s string) {
 	return
 }
 
+func ZeroValue[T any](v T, opts ...cmp.Option) (s string) {
+	var zero T
+	z, ok := any(v).(interface{ IsZero() bool })
+	if ok {
+		if !z.IsZero() {
+			s = "expected zero via IsZero method\n"
+			s += diff(zero, v, opts)
+		}
+		return
+	}
+
+	if !equal(zero, v, opts) {
+		s = "expected zero via cmp.Equal function\n"
+		s += diff(zero, v, opts)
+	}
+	return
+}
+
+func NotZeroValue[T any](v T, opts ...cmp.Option) (s string) {
+	var zero T
+	z, ok := any(v).(interface{ IsZero() bool })
+	if ok {
+		if z.IsZero() {
+			s = "expected non-zero via IsZero method\n"
+		}
+		return
+	}
+
+	if equal(zero, v, opts) {
+		s = "expected non-zero via cmp.Equal function\n"
+	}
+	return
+}
+
 func One[N interfaces.Number](value N) (s string) {
 	if value != 1 {
 		s = "expected value of 1\n"

test.go

@@ -359,6 +359,22 @@ func One[N interfaces.Number](t T, n N, settings ...Setting) {
 	invoke(t, assertions.One(n), settings...)
 }
 
+// ZeroValue asserts v is the zero value for its type.
+// If v implements IsZero() bool, that method is used.
+// Otherwise, cmp.Equal is used to compare against the zero value.
+func ZeroValue[A any](t T, v A, settings ...Setting) {
+	t.Helper()
+	invoke(t, assertions.ZeroValue(v, options(settings...)...), settings...)
+}
+
+// NotZeroValue asserts v is not the zero value for its type.
+// If v implements IsZero() bool, that method is used.
+// Otherwise, cmp.Equal is used to compare against the zero value.
+func NotZeroValue[A any](t T, v A, settings ...Setting) {
+	t.Helper()
+	invoke(t, assertions.NotZeroValue(v, options(settings...)...), settings...)
+}
+
 // Less asserts val < exp.
 func Less[O constraints.Ordered](t T, exp, val O, settings ...Setting) {
 	t.Helper()

test_test.go

@@ -949,6 +949,57 @@ func TestOne(t *testing.T) {
 	One(tc, 1.1)
 }
 
+func TestZeroValue(t *testing.T) {
+	t.Run("basic types", func(t *testing.T) {
+		tc := newCase(t, `expected zero via cmp.Equal function`)
+		t.Cleanup(tc.assert)
+
+		ZeroValue(tc, 42)
+		ZeroValue(tc, "hello")
+		ZeroValue(tc, true)
+	})
+
+	t.Run("with IsZero method", func(t *testing.T) {
+		tc := newCase(t, `expected zero via IsZero method`)
+		t.Cleanup(tc.assert)
+
+		ZeroValue(tc, time.Now())
+	})
+
+	t.Run("slice", func(t *testing.T) {
+		tc := newCase(t, `expected zero via cmp.Equal function`)
+		t.Cleanup(tc.assert)
+
+		ZeroValue(tc, []int{1, 2, 3})
+	})
+}
+
+func TestNotZeroValue(t *testing.T) {
+	t.Run("basic types", func(t *testing.T) {
+		tc := newCase(t, `expected non-zero via cmp.Equal function`)
+		t.Cleanup(tc.assert)
+
+		NotZeroValue(tc, 0)
+		NotZeroValue(tc, "")
+		NotZeroValue(tc, false)
+	})
+
+	t.Run("with IsZero method", func(t *testing.T) {
+		tc := newCase(t, `expected non-zero via IsZero method`)
+		t.Cleanup(tc.assert)
+
+		NotZeroValue(tc, time.Time{})
+	})
+
+	t.Run("slice", func(t *testing.T) {
+		tc := newCase(t, `expected non-zero via cmp.Equal function`)
+		t.Cleanup(tc.assert)
+
+		var empty []int
+		NotZeroValue(tc, empty)
+	})
+}
+
 func TestLess(t *testing.T) {
 	t.Run("integers", func(t *testing.T) {
 		tc := newCase(t, `expected 7 < 5`)