Merge pull request #122

Enhance test utilities with comprehensive helper functions

Author: karasz

AGENT.md

@@ -165,6 +165,67 @@ Always run `make tidy` before committing to ensure proper formatting.
 - Helper functions like `S[T]()` create test slices.
 - Comprehensive coverage for generic functions is expected.
 
+#### Test Helper Functions
+
+The project uses a comprehensive set of test helper functions defined in
+`testutils_test.go` to reduce boilerplate and improve test consistency:
+
+**Slice Creation:**
+
+- `S[T](values...)` - Creates test slices concisely: `S(1, 2, 3)` instead of
+  `[]int{1, 2, 3}`
+- `S[T]()` - Creates empty slices: `S[string]()` instead of `[]string{}`
+
+**Assertion Helpers:**
+
+- `AssertEqual[T](t, expected, actual, msg...)` - Generic value comparison with
+  better error messages
+- `AssertSliceEqual[T](t, expected, actual, msg...)` - Slice comparison using
+  `reflect.DeepEqual`
+- `AssertError(t, err, expectError, msg...)` - Standardized error expectation
+  checking
+- `AssertBool(t, actual, expected, msg...)` - Boolean assertions with context
+- `AssertPanic(t, fn, expectedPanic, msg...)` - Simplified panic testing
+- `AssertNoPanic(t, fn, msg...)` - Ensure functions don't panic
+
+**Advanced Helpers:**
+
+- `RunConcurrentTest(t, numWorkers, workerFn)` - Concurrent testing with
+  goroutines
+- `RunBenchmark(b, setupFn, execFn)` - Benchmark testing with setup/execution
+  phases
+- `RunTestCases(t, []TestCase)` - Table-driven test runner (requires
+  `TestCase` interface)
+
+**Usage Examples:**
+
+```go
+// Before: Manual assertions
+if !reflect.DeepEqual(got, expected) {
+    t.Errorf("Expected %v, got %v", expected, got)
+}
+
+// After: Helper function
+AssertSliceEqual(t, expected, got, "operation failed")
+
+// Before: Manual error checking
+if expectError && err == nil {
+    t.Error("Expected error but got nil")
+} else if !expectError && err != nil {
+    t.Errorf("Expected no error but got: %v", err)
+}
+
+// After: Helper function
+AssertError(t, err, expectError, "operation error expectation")
+```
+
+These helpers provide:
+
+- Consistent error messages across all tests
+- Reduced boilerplate code
+- Better test maintainability
+- Clearer test intent
+
 ## Important Notes
 
 - Go 1.23 is the minimum required version.
@@ -286,18 +347,18 @@ go run "$FA@latest" -fix ./...
 
 This tool will:
 
-- Analyze all struct definitions in the project
-- Reorder fields to minimize memory padding
-- Automatically update source files with optimized field ordering
+- Analyze all struct definitions in the project.
+- Reorder fields to minimize memory padding.
+- Automatically update source files with optimized field ordering.
 
 #### Field Alignment Notes
 
 - Always run `make tidy` after field alignment fixes to ensure all linting
-  passes
-- Field alignment changes may require updating struct literal initializations
-- The tool is safe to run repeatedly - it only makes changes when beneficial
-- Memory savings can be significant for frequently allocated structs
-- Run field alignment manually as needed for struct optimization
+  passes.
+- Field alignment changes may require updating struct literal initializations.
+- The tool is safe to run repeatedly - it only makes changes when beneficial.
+- Memory savings can be significant for frequently allocated structs.
+- Run field alignment manually as needed for struct optimization.
 
 ### golangci-lint Configuration
 
@@ -343,17 +404,18 @@ linters-settings:
 
 Common IDE diagnostics and their meanings:
 
-1. **Missing property "version"**: IDE schema expects `version: "2"`
-2. **Property linters-settings is not allowed**: IDE expects v2 structure
+1. **Missing property "version"**: IDE schema expects `version: "2"`.
+2. **Property linters-settings is not allowed**: IDE expects v2 structure.
 3. **cSpell warnings**: Linter names are technical terms not in spell-check
-   dictionary
+   dictionary.
 
 #### Resolution Status
 
