Merge changes I9bec563c,I34f06abd

am: 5a8d428dc7

Change-Id: Ifa6cd752e00eb31ec15a1bcc4094087529ee843b

android/util.go

@@ -101,11 +101,18 @@ func RemoveListFromList(list []string, filter_out []string) (result []string) {
 
 func RemoveFromList(s string, list []string) (bool, []string) {
 	i := IndexList(s, list)
-	if i != -1 {
-		return true, append(list[:i], list[i+1:]...)
-	} else {
+	if i == -1 {
 		return false, list
 	}
+
+	result := make([]string, 0, len(list)-1)
+	result = append(result, list[:i]...)
+	for _, l := range list[i+1:] {
+		if l != s {
+			result = append(result, l)
+		}
+	}
+	return true, result
 }
 
 // FirstUniqueStrings returns all unique elements of a slice of strings, keeping the first copy of

android/util_test.go

@@ -118,3 +118,244 @@ func TestLastUniqueStrings(t *testing.T) {
 		}
 	}
 }
+
+func TestJoinWithPrefix(t *testing.T) {
+	testcases := []struct {
+		name     string
+		input    []string
+		expected string
+	}{
+		{
+			name:     "zero_inputs",
+			input:    []string{},
+			expected: "",
+		},
+		{
+			name:     "one_input",
+			input:    []string{"a"},
+			expected: "prefix:a",
+		},
+		{
+			name:     "two_inputs",
+			input:    []string{"a", "b"},
+			expected: "prefix:a prefix:b",
+		},
+	}
+
+	prefix := "prefix:"
+
+	for _, testCase := range testcases {
+		t.Run(testCase.name, func(t *testing.T) {
+			out := JoinWithPrefix(testCase.input, prefix)
+			if out != testCase.expected {
+				t.Errorf("incorrect output:")
+				t.Errorf("     input: %#v", testCase.input)
+				t.Errorf("    prefix: %#v", prefix)
+				t.Errorf("  expected: %#v", testCase.expected)
+				t.Errorf("       got: %#v", out)
+			}
+		})
+	}
+}
+
+func TestIndexList(t *testing.T) {
+	input := []string{"a", "b", "c"}
+
+	testcases := []struct {
+		key      string
+		expected int
+	}{
+		{
+			key:      "a",
+			expected: 0,
+		},
+		{
+			key:      "b",
+			expected: 1,
+		},
+		{
+			key:      "c",
+			expected: 2,
+		},
+		{
+			key:      "X",
+			expected: -1,
+		},
+	}
+
+	for _, testCase := range testcases {
+		t.Run(testCase.key, func(t *testing.T) {
+			out := IndexList(testCase.key, input)
+			if out != testCase.expected {
+				t.Errorf("incorrect output:")
+				t.Errorf("       key: %#v", testCase.key)
+				t.Errorf("     input: %#v", input)
+				t.Errorf("  expected: %#v", testCase.expected)
+				t.Errorf("       got: %#v", out)
+			}
+		})
+	}
+}
+
+func TestInList(t *testing.T) {
+	input := []string{"a"}
+
+	testcases := []struct {
+		key      string
+		expected bool
+	}{
+		{
+			key:      "a",
+			expected: true,
+		},
+		{
+			key:      "X",
+			expected: false,
+		},
+	}
+
+	for _, testCase := range testcases {
+		t.Run(testCase.key, func(t *testing.T) {
+			out := InList(testCase.key, input)
+			if out != testCase.expected {
+				t.Errorf("incorrect output:")
+				t.Errorf("       key: %#v", testCase.key)
+				t.Errorf("     input: %#v", input)
+				t.Errorf("  expected: %#v", testCase.expected)
+				t.Errorf("       got: %#v", out)
+			}
+		})
+	}
+}
+
+func TestPrefixInList(t *testing.T) {
+	prefixes := []string{"a", "b"}
+
+	testcases := []struct {
+		str      string
+		expected bool
+	}{
+		{
+			str:      "a-example",
+			expected: true,
+		},
+		{
+			str:      "b-example",
+			expected: true,
+		},
+		{
+			str:      "X-example",
+			expected: false,
+		},
+	}
+
+	for _, testCase := range testcases {
+		t.Run(testCase.str, func(t *testing.T) {
+			out := PrefixInList(testCase.str, prefixes)
+			if out != testCase.expected {
+				t.Errorf("incorrect output:")
+				t.Errorf("       str: %#v", testCase.str)
+				t.Errorf("  prefixes: %#v", prefixes)
+				t.Errorf("  expected: %#v", testCase.expected)
+				t.Errorf("       got: %#v", out)
+			}
+		})
+	}
+}
+
+func TestFilterList(t *testing.T) {
+	input := []string{"a", "b", "c", "c", "b", "d", "a"}
+	filter := []string{"a", "c"}
+	remainder, filtered := FilterList(input, filter)
+
+	expected := []string{"b", "b", "d"}
+	if !reflect.DeepEqual(remainder, expected) {
+		t.Errorf("incorrect remainder output:")
+		t.Errorf("     input: %#v", input)
+		t.Errorf("    filter: %#v", filter)
+		t.Errorf("  expected: %#v", expected)
+		t.Errorf("       got: %#v", remainder)
+	}
+
+	expected = []string{"a", "c", "c", "a"}
+	if !reflect.DeepEqual(filtered, expected) {
+		t.Errorf("incorrect filtered output:")
+		t.Errorf("     input: %#v", input)
+		t.Errorf("    filter: %#v", filter)
+		t.Errorf("  expected: %#v", expected)
+		t.Errorf("       got: %#v", filtered)
+	}
+}
+
+func TestRemoveListFromList(t *testing.T) {
+	input := []string{"a", "b", "c", "d", "a", "c", "d"}
+	filter := []string{"a", "c"}
+	expected := []string{"b", "d", "d"}
+	out := RemoveListFromList(input, filter)
+	if !reflect.DeepEqual(out, expected) {
+		t.Errorf("incorrect output:")
+		t.Errorf("     input: %#v", input)
+		t.Errorf("    filter: %#v", filter)
+		t.Errorf("  expected: %#v", expected)
+		t.Errorf("       got: %#v", out)
+	}
+}
+
+func TestRemoveFromList(t *testing.T) {
+	testcases := []struct {
+		name          string
+		key           string
+		input         []string
+		expectedFound bool
+		expectedOut   []string
+	}{
+		{
+			name:          "remove_one_match",
+			key:           "a",
+			input:         []string{"a", "b", "c"},
+			expectedFound: true,
+			expectedOut:   []string{"b", "c"},
+		},
+		{
+			name:          "remove_three_matches",
+			key:           "a",
+			input:         []string{"a", "b", "a", "c", "a"},
+			expectedFound: true,
+			expectedOut:   []string{"b", "c"},
+		},
+		{
+			name:          "remove_zero_matches",
+			key:           "X",
+			input:         []string{"a", "b", "a", "c", "a"},
+			expectedFound: false,
+			expectedOut:   []string{"a", "b", "a", "c", "a"},
+		},
+		{
+			name:          "remove_all_matches",
+			key:           "a",
+			input:         []string{"a", "a", "a", "a"},
+			expectedFound: true,
+			expectedOut:   []string{},
+		},
+	}
+
+	for _, testCase := range testcases {
+		t.Run(testCase.name, func(t *testing.T) {
+			found, out := RemoveFromList(testCase.key, testCase.input)
+			if found != testCase.expectedFound {
+				t.Errorf("incorrect output:")
+				t.Errorf("       key: %#v", testCase.key)
+				t.Errorf("     input: %#v", testCase.input)
+				t.Errorf("  expected: %#v", testCase.expectedFound)
+				t.Errorf("       got: %#v", found)
+			}
+			if !reflect.DeepEqual(out, testCase.expectedOut) {
+				t.Errorf("incorrect output:")
+				t.Errorf("       key: %#v", testCase.key)
+				t.Errorf("     input: %#v", testCase.input)
+				t.Errorf("  expected: %#v", testCase.expectedOut)
+				t.Errorf("       got: %#v", out)
+			}
+		})
+	}
+}