| // Copyright 2021 Google Inc. All rights reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package bazel |
| |
| import ( |
| "reflect" |
| "strings" |
| "testing" |
| |
| "github.com/google/blueprint/proptools" |
| ) |
| |
| func TestUniqueBazelLabels(t *testing.T) { |
| testCases := []struct { |
| originalLabels []Label |
| expectedUniqueLabels []Label |
| }{ |
| { |
| originalLabels: []Label{ |
| {Label: "a"}, |
| {Label: "b"}, |
| {Label: "a"}, |
| {Label: "c"}, |
| // namespaces |
| {Label: "//foo:bar", OriginalModuleName: "bar"}, // when referenced from foo namespace |
| {Label: "//foo:bar", OriginalModuleName: "//foo:bar"}, // when reference from root namespace |
| }, |
| expectedUniqueLabels: []Label{ |
| {Label: "//foo:bar", OriginalModuleName: "bar"}, |
| {Label: "a"}, |
| {Label: "b"}, |
| {Label: "c"}, |
| }, |
| }, |
| } |
| for _, tc := range testCases { |
| actualUniqueLabels := UniqueSortedBazelLabels(tc.originalLabels) |
| if !reflect.DeepEqual(tc.expectedUniqueLabels, actualUniqueLabels) { |
| t.Fatalf("Expected %v, got %v", tc.expectedUniqueLabels, actualUniqueLabels) |
| } |
| } |
| } |
| |
| func TestSubtractStrings(t *testing.T) { |
| testCases := []struct { |
| haystack []string |
| needle []string |
| expectedResult []string |
| }{ |
| { |
| haystack: []string{ |
| "a", |
| "b", |
| "c", |
| }, |
| needle: []string{ |
| "a", |
| }, |
| expectedResult: []string{ |
| "b", "c", |
| }, |
| }, |
| } |
| for _, tc := range testCases { |
| actualResult := SubtractStrings(tc.haystack, tc.needle) |
| if !reflect.DeepEqual(tc.expectedResult, actualResult) { |
| t.Fatalf("Expected %v, got %v", tc.expectedResult, actualResult) |
| } |
| } |
| } |
| |
| func TestSubtractBazelLabelList(t *testing.T) { |
| testCases := []struct { |
| haystack LabelList |
| needle LabelList |
| expectedResult LabelList |
| }{ |
| { |
| haystack: LabelList{ |
| Includes: []Label{ |
| {Label: "a"}, |
| {Label: "b"}, |
| {Label: "c"}, |
| }, |
| Excludes: []Label{ |
| {Label: "x"}, |
| {Label: "y"}, |
| {Label: "z"}, |
| }, |
| }, |
| needle: LabelList{ |
| Includes: []Label{ |
| {Label: "a"}, |
| }, |
| Excludes: []Label{ |
| {Label: "z"}, |
| }, |
| }, |
| // NOTE: Excludes are intentionally not subtracted |
| expectedResult: LabelList{ |
| Includes: []Label{ |
| {Label: "b"}, |
| {Label: "c"}, |
| }, |
| Excludes: []Label{ |
| {Label: "x"}, |
| {Label: "y"}, |
| {Label: "z"}, |
| }, |
| }, |
| }, |
| } |
| for _, tc := range testCases { |
| actualResult := SubtractBazelLabelList(tc.haystack, tc.needle) |
| if !reflect.DeepEqual(tc.expectedResult, actualResult) { |
| t.Fatalf("Expected %v, got %v", tc.expectedResult, actualResult) |
| } |
| } |
| } |
| |
| func TestSubtractBazelLabelListAttribute(t *testing.T) { |
| testCases := []struct { |
| haystack LabelListAttribute |
| needle LabelListAttribute |
| expected LabelListAttribute |
| }{ |
| { |
| haystack: LabelListAttribute{ |
| Value: makeLabelList( |
| []string{"a", "b", "a", "c"}, |
| []string{"x", "x", "y", "z"}, |
| ), |
| ConfigurableValues: configurableLabelLists{ |
| ArchConfigurationAxis: labelListSelectValues{ |
| "arm": makeLabelList([]string{"arm_1", "arm_2"}, []string{}), |
| "x86": makeLabelList([]string{"x86_3", "x86_4", "x86_5"}, []string{"x86_5"}), |
| }, |
| }, |
| }, |
| needle: LabelListAttribute{ |
| Value: makeLabelList( |
| []string{"d", "a"}, |
| []string{"x", "y2", "z2"}, |
| ), |
| ConfigurableValues: configurableLabelLists{ |
| ArchConfigurationAxis: labelListSelectValues{ |
| "arm": makeLabelList([]string{"arm_1", "arm_3"}, []string{}), |
| "x86": makeLabelList([]string{"x86_3", "x86_4"}, []string{"x86_6"}), |
| }, |
| }, |
| }, |
| expected: LabelListAttribute{ |
| Value: makeLabelList( |
| []string{"b", "c"}, |
| []string{"x", "x", "y", "z"}, |
| ), |
| ConfigurableValues: configurableLabelLists{ |
| ArchConfigurationAxis: labelListSelectValues{ |
| "arm": makeLabelList([]string{"arm_2"}, []string{}), |
| "x86": makeLabelList([]string{"x86_5"}, []string{"x86_5"}), |
| }, |
| }, |
| ForceSpecifyEmptyList: false, |
| EmitEmptyList: false, |
| Prepend: false, |
| }, |
| }, |
| } |
| for _, tc := range testCases { |
| got := SubtractBazelLabelListAttribute(tc.haystack, tc.needle) |
| if !reflect.DeepEqual(tc.expected, got) { |
| t.Fatalf("Expected\n%v, but got\n%v", tc.expected, got) |
| } |
| } |
| } |
| |
| func TestFirstUniqueBazelLabelList(t *testing.T) { |
| testCases := []struct { |
| originalLabelList LabelList |
| expectedUniqueLabelList LabelList |
| }{ |
| { |
| originalLabelList: LabelList{ |
| Includes: []Label{ |
| {Label: "a"}, |
| {Label: "b"}, |
| {Label: "a"}, |
| {Label: "c"}, |
| // namespaces |
| {Label: "//foo:bar", OriginalModuleName: "bar"}, // when referenced from foo namespace |
| {Label: "//foo:bar", OriginalModuleName: "//foo:bar"}, // when referenced from root namespace |
| }, |
| Excludes: []Label{ |
| {Label: "x"}, |
| {Label: "x"}, |
| {Label: "y"}, |
| {Label: "z"}, |
| }, |
| }, |
| expectedUniqueLabelList: LabelList{ |
| Includes: []Label{ |
| {Label: "a"}, |
| {Label: "b"}, |
| {Label: "c"}, |
| {Label: "//foo:bar", OriginalModuleName: "bar"}, |
| }, |
| Excludes: []Label{ |
| {Label: "x"}, |
| {Label: "y"}, |
| {Label: "z"}, |
| }, |
| }, |
| }, |
| } |
| for _, tc := range testCases { |
| actualUniqueLabelList := FirstUniqueBazelLabelList(tc.originalLabelList) |
| if !reflect.DeepEqual(tc.expectedUniqueLabelList, actualUniqueLabelList) { |
| t.Fatalf("Expected %v, got %v", tc.expectedUniqueLabelList, actualUniqueLabelList) |
| } |
| } |
| } |
| |
| func TestFirstUniqueBazelLabelListAttribute(t *testing.T) { |
| testCases := []struct { |
| originalLabelList LabelListAttribute |
| expectedUniqueLabelList LabelListAttribute |
| }{ |
| { |
| originalLabelList: LabelListAttribute{ |
| Value: makeLabelList( |
| []string{"a", "b", "a", "c"}, |
| []string{"x", "x", "y", "z"}, |
| ), |
| ConfigurableValues: configurableLabelLists{ |
| ArchConfigurationAxis: labelListSelectValues{ |
| "arm": makeLabelList([]string{"1", "2", "1"}, []string{}), |
| "x86": makeLabelList([]string{"3", "4", "4"}, []string{"5", "5"}), |
| }, |
| }, |
| }, |
| expectedUniqueLabelList: LabelListAttribute{ |
| Value: makeLabelList( |
| []string{"a", "b", "c"}, |
| []string{"x", "y", "z"}, |
| ), |
| ConfigurableValues: configurableLabelLists{ |
| ArchConfigurationAxis: labelListSelectValues{ |
| "arm": makeLabelList([]string{"1", "2"}, []string{}), |
| "x86": makeLabelList([]string{"3", "4"}, []string{"5"}), |
| }, |
| }, |
| }, |
| }, |
| } |
| for _, tc := range testCases { |
| actualUniqueLabelList := FirstUniqueBazelLabelListAttribute(tc.originalLabelList) |
| if !reflect.DeepEqual(tc.expectedUniqueLabelList, actualUniqueLabelList) { |
| t.Fatalf("Expected %v, got %v", tc.expectedUniqueLabelList, actualUniqueLabelList) |
| } |
| } |
| } |
| |
| func TestUniqueSortedBazelLabelList(t *testing.T) { |
| testCases := []struct { |
| originalLabelList LabelList |
| expectedUniqueLabelList LabelList |
| }{ |
| { |
| originalLabelList: LabelList{ |
| Includes: []Label{ |
| {Label: "c"}, |
| {Label: "a"}, |
| {Label: "a"}, |
| {Label: "b"}, |
| }, |
| Excludes: []Label{ |
| {Label: "y"}, |
| {Label: "z"}, |
| {Label: "x"}, |
| {Label: "x"}, |
| }, |
| }, |
| expectedUniqueLabelList: LabelList{ |
| Includes: []Label{ |
| {Label: "a"}, |
| {Label: "b"}, |
| {Label: "c"}, |
| }, |
| Excludes: []Label{ |
| {Label: "x"}, |
| {Label: "y"}, |
| {Label: "z"}, |
| }, |
| }, |
| }, |
| } |
| for _, tc := range testCases { |
| actualUniqueLabelList := UniqueSortedBazelLabelList(tc.originalLabelList) |
| if !reflect.DeepEqual(tc.expectedUniqueLabelList, actualUniqueLabelList) { |
| t.Fatalf("Expected %v, got %v", tc.expectedUniqueLabelList, actualUniqueLabelList) |
| } |
| } |
| } |
| |
| func makeLabels(labels ...string) []Label { |
| var ret []Label |
| for _, l := range labels { |
| ret = append(ret, Label{Label: l}) |
| } |
| return ret |
| } |
| |
| func makeLabelList(includes, excludes []string) LabelList { |
| return LabelList{ |
| Includes: makeLabels(includes...), |
| Excludes: makeLabels(excludes...), |
| } |
| } |
| |
| func TestResolveExcludes(t *testing.T) { |
| attr := LabelListAttribute{ |
| Value: makeLabelList( |
| []string{ |
| "all_include", |
| "arm_exclude", |
| "android_exclude", |
| "product_config_exclude", |
| }, |
| []string{"all_exclude"}, |
| ), |
| ConfigurableValues: configurableLabelLists{ |
| ArchConfigurationAxis: labelListSelectValues{ |
| "arm": makeLabelList([]string{}, []string{"arm_exclude"}), |
| "x86": makeLabelList([]string{"x86_include"}, []string{}), |
| ConditionsDefaultConfigKey: makeLabelList([]string{"default_include"}, []string{}), |
| }, |
| OsConfigurationAxis: labelListSelectValues{ |
| "android": makeLabelList([]string{}, []string{"android_exclude"}), |
| "linux": makeLabelList([]string{"linux_include"}, []string{}), |
| }, |
| OsArchConfigurationAxis: labelListSelectValues{ |
| "linux_x86": makeLabelList([]string{"linux_x86_include"}, []string{}), |
| }, |
| ProductVariableConfigurationAxis(false, "product_with_defaults"): labelListSelectValues{ |
| "a": makeLabelList([]string{}, []string{"not_in_value"}), |
| "b": makeLabelList([]string{"b_val"}, []string{}), |
| "c": makeLabelList([]string{"c_val"}, []string{}), |
| ConditionsDefaultConfigKey: makeLabelList([]string{"c_val", "default", "default2", "all_exclude"}, []string{}), |
| }, |
| ProductVariableConfigurationAxis(false, "product_only_with_excludes"): labelListSelectValues{ |
| "a": makeLabelList([]string{}, []string{"product_config_exclude"}), |
| }, |
| }, |
| } |
| |
| attr.ResolveExcludes() |
| |
| expectedBaseIncludes := []Label{{Label: "all_include"}} |
| if !reflect.DeepEqual(expectedBaseIncludes, attr.Value.Includes) { |
| t.Errorf("Expected Value includes %q, got %q", attr.Value.Includes, expectedBaseIncludes) |
| } |
| var nilLabels []Label |
| expectedConfiguredIncludes := map[ConfigurationAxis]map[string][]Label{ |
| ArchConfigurationAxis: { |
| "arm": nilLabels, |
| "x86": makeLabels("arm_exclude", "x86_include"), |
| ConditionsDefaultConfigKey: makeLabels("arm_exclude", "default_include"), |
| }, |
| OsConfigurationAxis: { |
| "android": nilLabels, |
| "linux": makeLabels("android_exclude", "linux_include"), |
| ConditionsDefaultConfigKey: makeLabels("android_exclude"), |
| }, |
| OsArchConfigurationAxis: { |
| "linux_x86": makeLabels("linux_x86_include"), |
| ConditionsDefaultConfigKey: nilLabels, |
| }, |
| ProductVariableConfigurationAxis(false, "product_with_defaults"): { |
| "a": nilLabels, |
| "b": makeLabels("b_val"), |
| "c": makeLabels("c_val"), |
| ConditionsDefaultConfigKey: makeLabels("c_val", "default", "default2"), |
| }, |
| ProductVariableConfigurationAxis(false, "product_only_with_excludes"): { |
| "a": nilLabels, |
| ConditionsDefaultConfigKey: makeLabels("product_config_exclude"), |
| }, |
| } |
| for _, axis := range attr.SortedConfigurationAxes() { |
| if _, ok := expectedConfiguredIncludes[axis]; !ok { |
| t.Errorf("Found unexpected axis %s", axis) |
| continue |
| } |
| expectedForAxis := expectedConfiguredIncludes[axis] |
| gotForAxis := attr.ConfigurableValues[axis] |
| if len(expectedForAxis) != len(gotForAxis) { |
| t.Errorf("Expected %d configs for %s, got %d: %s", len(expectedForAxis), axis, len(gotForAxis), gotForAxis) |
| } |
| for config, value := range gotForAxis { |
| if expected, ok := expectedForAxis[config]; ok { |
| if !reflect.DeepEqual(expected, value.Includes) { |
| t.Errorf("For %s,\nexpected: %#v\ngot %#v", axis, expected, value.Includes) |
| } |
| } else { |
| t.Errorf("Got unexpected config %q for %s", config, axis) |
| } |
| } |
| } |
| } |
| |
| func TestLabelListAttributePartition(t *testing.T) { |
| testCases := []struct { |
| name string |
| input LabelListAttribute |
| predicated LabelListAttribute |
| unpredicated LabelListAttribute |
| predicate func(label Label) bool |
| }{ |
| { |
| name: "move all to predicated partition", |
| input: MakeLabelListAttribute(makeLabelList( |
| []string{"keep1", "throw1", "keep2", "throw2"}, |
| []string{"keep1", "throw1", "keep2", "throw2"}, |
| )), |
| predicated: MakeLabelListAttribute(makeLabelList( |
| []string{"keep1", "throw1", "keep2", "throw2"}, |
| []string{"keep1", "throw1", "keep2", "throw2"}, |
| )), |
| unpredicated: LabelListAttribute{}, |
| predicate: func(label Label) bool { |
| return true |
| }, |
| }, |
| { |
| name: "move all to unpredicated partition", |
| input: MakeLabelListAttribute(makeLabelList( |
| []string{"keep1", "throw1", "keep2", "throw2"}, |
| []string{"keep1", "throw1", "keep2", "throw2"}, |
| )), |
| predicated: LabelListAttribute{}, |
| unpredicated: MakeLabelListAttribute(makeLabelList( |
| []string{"keep1", "throw1", "keep2", "throw2"}, |
| []string{"keep1", "throw1", "keep2", "throw2"}, |
| )), |
| predicate: func(label Label) bool { |
| return false |
| }, |
| }, |
| { |
| name: "partition includes and excludes", |
| input: MakeLabelListAttribute(makeLabelList( |
| []string{"keep1", "throw1", "keep2", "throw2"}, |
| []string{"keep1", "throw1", "keep2", "throw2"}, |
| )), |
| predicated: MakeLabelListAttribute(makeLabelList( |
| []string{"keep1", "keep2"}, |
| []string{"keep1", "keep2"}, |
| )), |
| unpredicated: MakeLabelListAttribute(makeLabelList( |
| []string{"throw1", "throw2"}, |
| []string{"throw1", "throw2"}, |
| )), |
| predicate: func(label Label) bool { |
| return strings.HasPrefix(label.Label, "keep") |
| }, |
| }, |
| { |
| name: "partition excludes only", |
| input: MakeLabelListAttribute(makeLabelList( |
| []string{}, |
| []string{"keep1", "throw1", "keep2", "throw2"}, |
| )), |
| predicated: MakeLabelListAttribute(makeLabelList( |
| []string{}, |
| []string{"keep1", "keep2"}, |
| )), |
| unpredicated: MakeLabelListAttribute(makeLabelList( |
| []string{}, |
| []string{"throw1", "throw2"}, |
| )), |
| predicate: func(label Label) bool { |
| return strings.HasPrefix(label.Label, "keep") |
| }, |
| }, |
| { |
| name: "partition includes only", |
| input: MakeLabelListAttribute(makeLabelList( |
| []string{"keep1", "throw1", "keep2", "throw2"}, |
| []string{}, |
| )), |
| predicated: MakeLabelListAttribute(makeLabelList( |
| []string{"keep1", "keep2"}, |
| []string{}, |
| )), |
| unpredicated: MakeLabelListAttribute(makeLabelList( |
| []string{"throw1", "throw2"}, |
| []string{}, |
| )), |
| predicate: func(label Label) bool { |
| return strings.HasPrefix(label.Label, "keep") |
| }, |
| }, |
| { |
| name: "empty partition", |
| input: MakeLabelListAttribute(makeLabelList([]string{}, []string{})), |
| predicated: LabelListAttribute{}, |
| unpredicated: LabelListAttribute{}, |
| predicate: func(label Label) bool { |
| return true |
| }, |
| }, |
| } |
| |
| for _, tc := range testCases { |
| t.Run(tc.name, func(t *testing.T) { |
| predicated, unpredicated := tc.input.Partition(tc.predicate) |
| if !predicated.Value.Equals(tc.predicated.Value) { |
| t.Errorf("expected predicated labels to be %v; got %v", tc.predicated, predicated) |
| } |
| for axis, configs := range predicated.ConfigurableValues { |
| tcConfigs, ok := tc.predicated.ConfigurableValues[axis] |
| if !ok || !reflect.DeepEqual(configs, tcConfigs) { |
| t.Errorf("expected predicated labels to be %v; got %v", tc.predicated, predicated) |
| } |
| } |
| if !unpredicated.Value.Equals(tc.unpredicated.Value) { |
| t.Errorf("expected unpredicated labels to be %v; got %v", tc.unpredicated, unpredicated) |
| } |
| for axis, configs := range unpredicated.ConfigurableValues { |
| tcConfigs, ok := tc.unpredicated.ConfigurableValues[axis] |
| if !ok || !reflect.DeepEqual(configs, tcConfigs) { |
| t.Errorf("expected unpredicated labels to be %v; got %v", tc.unpredicated, unpredicated) |
| } |
| } |
| }) |
| } |
| } |
| |
| // labelAddSuffixForTypeMapper returns a LabelMapper that adds suffix to label name for modules of |
| // typ |
| func labelAddSuffixForTypeMapper(suffix, typ string) LabelMapper { |
| return func(omc OtherModuleContext, label Label) (string, bool) { |
| m, ok := omc.ModuleFromName(label.Label) |
| if !ok { |
| return label.Label, false |
| } |
| mTyp := omc.OtherModuleType(m) |
| if typ == mTyp { |
| return label.Label + suffix, true |
| } |
| return label.Label, false |
| } |
| } |
| |
| func TestPartitionLabelListAttribute(t *testing.T) { |
| testCases := []struct { |
| name string |
| ctx *OtherModuleTestContext |
| labelList LabelListAttribute |
| filters LabelPartitions |
| expected PartitionToLabelListAttribute |
| expectedErrMsg *string |
| }{ |
| { |
| name: "no configurable values", |
| ctx: &OtherModuleTestContext{}, |
| labelList: LabelListAttribute{ |
| Value: makeLabelList([]string{"a.a", "b.b", "c.c", "d.d", "e.e"}, []string{}), |
| }, |
| filters: LabelPartitions{ |
| "A": LabelPartition{Extensions: []string{".a"}}, |
| "B": LabelPartition{Extensions: []string{".b"}}, |
| "C": LabelPartition{Extensions: []string{".c"}}, |
| }, |
| expected: PartitionToLabelListAttribute{ |
| "A": LabelListAttribute{Value: makeLabelList([]string{"a.a"}, []string{})}, |
| "B": LabelListAttribute{Value: makeLabelList([]string{"b.b"}, []string{})}, |
| "C": LabelListAttribute{Value: makeLabelList([]string{"c.c"}, []string{})}, |
| }, |
| }, |
| { |
| name: "no configurable values, remainder partition", |
| ctx: &OtherModuleTestContext{}, |
| labelList: LabelListAttribute{ |
| Value: makeLabelList([]string{"a.a", "b.b", "c.c", "d.d", "e.e"}, []string{}), |
| }, |
| filters: LabelPartitions{ |
| "A": LabelPartition{Extensions: []string{".a"}, Keep_remainder: true}, |
| "B": LabelPartition{Extensions: []string{".b"}}, |
| "C": LabelPartition{Extensions: []string{".c"}}, |
| }, |
| expected: PartitionToLabelListAttribute{ |
| "A": LabelListAttribute{Value: makeLabelList([]string{"a.a", "d.d", "e.e"}, []string{})}, |
| "B": LabelListAttribute{Value: makeLabelList([]string{"b.b"}, []string{})}, |
| "C": LabelListAttribute{Value: makeLabelList([]string{"c.c"}, []string{})}, |
| }, |
| }, |
| { |
| name: "no configurable values, empty partition", |
| ctx: &OtherModuleTestContext{}, |
| labelList: LabelListAttribute{ |
| Value: makeLabelList([]string{"a.a", "c.c"}, []string{}), |
| }, |
| filters: LabelPartitions{ |
| "A": LabelPartition{Extensions: []string{".a"}}, |
| "B": LabelPartition{Extensions: []string{".b"}}, |
| "C": LabelPartition{Extensions: []string{".c"}}, |
| }, |
| expected: PartitionToLabelListAttribute{ |
| "A": LabelListAttribute{Value: makeLabelList([]string{"a.a"}, []string{})}, |
| "C": LabelListAttribute{Value: makeLabelList([]string{"c.c"}, []string{})}, |
| }, |
| }, |
| { |
| name: "no configurable values, has map", |
| ctx: &OtherModuleTestContext{ |
| Modules: []TestModuleInfo{{ModuleName: "srcs", Typ: "fg", Dir: "dir"}}, |
| }, |
| labelList: LabelListAttribute{ |
| Value: makeLabelList([]string{"a.a", "srcs", "b.b", "c.c"}, []string{}), |
| }, |
| filters: LabelPartitions{ |
| "A": LabelPartition{Extensions: []string{".a"}, LabelMapper: labelAddSuffixForTypeMapper("_a", "fg")}, |
| "B": LabelPartition{Extensions: []string{".b"}}, |
| "C": LabelPartition{Extensions: []string{".c"}}, |
| }, |
| expected: PartitionToLabelListAttribute{ |
| "A": LabelListAttribute{Value: makeLabelList([]string{"a.a", "srcs_a"}, []string{})}, |
| "B": LabelListAttribute{Value: makeLabelList([]string{"b.b"}, []string{})}, |
| "C": LabelListAttribute{Value: makeLabelList([]string{"c.c"}, []string{})}, |
| }, |
| }, |
| { |
| name: "configurable values, keeps empty if excludes", |
| ctx: &OtherModuleTestContext{}, |
| labelList: LabelListAttribute{ |
| ConfigurableValues: configurableLabelLists{ |
| ArchConfigurationAxis: labelListSelectValues{ |
| "x86": makeLabelList([]string{"a.a", "c.c"}, []string{}), |
| "arm": makeLabelList([]string{"b.b"}, []string{}), |
| "x86_64": makeLabelList([]string{"b.b"}, []string{"d.d"}), |
| }, |
| }, |
| }, |
| filters: LabelPartitions{ |
| "A": LabelPartition{Extensions: []string{".a"}}, |
| "B": LabelPartition{Extensions: []string{".b"}}, |
| "C": LabelPartition{Extensions: []string{".c"}}, |
| }, |
| expected: PartitionToLabelListAttribute{ |
| "A": LabelListAttribute{ |
| ConfigurableValues: configurableLabelLists{ |
| ArchConfigurationAxis: labelListSelectValues{ |
| "x86": makeLabelList([]string{"a.a"}, []string{}), |
| "x86_64": makeLabelList([]string{}, []string{"c.c"}), |
| }, |
| }, |
| }, |
| "B": LabelListAttribute{ |
| ConfigurableValues: configurableLabelLists{ |
| ArchConfigurationAxis: labelListSelectValues{ |
| "arm": makeLabelList([]string{"b.b"}, []string{}), |
| "x86_64": makeLabelList([]string{"b.b"}, []string{"c.c"}), |
| }, |
| }, |
| }, |
| "C": LabelListAttribute{ |
| ConfigurableValues: configurableLabelLists{ |
| ArchConfigurationAxis: labelListSelectValues{ |
| "x86": makeLabelList([]string{"c.c"}, []string{}), |
| "x86_64": makeLabelList([]string{}, []string{"c.c"}), |
| }, |
| }, |
| }, |
| }, |
| }, |
| { |
| name: "error for multiple partitions same value", |
| ctx: &OtherModuleTestContext{}, |
| labelList: LabelListAttribute{ |
| Value: makeLabelList([]string{"a.a", "b.b", "c.c", "d.d", "e.e"}, []string{}), |
| }, |
| filters: LabelPartitions{ |
| "A": LabelPartition{Extensions: []string{".a"}}, |
| "other A": LabelPartition{Extensions: []string{".a"}}, |
| }, |
| expected: PartitionToLabelListAttribute{}, |
| expectedErrMsg: proptools.StringPtr(`"a.a" was found in multiple partitions:`), |
| }, |
| } |
| |
| for _, tc := range testCases { |
| t.Run(tc.name, func(t *testing.T) { |
| got := PartitionLabelListAttribute(tc.ctx, &tc.labelList, tc.filters) |
| |
| if hasErrors, expectsErr := len(tc.ctx.errors) > 0, tc.expectedErrMsg != nil; hasErrors != expectsErr { |
| t.Errorf("Unexpected error(s): %q, expected: %q", tc.ctx.errors, *tc.expectedErrMsg) |
| } else if tc.expectedErrMsg != nil { |
| found := false |
| for _, err := range tc.ctx.errors { |
| if strings.Contains(err, *tc.expectedErrMsg) { |
| found = true |
| break |
| } |
| } |
| |
| if !found { |
| t.Errorf("Expected error message: %q, got %q", *tc.expectedErrMsg, tc.ctx.errors) |
| } |
| return |
| } |
| |
| if len(tc.expected) != len(got) { |
| t.Errorf("Expected %d partitions, got %d partitions", len(tc.expected), len(got)) |
| } |
| for partition, expectedLla := range tc.expected { |
| gotLla, ok := got[partition] |
| if !ok { |
| t.Errorf("Expected partition %q, but it was not found %v", partition, got) |
| continue |
| } |
| expectedLabelList := expectedLla.Value |
| gotLabelList := gotLla.Value |
| if !reflect.DeepEqual(expectedLabelList.Includes, gotLabelList.Includes) { |
| t.Errorf("Expected no config includes %v, got %v", expectedLabelList.Includes, gotLabelList.Includes) |
| } |
| expectedAxes := expectedLla.SortedConfigurationAxes() |
| gotAxes := gotLla.SortedConfigurationAxes() |
| if !reflect.DeepEqual(expectedAxes, gotAxes) { |
| t.Errorf("Expected axes %v, got %v (%#v)", expectedAxes, gotAxes, gotLla) |
| } |
| for _, axis := range expectedLla.SortedConfigurationAxes() { |
| if _, exists := gotLla.ConfigurableValues[axis]; !exists { |
| t.Errorf("Expected %s to be a supported axis, but it was not found", axis) |
| } |
| if expected, got := expectedLla.ConfigurableValues[axis], gotLla.ConfigurableValues[axis]; len(expected) != len(got) { |
| t.Errorf("For axis %q: expected configs %v, got %v", axis, expected, got) |
| } |
| for config, expectedLabelList := range expectedLla.ConfigurableValues[axis] { |
| gotLabelList, exists := gotLla.ConfigurableValues[axis][config] |
| if !exists { |
| t.Errorf("Expected %s to be a supported config, but config was not found", config) |
| continue |
| } |
| if !reflect.DeepEqual(expectedLabelList.Includes, gotLabelList.Includes) { |
| t.Errorf("Expected %s %s includes %v, got %v", axis, config, expectedLabelList.Includes, gotLabelList.Includes) |
| } |
| } |
| } |
| } |
| }) |
| } |
| } |
| |
| func TestDeduplicateAxesFromBase(t *testing.T) { |
| attr := StringListAttribute{ |
| Value: []string{ |
| "all_include", |
| "arm_include", |
| "android_include", |
| "linux_x86_include", |
| }, |
| ConfigurableValues: configurableStringLists{ |
| ArchConfigurationAxis: stringListSelectValues{ |
| "arm": []string{"arm_include"}, |
| "x86": []string{"x86_include"}, |
| }, |
| OsConfigurationAxis: stringListSelectValues{ |
| "android": []string{"android_include"}, |
| "linux": []string{"linux_include"}, |
| }, |
| OsArchConfigurationAxis: stringListSelectValues{ |
| "linux_x86": {"linux_x86_include"}, |
| }, |
| ProductVariableConfigurationAxis(false, "a"): stringListSelectValues{ |
| "a": []string{"not_in_value"}, |
| }, |
| }, |
| } |
| |
| attr.DeduplicateAxesFromBase() |
| |
| expectedBaseIncludes := []string{ |
| "all_include", |
| "arm_include", |
| "android_include", |
| "linux_x86_include", |
| } |
| if !reflect.DeepEqual(expectedBaseIncludes, attr.Value) { |
| t.Errorf("Expected Value includes %q, got %q", attr.Value, expectedBaseIncludes) |
| } |
| expectedConfiguredIncludes := configurableStringLists{ |
| ArchConfigurationAxis: stringListSelectValues{ |
| "x86": []string{"x86_include"}, |
| }, |
| OsConfigurationAxis: stringListSelectValues{ |
| "linux": []string{"linux_include"}, |
| }, |
| OsArchConfigurationAxis: stringListSelectValues{}, |
| ProductVariableConfigurationAxis(false, "a"): stringListSelectValues{ |
| "a": []string{"not_in_value"}, |
| }, |
| } |
| for _, axis := range attr.SortedConfigurationAxes() { |
| if _, ok := expectedConfiguredIncludes[axis]; !ok { |
| t.Errorf("Found unexpected axis %s", axis) |
| continue |
| } |
| expectedForAxis := expectedConfiguredIncludes[axis] |
| gotForAxis := attr.ConfigurableValues[axis] |
| if len(expectedForAxis) != len(gotForAxis) { |
| t.Errorf("Expected %d configs for %s, got %d: %s", len(expectedForAxis), axis, len(gotForAxis), gotForAxis) |
| } |
| for config, value := range gotForAxis { |
| if expected, ok := expectedForAxis[config]; ok { |
| if !reflect.DeepEqual(expected, value) { |
| t.Errorf("For %s, expected: %#v, got %#v", axis, expected, value) |
| } |
| } else { |
| t.Errorf("Got unexpected config %q for %s", config, axis) |
| } |
| } |
| } |
| } |