[🤖] Add Unit-Tests

tst/assertions_test.go

@@ -0,0 +1,240 @@
+package tst
+
+import (
+	"testing"
+)
+
+// These tests exercise the success-paths of each assertion: i.e. the cases
+// where the assertion should NOT mark the test as failed. They verify the
+// boolean/conditional logic of each function. We avoid testing the failure
+// branches because the assertions take a concrete *testing.T (not an
+// interface), so substituting a mock would require unsafe/reflection tricks
+// that are brittle and cascade failures to the parent test.
+
+// --- AssertEqual ----------------------------------------------------------
+
+func TestAssertEqual_Int(t *testing.T) {
+	AssertEqual(t, 42, 42)
+	AssertEqual(t, -1, -1)
+	AssertEqual(t, 0, 0)
+}
+
+func TestAssertEqual_String(t *testing.T) {
+	AssertEqual(t, "hello", "hello")
+	AssertEqual(t, "", "")
+}
+
+func TestAssertEqual_Bool(t *testing.T) {
+	AssertEqual(t, true, true)
+	AssertEqual(t, false, false)
+}
+
+func TestAssertEqual_Float(t *testing.T) {
+	AssertEqual(t, 3.14, 3.14)
+}
+
+// --- AssertArrayEqual -----------------------------------------------------
+
+func TestAssertArrayEqual_Empty(t *testing.T) {
+	AssertArrayEqual(t, []int{}, []int{})
+}
+
+func TestAssertArrayEqual_Equal(t *testing.T) {
+	AssertArrayEqual(t, []int{1, 2, 3}, []int{1, 2, 3})
+	AssertArrayEqual(t, []string{"a", "b"}, []string{"a", "b"})
+}
+
+func TestAssertArrayEqual_SingleElement(t *testing.T) {
+	AssertArrayEqual(t, []int{7}, []int{7})
+}
+
+// --- AssertNotEqual -------------------------------------------------------
+
+func TestAssertNotEqual_Int(t *testing.T) {
+	AssertNotEqual(t, 1, 2)
+	AssertNotEqual(t, 0, -1)
+}
+
+func TestAssertNotEqual_String(t *testing.T) {
+	AssertNotEqual(t, "foo", "bar")
+	AssertNotEqual(t, "", "x")
+}
+
+func TestAssertNotEqual_Bool(t *testing.T) {
+	AssertNotEqual(t, true, false)
+}
+
+// --- AssertDeepEqual ------------------------------------------------------
+
+func TestAssertDeepEqual_Struct(t *testing.T) {
+	type s struct {
+		A int
+		B string
+	}
+	AssertDeepEqual(t, s{A: 1, B: "x"}, s{A: 1, B: "x"})
+}
+
+func TestAssertDeepEqual_Slice(t *testing.T) {
+	AssertDeepEqual(t, []int{1, 2, 3}, []int{1, 2, 3})
+}
+
+func TestAssertDeepEqual_Map(t *testing.T) {
+	AssertDeepEqual(t, map[string]int{"a": 1, "b": 2}, map[string]int{"a": 1, "b": 2})
+}
+
+func TestAssertDeepEqual_NilSlice(t *testing.T) {
+	var a, b []int
+	AssertDeepEqual(t, a, b)
+}
+
+func TestAssertDeepEqual_NestedStruct(t *testing.T) {
+	type inner struct{ X int }
+	type outer struct {
+		I inner
+		S []string
+	}
+	a := outer{I: inner{X: 1}, S: []string{"a", "b"}}
+	b := outer{I: inner{X: 1}, S: []string{"a", "b"}}
+	AssertDeepEqual(t, a, b)
+}
+
+// --- AssertSetDeepEqual ---------------------------------------------------
+
+func TestAssertSetDeepEqual_Empty(t *testing.T) {
+	AssertSetDeepEqual(t, []int{}, []int{})
+}
+
+func TestAssertSetDeepEqual_SameOrder(t *testing.T) {
+	AssertSetDeepEqual(t, []int{1, 2, 3}, []int{1, 2, 3})
+}
+
+func TestAssertSetDeepEqual_DifferentOrder(t *testing.T) {
+	AssertSetDeepEqual(t, []int{3, 1, 2}, []int{1, 2, 3})
+}
+
+func TestAssertSetDeepEqual_Strings(t *testing.T) {
+	AssertSetDeepEqual(t, []string{"b", "a", "c"}, []string{"a", "b", "c"})
+}
+
+func TestAssertSetDeepEqual_Structs(t *testing.T) {
+	type s struct{ V int }
+	AssertSetDeepEqual(t, []s{{V: 2}, {V: 1}}, []s{{V: 1}, {V: 2}})
+}
+
+// --- AssertNotDeepEqual ---------------------------------------------------
+
+func TestAssertNotDeepEqual_Struct(t *testing.T) {
+	type s struct {
+		A int
+	}
+	AssertNotDeepEqual(t, s{A: 1}, s{A: 2})
+}
+
+func TestAssertNotDeepEqual_Slice(t *testing.T) {
+	AssertNotDeepEqual(t, []int{1, 2}, []int{1, 2, 3})
+}
+
+func TestAssertNotDeepEqual_Map(t *testing.T) {
+	AssertNotDeepEqual(t, map[string]int{"a": 1}, map[string]int{"b": 1})
+}
+
+// --- AssertDeRefEqual -----------------------------------------------------
+
+func TestAssertDeRefEqual_Int(t *testing.T) {
+	v := 42
+	AssertDeRefEqual(t, &v, 42)
+}
+
+func TestAssertDeRefEqual_String(t *testing.T) {
+	v := "hello"
+	AssertDeRefEqual(t, &v, "hello")
+}
+
+func TestAssertDeRefEqual_Bool(t *testing.T) {
+	v := true
+	AssertDeRefEqual(t, &v, true)
+}
+
+// --- AssertPtrEqual -------------------------------------------------------
+
+func TestAssertPtrEqual_BothNil(t *testing.T) {
+	var a, b *int
+	AssertPtrEqual(t, a, b)
+}
+
+func TestAssertPtrEqual_SameValue(t *testing.T) {
+	a, b := 5, 5
+	AssertPtrEqual(t, &a, &b)
+}
+
+func TestAssertPtrEqual_DifferentPointersSameValue(t *testing.T) {
+	a, b := "hi", "hi"
+	AssertPtrEqual(t, &a, &b)
+}
+
+func TestAssertPtrEqual_SamePointer(t *testing.T) {
+	a := 99
+	AssertPtrEqual(t, &a, &a)
+}
+
+// --- AssertHexEqual -------------------------------------------------------
+
+func TestAssertHexEqual_Empty(t *testing.T) {
+	AssertHexEqual(t, "", []byte{})
+}
+
+func TestAssertHexEqual_Bytes(t *testing.T) {
+	AssertHexEqual(t, "deadbeef", []byte{0xde, 0xad, 0xbe, 0xef})
+}
+
+func TestAssertHexEqual_SingleByte(t *testing.T) {
+	AssertHexEqual(t, "ff", []byte{0xff})
+}
+
+func TestAssertHexEqual_AllZero(t *testing.T) {
+	AssertHexEqual(t, "0000", []byte{0x00, 0x00})
+}
+
+// --- AssertTrue / AssertFalse ---------------------------------------------
+
+func TestAssertTrue(t *testing.T) {
+	AssertTrue(t, true)
+}
+
+func TestAssertFalse(t *testing.T) {
+	AssertFalse(t, false)
+}
+
+// --- AssertNoErr ----------------------------------------------------------
+
+func TestAssertNoErr_Nil(t *testing.T) {
+	AssertNoErr(t, nil)
+}
+
+// --- AssertStrRepEqual ----------------------------------------------------
+
+func TestAssertStrRepEqual_Same(t *testing.T) {
+	AssertStrRepEqual(t, 42, 42)
+	AssertStrRepEqual(t, "abc", "abc")
+}
+
+func TestAssertStrRepEqual_DifferentTypesSameRep(t *testing.T) {
+	// 42 and "42" both stringify to "42" via %v
+	AssertStrRepEqual(t, 42, "42")
+}
+
+func TestAssertStrRepEqual_Bool(t *testing.T) {
+	AssertStrRepEqual(t, true, true)
+}
+
+// --- AssertStrRepNotEqual -------------------------------------------------
+
+func TestAssertStrRepNotEqual_Different(t *testing.T) {
+	AssertStrRepNotEqual(t, 42, 43)
+	AssertStrRepNotEqual(t, "abc", "xyz")
+}
+
+func TestAssertStrRepNotEqual_BoolVsInt(t *testing.T) {
+	// "true" != "1"
+	AssertStrRepNotEqual(t, true, 1)
+}