make EqualStringSlice to generic EqualSliceValues (#2179)

just a fly-by refactoring

shared/utils/slices.go

@@ -31,3 +31,29 @@ func MergeSlices[T any](slices ...[]T) []T {
 	}
 	return result
 }
+
+// EqualSliceValues compare two slices if they have equal values independent of how they are sorted
+func EqualSliceValues[E comparable](s1, s2 []E) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+
+	m1 := sliceToCountMap(s1)
+	m2 := sliceToCountMap(s2)
+
+	for k, v := range m1 {
+		if m2[k] != v {
+			return false
+		}
+	}
+
+	return true
+}
+
+func sliceToCountMap[E comparable](list []E) map[E]int {
+	m := make(map[E]int)
+	for i := range list {
+		m[list[i]]++
+	}
+	return m
+}

shared/utils/slices_test.go

@@ -27,3 +27,34 @@ func TestMergeSlices(t *testing.T) {
 	resultIS := MergeSlices([]int{}, []int{1, 2}, []int{4}, nil)
 	assert.EqualValues(t, []int{1, 2, 4}, resultIS)
 }
+
+func TestEqualSliceValues(t *testing.T) {
+	tests := []struct {
+		in1 []string
+		in2 []string
+		out bool
+	}{{
+		in1: []string{"", "ab", "12", "ab"},
+		in2: []string{"12", "ab"},
+		out: false,
+	}, {
+		in1: nil,
+		in2: nil,
+		out: true,
+	}, {
+		in1: []string{"AA", "AA", "2", " "},
+		in2: []string{"2", "AA", " ", "AA"},
+		out: true,
+	}, {
+		in1: []string{"AA", "AA", "2", " "},
+		in2: []string{"2", "2", " ", "AA"},
+		out: false,
+	}}
+
+	for _, tc := range tests {
+		assert.EqualValues(t, tc.out, EqualSliceValues(tc.in1, tc.in2), "could not correctly process input: '%#v', %#v", tc.in1, tc.in2)
+	}
+
+	assert.True(t, EqualSliceValues([]bool{true, false, false}, []bool{false, false, true}))
+	assert.False(t, EqualSliceValues([]bool{true, false, false}, []bool{true, false, true}))
+}

shared/utils/strings.go

@@ -34,29 +34,3 @@ func DedupStrings(src []string) []string {
 
 	return dst
 }
-
-// EqualStringSlice compare two string slices if they have equal values independent of how they are sorted
-func EqualStringSlice(l1, l2 []string) bool {
-	if len(l1) != len(l2) {
-		return false
-	}
-
-	m1 := sliceToCountMap(l1)
-	m2 := sliceToCountMap(l2)
-
-	for k, v := range m1 {
-		if m2[k] != v {
-			return false
-		}
-	}
-
-	return true
-}
-
-func sliceToCountMap(list []string) map[string]int {
-	m := make(map[string]int)
-	for i := range list {
-		m[list[i]]++
-	}
-	return m
-}

shared/utils/strings_test.go

@@ -46,31 +46,3 @@ func TestDedupStrings(t *testing.T) {
 		}
 	}
 }
-
-func TestEqualStringSlice(t *testing.T) {
-	tests := []struct {
-		in1 []string
-		in2 []string
-		out bool
-	}{{
-		in1: []string{"", "ab", "12", "ab"},
-		in2: []string{"12", "ab"},
-		out: false,
-	}, {
-		in1: nil,
-		in2: nil,
-		out: true,
-	}, {
-		in1: []string{"AA", "AA", "2", " "},
-		in2: []string{"2", "AA", " ", "AA"},
-		out: true,
-	}, {
-		in1: []string{"AA", "AA", "2", " "},
-		in2: []string{"2", "2", " ", "AA"},
-		out: false,
-	}}
-
-	for _, tc := range tests {
-		assert.EqualValues(t, tc.out, EqualStringSlice(tc.in1, tc.in2), "could not correctly process input: '%#v', %#v", tc.in1, tc.in2)
-	}
-}