-- **Current priority**: Low - configuration works functionally
-- **IDE warnings**: Cannot be resolved without upgrading golangci-lint to v2
-- **System constraint**: Project uses v1.64.8 to avoid v2 configuration issues
-- **Workaround**: IDE warnings can be ignored as they don't affect functionality
+- **Current priority**: Low - configuration works functionally.
+- **IDE warnings**: Cannot be resolved without upgrading golangci-lint to v2.
+- **System constraint**: Project uses v1.64.8 to avoid v2 configuration issues.
+- **Workaround**: IDE warnings can be ignored as they don't affect
+  functionality.
 
 #### Field Alignment Integration
 

addrport_test.go

@@ -225,13 +225,13 @@ var typeSpecificAddrPortTestCases = []typeSpecificAddrPortTestCase{
 	},
 	{
 		name:   "TCPAddr with invalid IP",
-		input:  &net.TCPAddr{IP: []byte{1, 2, 3}, Port: 80}, // Invalid IP length
+		input:  &net.TCPAddr{IP: S[byte](1, 2, 3), Port: 80}, // Invalid IP length
 		want:   netip.AddrPort{},
 		wantOk: false,
 	},
 	{
 		name:   "UDPAddr with invalid IP",
-		input:  &net.UDPAddr{IP: []byte{}, Port: 80}, // Empty IP
+		input:  &net.UDPAddr{IP: S[byte](), Port: 80}, // Empty IP
 		want:   netip.AddrPort{},
 		wantOk: false,
 	},

addrs_test.go

