diff --git a/internal/utils/slices.go b/internal/utils/slices.go
index 00e7cd6b..b226a803 100644
--- a/internal/utils/slices.go
+++ b/internal/utils/slices.go
@@ -2,6 +2,7 @@ package utils
 
 import "slices"
 
+// Flatten flattens a slice of slices into a single slice
 func Flatten[T any](sl ...[]T) []T {
 	var result []T
 	for _, slice := range sl {
@@ -11,6 +12,7 @@ func Flatten[T any](sl ...[]T) []T {
 	return result
 }
 
+// Map maps a slice of type T1 to a slice of type T2 using the given function
 func Map[T1, T2 any](slice []T1, f func(T1) T2) []T2 {
 	if slice == nil {
 		return nil
@@ -24,8 +26,16 @@ func Map[T1, T2 any](slice []T1, f func(T1) T2) []T2 {
 	return result
 }
 
+// Filter filters a slice of type T using the given predicate, returning a new slice with the elements that match the predicate
 func Filter[T any](slice []T, f func(T) bool) []T {
-	var result []T
+	if slice == nil {
+		return nil
+	}
+	if len(slice) == 0 {
+		return slice
+	}
+
+	result := make([]T, 0)
 	for _, e := range slice {
 		if f(e) {
 			result = append(result, e)
diff --git a/internal/utils/slices_test.go b/internal/utils/slices_test.go
new file mode 100644
index 00000000..68978a26
--- /dev/null
+++ b/internal/utils/slices_test.go
@@ -0,0 +1,207 @@
+package utils
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFlatten(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		input    [][]int
+		expected []int
+	}{
+		{
+			name:     "nil slice",
+			input:    nil,
+			expected: nil,
+		},
+		{
+			name:     "empty slices",
+			input:    [][]int{{}},
+			expected: nil,
+		},
+		{
+			name:     "single slice",
+			input:    [][]int{{1, 2, 3}},
+			expected: []int{1, 2, 3},
+		},
+		{
+			name:     "multiple slices",
+			input:    [][]int{{1, 2}, {3, 4}, {5}},
+			expected: []int{1, 2, 3, 4, 5},
+		},
+		{
+			name:     "mixed empty and non-empty slices",
+			input:    [][]int{{}, {1, 2}, {}, {3}, {}},
+			expected: []int{1, 2, 3},
+		},
+		{
+			name:     "all empty slices",
+			input:    [][]int{{}, {}, {}},
+			expected: nil,
+		},
+	}
+
+	for _, tc := range tests {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			result := Flatten(tc.input...)
+			assert.ElementsMatch(t, result, tc.expected)
+		})
+	}
+}
+
+func TestMap(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		input    []int
+		expected []string
+	}{
+		{
+			name:     "nil slice",
+			input:    nil,
+			expected: nil,
+		},
+		{
+			name:     "empty slice",
+			input:    []int{},
+			expected: []string{},
+		},
+		{
+			name:     "non-empty slice",
+			input:    []int{1, 2, 3},
+			expected: []string{"1", "2", "3"},
+		},
+		{
+			name:     "single element",
+			input:    []int{42},
+			expected: []string{"42"},
+		},
+	}
+
+	for _, tc := range tests {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			result := Map(tc.input, func(i int) string { return fmt.Sprintf("%d", i) })
+			assert.ElementsMatch(t, result, tc.expected)
+		})
+	}
+}
+
+func TestFilter(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		input    []int
+		expected []int
+	}{
+		{
+			name:     "nil slice",
+			input:    nil,
+			expected: nil,
+		},
+		{
+			name:     "empty slice",
+			input:    []int{},
+			expected: []int{},
+		},
+		{
+			name:     "filter even numbers",
+			input:    []int{1, 2, 3, 4, 5},
+			expected: []int{2, 4},
+		},
+		{
+			name:     "no matches",
+			input:    []int{1, 3, 5, 7, 9},
+			expected: []int{},
+		},
+		{
+			name:     "all matches",
+			input:    []int{2, 4, 6, 8, 10},
+			expected: []int{2, 4, 6, 8, 10},
+		},
+		{
+			name:     "single element match",
+			input:    []int{1, 2, 3},
+			expected: []int{2},
+		},
+	}
+
+	for _, tc := range tests {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			result := Filter(tc.input, func(i int) bool { return i%2 == 0 })
+			assert.ElementsMatch(t, result, tc.expected)
+		})
+	}
+}
+
+func TestAll(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		input    []int
+		pred     func(int) bool
+		expected bool
+	}{
+		{
+			name:     "nil slice",
+			input:    nil,
+			pred:     func(i int) bool { return true },
+			expected: true,
+		},
+		{
+			name:     "empty slice",
+			input:    []int{},
+			pred:     func(i int) bool { return true },
+			expected: true,
+		},
+		{
+			name:     "all even numbers",
+			input:    []int{2, 4, 6, 8, 10},
+			pred:     func(i int) bool { return i%2 == 0 },
+			expected: true,
+		},
+		{
+			name:     "mixed numbers",
+			input:    []int{2, 3, 4, 6, 8},
+			pred:     func(i int) bool { return i%2 == 0 },
+			expected: false,
+		},
+		{
+			name:     "all odd numbers",
+			input:    []int{1, 3, 5, 7, 9},
+			pred:     func(i int) bool { return i%2 == 1 },
+			expected: true,
+		},
+		{
+			name:     "single element true",
+			input:    []int{2},
+			pred:     func(i int) bool { return i%2 == 0 },
+			expected: true,
+		},
+		{
+			name:     "single element false",
+			input:    []int{1},
+			pred:     func(i int) bool { return i%2 == 0 },
+			expected: false,
+		},
+	}
+
+	for _, tc := range tests {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			result := All(tc.input, tc.pred)
+			assert.Equal(t, result, tc.expected)
+		})
+	}
+}