tequilaOS/platform_build
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "Policy change: GPL+CE is permissive."

Browse source
This commit is contained in:
Bob Badour 2022-09-21 23:33:30 +00:00 committed by Gerrit Code Review
commit 9a76135e44
11 changed files with 101 additions and 218 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
core/tasks/tools/compatibility.mk
View file

@ -53,7 +53,7 @@ $(test_suite_jdk): $(shell find $(test_suite_jdk_dir) -type f | sort)
$(test_suite_jdk): $(SOONG_ZIP) $(test_suite_jdk): $(SOONG_ZIP)
$(SOONG_ZIP) -o $@ -P $(PRIVATE_SUBDIR)/jdk -C $(PRIVATE_JDK_DIR) -D $(PRIVATE_JDK_DIR) $(SOONG_ZIP) -o $@ -P $(PRIVATE_SUBDIR)/jdk -C $(PRIVATE_JDK_DIR) -D $(PRIVATE_JDK_DIR)
$(call declare-license-metadata,$(test_suite_jdk),SPDX-license-identifier-GPL-2.0-with-classpath-exception,restricted,\ $(call declare-license-metadata,$(test_suite_jdk),SPDX-license-identifier-GPL-2.0-with-classpath-exception,permissive,\
$(test_suite_jdk_dir)/legal/java.base/LICENSE,JDK,prebuilts/jdk/$(notdir $(patsubst %/,%,$(dir $(test_suite_jdk_dir))))) $(test_suite_jdk_dir)/legal/java.base/LICENSE,JDK,prebuilts/jdk/$(notdir $(patsubst %/,%,$(dir $(test_suite_jdk_dir)))))
# Copy license metadata # Copy license metadata

18
tools/compliance/condition.go
View file

@ -23,7 +23,7 @@ import (
type LicenseCondition uint16 type LicenseCondition uint16
// LicenseConditionMask is a bitmask for the recognized license conditions. // LicenseConditionMask is a bitmask for the recognized license conditions.
const LicenseConditionMask = LicenseCondition(0x3ff) const LicenseConditionMask = LicenseCondition(0x1ff)
const ( const (
// UnencumberedCondition identifies public domain or public domain- // UnencumberedCondition identifies public domain or public domain-
@ -41,21 +41,18 @@ const (
// RestrictedCondition identifies a license with requirement to share // RestrictedCondition identifies a license with requirement to share
// all source code linked to the module's source. // all source code linked to the module's source.
RestrictedCondition = LicenseCondition(0x0010) RestrictedCondition = LicenseCondition(0x0010)
// RestrictedClasspathExceptionCondition identifies RestrictedCondition
// waived for dynamic linking from independent modules.
RestrictedClasspathExceptionCondition = LicenseCondition(0x0020)
// WeaklyRestrictedCondition identifies a RestrictedCondition waived // WeaklyRestrictedCondition identifies a RestrictedCondition waived
// for dynamic linking. // for dynamic linking.
WeaklyRestrictedCondition = LicenseCondition(0x0040) WeaklyRestrictedCondition = LicenseCondition(0x0020)
// ProprietaryCondition identifies a license with source privacy // ProprietaryCondition identifies a license with source privacy
// requirements. // requirements.
ProprietaryCondition = LicenseCondition(0x0080) ProprietaryCondition = LicenseCondition(0x0040)
// ByExceptionOnly identifies a license where policy requires product // ByExceptionOnly identifies a license where policy requires product
// counsel review prior to use. // counsel review prior to use.
ByExceptionOnlyCondition = LicenseCondition(0x0100) ByExceptionOnlyCondition = LicenseCondition(0x0080)
// NotAllowedCondition identifies a license with onerous conditions // NotAllowedCondition identifies a license with onerous conditions
// where policy prohibits use. // where policy prohibits use.
NotAllowedCondition = LicenseCondition(0x0200) NotAllowedCondition = LicenseCondition(0x0100)
) )
var ( var (
@ -66,7 +63,6 @@ var (
"notice": NoticeCondition, "notice": NoticeCondition,
"reciprocal": ReciprocalCondition, "reciprocal": ReciprocalCondition,
"restricted": RestrictedCondition, "restricted": RestrictedCondition,
"restricted_with_classpath_exception": RestrictedClasspathExceptionCondition,
"restricted_allows_dynamic_linking": WeaklyRestrictedCondition, "restricted_allows_dynamic_linking": WeaklyRestrictedCondition,
"proprietary": ProprietaryCondition, "proprietary": ProprietaryCondition,
"by_exception_only": ByExceptionOnlyCondition, "by_exception_only": ByExceptionOnlyCondition,
@ -87,8 +83,6 @@ func (lc LicenseCondition) Name() string {
return "reciprocal" return "reciprocal"
case RestrictedCondition: case RestrictedCondition:
return "restricted" return "restricted"
case RestrictedClasspathExceptionCondition:
return "restricted_with_classpath_exception"
case WeaklyRestrictedCondition: case WeaklyRestrictedCondition:
return "restricted_allows_dynamic_linking" return "restricted_allows_dynamic_linking"
case ProprietaryCondition: case ProprietaryCondition:
@ -98,5 +92,5 @@ func (lc LicenseCondition) Name() string {
case NotAllowedCondition: case NotAllowedCondition:
return "not_allowed" return "not_allowed"
} }
panic(fmt.Errorf("unrecognized license condition: %04x", lc)) panic(fmt.Errorf("unrecognized license condition: %#v", lc))
} }

14
tools/compliance/condition_test.go
View file

@ -21,22 +21,22 @@ import (
func TestConditionSetHas(t *testing.T) { func TestConditionSetHas(t *testing.T) {
impliesShare := ImpliesShared impliesShare := ImpliesShared
t.Logf("testing with imliesShare=%04x", impliesShare) t.Logf("testing with imliesShare=%#v", impliesShare)
if impliesShare.HasAny(NoticeCondition) { if impliesShare.HasAny(NoticeCondition) {
t.Errorf("impliesShare.HasAny(\"notice\"=%04x) got true, want false", NoticeCondition) t.Errorf("impliesShare.HasAny(\"notice\"=%#v) got true, want false", NoticeCondition)
} }
if !impliesShare.HasAny(RestrictedCondition) { if !impliesShare.HasAny(RestrictedCondition) {
t.Errorf("impliesShare.HasAny(\"restricted\"=%04x) got false, want true", RestrictedCondition) t.Errorf("impliesShare.HasAny(\"restricted\"=%#v) got false, want true", RestrictedCondition)
} }
if !impliesShare.HasAny(ReciprocalCondition) { if !impliesShare.HasAny(ReciprocalCondition) {
t.Errorf("impliesShare.HasAny(\"reciprocal\"=%04x) got false, want true", ReciprocalCondition) t.Errorf("impliesShare.HasAny(\"reciprocal\"=%#v) got false, want true", ReciprocalCondition)
} }
if impliesShare.HasAny(LicenseCondition(0x0000)) { if impliesShare.HasAny(LicenseCondition(0x0000)) {
t.Errorf("impliesShare.HasAny(nil=%04x) got true, want false", LicenseCondition(0x0000)) t.Errorf("impliesShare.HasAny(nil=%#v) got true, want false", LicenseCondition(0x0000))
} }
} }
@ -44,7 +44,7 @@ func TestConditionName(t *testing.T) {
for expected, condition := range RecognizedConditionNames { for expected, condition := range RecognizedConditionNames {
actual := condition.Name() actual := condition.Name()
if expected != actual { if expected != actual {
t.Errorf("unexpected name for condition %04x: got %s, want %s", condition, actual, expected) t.Errorf("unexpected name for condition %#v: got %s, want %s", condition, actual, expected)
} }
} }
} }
@ -62,6 +62,6 @@ func TestConditionName_InvalidCondition(t *testing.T) {
t.Errorf("invalid condition unexpected name: got %s, wanted panic", name) t.Errorf("invalid condition unexpected name: got %s, wanted panic", name)
}() }()
if !panicked { if !panicked {
t.Errorf("no expected panic for %04x.Name(): got no panic, wanted panic", lc) t.Errorf("no expected panic for %#v.Name(): got no panic, wanted panic", lc)
} }
} }

