test: 100% test coverage.

Author: ghosind

equal_test.go

@@ -1,8 +1,9 @@
 package assert
 
 import (
-	"sync"
 	"testing"
+
+	"github.com/ghosind/go-assert/internal"
 )
 
 type testStruct struct {
@@ -34,43 +35,84 @@ func TestDeepEqualAndNotDeepEqual(t *testing.T) {
 }
 
 func testDeepEqualAndNotDeepEqual(t *testing.T, assertion *Assertion, v1, v2 any, isEqual bool) {
+	testDeepEqual(t, assertion, v1, v2, isEqual)
+
+	testNotDeepEqual(t, assertion, v1, v2, isEqual)
+
+	testDeepEqualNow(t, assertion, v1, v2, isEqual)
+
+	testNotDeepEqualNow(t, assertion, v1, v2, isEqual)
+}
+
+func testDeepEqual(t *testing.T, assertion *Assertion, v1, v2 any, isEqual bool) {
 	err := assertion.DeepEqual(v1, v2)
 	if isEqual && err != nil {
 		t.Errorf("Equal(%v, %v) = %v, want = nil", v1, v2, err)
 	} else if !isEqual && err == nil {
 		t.Errorf("Equal(%v, %v) = nil, want = error", v1, v2)
 	}
 
-	err = assertion.NotDeepEqual(v1, v2)
+	err = DeepEqual(assertion.T, v1, v2)
+	if isEqual && err != nil {
+		t.Errorf("Equal(%v, %v) = %v, want = nil", v1, v2, err)
+	} else if !isEqual && err == nil {
+		t.Errorf("Equal(%v, %v) = nil, want = error", v1, v2)
+	}
+}
+
+func testNotDeepEqual(t *testing.T, assertion *Assertion, v1, v2 any, isEqual bool) {
+	err := assertion.NotDeepEqual(v1, v2)
 	if isEqual && err == nil {
 		t.Errorf("NotEqual(%v, %v) = nil, want = error", v1, v2)
 	} else if !isEqual && err != nil {
 		t.Errorf("NotEqual(%v, %v) = %v, want = nil", v1, v2, err)
 	}
 
-	isTerminated := true
-	wg := sync.WaitGroup{}
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
+	err = NotDeepEqual(assertion.T, v1, v2)
+	if isEqual && err == nil {
+		t.Errorf("NotEqual(%v, %v) = nil, want = error", v1, v2)
+	} else if !isEqual && err != nil {
+		t.Errorf("NotEqual(%v, %v) = %v, want = nil", v1, v2, err)
+	}
+}
+
+func testDeepEqualNow(t *testing.T, assertion *Assertion, v1, v2 any, isEqual bool) {
+	isTerminated := internal.CheckTermination(func() {
 		assertion.DeepEqualNow(v1, v2)
-		isTerminated = false
-	}()
-	wg.Wait()
+	})
+	if isEqual && isTerminated {
+		t.Error("execution stopped, want do not stop")
+	} else if !isEqual && !isTerminated {
+		t.Error("execution do not stopped, want stop")
+	}
+
+	isTerminated = internal.CheckTermination(func() {
+		DeepEqualNow(assertion.T, v1, v2)
+	})
 	if isEqual && isTerminated {
 		t.Error("execution stopped, want do not stop")
+	} else if !isEqual && !isTerminated {
+		t.Error("execution do not stopped, want stop")
 	}
+}
 
-	isTerminated = true
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
+func testNotDeepEqualNow(t *testing.T, assertion *Assertion, v1, v2 any, isEqual bool) {
+	isTerminated := internal.CheckTermination(func() {
 		assertion.NotDeepEqualNow(v1, v2)
-		isTerminated = false
-	}()
-	wg.Wait()
+	})
+	if !isEqual && isTerminated {
+		t.Error("execution stopped, want do not stop")
+	} else if isEqual && !isTerminated {
+		t.Error("execution do not stopped, want stop")
+	}
+
+	isTerminated = internal.CheckTermination(func() {
+		NotDeepEqualNow(assertion.T, v1, v2)
+	})
 	if !isEqual && isTerminated {
 		t.Error("execution stopped, want do not stop")
+	} else if isEqual && !isTerminated {
+		t.Error("execution do not stopped, want stop")
 	}
 }
 