@@ -9,10 +9,10 @@ import (
 
 // Test cases for ParseAddr
 type parseAddrTestCase struct {
-	// netip.Addr struct (24 bytes) - result value
+	// netip.Addr struct - result value
 	want netip.Addr
 
-	// String fields (16 bytes each) - alphabetically ordered
+	// String fields - alphabetically ordered
 	input string
 	name  string
 
@@ -180,13 +180,13 @@ func TestParseNetIP(t *testing.T) {
 
 // Test cases for AddrFromNetIP
 type addrFromNetIPTestCase struct {
-	// netip.Addr struct (24 bytes) - result value
+	// netip.Addr struct - result value
 	want netip.Addr
 
-	// Interface field (16 bytes) - input value
+	// Interface field - input value
 	input net.Addr
 
-	// String field (16 bytes) - test name
+	// String field - test name
 	name string
 
 	// Boolean field (1 byte) - success flag
@@ -324,7 +324,7 @@ func TestGetStringIPAddresses(t *testing.T) {
 
 func testLoopbackInterface(t *testing.T) {
 	// Most systems have a loopback interface
-	loopbackNames := []string{"lo", "lo0", "Loopback Pseudo-Interface 1"}
+	loopbackNames := S("lo", "lo0", "Loopback Pseudo-Interface 1")
 
 	var found bool
 	for _, name := range loopbackNames {
@@ -430,15 +430,15 @@ var getInterfacesNamesTestCases = []getInterfacesNamesTestCase{
 	},
 	{
 		name:   "empty exclusions",
-		except: []string{},
+		except: S[string](),
 	},
 	{
 		name:   "exclude invalid",
-		except: []string{"invalid-interface"},
+		except: S("invalid-interface"),
 	},
 	{
 		name:   "exclude multiple",
-		except: []string{"eth0", "eth1", "lo"},
+		except: S("eth0", "eth1", "lo"),
 	},
 }
 
@@ -513,28 +513,28 @@ func TestGetInterfacesNames(t *testing.T) {
 
 // Test internal helper functions
 func TestAsStringIPAddresses(t *testing.T) {
-	addrs := []netip.Addr{
+	addrs := S[netip.Addr](
 		netip.MustParseAddr("192.168.1.1"),
 		netip.MustParseAddr("2001:db8::1"),
-		{}, // Invalid address
+		netip.Addr{}, // Invalid address
 		netip.MustParseAddr("10.0.0.1"),
-	}
+	)
 
 	result := asStringIPAddresses(addrs...)
-	expected := []string{"192.168.1.1", "2001:db8::1", "10.0.0.1"}
+	expected := S("192.168.1.1", "2001:db8::1", "10.0.0.1")
 
 	if !reflect.DeepEqual(result, expected) {
 		t.Errorf("Expected %v, got %v", expected, result)
 	}
 }
 
 func TestAsNetIPAddresses(t *testing.T) {
-	addrs := []netip.Addr{
+	addrs := S[netip.Addr](
 		netip.MustParseAddr("192.168.1.1"),
 		netip.MustParseAddr("2001:db8::1"),
-		{}, // Invalid address
+		netip.Addr{},                              // Invalid address
 		netip.MustParseAddr("::ffff:192.168.1.2"), // IPv4-mapped IPv6
-	}
+	)
 
 	result := asNetIPAddresses(addrs...)
 
@@ -582,12 +582,12 @@ func TestAsNetIP(t *testing.T) {
 func TestAppendNetIPAsIP(t *testing.T) {
 	var out []netip.Addr
 
-	addrs := []net.Addr{
+	addrs := S[net.Addr](
 		&net.IPAddr{IP: net.ParseIP("192.168.1.1")},
 		&net.IPNet{IP: net.ParseIP("10.0.0.0"), Mask: net.CIDRMask(24, 32)},
 		&net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8080}, // Should be skipped
 		&net.IPAddr{IP: nil}, // Should be skipped
-	}
+	)
 
 	result := appendNetIPAsIP(out, addrs...)
 

as_test.go

@@ -8,11 +8,11 @@ import (
 
 // asTestCase tests As function
 type asTestCase struct {
-	// Interface fields (16 bytes each) - input/output test data
+	// Interface fields - input/output test data
 	input any
 	want  any
 
-	// String fields (16 bytes) - test identification
+	// String fields - test identification
 	name string
 
 	// Boolean fields (1 byte) - expected result flags
@@ -151,10 +151,10 @@ func (e errorWithOK) OK() bool {
 
 // asErrorTestCase tests AsError function
 type asErrorTestCase struct {
-	// Interface fields (16 bytes) - input test data
+	// Interface fields - input test data
 	input any
 
-	// String fields (16 bytes) - test identification and expected message
+	// String fields - test identification and expected message
 	name    string
 	wantMsg string
 
@@ -292,12 +292,12 @@ func TestSliceAs(t *testing.T) {
 		{
 			name:  "mixed types to string",
 			input: S[any]("hello", 42, "world", 3.14, "!"),
-			want:  []string{"hello", "world", "!"},
+			want:  S("hello", "world", "!"),
 		},
 		{
 			name:  "all strings",
 			input: S[any]("a", "b", "c"),
-			want:  []string{"a", "b", "c"},
+			want:  S("a", "b", "c"),
 		},
 		{
 			name:  "no strings",
@@ -317,7 +317,7 @@ func TestSliceAs(t *testing.T) {
 		{
 			name:  "with nil values",
 			input: S[any]("hello", nil, "world"),
-			want:  []string{"hello", "world"},
+			want:  S("hello", "world"),
 		},
 	}
 
@@ -340,7 +340,7 @@ func TestSliceAsFn(t *testing.T) {
 			name:  "with custom conversion",
 			fn:    prefixString,
 			input: S[any]("a", 1, "b", 2, "c"),
-			want:  []string{"prefix:a", "prefix:b", "prefix:c"},
+			want:  S("prefix:a", "prefix:b", "prefix:c"),
 		},
 		{
 			name:  "with nil function",
@@ -443,7 +443,7 @@ func TestAsErrors(t *testing.T) {
 				nil,
 			),
 			wantLen:  3,
-			wantMsgs: []string{"error1", "error2", "error3"},
+			wantMsgs: S("error1", "error2", "error3"),
 		},
 		{
 			name: "all errors",
@@ -453,25 +453,25 @@ func TestAsErrors(t *testing.T) {
 				errors.New("c"),
 			),
 			wantLen:  3,
-			wantMsgs: []string{"a", "b", "c"},
+			wantMsgs: S("a", "b", "c"),
 		},
 		{
 			name:     "no errors",
 			input:    S[any]("a", 1, true, nil),
 			wantLen:  0,
-			wantMsgs: nil,
+			wantMsgs: S[string](),
 		},
 		{
 			name:     "empty slice",
 			input:    S[any](),
 			wantLen:  0,
-			wantMsgs: nil,
+			wantMsgs: S[string](),
 		},
 		{
 			name:     "nil slice",
 			input:    nil,
 			wantLen:  0,
-			wantMsgs: nil,
+			wantMsgs: S[string](),
 		},
 		{
 			name: "with OK interface",
@@ -481,7 +481,7 @@ func TestAsErrors(t *testing.T) {
 				errorWithOK{msg: "fail2", ok: false},
 			),
 			wantLen:  2,
-			wantMsgs: []string{"fail", "fail2"},
+			wantMsgs: S("fail", "fail2"),
 		},
 	}