50
tools/compliance/conditionset_test.go
View file

@ -96,14 +96,13 @@ func TestConditionSet(t *testing.T) {
{ {
name: "everything", name: "everything",
conditions: []string{"unencumbered", "permissive", "notice", "reciprocal", "restricted", "proprietary"}, conditions: []string{"unencumbered", "permissive", "notice", "reciprocal", "restricted", "proprietary"},
plus: &[]string{"restricted_with_classpath_exception", "restricted_allows_dynamic_linking", "by_exception_only", "not_allowed"}, plus: &[]string{"restricted_allows_dynamic_linking", "by_exception_only", "not_allowed"},
matchingAny: map[string][]string{ matchingAny: map[string][]string{
"unencumbered": []string{"unencumbered"}, "unencumbered": []string{"unencumbered"},
"permissive": []string{"permissive"}, "permissive": []string{"permissive"},
"notice": []string{"notice"}, "notice": []string{"notice"},
"reciprocal": []string{"reciprocal"}, "reciprocal": []string{"reciprocal"},
"restricted": []string{"restricted"}, "restricted": []string{"restricted"},
"restricted_with_classpath_exception": []string{"restricted_with_classpath_exception"},
"restricted_allows_dynamic_linking": []string{"restricted_allows_dynamic_linking"}, "restricted_allows_dynamic_linking": []string{"restricted_allows_dynamic_linking"},
"proprietary": []string{"proprietary"}, "proprietary": []string{"proprietary"},
"by_exception_only": []string{"by_exception_only"}, "by_exception_only": []string{"by_exception_only"},
@ -116,7 +115,6 @@ func TestConditionSet(t *testing.T) {
"notice", "notice",
"reciprocal", "reciprocal",
"restricted", "restricted",
"restricted_with_classpath_exception",
"restricted_allows_dynamic_linking", "restricted_allows_dynamic_linking",
"proprietary", "proprietary",
"by_exception_only", "by_exception_only",
@ -131,7 +129,6 @@ func TestConditionSet(t *testing.T) {
"notice", "notice",
"reciprocal", "reciprocal",
"restricted", "restricted",
"restricted_with_classpath_exception",
"restricted_allows_dynamic_linking", "restricted_allows_dynamic_linking",
"proprietary", "proprietary",
"by_exception_only", "by_exception_only",
@ -151,7 +148,6 @@ func TestConditionSet(t *testing.T) {
"notice", "notice",
"reciprocal", "reciprocal",
"restricted", "restricted",
"restricted_with_classpath_exception",
"restricted_allows_dynamic_linking", "restricted_allows_dynamic_linking",
"proprietary", "proprietary",
"by_exception_only", "by_exception_only",
@ -168,7 +164,6 @@ func TestConditionSet(t *testing.T) {
"notice": []string{"notice"}, "notice": []string{"notice"},
"reciprocal": []string{"reciprocal"}, "reciprocal": []string{"reciprocal"},
"restricted": []string{"restricted"}, "restricted": []string{"restricted"},
"restricted_with_classpath_exception": []string{},
"restricted_allows_dynamic_linking": []string{"restricted_allows_dynamic_linking"}, "restricted_allows_dynamic_linking": []string{"restricted_allows_dynamic_linking"},
"proprietary": []string{"proprietary"}, "proprietary": []string{"proprietary"},
"by_exception_only": []string{"by_exception_only"}, "by_exception_only": []string{"by_exception_only"},
@ -195,7 +190,6 @@ func TestConditionSet(t *testing.T) {
"notice", "notice",
"reciprocal", "reciprocal",
"restricted", "restricted",
"restricted_with_classpath_exception",
"restricted_allows_dynamic_linking", "restricted_allows_dynamic_linking",
"proprietary", "proprietary",
"by_exception_only", "by_exception_only",
@ -208,7 +202,6 @@ func TestConditionSet(t *testing.T) {
"notice": []string{"notice"}, "notice": []string{"notice"},
"reciprocal": []string{"reciprocal"}, "reciprocal": []string{"reciprocal"},
"restricted": []string{"restricted"}, "restricted": []string{"restricted"},
"restricted_with_classpath_exception": []string{"restricted_with_classpath_exception"},
"restricted_allows_dynamic_linking": []string{}, "restricted_allows_dynamic_linking": []string{},
"proprietary": []string{"proprietary"}, "proprietary": []string{"proprietary"},
"by_exception_only": []string{"by_exception_only"}, "by_exception_only": []string{"by_exception_only"},
@ -221,7 +214,6 @@ func TestConditionSet(t *testing.T) {
"notice", "notice",
"reciprocal", "reciprocal",
"restricted", "restricted",
"restricted_with_classpath_exception",
"proprietary", "proprietary",
"by_exception_only", "by_exception_only",
"not_allowed", "not_allowed",
@ -235,7 +227,6 @@ func TestConditionSet(t *testing.T) {
"notice", "notice",
"reciprocal", "reciprocal",
"restricted", "restricted",
"restricted_with_classpath_exception",
"restricted_allows_dynamic_linking", "restricted_allows_dynamic_linking",
"proprietary", "proprietary",
"by_exception_only", "by_exception_only",
@ -247,7 +238,6 @@ func TestConditionSet(t *testing.T) {
"notice", "notice",
"reciprocal", "reciprocal",
"restricted", "restricted",
"restricted_with_classpath_exception",
"restricted_allows_dynamic_linking", "restricted_allows_dynamic_linking",
"proprietary", "proprietary",
"by_exception_only", "by_exception_only",
@ -259,7 +249,6 @@ func TestConditionSet(t *testing.T) {
"notice": []string{}, "notice": []string{},
"reciprocal": []string{}, "reciprocal": []string{},
"restricted": []string{}, "restricted": []string{},
"restricted_with_classpath_exception": []string{},
"restricted_allows_dynamic_linking": []string{}, "restricted_allows_dynamic_linking": []string{},
"proprietary": []string{}, "proprietary": []string{},
"by_exception_only": []string{}, "by_exception_only": []string{},
@ -270,21 +259,20 @@ func TestConditionSet(t *testing.T) {
}, },
{ {
name: "restrictedplus", name: "restrictedplus",
conditions: []string{"restricted", "restricted_with_classpath_exception", "restricted_allows_dynamic_linking"}, conditions: []string{"restricted", "restricted_allows_dynamic_linking"},
plus: &[]string{"permissive", "notice", "restricted", "proprietary"}, plus: &[]string{"permissive", "notice", "restricted", "proprietary"},
matchingAny: map[string][]string{ matchingAny: map[string][]string{
"unencumbered": []string{}, "unencumbered": []string{},
"permissive": []string{"permissive"}, "permissive": []string{"permissive"},
"notice": []string{"notice"}, "notice": []string{"notice"},
"restricted": []string{"restricted"}, "restricted": []string{"restricted"},
"restricted_with_classpath_exception": []string{"restricted_with_classpath_exception"},
"restricted_allows_dynamic_linking": []string{"restricted_allows_dynamic_linking"}, "restricted_allows_dynamic_linking": []string{"restricted_allows_dynamic_linking"},
"proprietary": []string{"proprietary"}, "proprietary": []string{"proprietary"},
"restricted|proprietary": []string{"restricted", "proprietary"}, "restricted|proprietary": []string{"restricted", "proprietary"},
"by_exception_only": []string{}, "by_exception_only": []string{},
"proprietary|by_exception_only": []string{"proprietary"}, "proprietary|by_exception_only": []string{"proprietary"},
}, },
expected: []string{"permissive", "notice", "restricted", "restricted_with_classpath_exception", "restricted_allows_dynamic_linking", "proprietary"}, expected: []string{"permissive", "notice", "restricted", "restricted_allows_dynamic_linking", "proprietary"},
}, },
} }
for _, tt := range tests { for _, tt := range tests {
@ -342,11 +330,11 @@ func TestConditionSet(t *testing.T) {
actual := cs.MatchingAny(toConditions(strings.Split(data, "|"))...) actual := cs.MatchingAny(toConditions(strings.Split(data, "|"))...)
actualNames := actual.Names() actualNames := actual.Names()
t.Logf("MatchingAny(%s): actual set %04x %s", data, actual, actual.String()) t.Logf("MatchingAny(%s): actual set %#v %s", data, actual, actual.String())
t.Logf("MatchingAny(%s): expected set %04x %s", data, expected, expected.String()) t.Logf("MatchingAny(%s): expected set %#v %s", data, expected, expected.String())
if actual != expected { if actual != expected {
t.Errorf("MatchingAny(%s): got %04x, want %04x", data, actual, expected) t.Errorf("MatchingAny(%s): got %#v, want %#v", data, actual, expected)
continue continue
} }
if len(actualNames) != len(expectedNames) { if len(actualNames) != len(expectedNames) {
@ -382,11 +370,11 @@ func TestConditionSet(t *testing.T) {
actual := cs.MatchingAnySet(NewLicenseConditionSet(toConditions(strings.Split(data, "|"))...)) actual := cs.MatchingAnySet(NewLicenseConditionSet(toConditions(strings.Split(data, "|"))...))
actualNames := actual.Names() actualNames := actual.Names()
t.Logf("MatchingAnySet(%s): actual set %04x %s", data, actual, actual.String()) t.Logf("MatchingAnySet(%s): actual set %#v %s", data, actual, actual.String())
t.Logf("MatchingAnySet(%s): expected set %04x %s", data, expected, expected.String()) t.Logf("MatchingAnySet(%s): expected set %#v %s", data, expected, expected.String())
if actual != expected { if actual != expected {
t.Errorf("MatchingAnySet(%s): got %04x, want %04x", data, actual, expected) t.Errorf("MatchingAnySet(%s): got %#v, want %#v", data, actual, expected)
continue continue
} }
if len(actualNames) != len(expectedNames) { if len(actualNames) != len(expectedNames) {
@ -426,11 +414,11 @@ func TestConditionSet(t *testing.T) {
actualNames := actual.Names() actualNames := actual.Names()
t.Logf("actual license condition set: %04x %s", actual, actual.String()) t.Logf("actual license condition set: %#v %s", actual, actual.String())
t.Logf("expected license condition set: %04x %s", expected, expected.String()) t.Logf("expected license condition set: %#v %s", expected, expected.String())
if actual != expected { if actual != expected {
t.Errorf("checkExpected: got %04x, want %04x", actual, expected) t.Errorf("checkExpected: got %#v, want %#v", actual, expected)
return false return false
} }
@ -487,7 +475,7 @@ func TestConditionSet(t *testing.T) {
notExpected := (AllLicenseConditions &^ expected) notExpected := (AllLicenseConditions &^ expected)
notExpectedList := notExpected.AsList() notExpectedList := notExpected.AsList()
t.Logf("not expected license condition set: %04x %s", notExpected, notExpected.String()) t.Logf("not expected license condition set: %#v %s", notExpected, notExpected.String())
if len(tt.expected) == 0 { if len(tt.expected) == 0 {
if actual.HasAny(append(expectedConditions, notExpectedList...)...) { if actual.HasAny(append(expectedConditions, notExpectedList...)...) {
@ -526,11 +514,11 @@ func TestConditionSet(t *testing.T) {
actualNames := actual.Names() actualNames := actual.Names()
t.Logf("actual license condition set: %04x %s", actual, actual.String()) t.Logf("actual license condition set: %#v %s", actual, actual.String())
t.Logf("expected license condition set: %04x %s", expected, expected.String()) t.Logf("expected license condition set: %#v %s", expected, expected.String())
if actual != expected { if actual != expected {
t.Errorf("checkExpectedSet: got %04x, want %04x", actual, expected) t.Errorf("checkExpectedSet: got %#v, want %#v", actual, expected)
return false return false
} }
@ -581,7 +569,7 @@ func TestConditionSet(t *testing.T) {
} }
notExpected := (AllLicenseConditions &^ expected) notExpected := (AllLicenseConditions &^ expected)
t.Logf("not expected license condition set: %04x %s", notExpected, notExpected.String()) t.Logf("not expected license condition set: %#v %s", notExpected, notExpected.String())
if len(tt.expected) == 0 { if len(tt.expected) == 0 {
if actual.MatchesAnySet(expected, notExpected) { if actual.MatchesAnySet(expected, notExpected) {
@ -606,10 +594,10 @@ func TestConditionSet(t *testing.T) {
t.Errorf("actual.Difference({expected}).IsEmpty(): want true, got false") t.Errorf("actual.Difference({expected}).IsEmpty(): want true, got false")
} }
if expected != actual.Intersection(expected) { if expected != actual.Intersection(expected) {
t.Errorf("expected == actual.Intersection({expected}): want true, got false (%04x != %04x)", 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) { if actual != actual.Intersection(expected) {
t.Errorf("actual == actual.Intersection({expected}): want true, got false (%04x != %04x)", actual, actual.Intersection(expected)) t.Errorf("actual == actual.Intersection({expected}): want true, got false (%#v != %#v)", actual, actual.Intersection(expected))
} }
return true return true
} }

33
tools/compliance/policy_policy.go
View file

@ -16,7 +16,6 @@ package compliance
import ( import (
"regexp" "regexp"
"strings"
) )
var ( var (
@ -62,14 +61,13 @@ var (
// ImpliesNotice lists the condition names implying a notice or attribution policy. // ImpliesNotice lists the condition names implying a notice or attribution policy.
ImpliesNotice = LicenseConditionSet(UnencumberedCondition | PermissiveCondition | NoticeCondition | ReciprocalCondition | ImpliesNotice = LicenseConditionSet(UnencumberedCondition | PermissiveCondition | NoticeCondition | ReciprocalCondition |
RestrictedCondition | RestrictedClasspathExceptionCondition | WeaklyRestrictedCondition | RestrictedCondition | WeaklyRestrictedCondition | ProprietaryCondition | ByExceptionOnlyCondition)
ProprietaryCondition | ByExceptionOnlyCondition)
// ImpliesReciprocal lists the condition names implying a local source-sharing policy. // ImpliesReciprocal lists the condition names implying a local source-sharing policy.
ImpliesReciprocal = LicenseConditionSet(ReciprocalCondition) ImpliesReciprocal = LicenseConditionSet(ReciprocalCondition)
// Restricted lists the condition names implying an infectious source-sharing policy. // Restricted lists the condition names implying an infectious source-sharing policy.
ImpliesRestricted = LicenseConditionSet(RestrictedCondition | RestrictedClasspathExceptionCondition | WeaklyRestrictedCondition) ImpliesRestricted = LicenseConditionSet(RestrictedCondition | WeaklyRestrictedCondition)
// ImpliesProprietary lists the condition names implying a confidentiality policy. // ImpliesProprietary lists the condition names implying a confidentiality policy.
ImpliesProprietary = LicenseConditionSet(ProprietaryCondition) ImpliesProprietary = LicenseConditionSet(ProprietaryCondition)
@ -81,7 +79,7 @@ var (
ImpliesPrivate = LicenseConditionSet(ProprietaryCondition) ImpliesPrivate = LicenseConditionSet(ProprietaryCondition)
// ImpliesShared lists the condition names implying a source-code sharing policy. // ImpliesShared lists the condition names implying a source-code sharing policy.
ImpliesShared = LicenseConditionSet(ReciprocalCondition | RestrictedCondition | RestrictedClasspathExceptionCondition | WeaklyRestrictedCondition) ImpliesShared = LicenseConditionSet(ReciprocalCondition | RestrictedCondition | WeaklyRestrictedCondition)
) )
var ( var (
@ -112,13 +110,9 @@ func LicenseConditionSetFromNames(tn *TargetNode, names ...string) LicenseCondit
continue continue
} }
hasLgpl := false hasLgpl := false
hasClasspath := false
hasGeneric := false hasGeneric := false
for _, kind := range tn.LicenseKinds() { for _, kind := range tn.LicenseKinds() {
if strings.HasSuffix(kind, "-with-classpath-exception") { if anyLgpl.MatchString(kind) {
cs = cs.Plus(RestrictedClasspathExceptionCondition)
hasClasspath = true
} else if anyLgpl.MatchString(kind) {
cs = cs.Plus(WeaklyRestrictedCondition) cs = cs.Plus(WeaklyRestrictedCondition)
hasLgpl = true hasLgpl = true
} else if versionedGpl.MatchString(kind) { } else if versionedGpl.MatchString(kind) {
@ -131,7 +125,7 @@ func LicenseConditionSetFromNames(tn *TargetNode, names ...string) LicenseCondit
cs = cs.Plus(RestrictedCondition) cs = cs.Plus(RestrictedCondition)
} }
} }
if hasGeneric && !hasLgpl && !hasClasspath { if hasGeneric && !hasLgpl {
cs = cs.Plus(RestrictedCondition) cs = cs.Plus(RestrictedCondition)
} }
continue continue
@ -202,9 +196,6 @@ func depConditionsPropagatingToTarget(lg *LicenseGraph, e *TargetEdge, depCondit
} }
result |= depConditions & LicenseConditionSet(RestrictedCondition) result |= depConditions & LicenseConditionSet(RestrictedCondition)
if 0 != (depConditions&LicenseConditionSet(RestrictedClasspathExceptionCondition)) && !edgeNodesAreIndependentModules(e) {
result |= LicenseConditionSet(RestrictedClasspathExceptionCondition)
}
return result return result
} }
@ -241,9 +232,6 @@ func targetConditionsPropagatingToDep(lg *LicenseGraph, e *TargetEdge, targetCon
return result return result
} }
result = result.Minus(WeaklyRestrictedCondition) result = result.Minus(WeaklyRestrictedCondition)
if edgeNodesAreIndependentModules(e) {
result = result.Minus(RestrictedClasspathExceptionCondition)
}
return result return result
} }
@ -261,10 +249,7 @@ func conditionsAttachingAcrossEdge(lg *LicenseGraph, e *TargetEdge, universe Lic
return NewLicenseConditionSet() return NewLicenseConditionSet()
} }
result &= LicenseConditionSet(RestrictedCondition | RestrictedClasspathExceptionCondition) result &= LicenseConditionSet(RestrictedCondition)
if 0 != (result&LicenseConditionSet(RestrictedClasspathExceptionCondition)) && edgeNodesAreIndependentModules(e) {
result &= LicenseConditionSet(RestrictedCondition)
}
return result return result
} }
@ -281,9 +266,3 @@ func edgeIsDerivation(e *TargetEdge) bool {
isToolchain := e.annotations.HasAnnotation("toolchain") isToolchain := e.annotations.HasAnnotation("toolchain")
return !isDynamic && !isToolchain return !isDynamic && !isToolchain
} }
// edgeNodesAreIndependentModules returns true for edges where the target and
// dependency are independent modules.
func edgeNodesAreIndependentModules(e *TargetEdge) bool {
return e.target.PackageName() != e.dependency.PackageName()
}

22
tools/compliance/policy_policy_test.go
View file

@ -85,19 +85,13 @@ func TestPolicy_edgeConditions(t *testing.T) {
{ {
name: "independentmodulestatic", name: "independentmodulestatic",
edge: annotated{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", []string{"static"}}, edge: annotated{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", []string{"static"}},
expectedDepActions: []string{ expectedDepActions: []string{},
"apacheBin.meta_lic:gplWithClasspathException.meta_lic:restricted_with_classpath_exception",
"gplWithClasspathException.meta_lic:gplWithClasspathException.meta_lic:restricted_with_classpath_exception",
},
expectedTargetConditions: []string{}, expectedTargetConditions: []string{},
}, },
{ {
name: "dependentmodule", name: "dependentmodule",
edge: annotated{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}}, edge: annotated{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}},
expectedDepActions: []string{ expectedDepActions: []string{},
"dependentModule.meta_lic:gplWithClasspathException.meta_lic:restricted_with_classpath_exception",
"gplWithClasspathException.meta_lic:gplWithClasspathException.meta_lic:restricted_with_classpath_exception",
},
expectedTargetConditions: []string{}, expectedTargetConditions: []string{},
}, },
@ -166,13 +160,13 @@ func TestPolicy_edgeConditions(t *testing.T) {
name: "independentmodulereversestatic", name: "independentmodulereversestatic",
edge: annotated{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"static"}}, edge: annotated{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"static"}},
expectedDepActions: []string{}, expectedDepActions: []string{},
expectedTargetConditions: []string{"gplWithClasspathException.meta_lic:restricted_with_classpath_exception"}, expectedTargetConditions: []string{},
}, },
{ {
name: "dependentmodulereverse", name: "dependentmodulereverse",
edge: annotated{"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}}, edge: annotated{"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}},
expectedDepActions: []string{}, expectedDepActions: []string{},
expectedTargetConditions: []string{"gplWithClasspathException.meta_lic:restricted_with_classpath_exception"}, expectedTargetConditions: []string{},
}, },
{ {
name: "ponr", name: "ponr",
@ -257,9 +251,9 @@ func TestPolicy_edgeConditions(t *testing.T) {
otherCs := otn.LicenseConditions() otherCs := otn.LicenseConditions()
depConditions |= otherCs depConditions |= otherCs
} }
t.Logf("calculate target actions for edge=%s, dep conditions=%04x, treatAsAggregate=%v", edge.String(), depConditions, tt.treatAsAggregate) t.Logf("calculate target actions for edge=%s, dep conditions=%#v %s, treatAsAggregate=%v", edge.String(), depConditions, depConditions, tt.treatAsAggregate)
csActual := depConditionsPropagatingToTarget(lg, edge, depConditions, tt.treatAsAggregate) csActual := depConditionsPropagatingToTarget(lg, edge, depConditions, tt.treatAsAggregate)
t.Logf("calculated target conditions as %04x{%s}", csActual, strings.Join(csActual.Names(), ", ")) t.Logf("calculated target conditions as %#v %s", csActual, csActual)
csExpected := NewLicenseConditionSet() csExpected := NewLicenseConditionSet()
for _, triple := range tt.expectedDepActions { for _, triple := range tt.expectedDepActions {
fields := strings.Split(triple, ":") fields := strings.Split(triple, ":")
@ -269,9 +263,9 @@ func TestPolicy_edgeConditions(t *testing.T) {
} }
csExpected |= expectedConditions csExpected |= expectedConditions
} }
t.Logf("expected target conditions as %04x{%s}", csExpected, strings.Join(csExpected.Names(), ", ")) t.Logf("expected target conditions as %#v %s", csExpected, csExpected)
if csActual != csExpected { if csActual != csExpected {
t.Errorf("unexpected license conditions: got %04x, want %04x", csActual, csExpected) t.Errorf("unexpected license conditions: got %#v, want %#v", csActual, csExpected)
} }
}) })
} }

34
tools/compliance/policy_resolve_test.go
View file

@ -289,8 +289,8 @@ func TestResolveBottomUpConditions(t *testing.T) {
{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", []string{"static"}}, {"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", []string{"static"}},
}, },
expectedActions: []tcond{ expectedActions: []tcond{
{"apacheBin.meta_lic", "notice|restricted_with_classpath_exception"}, {"apacheBin.meta_lic", "notice"},
{"gplWithClasspathException.meta_lic", "restricted_with_classpath_exception"}, {"gplWithClasspathException.meta_lic", "permissive"},
}, },
}, },
{ {
@ -300,8 +300,8 @@ func TestResolveBottomUpConditions(t *testing.T) {
{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"static"}}, {"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"static"}},
}, },
expectedActions: []tcond{ expectedActions: []tcond{
{"dependentModule.meta_lic", "notice|restricted_with_classpath_exception"}, {"dependentModule.meta_lic", "notice"},
{"gplWithClasspathException.meta_lic", "restricted_with_classpath_exception"}, {"gplWithClasspathException.meta_lic", "permissive"},
}, },
}, },
{ {
@ -312,7 +312,7 @@ func TestResolveBottomUpConditions(t *testing.T) {
}, },
expectedActions: []tcond{ expectedActions: []tcond{
{"apacheBin.meta_lic", "notice"}, {"apacheBin.meta_lic", "notice"},
{"gplWithClasspathException.meta_lic", "restricted_with_classpath_exception"}, {"gplWithClasspathException.meta_lic", "permissive"},
}, },
}, },
{ {
@ -322,8 +322,8 @@ func TestResolveBottomUpConditions(t *testing.T) {
{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}}, {"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}},
}, },
expectedActions: []tcond{ expectedActions: []tcond{
{"dependentModule.meta_lic", "notice|restricted_with_classpath_exception"}, {"dependentModule.meta_lic", "notice"},
{"gplWithClasspathException.meta_lic", "restricted_with_classpath_exception"}, {"gplWithClasspathException.meta_lic", "permissive"},
}, },
}, },
} }
@ -593,9 +593,9 @@ func TestResolveTopDownConditions(t *testing.T) {
{"apacheBin.meta_lic", "mitLib.meta_lic", []string{"static"}}, {"apacheBin.meta_lic", "mitLib.meta_lic", []string{"static"}},
}, },
expectedActions: []tcond{ expectedActions: []tcond{
{"apacheBin.meta_lic", "notice|restricted_with_classpath_exception"}, {"apacheBin.meta_lic", "notice"},
{"gplWithClasspathException.meta_lic", "restricted_with_classpath_exception"}, {"gplWithClasspathException.meta_lic", "permissive"},
{"mitLib.meta_lic", "notice|restricted_with_classpath_exception"}, {"mitLib.meta_lic", "notice"},
}, },
}, },
{ {
@ -606,9 +606,9 @@ func TestResolveTopDownConditions(t *testing.T) {
{"dependentModule.meta_lic", "mitLib.meta_lic", []string{"static"}}, {"dependentModule.meta_lic", "mitLib.meta_lic", []string{"static"}},
}, },
expectedActions: []tcond{ expectedActions: []tcond{
{"dependentModule.meta_lic", "notice|restricted_with_classpath_exception"}, {"dependentModule.meta_lic", "notice"},
{"gplWithClasspathException.meta_lic", "restricted_with_classpath_exception"}, {"gplWithClasspathException.meta_lic", "permissive"},
{"mitLib.meta_lic", "notice|restricted_with_classpath_exception"}, {"mitLib.meta_lic", "notice"},
}, },
}, },
{ {
@ -620,7 +620,7 @@ func TestResolveTopDownConditions(t *testing.T) {
}, },
expectedActions: []tcond{ expectedActions: []tcond{
{"apacheBin.meta_lic", "notice"}, {"apacheBin.meta_lic", "notice"},
{"gplWithClasspathException.meta_lic", "restricted_with_classpath_exception"}, {"gplWithClasspathException.meta_lic", "permissive"},
{"mitLib.meta_lic", "notice"}, {"mitLib.meta_lic", "notice"},
}, },
}, },
@ -632,9 +632,9 @@ func TestResolveTopDownConditions(t *testing.T) {
{"dependentModule.meta_lic", "mitLib.meta_lic", []string{"static"}}, {"dependentModule.meta_lic", "mitLib.meta_lic", []string{"static"}},
}, },
expectedActions: []tcond{ expectedActions: []tcond{
{"dependentModule.meta_lic", "notice|restricted_with_classpath_exception"}, {"dependentModule.meta_lic", "notice"},
{"gplWithClasspathException.meta_lic", "restricted_with_classpath_exception"}, {"gplWithClasspathException.meta_lic", "permissive"},
{"mitLib.meta_lic", "notice|restricted_with_classpath_exception"}, {"mitLib.meta_lic", "notice"},
}, },
}, },
} }

