test: consolidate Go tests (#39962)

Consolidate all Go tests. Coverage is identical to before. Go tests are
around 5% faster while being 7% smaller. No non-test code is touched.

modules/util/diff_slice_test.go

@@ -10,65 +10,36 @@ import (
 )
 
 func TestDiffSliceBasic(t *testing.T) {
-	// Typical integer cases
-	t.Run("additions", func(t *testing.T) {
-		added, removed := DiffSlice([]int{1, 2}, []int{1, 2, 3})
-		assert.Equal(t, []int{3}, added)
-		assert.Empty(t, removed)
-	})
-
-	t.Run("removals", func(t *testing.T) {
-		added, removed := DiffSlice([]int{1, 2, 3}, []int{1, 2})
-		assert.Empty(t, added)
-		assert.Equal(t, []int{3}, removed)
-	})
-
-	t.Run("no changes", func(t *testing.T) {
-		added, removed := DiffSlice([]int{1, 2}, []int{1, 2})
-		assert.Empty(t, added)
-		assert.Empty(t, removed)
-	})
-
-	t.Run("empty slices", func(t *testing.T) {
-		added, removed := DiffSlice([]int{}, []int{})
-		assert.Empty(t, added)
-		assert.Empty(t, removed)
-	})
-
-	t.Run("overlapping elements", func(t *testing.T) {
-		added, removed := DiffSlice([]int{1, 2, 4}, []int{2, 3, 4})
-		assert.Equal(t, []int{3}, added)
-		assert.Equal(t, []int{1}, removed)
-	})
-}
-
-func TestDiffSliceOrderAndDuplicates(t *testing.T) {
-	oldSlice := []int{1, 2, 2, 3}
-	newSlice := []int{2, 4, 2, 5}
-
-	added, removed := DiffSlice(oldSlice, newSlice)
-	assert.Equal(t, []int{4, 5}, added)
-	assert.Equal(t, []int{1, 3}, removed)
-}
-
-func TestDiffSliceDeduplicatesOutput(t *testing.T) {
-	// Test case from issue: newSlice contains [4, 4, 5] and oldSlice is [1]
-	// added should return [4, 5], not [4, 4, 5]
-	t.Run("deduplicates added", func(t *testing.T) {
-		added, removed := DiffSlice([]int{1}, []int{4, 4, 5})
-		assert.Equal(t, []int{4, 5}, added)
-		assert.Equal(t, []int{1}, removed)
-	})
-
-	t.Run("deduplicates removed", func(t *testing.T) {
-		added, removed := DiffSlice([]int{1, 1, 2}, []int{3})
-		assert.Equal(t, []int{3}, added)
-		assert.Equal(t, []int{1, 2}, removed)
-	})
-
-	t.Run("deduplicates both", func(t *testing.T) {
-		added, removed := DiffSlice([]int{1, 1, 2, 2}, []int{3, 3, 4, 4})
-		assert.Equal(t, []int{3, 4}, added)
-		assert.Equal(t, []int{1, 2}, removed)
-	})
+	for _, testCase := range []struct {
+		name                           string
+		oldSlice, newSlice             []int
+		expectedAdded, expectedRemoved []int
+	}{
+		// Typical integer cases
+		{"additions", []int{1, 2}, []int{1, 2, 3}, []int{3}, nil},
+		{"removals", []int{1, 2, 3}, []int{1, 2}, nil, []int{3}},
+		{"no changes", []int{1, 2}, []int{1, 2}, nil, nil},
+		{"empty slices", []int{}, []int{}, nil, nil},
+		{"overlapping elements", []int{1, 2, 4}, []int{2, 3, 4}, []int{3}, []int{1}},
+		{"order and duplicates", []int{1, 2, 2, 3}, []int{2, 4, 2, 5}, []int{4, 5}, []int{1, 3}},
+		// Test case from issue: newSlice contains [4, 4, 5] and oldSlice is [1]
+		// added should return [4, 5], not [4, 4, 5]
+		{"deduplicates added", []int{1}, []int{4, 4, 5}, []int{4, 5}, []int{1}},
+		{"deduplicates removed", []int{1, 1, 2}, []int{3}, []int{3}, []int{1, 2}},
+		{"deduplicates both", []int{1, 1, 2, 2}, []int{3, 3, 4, 4}, []int{3, 4}, []int{1, 2}},
+	} {
+		t.Run(testCase.name, func(t *testing.T) {
+			added, removed := DiffSlice(testCase.oldSlice, testCase.newSlice)
+			if testCase.expectedAdded == nil {
+				assert.Empty(t, added)
+			} else {
+				assert.Equal(t, testCase.expectedAdded, added)
+			}
+			if testCase.expectedRemoved == nil {
+				assert.Empty(t, removed)
+			} else {
+				assert.Equal(t, testCase.expectedRemoved, removed)
+			}
+		})
+	}
 }