cac8a3cf09
Policy uses restricted_if_statically_linked at https://opensource.google/documentation/reference/thirdparty/licenses#RestrictedIfStaticallyLinked Test: m droid Change-Id: I9b18d3133ae72de1bede99f46b530298313bc2e6
645 lines
21 KiB
Go
645 lines
21 KiB
Go
// Copyright 2021 Google LLC
|
|
//
|
|
// 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 compliance
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestConditionSet(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
conditions []string
|
|
plus *[]string
|
|
minus *[]string
|
|
matchingAny map[string][]string
|
|
expected []string
|
|
}{
|
|
{
|
|
name: "empty",
|
|
conditions: []string{},
|
|
plus: &[]string{},
|
|
matchingAny: map[string][]string{
|
|
"notice": []string{},
|
|
"restricted": []string{},
|
|
"restricted|reciprocal": []string{},
|
|
},
|
|
expected: []string{},
|
|
},
|
|
{
|
|
name: "emptyminusnothing",
|
|
conditions: []string{},
|
|
minus: &[]string{},
|
|
matchingAny: map[string][]string{
|
|
"notice": []string{},
|
|
"restricted": []string{},
|
|
"restricted|reciprocal": []string{},
|
|
},
|
|
expected: []string{},
|
|
},
|
|
{
|
|
name: "emptyminusnotice",
|
|
conditions: []string{},
|
|
minus: &[]string{"notice"},
|
|
matchingAny: map[string][]string{
|
|
"notice": []string{},
|
|
"restricted": []string{},
|
|
"restricted|reciprocal": []string{},
|
|
},
|
|
expected: []string{},
|
|
},
|
|
{
|
|
name: "noticeonly",
|
|
conditions: []string{"notice"},
|
|
matchingAny: map[string][]string{
|
|
"notice": []string{"notice"},
|
|
"notice|proprietary": []string{"notice"},
|
|
"restricted": []string{},
|
|
},
|
|
expected: []string{"notice"},
|
|
},
|
|
{
|
|
name: "allnoticeonly",
|
|
conditions: []string{"notice"},
|
|
plus: &[]string{"notice"},
|
|
matchingAny: map[string][]string{
|
|
"notice": []string{"notice"},
|
|
"notice|proprietary": []string{"notice"},
|
|
"restricted": []string{},
|
|
},
|
|
expected: []string{"notice"},
|
|
},
|
|
{
|
|
name: "emptyplusnotice",
|
|
conditions: []string{},
|
|
plus: &[]string{"notice"},
|
|
matchingAny: map[string][]string{
|
|
"notice": []string{"notice"},
|
|
"notice|proprietary": []string{"notice"},
|
|
"restricted": []string{},
|
|
},
|
|
expected: []string{"notice"},
|
|
},
|
|
{
|
|
name: "everything",
|
|
conditions: []string{"unencumbered", "permissive", "notice", "reciprocal", "restricted", "proprietary"},
|
|
plus: &[]string{"restricted_if_statically_linked", "by_exception_only", "not_allowed"},
|
|
matchingAny: map[string][]string{
|
|
"unencumbered": []string{"unencumbered"},
|
|
"permissive": []string{"permissive"},
|
|
"notice": []string{"notice"},
|
|
"reciprocal": []string{"reciprocal"},
|
|
"restricted": []string{"restricted"},
|
|
"restricted_if_statically_linked": []string{"restricted_if_statically_linked"},
|
|
"proprietary": []string{"proprietary"},
|
|
"by_exception_only": []string{"by_exception_only"},
|
|
"not_allowed": []string{"not_allowed"},
|
|
"notice|proprietary": []string{"notice", "proprietary"},
|
|
},
|
|
expected: []string{
|
|
"unencumbered",
|
|
"permissive",
|
|
"notice",
|
|
"reciprocal",
|
|
"restricted",
|
|
"restricted_if_statically_linked",
|
|
"proprietary",
|
|
"by_exception_only",
|
|
"not_allowed",
|
|
},
|
|
},
|
|
{
|
|
name: "everythingplusminusnothing",
|
|
conditions: []string{
|
|
"unencumbered",
|
|
"permissive",
|
|
"notice",
|
|
"reciprocal",
|
|
"restricted",
|
|
"restricted_if_statically_linked",
|
|
"proprietary",
|
|
"by_exception_only",
|
|
"not_allowed",
|
|
},
|
|
plus: &[]string{},
|
|
minus: &[]string{},
|
|
matchingAny: map[string][]string{
|
|
"unencumbered|permissive|notice": []string{"unencumbered", "permissive", "notice"},
|
|
"restricted|reciprocal": []string{"reciprocal", "restricted"},
|
|
"proprietary|by_exception_only": []string{"proprietary", "by_exception_only"},
|
|
"not_allowed": []string{"not_allowed"},
|
|
},
|
|
expected: []string{
|
|
"unencumbered",
|
|
"permissive",
|
|
"notice",
|
|
"reciprocal",
|
|
"restricted",
|
|
"restricted_if_statically_linked",
|
|
"proprietary",
|
|
"by_exception_only",
|
|
"not_allowed",
|
|
},
|
|
},
|
|
{
|
|
name: "allbutone",
|
|
conditions: []string{"unencumbered", "permissive", "notice", "reciprocal", "restricted", "proprietary"},
|
|
plus: &[]string{"restricted_if_statically_linked", "by_exception_only", "not_allowed"},
|
|
matchingAny: map[string][]string{
|
|
"unencumbered": []string{"unencumbered"},
|
|
"permissive": []string{"permissive"},
|
|
"notice": []string{"notice"},
|
|
"reciprocal": []string{"reciprocal"},
|
|
"restricted": []string{"restricted"},
|
|
"restricted_if_statically_linked": []string{"restricted_if_statically_linked"},
|
|
"proprietary": []string{"proprietary"},
|
|
"by_exception_only": []string{"by_exception_only"},
|
|
"not_allowed": []string{"not_allowed"},
|
|
"notice|proprietary": []string{"notice", "proprietary"},
|
|
},
|
|
expected: []string{
|
|
"unencumbered",
|
|
"permissive",
|
|
"notice",
|
|
"reciprocal",
|
|
"restricted",
|
|
"restricted_if_statically_linked",
|
|
"proprietary",
|
|
"by_exception_only",
|
|
"not_allowed",
|
|
},
|
|
},
|
|
{
|
|
name: "everythingminusone",
|
|
conditions: []string{
|
|
"unencumbered",
|
|
"permissive",
|
|
"notice",
|
|
"reciprocal",
|
|
"restricted",
|
|
"restricted_if_statically_linked",
|
|
"proprietary",
|
|
"by_exception_only",
|
|
"not_allowed",
|
|
},
|
|
minus: &[]string{"restricted_if_statically_linked"},
|
|
matchingAny: map[string][]string{
|
|
"unencumbered": []string{"unencumbered"},
|
|
"permissive": []string{"permissive"},
|
|
"notice": []string{"notice"},
|
|
"reciprocal": []string{"reciprocal"},
|
|
"restricted": []string{"restricted"},
|
|
"restricted_if_statically_linked": []string{},
|
|
"proprietary": []string{"proprietary"},
|
|
"by_exception_only": []string{"by_exception_only"},
|
|
"not_allowed": []string{"not_allowed"},
|
|
"restricted|proprietary": []string{"restricted", "proprietary"},
|
|
},
|
|
expected: []string{
|
|
"unencumbered",
|
|
"permissive",
|
|
"notice",
|
|
"reciprocal",
|
|
"restricted",
|
|
"proprietary",
|
|
"by_exception_only",
|
|
"not_allowed",
|
|
},
|
|
},
|
|
{
|
|
name: "everythingminuseverything",
|
|
conditions: []string{
|
|
"unencumbered",
|
|
"permissive",
|
|
"notice",
|
|
"reciprocal",
|
|
"restricted",
|
|
"restricted_if_statically_linked",
|
|
"proprietary",
|
|
"by_exception_only",
|
|
"not_allowed",
|
|
},
|
|
minus: &[]string{
|
|
"unencumbered",
|
|
"permissive",
|
|
"notice",
|
|
"reciprocal",
|
|
"restricted",
|
|
"restricted_if_statically_linked",
|
|
"proprietary",
|
|
"by_exception_only",
|
|
"not_allowed",
|
|
},
|
|
matchingAny: map[string][]string{
|
|
"unencumbered": []string{},
|
|
"permissive": []string{},
|
|
"notice": []string{},
|
|
"reciprocal": []string{},
|
|
"restricted": []string{},
|
|
"restricted_if_statically_linked": []string{},
|
|
"proprietary": []string{},
|
|
"by_exception_only": []string{},
|
|
"not_allowed": []string{},
|
|
"restricted|proprietary": []string{},
|
|
},
|
|
expected: []string{},
|
|
},
|
|
{
|
|
name: "restrictedplus",
|
|
conditions: []string{"restricted", "restricted_if_statically_linked"},
|
|
plus: &[]string{"permissive", "notice", "restricted", "proprietary"},
|
|
matchingAny: map[string][]string{
|
|
"unencumbered": []string{},
|
|
"permissive": []string{"permissive"},
|
|
"notice": []string{"notice"},
|
|
"restricted": []string{"restricted"},
|
|
"restricted_if_statically_linked": []string{"restricted_if_statically_linked"},
|
|
"proprietary": []string{"proprietary"},
|
|
"restricted|proprietary": []string{"restricted", "proprietary"},
|
|
"by_exception_only": []string{},
|
|
"proprietary|by_exception_only": []string{"proprietary"},
|
|
},
|
|
expected: []string{"permissive", "notice", "restricted", "restricted_if_statically_linked", "proprietary"},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
toConditions := func(names []string) []LicenseCondition {
|
|
result := make([]LicenseCondition, 0, len(names))
|
|
for _, name := range names {
|
|
result = append(result, RecognizedConditionNames[name])
|
|
}
|
|
return result
|
|
}
|
|
populate := func() LicenseConditionSet {
|
|
testSet := NewLicenseConditionSet(toConditions(tt.conditions)...)
|
|
if tt.plus != nil {
|
|
testSet = testSet.Plus(toConditions(*tt.plus)...)
|
|
}
|
|
if tt.minus != nil {
|
|
testSet = testSet.Minus(toConditions(*tt.minus)...)
|
|
}
|
|
return testSet
|
|
}
|
|
populateSet := func() LicenseConditionSet {
|
|
testSet := NewLicenseConditionSet(toConditions(tt.conditions)...)
|
|
if tt.plus != nil {
|
|
testSet = testSet.Union(NewLicenseConditionSet(toConditions(*tt.plus)...))
|
|
}
|
|
if tt.minus != nil {
|
|
testSet = testSet.Difference(NewLicenseConditionSet(toConditions(*tt.minus)...))
|
|
}
|
|
return testSet
|
|
}
|
|
populatePlusSet := func() LicenseConditionSet {
|
|
testSet := NewLicenseConditionSet(toConditions(tt.conditions)...)
|
|
if tt.plus != nil {
|
|
testSet = testSet.Union(NewLicenseConditionSet(toConditions(*tt.plus)...))
|
|
}
|
|
if tt.minus != nil {
|
|
testSet = testSet.Minus(toConditions(*tt.minus)...)
|
|
}
|
|
return testSet
|
|
}
|
|
populateMinusSet := func() LicenseConditionSet {
|
|
testSet := NewLicenseConditionSet(toConditions(tt.conditions)...)
|
|
if tt.plus != nil {
|
|
testSet = testSet.Plus(toConditions(*tt.plus)...)
|
|
}
|
|
if tt.minus != nil {
|
|
testSet = testSet.Difference(NewLicenseConditionSet(toConditions(*tt.minus)...))
|
|
}
|
|
return testSet
|
|
}
|
|
checkMatching := func(cs LicenseConditionSet, t *testing.T) {
|
|
for data, expectedNames := range tt.matchingAny {
|
|
expectedConditions := toConditions(expectedNames)
|
|
expected := NewLicenseConditionSet(expectedConditions...)
|
|
actual := cs.MatchingAny(toConditions(strings.Split(data, "|"))...)
|
|
actualNames := actual.Names()
|
|
|
|
t.Logf("MatchingAny(%s): actual set %#v %s", data, actual, actual.String())
|
|
t.Logf("MatchingAny(%s): expected set %#v %s", data, expected, expected.String())
|
|
|
|
if actual != expected {
|
|
t.Errorf("MatchingAny(%s): got %#v, want %#v", data, actual, expected)
|
|
continue
|
|
}
|
|
if len(actualNames) != len(expectedNames) {
|
|
t.Errorf("len(MatchinAny(%s).Names()): got %d, want %d",
|
|
data, len(actualNames), len(expectedNames))
|
|
} else {
|
|
for i := 0; i < len(actualNames); i++ {
|
|
if actualNames[i] != expectedNames[i] {
|
|
t.Errorf("MatchingAny(%s).Names()[%d]: got %s, want %s",
|
|
data, i, actualNames[i], expectedNames[i])
|
|
break
|
|
}
|
|
}
|
|
}
|
|
actualConditions := actual.AsList()
|
|
if len(actualConditions) != len(expectedConditions) {
|
|
t.Errorf("len(MatchingAny(%s).AsList()): got %d, want %d",
|
|
data, len(actualNames), len(expectedNames))
|
|
} else {
|
|
for i := 0; i < len(actualNames); i++ {
|
|
if actualNames[i] != expectedNames[i] {
|
|
t.Errorf("MatchingAny(%s).AsList()[%d]: got %s, want %s",
|
|
data, i, actualNames[i], expectedNames[i])
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
checkMatchingSet := func(cs LicenseConditionSet, t *testing.T) {
|
|
for data, expectedNames := range tt.matchingAny {
|
|
expected := NewLicenseConditionSet(toConditions(expectedNames)...)
|
|
actual := cs.MatchingAnySet(NewLicenseConditionSet(toConditions(strings.Split(data, "|"))...))
|
|
actualNames := actual.Names()
|
|
|
|
t.Logf("MatchingAnySet(%s): actual set %#v %s", data, actual, actual.String())
|
|
t.Logf("MatchingAnySet(%s): expected set %#v %s", data, expected, expected.String())
|
|
|
|
if actual != expected {
|
|
t.Errorf("MatchingAnySet(%s): got %#v, want %#v", data, actual, expected)
|
|
continue
|
|
}
|
|
if len(actualNames) != len(expectedNames) {
|
|
t.Errorf("len(MatchingAnySet(%s).Names()): got %d, want %d",
|
|
data, len(actualNames), len(expectedNames))
|
|
} else {
|
|
for i := 0; i < len(actualNames); i++ {
|
|
if actualNames[i] != expectedNames[i] {
|
|
t.Errorf("MatchingAnySet(%s).Names()[%d]: got %s, want %s",
|
|
data, i, actualNames[i], expectedNames[i])
|
|
break
|
|
}
|
|
}
|
|
}
|
|
expectedConditions := toConditions(expectedNames)
|
|
actualConditions := actual.AsList()
|
|
if len(actualConditions) != len(expectedConditions) {
|
|
t.Errorf("len(MatchingAnySet(%s).AsList()): got %d, want %d",
|
|
data, len(actualNames), len(expectedNames))
|
|
} else {
|
|
for i := 0; i < len(actualNames); i++ {
|
|
if actualNames[i] != expectedNames[i] {
|
|
t.Errorf("MatchingAnySet(%s).AsList()[%d]: got %s, want %s",
|
|
data, i, actualNames[i], expectedNames[i])
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
checkExpected := func(actual LicenseConditionSet, t *testing.T) bool {
|
|
t.Logf("checkExpected{%s}", strings.Join(tt.expected, ", "))
|
|
|
|
expectedConditions := toConditions(tt.expected)
|
|
expected := NewLicenseConditionSet(expectedConditions...)
|
|
|
|
actualNames := actual.Names()
|
|
|
|
t.Logf("actual license condition set: %#v %s", actual, actual.String())
|
|
t.Logf("expected license condition set: %#v %s", expected, expected.String())
|
|
|
|
if actual != expected {
|
|
t.Errorf("checkExpected: got %#v, want %#v", actual, expected)
|
|
return false
|
|
}
|
|
|
|
if len(actualNames) != len(tt.expected) {
|
|
t.Errorf("len(actual.Names()): got %d, want %d", len(actualNames), len(tt.expected))
|
|
} else {
|
|
for i := 0; i < len(actualNames); i++ {
|
|
if actualNames[i] != tt.expected[i] {
|
|
t.Errorf("actual.Names()[%d]: got %s, want %s", i, actualNames[i], tt.expected[i])
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
actualConditions := actual.AsList()
|
|
if len(actualConditions) != len(expectedConditions) {
|
|
t.Errorf("len(actual.AsList()): got %d, want %d", len(actualConditions), len(expectedConditions))
|
|
} else {
|
|
for i := 0; i < len(actualConditions); i++ {
|
|
if actualConditions[i] != expectedConditions[i] {
|
|
t.Errorf("actual.AsList()[%d]: got %s, want %s",
|
|
i, actualConditions[i].Name(), expectedConditions[i].Name())
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(tt.expected) == 0 {
|
|
if !actual.IsEmpty() {
|
|
t.Errorf("actual.IsEmpty(): got false, want true")
|
|
}
|
|
if actual.HasAny(expectedConditions...) {
|
|
t.Errorf("actual.HasAny(): got true, want false")
|
|
}
|
|
} else {
|
|
if actual.IsEmpty() {
|
|
t.Errorf("actual.IsEmpty(): got true, want false")
|
|
}
|
|
if !actual.HasAny(expectedConditions...) {
|
|
t.Errorf("actual.HasAny(all expected): got false, want true")
|
|
}
|
|
}
|
|
if !actual.HasAll(expectedConditions...) {
|
|
t.Errorf("actual.Hasll(all expected): want true, got false")
|
|
}
|
|
for _, expectedCondition := range expectedConditions {
|
|
if !actual.HasAny(expectedCondition) {
|
|
t.Errorf("actual.HasAny(%q): got false, want true", expectedCondition.Name())
|
|
}
|
|
if !actual.HasAll(expectedCondition) {
|
|
t.Errorf("actual.HasAll(%q): got false, want true", expectedCondition.Name())
|
|
}
|
|
}
|
|
|
|
notExpected := (AllLicenseConditions &^ expected)
|
|
notExpectedList := notExpected.AsList()
|
|
t.Logf("not expected license condition set: %#v %s", notExpected, notExpected.String())
|
|
|
|
if len(tt.expected) == 0 {
|
|
if actual.HasAny(append(expectedConditions, notExpectedList...)...) {
|
|
t.Errorf("actual.HasAny(all conditions): want false, got true")
|
|
}
|
|
} else {
|
|
if !actual.HasAny(append(expectedConditions, notExpectedList...)...) {
|
|
t.Errorf("actual.HasAny(all conditions): want true, got false")
|
|
}
|
|
}
|
|
if len(notExpectedList) == 0 {
|
|
if !actual.HasAll(append(expectedConditions, notExpectedList...)...) {
|
|
t.Errorf("actual.HasAll(all conditions): want true, got false")
|
|
}
|
|
} else {
|
|
if actual.HasAll(append(expectedConditions, notExpectedList...)...) {
|
|
t.Errorf("actual.HasAll(all conditions): want false, got true")
|
|
}
|
|
}
|
|
for _, unexpectedCondition := range notExpectedList {
|
|
if actual.HasAny(unexpectedCondition) {
|
|
t.Errorf("actual.HasAny(%q): got true, want false", unexpectedCondition.Name())
|
|
}
|
|
if actual.HasAll(unexpectedCondition) {
|
|
t.Errorf("actual.HasAll(%q): got true, want false", unexpectedCondition.Name())
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
checkExpectedSet := func(actual LicenseConditionSet, t *testing.T) bool {
|
|
t.Logf("checkExpectedSet{%s}", strings.Join(tt.expected, ", "))
|
|
|
|
expectedConditions := toConditions(tt.expected)
|
|
expected := NewLicenseConditionSet(expectedConditions...)
|
|
|
|
actualNames := actual.Names()
|
|
|
|
t.Logf("actual license condition set: %#v %s", actual, actual.String())
|
|
t.Logf("expected license condition set: %#v %s", expected, expected.String())
|
|
|
|
if actual != expected {
|
|
t.Errorf("checkExpectedSet: got %#v, want %#v", actual, expected)
|
|
return false
|
|
}
|
|
|
|
if len(actualNames) != len(tt.expected) {
|
|
t.Errorf("len(actual.Names()): got %d, want %d", len(actualNames), len(tt.expected))
|
|
} else {
|
|
for i := 0; i < len(actualNames); i++ {
|
|
if actualNames[i] != tt.expected[i] {
|
|
t.Errorf("actual.Names()[%d]: got %s, want %s", i, actualNames[i], tt.expected[i])
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
actualConditions := actual.AsList()
|
|
if len(actualConditions) != len(expectedConditions) {
|
|
t.Errorf("len(actual.AsList()): got %d, want %d", len(actualConditions), len(expectedConditions))
|
|
} else {
|
|
for i := 0; i < len(actualConditions); i++ {
|
|
if actualConditions[i] != expectedConditions[i] {
|
|
t.Errorf("actual.AsList()[%d}: got %s, want %s",
|
|
i, actualConditions[i].Name(), expectedConditions[i].Name())
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(tt.expected) == 0 {
|
|
if !actual.IsEmpty() {
|
|
t.Errorf("actual.IsEmpty(): got false, want true")
|
|
}
|
|
if actual.MatchesAnySet(expected) {
|
|
t.Errorf("actual.MatchesAnySet({}): got true, want false")
|
|
}
|
|
if actual.MatchesEverySet(expected, expected) {
|
|
t.Errorf("actual.MatchesEverySet({}, {}): want false, got true")
|
|
}
|
|
} else {
|
|
if actual.IsEmpty() {
|
|
t.Errorf("actual.IsEmpty(): got true, want false")
|
|
}
|
|
if !actual.MatchesAnySet(expected) {
|
|
t.Errorf("actual.MatchesAnySet({all expected}): want true, got false")
|
|
}
|
|
if !actual.MatchesEverySet(expected, expected) {
|
|
t.Errorf("actual.MatchesEverySet({all expected}, {all expected}): want true, got false")
|
|
}
|
|
}
|
|
|
|
notExpected := (AllLicenseConditions &^ expected)
|
|
t.Logf("not expected license condition set: %#v %s", notExpected, notExpected.String())
|
|
|
|
if len(tt.expected) == 0 {
|
|
if actual.MatchesAnySet(expected, notExpected) {
|
|
t.Errorf("empty actual.MatchesAnySet({expected}, {not expected}): want false, got true")
|
|
}
|
|
} else {
|
|
if !actual.MatchesAnySet(expected, notExpected) {
|
|
t.Errorf("actual.MatchesAnySet({expected}, {not expected}): want true, got false")
|
|
}
|
|
}
|
|
if actual.MatchesAnySet(notExpected) {
|
|
t.Errorf("actual.MatchesAnySet({not expected}): want false, got true")
|
|
}
|
|
if actual.MatchesEverySet(notExpected) {
|
|
t.Errorf("actual.MatchesEverySet({not expected}): want false, got true")
|
|
}
|
|
if actual.MatchesEverySet(expected, notExpected) {
|
|
t.Errorf("actual.MatchesEverySet({expected}, {not expected}): want false, got true")
|
|
}
|
|
|
|
if !actual.Difference(expected).IsEmpty() {
|
|
t.Errorf("actual.Difference({expected}).IsEmpty(): want true, got false")
|
|
}
|
|
if expected != actual.Intersection(expected) {
|
|
t.Errorf("expected == actual.Intersection({expected}): want true, got false (%#v != %#v)", expected, actual.Intersection(expected))
|
|
}
|
|
if actual != actual.Intersection(expected) {
|
|
t.Errorf("actual == actual.Intersection({expected}): want true, got false (%#v != %#v)", actual, actual.Intersection(expected))
|
|
}
|
|
return true
|
|
}
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
cs := populate()
|
|
if checkExpected(cs, t) {
|
|
checkMatching(cs, t)
|
|
}
|
|
if checkExpectedSet(cs, t) {
|
|
checkMatchingSet(cs, t)
|
|
}
|
|
})
|
|
|
|
t.Run(tt.name+"_sets", func(t *testing.T) {
|
|
cs := populateSet()
|
|
if checkExpected(cs, t) {
|
|
checkMatching(cs, t)
|
|
}
|
|
if checkExpectedSet(cs, t) {
|
|
checkMatchingSet(cs, t)
|
|
}
|
|
})
|
|
|
|
t.Run(tt.name+"_plusset", func(t *testing.T) {
|
|
cs := populatePlusSet()
|
|
if checkExpected(cs, t) {
|
|
checkMatching(cs, t)
|
|
}
|
|
if checkExpectedSet(cs, t) {
|
|
checkMatchingSet(cs, t)
|
|
}
|
|
})
|
|
|
|
t.Run(tt.name+"_minusset", func(t *testing.T) {
|
|
cs := populateMinusSet()
|
|
if checkExpected(cs, t) {
|
|
checkMatching(cs, t)
|
|
}
|
|
if checkExpectedSet(cs, t) {
|
|
checkMatchingSet(cs, t)
|
|
}
|
|
})
|
|
}
|
|
}
|