17
tools/compliance/policy_resolvenotices_test.go
View file

@ -375,10 +375,8 @@ func TestResolveNotices(t *testing.T) {
}, },
expectedResolutions: []res{ expectedResolutions: []res{
{"apacheBin.meta_lic", "apacheBin.meta_lic", "apacheBin.meta_lic", "notice"}, {"apacheBin.meta_lic", "apacheBin.meta_lic", "apacheBin.meta_lic", "notice"},
{"apacheBin.meta_lic", "apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "restricted"}, {"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "permissive"},
{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"apacheBin.meta_lic", "mitLib.meta_lic", "mitLib.meta_lic", "notice"}, {"apacheBin.meta_lic", "mitLib.meta_lic", "mitLib.meta_lic", "notice"},
{"apacheBin.meta_lic", "mitLib.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
}, },
}, },
{ {
@ -390,10 +388,8 @@ func TestResolveNotices(t *testing.T) {
}, },
expectedResolutions: []res{ expectedResolutions: []res{
{"dependentModule.meta_lic", "dependentModule.meta_lic", "dependentModule.meta_lic", "notice"}, {"dependentModule.meta_lic", "dependentModule.meta_lic", "dependentModule.meta_lic", "notice"},
{"dependentModule.meta_lic", "dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"}, {"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "permissive"},
{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"dependentModule.meta_lic", "mitLib.meta_lic", "mitLib.meta_lic", "notice"}, {"dependentModule.meta_lic", "mitLib.meta_lic", "mitLib.meta_lic", "notice"},
{"dependentModule.meta_lic", "mitLib.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
}, },
}, },
{ {
@ -418,7 +414,7 @@ func TestResolveNotices(t *testing.T) {
expectedResolutions: []res{ expectedResolutions: []res{
{"apacheBin.meta_lic", "apacheBin.meta_lic", "apacheBin.meta_lic", "notice"}, {"apacheBin.meta_lic", "apacheBin.meta_lic", "apacheBin.meta_lic", "notice"},
{"apacheBin.meta_lic", "mitLib.meta_lic", "mitLib.meta_lic", "notice"}, {"apacheBin.meta_lic", "mitLib.meta_lic", "mitLib.meta_lic", "notice"},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"}, {"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "permissive"},
}, },
}, },
{ {
@ -430,9 +426,7 @@ func TestResolveNotices(t *testing.T) {
}, },
expectedResolutions: []res{ expectedResolutions: []res{
{"dependentModule.meta_lic", "dependentModule.meta_lic", "dependentModule.meta_lic", "notice"}, {"dependentModule.meta_lic", "dependentModule.meta_lic", "dependentModule.meta_lic", "notice"},
{"dependentModule.meta_lic", "dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"dependentModule.meta_lic", "mitLib.meta_lic", "mitLib.meta_lic", "notice"}, {"dependentModule.meta_lic", "mitLib.meta_lic", "mitLib.meta_lic", "notice"},
{"dependentModule.meta_lic", "mitLib.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
}, },
}, },
{ {
@ -444,11 +438,8 @@ func TestResolveNotices(t *testing.T) {
}, },
expectedResolutions: []res{ expectedResolutions: []res{
{"dependentModule.meta_lic", "dependentModule.meta_lic", "dependentModule.meta_lic", "notice"}, {"dependentModule.meta_lic", "dependentModule.meta_lic", "dependentModule.meta_lic", "notice"},
{"dependentModule.meta_lic", "dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"dependentModule.meta_lic", "mitLib.meta_lic", "mitLib.meta_lic", "notice"}, {"dependentModule.meta_lic", "mitLib.meta_lic", "mitLib.meta_lic", "notice"},
{"dependentModule.meta_lic", "mitLib.meta_lic", "gplWithClasspathException.meta_lic", "restricted"}, {"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "permissive"},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
}, },
}, },
} }

38
tools/compliance/policy_resolveshare_test.go
View file

@ -40,9 +40,7 @@ func TestResolveSourceSharing(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}}, {"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "independentmodulestaticrestricted", name: "independentmodulestaticrestricted",
@ -50,10 +48,7 @@ func TestResolveSourceSharing(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", []string{"static"}}, {"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", []string{"static"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"apacheBin.meta_lic", "apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "dependentmodulerestricted", name: "dependentmodulerestricted",
@ -61,9 +56,7 @@ func TestResolveSourceSharing(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}}, {"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"dependentModule.meta_lic", "dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "dependentmodulerestrictedshipclasspath", name: "dependentmodulerestrictedshipclasspath",
@ -71,11 +64,7 @@ func TestResolveSourceSharing(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}}, {"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"dependentModule.meta_lic", "dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "lgplonfprestricted", name: "lgplonfprestricted",
@ -185,9 +174,7 @@ func TestResolveSourceSharing(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "independentmodulereversestaticrestricted", name: "independentmodulereversestaticrestricted",
@ -195,10 +182,7 @@ func TestResolveSourceSharing(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"static"}}, {"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"static"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "dependentmodulereverserestricted", name: "dependentmodulereverserestricted",
@ -206,9 +190,7 @@ func TestResolveSourceSharing(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "dependentmodulereverserestrictedshipdependent", name: "dependentmodulereverserestrictedshipdependent",
@ -216,11 +198,7 @@ func TestResolveSourceSharing(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"dependentModule.meta_lic", "dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "ponrrestricted", name: "ponrrestricted",

85
tools/compliance/policy_walk_test.go
View file

@ -104,8 +104,7 @@ func TestWalkResolutionsForCondition(t *testing.T) {
}, },
expectedResolutions: []res{ expectedResolutions: []res{
{"apacheBin.meta_lic", "apacheBin.meta_lic", "apacheBin.meta_lic", "notice"}, {"apacheBin.meta_lic", "apacheBin.meta_lic", "apacheBin.meta_lic", "notice"},
{"apacheBin.meta_lic", "apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "restricted"}, {"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "permissive"},
{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
}, },
}, },
{ {
@ -115,10 +114,7 @@ func TestWalkResolutionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", []string{"static"}}, {"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", []string{"static"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"apacheBin.meta_lic", "apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "dependentmodulenotice", name: "dependentmodulenotice",
@ -129,7 +125,6 @@ func TestWalkResolutionsForCondition(t *testing.T) {
}, },
expectedResolutions: []res{ expectedResolutions: []res{
{"dependentModule.meta_lic", "dependentModule.meta_lic", "dependentModule.meta_lic", "notice"}, {"dependentModule.meta_lic", "dependentModule.meta_lic", "dependentModule.meta_lic", "notice"},
{"dependentModule.meta_lic", "dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
}, },
}, },
{ {
@ -139,9 +134,7 @@ func TestWalkResolutionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}}, {"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"dependentModule.meta_lic", "dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "lgplonfpnotice", name: "lgplonfpnotice",
@ -347,7 +340,7 @@ func TestWalkResolutionsForCondition(t *testing.T) {
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"}, {"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "permissive"},
}, },
}, },
{ {
@ -357,9 +350,7 @@ func TestWalkResolutionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "independentmodulereverserestrictedshipped", name: "independentmodulereverserestrictedshipped",
@ -368,9 +359,7 @@ func TestWalkResolutionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "independentmodulereversestaticnotice", name: "independentmodulereversestaticnotice",
@ -380,9 +369,8 @@ func TestWalkResolutionsForCondition(t *testing.T) {
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"static"}}, {"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"static"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"}, {"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "permissive"},
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", "apacheBin.meta_lic", "notice"}, {"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", "apacheBin.meta_lic", "notice"},
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
}, },
}, },
{ {
@ -392,10 +380,7 @@ func TestWalkResolutionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"static"}}, {"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"static"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "dependentmodulereversenotice", name: "dependentmodulereversenotice",
@ -405,7 +390,7 @@ func TestWalkResolutionsForCondition(t *testing.T) {
{"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"}, {"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "permissive"},
}, },
}, },
{ {
@ -415,9 +400,7 @@ func TestWalkResolutionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "dependentmodulereverserestrictedshipped", name: "dependentmodulereverserestrictedshipped",
@ -426,11 +409,7 @@ func TestWalkResolutionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}},
}, },
expectedResolutions: []res{ expectedResolutions: []res{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"dependentModule.meta_lic", "dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "ponrnotice", name: "ponrnotice",
@ -716,8 +695,7 @@ func TestWalkActionsForCondition(t *testing.T) {
}, },
expectedActions: []act{ expectedActions: []act{
{"apacheBin.meta_lic", "apacheBin.meta_lic", "notice"}, {"apacheBin.meta_lic", "apacheBin.meta_lic", "notice"},
{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "restricted"}, {"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "permissive"},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
}, },
}, },
{ {
@ -727,10 +705,7 @@ func TestWalkActionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", []string{"static"}}, {"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", []string{"static"}},
}, },
expectedActions: []act{ expectedActions: []act{},
{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "dependentmodulenotice", name: "dependentmodulenotice",
@ -741,7 +716,6 @@ func TestWalkActionsForCondition(t *testing.T) {
}, },
expectedActions: []act{ expectedActions: []act{
{"dependentModule.meta_lic", "dependentModule.meta_lic", "notice"}, {"dependentModule.meta_lic", "dependentModule.meta_lic", "notice"},
{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
}, },
}, },
{ {
@ -751,9 +725,7 @@ func TestWalkActionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}}, {"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", []string{"dynamic"}},
}, },
expectedActions: []act{ expectedActions: []act{},
{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "lgplonfpnotice", name: "lgplonfpnotice",
@ -956,7 +928,7 @@ func TestWalkActionsForCondition(t *testing.T) {
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}},
}, },
expectedActions: []act{ expectedActions: []act{
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"}, {"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "permissive"},
}, },
}, },
{ {
@ -966,9 +938,7 @@ func TestWalkActionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}},
}, },
expectedActions: []act{ expectedActions: []act{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "independentmodulereverserestrictedshipped", name: "independentmodulereverserestrictedshipped",
@ -977,9 +947,7 @@ func TestWalkActionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"dynamic"}},
}, },
expectedActions: []act{ expectedActions: []act{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "independentmodulereversestaticnotice", name: "independentmodulereversestaticnotice",
@ -989,9 +957,8 @@ func TestWalkActionsForCondition(t *testing.T) {
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"static"}}, {"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"static"}},
}, },
expectedActions: []act{ expectedActions: []act{
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"}, {"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "permissive"},
{"apacheBin.meta_lic", "apacheBin.meta_lic", "notice"}, {"apacheBin.meta_lic", "apacheBin.meta_lic", "notice"},
{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
}, },
}, },
{ {
@ -1001,10 +968,7 @@ func TestWalkActionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"static"}}, {"gplWithClasspathException.meta_lic", "apacheBin.meta_lic", []string{"static"}},
}, },
expectedActions: []act{ expectedActions: []act{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"apacheBin.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "dependentmodulereversenotice", name: "dependentmodulereversenotice",
@ -1014,7 +978,7 @@ func TestWalkActionsForCondition(t *testing.T) {
{"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}},
}, },
expectedActions: []act{ expectedActions: []act{
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"}, {"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "permissive"},
}, },
}, },
{ {
@ -1024,9 +988,7 @@ func TestWalkActionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}},
}, },
expectedActions: []act{ expectedActions: []act{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "dependentmodulereverserestrictedshipped", name: "dependentmodulereverserestrictedshipped",
@ -1035,10 +997,7 @@ func TestWalkActionsForCondition(t *testing.T) {
edges: []annotated{ edges: []annotated{
{"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}}, {"gplWithClasspathException.meta_lic", "dependentModule.meta_lic", []string{"dynamic"}},
}, },
expectedActions: []act{ expectedActions: []act{},
{"gplWithClasspathException.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
{"dependentModule.meta_lic", "gplWithClasspathException.meta_lic", "restricted"},
},
}, },
{ {
name: "ponrnotice", name: "ponrnotice",

6
tools/compliance/test_util.go
View file

@ -42,7 +42,7 @@ license_conditions: "restricted"
Classpath = `` + Classpath = `` +
`package_name: "Free Software" `package_name: "Free Software"
license_kinds: "SPDX-license-identifier-GPL-2.0-with-classpath-exception" license_kinds: "SPDX-license-identifier-GPL-2.0-with-classpath-exception"
license_conditions: "restricted" license_conditions: "permissive"
` `
// DependentModule starts a test metadata file for a module in the same package as `Classpath`. // DependentModule starts a test metadata file for a module in the same package as `Classpath`.
@ -521,7 +521,7 @@ func checkSame(rsActual, rsExpected ResolutionSet, t *testing.T) {
expectedConditions := expectedRl[i].Resolves() expectedConditions := expectedRl[i].Resolves()
actualConditions := actualRl[i].Resolves() actualConditions := actualRl[i].Resolves()
if expectedConditions != actualConditions { if expectedConditions != actualConditions {
t.Errorf("unexpected conditions apply to %q acting on %q: got %04x with names %s, want %04x with names %s", t.Errorf("unexpected conditions apply to %q acting on %q: got %#v with names %s, want %#v with names %s",
target.name, expectedRl[i].actsOn.name, target.name, expectedRl[i].actsOn.name,
actualConditions, actualConditions.Names(), actualConditions, actualConditions.Names(),
expectedConditions, expectedConditions.Names()) expectedConditions, expectedConditions.Names())
@ -586,7 +586,7 @@ func checkResolves(rsActual, rsExpected ResolutionSet, t *testing.T) {
expectedConditions := expectedRl[i].Resolves() expectedConditions := expectedRl[i].Resolves()
actualConditions := actualRl[i].Resolves() actualConditions := actualRl[i].Resolves()
if expectedConditions != (expectedConditions & actualConditions) { if expectedConditions != (expectedConditions & actualConditions) {
t.Errorf("expected conditions missing from %q acting on %q: got %04x with names %s, want %04x with names %s", t.Errorf("expected conditions missing from %q acting on %q: got %#v with names %s, want %#v with names %s",
target.name, expectedRl[i].actsOn.name, target.name, expectedRl[i].actsOn.name,
actualConditions, actualConditions.Names(), actualConditions, actualConditions.Names(),
expectedConditions, expectedConditions.Names()) expectedConditions, expectedConditions.Names())