v0

utils/slice_test.go

@@ -0,0 +1,120 @@
+package utils
+
+import "testing"
+
+type complexStruct struct {
+	field string
+	value int
+}
+
+func Test_IndexOf(t *testing.T) {
+	type expected struct {
+		idx       int
+		errIsNull bool
+	}
+	type example[T any] struct {
+		name     string
+		s        []T
+		searchFn func(T) bool
+		expected expected
+	}
+
+	strSlice := []string{"one", "two", "three"}
+	complexSlice := []complexStruct{
+		{field: "test", value: 12},
+		{field: "something", value: 333},
+		{field: "else", value: 3432},
+		{field: "foo", value: 2},
+	}
+
+	examples := []example[string]{
+		{
+			name:     "valid index in slice of strings",
+			s:        strSlice,
+			searchFn: func(s string) bool { return s == "three" },
+			expected: expected{idx: 2, errIsNull: true},
+		},
+		{
+			name:     "invalid index in slice of strings",
+			s:        strSlice,
+			searchFn: func(s string) bool { return s == "invalid" },
+			expected: expected{idx: -1, errIsNull: false},
+		},
+	}
+
+	cplxExamples := []example[complexStruct]{
+		{
+			name:     "valid index in slice of custom struct",
+			s:        complexSlice,
+			searchFn: func(el complexStruct) bool { return el.value == 333 },
+			expected: expected{idx: 1, errIsNull: true},
+		},
+		{
+			name:     "invalid index in slice of custom struct",
+			s:        complexSlice,
+			searchFn: func(el complexStruct) bool { return el.field == "invalid" },
+			expected: expected{idx: -1, errIsNull: false},
+		},
+	}
+
+	for _, ex := range examples {
+		idx, err := SliceIndexOf(ex.s, ex.searchFn)
+
+		if idx != ex.expected.idx {
+			t.Errorf("%s: expected index [%d] but got [%d]", ex.name, ex.expected.idx, idx)
+		}
+
+		errIsNull := err == nil
+		if errIsNull != ex.expected.errIsNull {
+			t.Errorf("%s: expected nil error [%t] but got [%t]", ex.name, ex.expected.errIsNull, errIsNull)
+		}
+	}
+
+	for _, ex := range cplxExamples {
+		idx, err := SliceIndexOf(ex.s, ex.searchFn)
+
+		if idx != ex.expected.idx {
+			t.Errorf("%s: expected index [%d] but got [%d]", ex.name, ex.expected.idx, idx)
+		}
+
+		errIsNull := err == nil
+		if errIsNull != ex.expected.errIsNull {
+			t.Errorf("%s: expected nil error [%t] but got [%t]", ex.name, ex.expected.errIsNull, errIsNull)
+		}
+	}
+}
+
+func Test_Contains(t *testing.T) {
+	type examples[T comparable] struct {
+		s        []T
+		values   []T
+		expected []bool
+	}
+
+	examples1 := examples[int]{
+		s:        []int{2, 3, 432, 123, 21},
+		values:   []int{432, 111},
+		expected: []bool{true, false},
+	}
+	examples2 := examples[string]{
+		s:        []string{"one", "two", "three"},
+		values:   []string{"invalid", "one"},
+		expected: []bool{false, true},
+	}
+
+	for i, v := range examples1.values {
+		expected := examples1.expected[i]
+
+		if SliceContains(examples1.s, v) != expected {
+			t.Errorf("Test_Contains - [%v] being in %+v should be %t", v, examples1.s, expected)
+		}
+	}
+
+	for i, v := range examples2.values {
+		expected := examples2.expected[i]
+
+		if SliceContains(examples2.s, v) != expected {
+			t.Errorf("Test_Contains - [%v] being in %+v should be %t", v, examples2.s, expected)
+		}
+	}
+}