New assert methods

Author: tomas-novotny

CHANGELOG.md

@@ -6,8 +6,24 @@ 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/v0.1.0...master)
+## [Unreleased](https://github.com/gravitton/assert/compare/v1.0.0...master)
 
 
-## v0.1.0 (2025-08-03)
+## v1.0.0 (2025-08-05)
 ### Added
+- Added new assert methods
+  - `True`
+  - `False`
+  - `Equal`
+  - `NotEqual`
+  - `Same`
+  - `NotSame`
+  - `Length`
+  - `Contains`
+  - `NotContains`
+  - `Error`
+  - `NoError`
+  - `ErrorIs`
+  - `NotErrorIs`
+  - `Fail`
+  - `Failf`

README.md

@@ -33,6 +33,8 @@ func TestSomething(t *testing.T) {
 	assert.Equal(t, 123, 123)
 	// assert inequality
 	assert.NotEqual(t, 123, 456)
+	// assert object contains element
+	assert.Contains(t, []int{1, 2, 3}, 2)
 }
 ```
 

assert.go

@@ -1,28 +1,22 @@
 package assert
 
 import (
-	"reflect"
+	"github.com/gravitton/assert/internal"
 )
 
 // Testing is an interface wrapper around *testing.T
 type Testing interface {
-	Errorf(format string, args ...any)
-}
-
-// helper is an interface wrapper around *testing.T
-type helper interface {
 	Helper()
+	Errorf(format string, args ...any)
 }
 
 // True asserts that the specified value is true.
 //
 //	assert.True(t, condition)
-func True(t Testing, actual bool) bool {
-	if h, ok := t.(helper); ok {
-		h.Helper()
-	}
+func True(t Testing, condition bool) bool {
+	t.Helper()
 
-	if !actual {
+	if !internal.Assert(condition) {
 		return Fail(t, "Should be true")
 	}
 
@@ -32,12 +26,10 @@ func True(t Testing, actual bool) bool {
 // False asserts that the specified value is false.
 //
 //	assert.False(t, condition)
-func False(t Testing, actual bool) bool {
-	if h, ok := t.(helper); ok {
-		h.Helper()
-	}
+func False(t Testing, condition bool) bool {
+	t.Helper()
 
-	if actual {
+	if internal.Assert(condition) {
 		return Fail(t, "Should be false")
 	}
 
@@ -51,12 +43,10 @@ func False(t Testing, actual bool) bool {
 // Pointer variable equality is determined based on the equality of the
 // referenced values (as opposed to the memory addresses).
 func Equal(t Testing, actual, expected any) bool {
-	if h, ok := t.(helper); ok {
-		h.Helper()
-	}
+	t.Helper()
 
-	if !equal(actual, expected) {
-		return Failf(t, "Should be equal: \nactual: %#v\n  expected: %#v", actual, expected)
+	if !internal.Equal(actual, expected) {
+		return Failf(t, "Should be equal:\n  object: %#v\nelement: %#v", actual, expected)
 	}
 
 	return true
@@ -69,38 +59,26 @@ func Equal(t Testing, actual, expected any) bool {
 // Pointer variable equality is determined based on the equality of the
 // referenced values (as opposed to the memory addresses).
 func NotEqual(t Testing, actual, expected any) bool {
-	if h, ok := t.(helper); ok {
-		h.Helper()
-	}
+	t.Helper()
 
-	if equal(actual, expected) {
-		return Failf(t, "Should not be equal: %#v", actual)
+	if internal.Equal(actual, expected) {
+		return Failf(t, "Should not be equal\n  object: %#v", actual)
 	}
 
 	return true
 }
 
-func equal(actual, expected any) bool {
-	if actual == nil || expected == nil {
-		return actual == expected
-	}
-
-	return reflect.DeepEqual(actual, expected)
-}
-
 // Same asserts that two pointers reference the same object.
 //
 //	assert.Same(t, actual, expected)
 //
 // Both arguments must be pointer variables. Pointer variable sameness is
 // determined based on the equality of both type and value.
 func Same(t Testing, actual, expected any) bool {
-	if h, ok := t.(helper); ok {
-		h.Helper()
-	}
+	t.Helper()
 
-	if !same(expected, actual) {
-		return Failf(t, "Should be same: \nactual: %[1]p %#[1]v\n  expected: %[2]p %#[2]v", actual, expected)
+	if !internal.Same(expected, actual) {
+		return Failf(t, "Should be same\n  object: %[1]p %#[1]v\nelement: %[2]p %#[2]v", actual, expected)
 	}
 
 	return true
@@ -113,37 +91,92 @@ func Same(t Testing, actual, expected any) bool {
 // Both arguments must be pointer variables. Pointer variable sameness is
 // determined based on the equality of both type and value.
 func NotSame(t Testing, actual, expected any) bool {
-	if h, ok := t.(helper); ok {
-		h.Helper()
+	t.Helper()
+
+	if internal.Same(expected, actual) {
+		return Failf(t, "Should not be same\n  object: %[1]p %#[1]v", actual)
+	}
+
+	return true
+}
+
+func Length(t Testing, object any, expected int) bool {
+	t.Helper()
+
+	if actual := internal.Length(object); actual != expected {
+		return Failf(t, "Should have element length\n  object: %#v\n  object: %d\nelement: %d", object, actual, expected)
+	}
+
+	return true
+}
+
+func Contains(t Testing, object, element any) bool {
+	t.Helper()
+
+	if found, ok := internal.Contains(object, element); !ok {
+		return Failf(t, "Should be iterable\n  object: %#v", object)
+	} else if !found {
+		return Failf(t, "Should contain element\n  object: %#v\n element: %#v", object, element)
 	}
 
-	if same(expected, actual) {
-		return Failf(t, "Should not be same: %[1]p %#[1]v", actual)
+	return true
+}
+
+func NotContains(t Testing, object any, element any) bool {
+	t.Helper()
+
+	if found, ok := internal.Contains(object, element); !ok {
+		return Failf(t, "Should be iterable\n  object: %#v", object)
+	} else if found {
+		return Failf(t, "Should not contain element\n  object: %#v\n element: %#v", object, element)
 	}
 
 	return true
 }
 
-func same(actual, expected any) bool {
-	actualPtr, expectedPtr := reflect.ValueOf(actual), reflect.ValueOf(expected)
-	if actualPtr.Kind() != reflect.Ptr || expectedPtr.Kind() != reflect.Ptr {
-		return false
+func Error(t Testing, err error) bool {
+	t.Helper()
+
+	if !internal.Error(err) {
+		return Failf(t, "Should be error")
 	}
 
-	actualType, expectedType := reflect.TypeOf(actual), reflect.TypeOf(expected)
-	if actualType != expectedType {
-		return false
+	return true
+}
+
+func NoError(t Testing, err error) bool {
+	t.Helper()
+
+	if internal.Error(err) {
+		return Failf(t, "Should not be error\n   error: %#v", err)
 	}
 
-	// compare pointer addresses
-	return actual == expected
+	return true
+}
+
+func ErrorIs(t Testing, err error, target error) bool {
+	t.Helper()
+
+	if !internal.ErrorIs(err, target) {
+		return Failf(t, "Should be same error\n   error: %#v\n  target: %#v", err, target)
+	}
+
+	return true
+}
+
+func NotErrorIs(t Testing, err error, target error) bool {
+	t.Helper()
+
+	if internal.ErrorIs(err, target) {
+		return Failf(t, "Should not be same error\n   error: %#v", err, target)
+	}
+
+	return true
 }
 
 // Fail reports a failure through
 func Fail(t Testing, message string) bool {
-	if h, ok := t.(helper); ok {
-		h.Helper()
-	}
+	t.Helper()
 
 	t.Errorf(message)
 
@@ -152,9 +185,7 @@ func Fail(t Testing, message string) bool {
 
 // Failf reports a failure through
 func Failf(t Testing, format string, args ...any) bool {
-	if h, ok := t.(helper); ok {
-		h.Helper()
-	}
+	t.Helper()
 
 	t.Errorf(format, args...)