test: improve unit tests assertions (#29)

Author: reugn

concurrent_map_test.go

@@ -44,7 +44,7 @@ func TestContainsKey(t *testing.T) {
 func TestGet(t *testing.T) {
 	m := prepareConcurrentMap()
 	assert.Equal(t, m.Get(1), util.Ptr("a"))
-	assert.Equal(t, m.Get(4), nil)
+	assert.IsNil(t, m.Get(4))
 }
 
 func TestGetOrDefault(t *testing.T) {
@@ -82,7 +82,7 @@ func TestRemove(t *testing.T) {
 	m := prepareConcurrentMap()
 	assert.Equal(t, m.Remove(3), util.Ptr("c"))
 	assert.Equal(t, m.Size(), 2)
-	assert.Equal(t, m.Remove(5), nil)
+	assert.IsNil(t, m.Remove(5))
 	assert.Equal(t, m.Size(), 2)
 }
 

future_test.go

@@ -21,7 +21,7 @@ func TestFuture(t *testing.T) {
 	res, err := p.Future().Join()
 
 	assert.Equal(t, true, *res)
-	assert.Equal(t, nil, err)
+	assert.IsNil(t, err)
 }
 
 func TestFutureUtils(t *testing.T) {
@@ -57,10 +57,8 @@ func TestFutureFirstCompleted(t *testing.T) {
 	timeout := FutureTimer[bool](10 * time.Millisecond)
 	futRes, futErr := FutureFirstCompletedOf(p.Future(), timeout).Join()
 
-	assert.Equal(t, nil, futRes)
-	if futErr == nil {
-		t.Fatalf("futErr is nil")
-	}
+	assert.IsNil(t, futRes)
+	assert.NotEqual(t, futErr, nil)
 }
 
 func TestFutureTransform(t *testing.T) {
@@ -113,7 +111,7 @@ func TestFutureRecover(t *testing.T) {
 
 	res, err := future.Join()
 	assert.Equal(t, 2, *res)
-	assert.Equal(t, nil, err)
+	assert.IsNil(t, err)
 }
 
 func TestFutureFailure(t *testing.T) {

goroutine_test.go

@@ -9,7 +9,7 @@ import (
 func TestGoroutineID(t *testing.T) {
 	gid, err := GoroutineID()
 
-	assert.Equal(t, nil, err)
+	assert.IsNil(t, err)
 	t.Log(gid)
 }
 

internal/assert/assertions.go

@@ -1,6 +1,7 @@
 package assert
 
 import (
+	"fmt"
 	"reflect"
 	"strings"
 	"testing"
@@ -9,12 +10,45 @@ import (
 // Equal verifies equality of two objects.
 func Equal[T any](t *testing.T, a, b T) {
 	if !reflect.DeepEqual(a, b) {
+		t.Helper()
 		t.Fatalf("%v != %v", a, b)
 	}
 }
 
+// NotEqual asserts that the given objects are not equal.
+func NotEqual[T any](t *testing.T, a, b T) {
+	if reflect.DeepEqual(a, b) {
+		t.Helper()
+		t.Fatalf("%v == %v", a, b)
+	}
+}
+
+// Same asserts that the given pointers point to the same object.
+func Same[T any](t *testing.T, a, b *T) {
+	if a != b {
+		t.Helper()
+		t.Fatalf("%p != %p", a, b)
+	}
+}
+
+// IsNil verifies that the object is nil.
+func IsNil(t *testing.T, obj any) {
+	if obj != nil {
+		value := reflect.ValueOf(obj)
+		switch value.Kind() {
+		case reflect.Ptr, reflect.Map, reflect.Slice,
+			reflect.Interface, reflect.Func, reflect.Chan:
+			if value.IsNil() {
+				return
+			}
+		}
+		t.Helper()
+		t.Fatalf("%v is not nil", obj)
+	}
+}
+
 // ElementsMatch checks whether the given slices contain the same elements.
-func ElementsMatch[T any](t *testing.T, a, b []T) {
+func ElementsMatch[S ~[]E, E any](t *testing.T, a, b S) {
 	if len(a) == len(b) {
 		count := 0
 		for _, va := range a {
@@ -29,23 +63,45 @@ func ElementsMatch[T any](t *testing.T, a, b []T) {
 			return
 		}
 	}
+	t.Helper()
 	t.Fatalf("Slice elements are not equal: %v != %v", a, b)
 }
 
 // ErrorContains checks whether the given error contains the specified string.
 func ErrorContains(t *testing.T, err error, str string) {
 	if err == nil {
+		t.Helper()
 		t.Fatalf("Error is nil")
 	} else if !strings.Contains(err.Error(), str) {
-		t.Fatalf("Error doen't contain string: %s", str)
+		t.Helper()
+		t.Fatalf("Error does not contain string: %s", str)
 	}
 }
 
-// Panic checks whether the given function panics.
-func Panic(t *testing.T, f func()) {
+// Panics checks whether the given function panics.
+func Panics(t *testing.T, f func()) {
 	defer func() {
 		if r := recover(); r == nil {
-			t.Errorf("The function did not panic")
+			t.Helper()
+			t.Errorf("Function did not panic")
+		}
+	}()
+	f()
+}
+
+// PanicMsgContains checks whether a function panics with a message containing
+// the given string.
+func PanicMsgContains(t *testing.T, f func(), str string) {
+	defer func() {
+		if r := recover(); r != nil {
+			panicMessage := fmt.Sprintf("%v", r)
+			if !strings.Contains(panicMessage, str) {
+				t.Helper()
+				t.Errorf("Panic message does not contain: %s", str)
+			}
+		} else {
+			t.Helper()
+			t.Errorf("Function did not panic")
 		}
 	}()
 	f()

task_test.go

@@ -17,7 +17,7 @@ func TestTaskSuccess(t *testing.T) {
 	res, err := task.Call().Join()
 
 	assert.Equal(t, "ok", *res)
-	assert.Equal(t, nil, err)
+	assert.IsNil(t, err)
 }
 
 func TestTaskFailure(t *testing.T) {
@@ -27,6 +27,6 @@ func TestTaskFailure(t *testing.T) {
 	})
 	res, err := task.Call().Join()
 
-	assert.Equal(t, nil, res)
+	assert.IsNil(t, res)
 	assert.ErrorContains(t, err, "error")
 }

value_test.go

@@ -12,15 +12,15 @@ func TestValueCompareAndSwap(t *testing.T) {
 	var value Value
 	swapped := value.CompareAndSwap(1, 2)
 	assert.Equal(t, swapped, false)
-	assert.Equal(t, value.Load(), nil)
+	assert.IsNil(t, value.Load())
 
 	swapped = value.CompareAndSwap(1, nil)
 	assert.Equal(t, swapped, false)
-	assert.Equal(t, value.Load(), nil)
+	assert.IsNil(t, value.Load())
 
 	swapped = value.CompareAndSwap(nil, 1)
 	assert.Equal(t, swapped, false)
-	assert.Equal(t, value.Load(), nil)
+	assert.IsNil(t, value.Load())
 
 	value.Store(1)
 
@@ -51,15 +51,11 @@ func TestValueCompareAndSwap(t *testing.T) {
 	stringPointer := util.Ptr("b")
 	swapped = value.CompareAndSwap("a", stringPointer)
 	assert.Equal(t, swapped, true)
-	if value.Load() != stringPointer {
-		t.Fail()
-	}
+	assert.Same(t, value.Load().(*string), stringPointer)
 
 	swapped = value.CompareAndSwap(util.Ptr("b"), "c")
 	assert.Equal(t, swapped, false)
-	if value.Load() != stringPointer {
-		t.Fail()
-	}
+	assert.Same(t, value.Load().(*string), stringPointer)
 
 	swapped = value.CompareAndSwap(stringPointer, "c")
 	assert.Equal(t, swapped, true)
@@ -68,7 +64,7 @@ func TestValueCompareAndSwap(t *testing.T) {
 
 func TestValueLoad(t *testing.T) {
 	var value Value
-	assert.Equal(t, value.Load(), nil)
+	assert.IsNil(t, value.Load())
 
 	value.Store(1)
 	assert.Equal(t, value.Load(), 1)
@@ -79,32 +75,28 @@ func TestValueStore(t *testing.T) {
 	value.Store(1)
 	assert.Equal(t, value.Load(), 1)
 
-	assert.Panic(t, func() { value.Store(nil) })
+	assert.Panics(t, func() { value.Store(nil) })
 
 	value.Store("a")
 	assert.Equal(t, value.Load(), "a")
 
 	stringPointer := util.Ptr("b")
 	value.Store(stringPointer)
-	if value.Load() != stringPointer {
-		t.Fail()
-	}
+	assert.Same(t, value.Load().(*string), stringPointer)
 }
 
 func TestValueSwap(t *testing.T) {
 	var value Value
 	old := value.Swap(1)
-	assert.Equal(t, old, nil)
+	assert.IsNil(t, old)
 
-	assert.Panic(t, func() { _ = value.Swap(nil) })
+	assert.Panics(t, func() { _ = value.Swap(nil) })
 
 	old = value.Swap("a")
 	assert.Equal(t, old, 1)
 
 	stringPointer := util.Ptr("b")
 	old = value.Swap(stringPointer)
 	assert.Equal(t, old, "a")
-	if value.Load() != stringPointer {
-		t.Fail()
-	}
+	assert.Same(t, value.Load().(*string), stringPointer)
 }

wait_group_context_test.go

@@ -72,7 +72,7 @@ func TestWaitGroupContextPanicNegativeCounter(t *testing.T) {
 		wgc := NewWaitGroupContext(context.Background())
 		wgc.Add(-2)
 	}
-	assert.Panic(t, negativeCounter)
+	assert.PanicMsgContains(t, negativeCounter, "negative")
 }
 
 func TestWaitGroupContextPanicReused(t *testing.T) {
@@ -91,7 +91,7 @@ func TestWaitGroupContextPanicReused(t *testing.T) {
 			wgc.Wait()
 		}
 	}
-	assert.Panic(t, reusedBeforeWaitReturned)
+	assert.PanicMsgContains(t, reusedBeforeWaitReturned, "reused")
 }
 
 func TestWaitGroupContextReused(t *testing.T) {