@@ -87,42 +129,83 @@ func TestNilAndNotNil(t *testing.T) {
 }
 
 func testNilAndNotNil(t *testing.T, assertion *Assertion, v any, isNil bool) {
+	testNil(t, assertion, v, isNil)
+
+	testNotNil(t, assertion, v, isNil)
+
+	testNilNow(t, assertion, v, isNil)
+
+	testNotNilNow(t, assertion, v, isNil)
+}
+
+func testNil(t *testing.T, assertion *Assertion, v any, isNil bool) {
 	err := assertion.Nil(v)
 	if isNil && err != nil {
 		t.Errorf("Nil(%v) = %v, want nil", v, err)
 	} else if !isNil && err == nil {
 		t.Errorf("Nil(%v) = nil, want error", v)
 	}
 
-	err = assertion.NotNil(v)
+	err = Nil(assertion.T, v)
+	if isNil && err != nil {
+		t.Errorf("Nil(%v) = %v, want nil", v, err)
+	} else if !isNil && err == nil {
+		t.Errorf("Nil(%v) = nil, want error", v)
+	}
+}
+
+func testNotNil(t *testing.T, assertion *Assertion, v any, isNil bool) {
+	err := assertion.NotNil(v)
+	if isNil && err == nil {
+		t.Errorf("Nil(%v) = nil, want error", v)
+	} else if !isNil && err != nil {
+		t.Errorf("Nil(%v) = %v, want nil", v, err)
+	}
+
+	err = NotNil(assertion.T, v)
 	if isNil && err == nil {
 		t.Errorf("Nil(%v) = nil, want error", v)
 	} else if !isNil && err != nil {
 		t.Errorf("Nil(%v) = %v, want nil", v, err)
 	}
+}
 
-	isTerminated := true
-	wg := sync.WaitGroup{}
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
+func testNilNow(t *testing.T, assertion *Assertion, v any, isNil bool) {
+	isTerminated := internal.CheckTermination(func() {
 		assertion.NilNow(v)
-		isTerminated = false
-	}()
-	wg.Wait()
+	})
+	if isNil && isTerminated {
+		t.Error("execution stopped, want do not stop")
+	} else if !isNil && !isTerminated {
+		t.Error("execution do not stopped, want stop")
+	}
+
+	isTerminated = internal.CheckTermination(func() {
+		NilNow(assertion.T, v)
+	})
 	if isNil && isTerminated {
 		t.Error("execution stopped, want do not stop")
+	} else if !isNil && !isTerminated {
+		t.Error("execution do not stopped, want stop")
 	}
+}
 
-	isTerminated = true
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
+func testNotNilNow(t *testing.T, assertion *Assertion, v any, isNil bool) {
+	isTerminated := internal.CheckTermination(func() {
 		assertion.NotNilNow(v)
-		isTerminated = false
-	}()
-	wg.Wait()
+	})
+	if !isNil && isTerminated {
+		t.Error("execution stopped, want do not stop")
+	} else if isNil && !isTerminated {
+		t.Error("execution do not stopped, want stop")
+	}
+
+	isTerminated = internal.CheckTermination(func() {
+		NotNilNow(assertion.T, v)
+	})
 	if !isNil && isTerminated {
 		t.Error("execution stopped, want do not stop")
+	} else if isNil && !isTerminated {
+		t.Error("execution do not stopped, want stop")
 	}
 }

internal/termination_test.go

@@ -0,0 +1,21 @@
+package internal
+
+import "testing"
+
+func TestCheckTermination(t *testing.T) {
+	mockT := new(testing.T)
+
+	isTerminated := CheckTermination(func() {
+		// no panic
+	})
+	if isTerminated {
+		t.Error("CheckTermination() = true, want = false")
+	}
+
+	isTerminated = CheckTermination(func() {
+		mockT.FailNow()
+	})
+	if !isTerminated {
+		t.Error("CheckTermination() = false, want = true")
+	}
+}

internal/termintion.go

@@ -0,0 +1,27 @@
+package internal
+
+import "sync"
+
+// CheckTermination runs the function `fn` with a goroutine, and tries to get the termination
+// status that the function terminates the execution by some panic.
+//
+// This function is for testing XXXNow assertions, and those functions will set `failed` status
+// and call `runtime.Goexit()` to stopping the execution of test.
+func CheckTermination(fn func()) bool {
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+
+	isTerminated := true
+
+	go func() {
+		defer wg.Done()
+
+		fn()
+
+		isTerminated = false
+	}()
+
+	wg.Wait()
+
+	return isTerminated
+}