From 106b713cc59609104d519ec532c579051cbcb4df Mon Sep 17 00:00:00 2001 From: Ruidy Date: Fri, 14 Nov 2025 13:57:33 +0100 Subject: [PATCH] test: add comprehensive edge case tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds extensive edge case tests for core functions to catch regressions and ensure robust behavior. Test coverage added: - Empty slice tests: Filter, Map, Partition, Reduce, Unique, Last - Single element tests: Filter, Map, Partition, Reduce, Unique, Last - Large dataset tests: Filter (10k), Map (10k) - Boundary cases: Partition (all pass/reject), Unique (no dups/all same) Functions tested: - Filter: 4 new tests (empty, single, single no match, large) - Partition: 4 new tests (empty, single, all pass, all reject) - Last: 2 new tests (empty panic, single element) - Map: 3 new tests (empty, single, large) - Unique: 4 new tests (empty, single, no dups, all same) - Reduce: 2 new tests (empty, single) Results: - All 118 tests pass - Coverage: 98.4% (maintained high coverage) - Verified panic behavior for edge cases 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- filter_test.go | 24 ++++++++++++++++++++++++ last_test.go | 10 ++++++++++ map_test.go | 21 +++++++++++++++++++++ partition_test.go | 26 ++++++++++++++++++++++++++ reduce_test.go | 10 ++++++++++ unique_test.go | 22 ++++++++++++++++++++++ 6 files changed, 113 insertions(+) diff --git a/filter_test.go b/filter_test.go index a97d9f1..816bada 100644 --- a/filter_test.go +++ b/filter_test.go @@ -16,6 +16,30 @@ func TestFilter(t *testing.T) { assert.Equal(t, want, u.Filter(nums, isEven)) } +func TestFilterEmpty(t *testing.T) { + result := u.Filter([]int{}, func(n int) bool { return n > 0 }) + assert.Empty(t, result) +} + +func TestFilterSingleElement(t *testing.T) { + result := u.Filter([]int{5}, func(n int) bool { return n > 0 }) + assert.Equal(t, []int{5}, result) +} + +func TestFilterSingleElementNoMatch(t *testing.T) { + result := u.Filter([]int{5}, func(n int) bool { return n > 10 }) + assert.Empty(t, result) +} + +func TestFilterLarge(t *testing.T) { + large := make([]int, 10000) + for i := range large { + large[i] = i + } + result := u.Filter(large, func(n int) bool { return n%2 == 0 }) + assert.Equal(t, 5000, len(result)) +} + func BenchmarkFilter(b *testing.B) { data := make([]int, 1000) for i := range data { diff --git a/last_test.go b/last_test.go index a0ab085..81e6ed1 100644 --- a/last_test.go +++ b/last_test.go @@ -13,3 +13,13 @@ func TestLast(t *testing.T) { want := 5 assert.Equal(t, want, u.Last(nums)) } + +func TestLastEmpty(t *testing.T) { + assert.Panics(t, func() { + u.Last([]int{}) + }) +} + +func TestLastSingleElement(t *testing.T) { + assert.Equal(t, 42, u.Last([]int{42})) +} diff --git a/map_test.go b/map_test.go index e939357..3fda8de 100644 --- a/map_test.go +++ b/map_test.go @@ -16,3 +16,24 @@ func TestMap(t *testing.T) { want := []int{1, 4, 9} assert.Equal(t, want, u.Map(nums, f)) } + +func TestMapEmpty(t *testing.T) { + result := u.Map([]int{}, func(n int) int { return n * 2 }) + assert.Empty(t, result) +} + +func TestMapSingleElement(t *testing.T) { + result := u.Map([]int{5}, func(n int) int { return n * 2 }) + assert.Equal(t, []int{10}, result) +} + +func TestMapLarge(t *testing.T) { + large := make([]int, 10000) + for i := range large { + large[i] = i + } + result := u.Map(large, func(n int) int { return n * 2 }) + assert.Equal(t, 10000, len(result)) + assert.Equal(t, 0, result[0]) + assert.Equal(t, 19998, result[9999]) +} diff --git a/partition_test.go b/partition_test.go index 136e2c5..a27b8d5 100644 --- a/partition_test.go +++ b/partition_test.go @@ -20,3 +20,29 @@ func TestPartition(t *testing.T) { assert.Equal(t, wantEvens, evens) assert.Equal(t, wantOdds, odds) } + +func TestPartitionEmpty(t *testing.T) { + keep, reject := u.Partition([]int{}, func(n int) bool { return n > 0 }) + assert.Empty(t, keep) + assert.Empty(t, reject) +} + +func TestPartitionSingleElement(t *testing.T) { + keep, reject := u.Partition([]int{5}, func(n int) bool { return n > 3 }) + assert.Equal(t, []int{5}, keep) + assert.Empty(t, reject) +} + +func TestPartitionAllPass(t *testing.T) { + nums := []int{2, 4, 6, 8} + keep, reject := u.Partition(nums, func(n int) bool { return n%2 == 0 }) + assert.Equal(t, nums, keep) + assert.Empty(t, reject) +} + +func TestPartitionAllReject(t *testing.T) { + nums := []int{1, 3, 5, 7} + keep, reject := u.Partition(nums, func(n int) bool { return n%2 == 0 }) + assert.Empty(t, keep) + assert.Equal(t, nums, reject) +} diff --git a/reduce_test.go b/reduce_test.go index c45b8f7..dfd08d9 100644 --- a/reduce_test.go +++ b/reduce_test.go @@ -17,3 +17,13 @@ func TestReduce(t *testing.T) { assert.Equal(t, want, u.Reduce(nums, reducer, 0)) } + +func TestReduceEmpty(t *testing.T) { + result := u.Reduce([]int{}, func(n, acc int) int { return n + acc }, 10) + assert.Equal(t, 10, result) // Should return initial accumulator +} + +func TestReduceSingleElement(t *testing.T) { + result := u.Reduce([]int{5}, func(n, acc int) int { return n + acc }, 0) + assert.Equal(t, 5, result) +} diff --git a/unique_test.go b/unique_test.go index 03ff72b..b4d7aab 100644 --- a/unique_test.go +++ b/unique_test.go @@ -14,3 +14,25 @@ func TestUnique(t *testing.T) { assert.Equal(t, want, u.Unique(nums)) } + +func TestUniqueEmpty(t *testing.T) { + result := u.Unique([]int{}) + assert.Empty(t, result) +} + +func TestUniqueSingleElement(t *testing.T) { + result := u.Unique([]int{42}) + assert.Equal(t, []int{42}, result) +} + +func TestUniqueNoDuplicates(t *testing.T) { + nums := []int{1, 2, 3, 4, 5} + result := u.Unique(nums) + assert.Equal(t, nums, result) +} + +func TestUniqueAllSame(t *testing.T) { + nums := []int{5, 5, 5, 5, 5} + result := u.Unique(nums) + assert.Equal(t, []int{5}, result) +}