Merge changes I9bec563c,I34f06abd am: 5a8d428dc7 (cb3b3106) · Commits · e / os / android_build_soong

android/util.go

+10 −3

Original line number	Diff line number	Diff line
		@@ -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

+241 −0

Original line number	Diff line number	Diff line
		@@ -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)
		}
		})
		}
		}