From 1ea7c9fa522c81da21989e0f1e5d1af67bb02b08 Mon Sep 17 00:00:00 2001 From: Paul Duffin Date: Mon, 15 Mar 2021 09:39:13 +0000 Subject: [PATCH] Add test to TestJavaStableSdkVersion for legacy core platform Adds a test case to TestJavaStableSdkVersion for the case where a module uses sdk_version: "core_platform" but is in the list of modules that can use the legacy version. This required storing the lookup map in the Config to allow it to be customized for the test. Bug: 180399951 Test: m nothing Change-Id: I404705c3fd8a559649c6ab2624856cf78f49f85c --- apex/apex_test.go | 43 +++++++++++++++++++++++--- java/base.go | 2 +- java/legacy_core_platform_api_usage.go | 22 +++++++++---- java/testing.go | 20 ++++++++++++ 4 files changed, 76 insertions(+), 11 deletions(-) diff --git a/apex/apex_test.go b/apex/apex_test.go index bcbf1adaf..2a2a1f45f 100644 --- a/apex/apex_test.go +++ b/apex/apex_test.go @@ -2187,6 +2187,7 @@ func TestJavaStableSdkVersion(t *testing.T) { name string expectedError string bp string + preparer android.FixturePreparer }{ { name: "Non-updatable apex with non-stable dep", @@ -2257,6 +2258,30 @@ func TestJavaStableSdkVersion(t *testing.T) { } `, }, + { + name: "Updatable apex with non-stable legacy core platform dep", + expectedError: `\Qcannot depend on "myjar-uses-legacy": non stable SDK core_platform_current - uses legacy core platform\E`, + bp: ` + apex { + name: "myapex", + java_libs: ["myjar-uses-legacy"], + key: "myapex.key", + updatable: true, + } + apex_key { + name: "myapex.key", + public_key: "testkey.avbpubkey", + private_key: "testkey.pem", + } + java_library { + name: "myjar-uses-legacy", + srcs: ["foo/bar/MyClass.java"], + sdk_version: "core_platform", + apex_available: ["myapex"], + } + `, + preparer: java.FixtureUseLegacyCorePlatformApi("myjar-uses-legacy"), + }, { name: "Updatable apex with non-stable transitive dep", // This is not actually detecting that the transitive dependency is unstable, rather it is @@ -2293,12 +2318,22 @@ func TestJavaStableSdkVersion(t *testing.T) { } for _, test := range testCases { + if test.name != "Updatable apex with non-stable legacy core platform dep" { + continue + } t.Run(test.name, func(t *testing.T) { - if test.expectedError == "" { - testApex(t, test.bp) - } else { - testApexError(t, test.expectedError, test.bp) + errorHandler := android.FixtureExpectsNoErrors + if test.expectedError != "" { + errorHandler = android.FixtureExpectsAtLeastOneErrorMatchingPattern(test.expectedError) } + android.GroupFixturePreparers( + java.PrepareForTestWithJavaDefaultModules, + PrepareForTestWithApexBuildComponents, + prepareForTestWithMyapex, + android.OptionalFixturePreparer(test.preparer), + ). + ExtendWithErrorHandler(errorHandler). + RunTestWithBp(t, test.bp) }) } } diff --git a/java/base.go b/java/base.go index 86022c3b2..da9293ce6 100644 --- a/java/base.go +++ b/java/base.go @@ -382,7 +382,7 @@ func (j *Module) CheckStableSdkVersion(ctx android.BaseModuleContext) error { return nil } if sdkVersion.Kind == android.SdkCorePlatform { - if useLegacyCorePlatformApiByName(j.BaseModuleName()) { + if useLegacyCorePlatformApi(ctx, j.BaseModuleName()) { return fmt.Errorf("non stable SDK %v - uses legacy core platform", sdkVersion) } else { // Treat stable core platform as stable. diff --git a/java/legacy_core_platform_api_usage.go b/java/legacy_core_platform_api_usage.go index 8c401a7d7..77493105e 100644 --- a/java/legacy_core_platform_api_usage.go +++ b/java/legacy_core_platform_api_usage.go @@ -163,17 +163,27 @@ func init() { } } -func useLegacyCorePlatformApi(ctx android.EarlyModuleContext) bool { - return useLegacyCorePlatformApiByName(ctx.ModuleName()) +var legacyCorePlatformApiLookupKey = android.NewOnceKey("legacyCorePlatformApiLookup") + +func getLegacyCorePlatformApiLookup(config android.Config) map[string]struct{} { + return config.Once(legacyCorePlatformApiLookupKey, func() interface{} { + return legacyCorePlatformApiLookup + }).(map[string]struct{}) } -func useLegacyCorePlatformApiByName(name string) bool { - _, found := legacyCorePlatformApiLookup[name] +// useLegacyCorePlatformApi checks to see whether the supplied module name is in the list of modules +// that are able to use the legacy core platform API and returns true if it does, false otherwise. +// +// This method takes the module name separately from the context as this may be being called for a +// module that is not the target of the supplied context. +func useLegacyCorePlatformApi(ctx android.EarlyModuleContext, moduleName string) bool { + lookup := getLegacyCorePlatformApiLookup(ctx.Config()) + _, found := lookup[moduleName] return found } func corePlatformSystemModules(ctx android.EarlyModuleContext) string { - if useLegacyCorePlatformApi(ctx) { + if useLegacyCorePlatformApi(ctx, ctx.ModuleName()) { return config.LegacyCorePlatformSystemModules } else { return config.StableCorePlatformSystemModules @@ -181,7 +191,7 @@ func corePlatformSystemModules(ctx android.EarlyModuleContext) string { } func corePlatformBootclasspathLibraries(ctx android.EarlyModuleContext) []string { - if useLegacyCorePlatformApi(ctx) { + if useLegacyCorePlatformApi(ctx, ctx.ModuleName()) { return config.LegacyCorePlatformBootclasspathLibraries } else { return config.StableCorePlatformBootclasspathLibraries diff --git a/java/testing.go b/java/testing.go index 8860b45fa..138ef8dc4 100644 --- a/java/testing.go +++ b/java/testing.go @@ -229,6 +229,26 @@ func FixtureConfigureApexBootJars(bootJars ...string) android.FixturePreparer { ) } +// FixtureUseLegacyCorePlatformApi prepares the fixture by setting the exception list of those +// modules that are allowed to use the legacy core platform API to be the ones supplied. +func FixtureUseLegacyCorePlatformApi(moduleNames ...string) android.FixturePreparer { + lookup := make(map[string]struct{}) + for _, moduleName := range moduleNames { + lookup[moduleName] = struct{}{} + } + return android.FixtureModifyConfig(func(config android.Config) { + // Try and set the legacyCorePlatformApiLookup in the config, the returned value will be the + // actual value that is set. + cached := config.Once(legacyCorePlatformApiLookupKey, func() interface{} { + return lookup + }) + // Make sure that the cached value is the one we need. + if !reflect.DeepEqual(cached, lookup) { + panic(fmt.Errorf("attempting to set legacyCorePlatformApiLookupKey to %q but it has already been set to %q", lookup, cached)) + } + }) +} + // registerRequiredBuildComponentsForTest registers the build components used by // PrepareForTestWithJavaDefaultModules. //