Add Greater, GreaterOrEqual, Less, LessOrEqual, Empty, NotEmpty, and NotEqualDelta assert methods

Author: tomas-novotny

CHANGELOG.md

@@ -6,9 +6,17 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 
-## [Unreleased](https://github.com/gravitton/assert/compare/v1.1.0...master)
+## [Unreleased](https://github.com/gravitton/assert/compare/v1.2.0...master)
 
-## v1.1.0 (2026-04-22)
+## v1.2.0 (2026-04-22)(https://github.com/gravitton/assert/compare/v1.1.0...v1.2.0)
+### Added
+- Added `Greater`, `GreaterOrEqual`, `Less`, and `LessOrEqual` assert methods for numeric comparison
+- Added `Empty` and `NotEmpty` assert methods for zero-length checks on strings, slices, maps, and channels
+- Added `NotEqualDelta` assert method, complementing `EqualDelta`
+### Fixed
+- `Error` and `NoError` now correctly treat typed nil errors (e.g. `(*MyError)(nil)`) as nil
+
+## v1.1.0 (2026-04-22)(https://github.com/gravitton/assert/compare/v1.0.0...v1.1.0)
 ### Added
 - Added `Matches` and `NotMatches` assert methods for regexp matching on strings
 

README.md

@@ -43,18 +43,27 @@ func TestFoo(t *testing.T) {
 |---|---|
 | `True(t, condition)` | condition is true |
 | `False(t, condition)` | condition is false |
+| `Same(t, actual, expected)` | pointers reference the same object |
+| `NotSame(t, actual, expected)` | pointers reference different objects |
 | `Equal(t, actual, expected)` | values are equal (deep) |
 | `NotEqual(t, actual, expected)` | values are not equal |
 | `EqualDelta(t, actual, expected, delta)` | numeric values differ by at most delta |
-| `Same(t, actual, expected)` | pointers reference the same object |
-| `NotSame(t, actual, expected)` | pointers reference different objects |
+| `NotEqualDelta(t, actual, expected, delta)` | numeric values differ by more than delta |
+| `Greater(t, actual, expected)` | actual > expected |
+| `GreaterOrEqual(t, actual, expected)` | actual >= expected |
+| `Less(t, actual, expected)` | actual < expected |
+| `LessOrEqual(t, actual, expected)` | actual <= expected |
 | `Length(t, object, n)` | string/slice/map/channel has length n |
+| `Empty(t, object)` | string/slice/map/channel has zero length |
+| `NotEmpty(t, object)` | string/slice/map/channel has non-zero length |
 | `Contains(t, object, element)` | string/slice/map/channel contains element |
 | `NotContains(t, object, element)` | string/slice/map/channel does not contain element |
 | `Error(t, err)` | error is not nil |
 | `NoError(t, err)` | error is nil |
 | `ErrorIs(t, err, target)` | error unwraps to target |
 | `NotErrorIs(t, err, target)` | error does not unwrap to target |
+| `Matches(t, actual, pattern)` | string matches regular expression |
+| `NotMatches(t, actual, pattern)` | string does not match regular expression |
 | `EqualJSON(t, actual, expected)` | JSON strings are semantically equal |
 | `JSON(t, object, expected)` | object marshals to expected JSON string |
 | `Fail(t, message)` | always fails with message |

assert.go

@@ -52,6 +52,38 @@ func False(t Testing, condition bool, messages ...string) bool {
 	return true
 }
 
+// Same asserts that two pointers reference the same object.
+//
+// Both arguments must be pointer variables. Pointer variable equality is
+// determined based on the equality of both type and value.
+func Same[T Reference](t Testing, actual, expected T, messages ...string) bool {
+	t.Helper()
+
+	if valid, ok := same[T](expected, actual); !ok {
+		return Failf(t, "%sShould be pointers\n  actual: %s\nexpected: %s", message(messages), print(actual), print(expected))
+	} else if !valid {
+		return Failf(t, "%sShould be same\n  actual: %s\nexpected: %s", message(messages), print(actual), print(expected))
+	}
+
+	return true
+}
+
+// NotSame asserts that two pointers do NOT reference the same object.
+//
+// Both arguments must be pointer variables. Pointer variable equality is
+// determined based on the equality of both type and value.
+func NotSame[T Reference](t Testing, actual, expected T, messages ...string) bool {
+	t.Helper()
+
+	if valid, ok := same(expected, actual); !ok {
+		Failf(t, "%sShould be pointers\n  actual: %s\nexpected: %s", message(messages), print(actual), print(expected))
+	} else if valid {
+		return Failf(t, "%sShould not be same\n  actual: %s", message(messages), print(actual))
+	}
+
+	return true
+}
+
 // Equal asserts that two objects are equal.
 //
 // Pointer variable equality is determined based on the equality of the
@@ -93,33 +125,58 @@ func EqualDelta[T Numeric](t Testing, actual, expected, delta T, messages ...str
 	return true
 }
 
-// Same asserts that two pointers reference the same object.
+// NotEqualDelta asserts that two numeric values difference is greater than delta.
 //
-// Both arguments must be pointer variables. Pointer variable equality is
-// determined based on the equality of both type and value.
-func Same[T Reference](t Testing, actual, expected T, messages ...string) bool {
+// Panics if delta is negative.
+func NotEqualDelta[T Numeric](t Testing, actual, expected, delta T, messages ...string) bool {
 	t.Helper()
 
-	if valid, ok := same[T](expected, actual); !ok {
-		return Failf(t, "%sShould be pointers\n  actual: %s\nexpected: %s", message(messages), print(actual), print(expected))
-	} else if !valid {
-		return Failf(t, "%sShould be same\n  actual: %s\nexpected: %s", message(messages), print(actual), print(expected))
+	if equalDelta(actual, expected, delta) {
+		return Failf(t, "%sShould not be equal in delta:\n  actual: %s\nexpected: %s", message(messages), print(actual), print(expected))
 	}
 
 	return true
 }
 
-// NotSame asserts that two pointers do NOT reference the same object.
-//
-// Both arguments must be pointer variables. Pointer variable equality is
-// determined based on the equality of both type and value.
-func NotSame[T Reference](t Testing, actual, expected T, messages ...string) bool {
+// Greater asserts that actual is greater than expected.
+func Greater[T Numeric](t Testing, actual, expected T, messages ...string) bool {
 	t.Helper()
 
-	if valid, ok := same(expected, actual); !ok {
-		Failf(t, "%sShould be pointers\n  actual: %s\nexpected: %s", message(messages), print(actual), print(expected))
-	} else if valid {
-		return Failf(t, "%sShould not be same\n  actual: %s", message(messages), print(actual))
+	if actual <= expected {
+		return Failf(t, "%sShould be greater\n  actual: %s\nexpected: %s", message(messages), print(actual), print(expected))
+	}
+
+	return true
+}
+
+// GreaterOrEqual asserts that actual is greater than or equal to expected.
+func GreaterOrEqual[T Numeric](t Testing, actual, expected T, messages ...string) bool {
+	t.Helper()
+
+	if actual < expected {
+		return Failf(t, "%sShould be greater or equal\n  actual: %s\nexpected: %s", message(messages), print(actual), print(expected))
+	}
+
+	return true
+}
+
+// Less asserts that actual is less than expected.
+func Less[T Numeric](t Testing, actual, expected T, messages ...string) bool {
+	t.Helper()
+
+	if actual >= expected {
+		return Failf(t, "%sShould be less\n  actual: %s\nexpected: %s", message(messages), print(actual), print(expected))
+	}
+
+	return true
+}
+
+// LessOrEqual asserts that actual is less than or equal to expected.
+func LessOrEqual[T Numeric](t Testing, actual, expected T, messages ...string) bool {
+	t.Helper()
+
+	if actual > expected {
+		return Failf(t, "%sShould be less or equal\n  actual: %s\nexpected: %s", message(messages), print(actual), print(expected))
 	}
 
 	return true
@@ -136,6 +193,28 @@ func Length[S Iterable[any]](t Testing, object S, expected int, messages ...stri
 	return true
 }
 
+// Empty asserts that object has zero length.
+func Empty[S Iterable[any]](t Testing, object S, messages ...string) bool {
+	t.Helper()
+
+	if length(object) != 0 {
+		return Failf(t, "%sShould be empty\n  object: %#v", message(messages), object)
+	}
+
+	return true
+}
+
+// NotEmpty asserts that object has non-zero length.
+func NotEmpty[S Iterable[any]](t Testing, object S, messages ...string) bool {
+	t.Helper()
+
+	if length(object) == 0 {
+		return Failf(t, "%sShould not be empty\n  object: %#v", message(messages), object)
+	}
+
+	return true
+}
+
 // Contains asserts that object contains given element.
 //
 // Works with strings, arrays, slices, maps values and channels.
@@ -167,21 +246,25 @@ func NotContains[S Iterable[E], E Comparable](t Testing, object S, element E, me
 }
 
 // Error asserts that error is NOT nil.
+//
+// A typed nil error (e.g. (*MyError)(nil)) is treated as nil.
 func Error(t Testing, err error, messages ...string) bool {
 	t.Helper()
 
-	if err == nil {
+	if isNilError(err) {
 		return Failf(t, "%sShould be error", message(messages))
 	}
 
 	return true
 }
 
 // NoError asserts that error is nil.
+//
+// A typed nil error (e.g. (*MyError)(nil)) is treated as nil.
 func NoError(t Testing, err error, messages ...string) bool {
 	t.Helper()
 
-	if err != nil {
+	if !isNilError(err) {
 		return Failf(t, "%sShould not be error\n   error: %#v", message(messages), err)
 	}
 
@@ -210,23 +293,6 @@ func NotErrorIs(t Testing, err error, target error, messages ...string) bool {
 	return true
 }
 
-// EqualJSON asserts that JSON strings are equal.
-func EqualJSON(t Testing, actual, expected string, messages ...string) bool {
-	t.Helper()
-
-	var actualJSON, expectedJSON any
-
-	if err := json.Unmarshal([]byte(actual), &actualJSON); err != nil {
-		return Failf(t, "%sShould be valid JSON\n  actual: %s\n     err: %v", message(messages), actual, err)
-	}
-
-	if err := json.Unmarshal([]byte(expected), &expectedJSON); err != nil {
-		return Failf(t, "%sShould be valid JSON\nexpected: %s\n     err: %v", message(messages), expected, err)
-	}
-
-	return Equal(t, actualJSON, expectedJSON)
-}
-
 // Matches asserts that a string matches the given regular expression.
 func Matches(t Testing, actual, pattern string, messages ...string) bool {
 	t.Helper()
@@ -259,6 +325,23 @@ func NotMatches(t Testing, actual, pattern string, messages ...string) bool {
 	return true
 }
 
+// EqualJSON asserts that JSON strings are equal.
+func EqualJSON(t Testing, actual, expected string, messages ...string) bool {
+	t.Helper()
+
+	var actualJSON, expectedJSON any
+
+	if err := json.Unmarshal([]byte(actual), &actualJSON); err != nil {
+		return Failf(t, "%sShould be valid JSON\n  actual: %s\n     err: %v", message(messages), actual, err)
+	}
+
+	if err := json.Unmarshal([]byte(expected), &expectedJSON); err != nil {
+		return Failf(t, "%sShould be valid JSON\nexpected: %s\n     err: %v", message(messages), expected, err)
+	}
+
+	return Equal(t, actualJSON, expectedJSON)
+}
+
 // JSON asserts that object can be marshaled to expected JSON string.
 func JSON(t Testing, actual any, expected string, messages ...string) bool {
 	t.Helper()