Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3e85da88 authored by Colin Cross's avatar Colin Cross
Browse files

Remove magic implementation selection based on test_for 

As part of simplifiying the way dependencies are selected and removing
ApexInfoMutator, remove the automatic selection of implementation
over stubs when building tests against libraries in apexes.  Tests
can manually select linking against implementations via "libfoo#impl".

Bug: 372543712
Test: builds
Flag: EXEMPT refactor
Change-Id: I927db38a5691a1cf61f25fa02936c87cd36306f4
parent 516c545d

apex/apex_test.go

+0 −190
Original line number Diff line number Diff line
@@ -8713,196 +8713,6 @@ func TestApexPermittedPackagesRules(t *testing.T) { 
	}

}



func TestTestFor(t *testing.T) {

	t.Parallel()

	ctx := testApex(t, `

		apex {

			name: "myapex",

			key: "myapex.key",

			native_shared_libs: ["mylib", "myprivlib"],

			updatable: false,

		}



		apex_key {

			name: "myapex.key",

			public_key: "testkey.avbpubkey",

			private_key: "testkey.pem",

		}



		cc_library {

			name: "mylib",

			srcs: ["mylib.cpp"],

			system_shared_libs: [],

			stl: "none",

			stubs: {

				versions: ["1"],

			},

			apex_available: ["myapex"],

		}



		cc_library {

			name: "myprivlib",

			srcs: ["mylib.cpp"],

			system_shared_libs: [],

			stl: "none",

			apex_available: ["myapex"],

		}





		cc_test {

			name: "mytest",

			gtest: false,

			srcs: ["mylib.cpp"],

			system_shared_libs: [],

			stl: "none",

			shared_libs: ["mylib", "myprivlib", "mytestlib"],

			test_for: ["myapex"]

		}



		cc_library {

			name: "mytestlib",

			srcs: ["mylib.cpp"],

			system_shared_libs: [],

			shared_libs: ["mylib", "myprivlib"],

			stl: "none",

			test_for: ["myapex"],

		}



		cc_benchmark {

			name: "mybench",

			srcs: ["mylib.cpp"],

			system_shared_libs: [],

			shared_libs: ["mylib", "myprivlib"],

			stl: "none",

			test_for: ["myapex"],

		}

	`)



	ensureLinkedLibIs := func(mod, variant, linkedLib, expectedVariant string) {

		ldFlags := strings.Split(ctx.ModuleForTests(mod, variant).Rule("ld").Args["libFlags"], " ")

		mylibLdFlags := android.FilterListPred(ldFlags, func(s string) bool { return strings.HasPrefix(s, linkedLib) })

		android.AssertArrayString(t, "unexpected "+linkedLib+" link library for "+mod, []string{linkedLib + expectedVariant}, mylibLdFlags)

	}



	// These modules are tests for the apex, therefore are linked to the

	// actual implementation of mylib instead of its stub.

	ensureLinkedLibIs("mytest", "android_arm64_armv8-a", "out/soong/.intermediates/mylib/", "android_arm64_armv8-a_shared/mylib.so")

	ensureLinkedLibIs("mytestlib", "android_arm64_armv8-a_shared", "out/soong/.intermediates/mylib/", "android_arm64_armv8-a_shared/mylib.so")

	ensureLinkedLibIs("mybench", "android_arm64_armv8-a", "out/soong/.intermediates/mylib/", "android_arm64_armv8-a_shared/mylib.so")

}



func TestIndirectTestFor(t *testing.T) {

	t.Parallel()

	ctx := testApex(t, `

		apex {

			name: "myapex",

			key: "myapex.key",

			native_shared_libs: ["mylib", "myprivlib"],

			updatable: false,

		}



		apex_key {

			name: "myapex.key",

			public_key: "testkey.avbpubkey",

			private_key: "testkey.pem",

		}



		cc_library {

			name: "mylib",

			srcs: ["mylib.cpp"],

			system_shared_libs: [],

			stl: "none",

			stubs: {

				versions: ["1"],

			},

			apex_available: ["myapex"],

		}



		cc_library {

			name: "myprivlib",

			srcs: ["mylib.cpp"],

			system_shared_libs: [],

			stl: "none",

			shared_libs: ["mylib"],

			apex_available: ["myapex"],

		}



		cc_library {

			name: "mytestlib",

			srcs: ["mylib.cpp"],

			system_shared_libs: [],

			shared_libs: ["myprivlib"],

			stl: "none",

			test_for: ["myapex"],

		}

	`)



	ensureLinkedLibIs := func(mod, variant, linkedLib, expectedVariant string) {

		ldFlags := strings.Split(ctx.ModuleForTests(mod, variant).Rule("ld").Args["libFlags"], " ")

		mylibLdFlags := android.FilterListPred(ldFlags, func(s string) bool { return strings.HasPrefix(s, linkedLib) })

		android.AssertArrayString(t, "unexpected "+linkedLib+" link library for "+mod, []string{linkedLib + expectedVariant}, mylibLdFlags)

	}



	// The platform variant of mytestlib links to the platform variant of the

	// internal myprivlib.

	ensureLinkedLibIs("mytestlib", "android_arm64_armv8-a_shared", "out/soong/.intermediates/myprivlib/", "android_arm64_armv8-a_shared/myprivlib.so")



	// The platform variant of myprivlib links to the platform variant of mylib

	// and bypasses its stubs.

	ensureLinkedLibIs("myprivlib", "android_arm64_armv8-a_shared", "out/soong/.intermediates/mylib/", "android_arm64_armv8-a_shared/mylib.so")

}



func TestTestForForLibInOtherApex(t *testing.T) {

	t.Parallel()

	// This case is only allowed for known overlapping APEXes, i.e. the ART APEXes.

	_ = testApex(t, `

		apex {

			name: "com.android.art",

			key: "myapex.key",

			native_shared_libs: ["libnativebridge"],

			updatable: false,

		}



		apex {

			name: "com.android.art.debug",

			key: "myapex.key",

			native_shared_libs: ["libnativebridge", "libnativebrdige_test"],

			updatable: false,

		}



		apex_key {

			name: "myapex.key",

			public_key: "testkey.avbpubkey",

			private_key: "testkey.pem",

		}



		cc_library {

			name: "libnativebridge",

			srcs: ["libnativebridge.cpp"],

			system_shared_libs: [],

			stl: "none",

			stubs: {

				versions: ["1"],

			},

			apex_available: ["com.android.art", "com.android.art.debug"],

		}



		cc_library {

			name: "libnativebrdige_test",

			srcs: ["mylib.cpp"],

			system_shared_libs: [],

			shared_libs: ["libnativebridge"],

			stl: "none",

			apex_available: ["com.android.art.debug"],

			test_for: ["com.android.art"],

		}

	`,

		android.MockFS{

			"system/sepolicy/apex/com.android.art-file_contexts":       nil,

			"system/sepolicy/apex/com.android.art.debug-file_contexts": nil,

		}.AddToFixture())

}



// TODO(jungjw): Move this to proptools

func intPtr(i int) *int {

	return &i

cc/cc.go

+0 −32
Original line number Diff line number Diff line
@@ -3323,10 +3323,6 @@ func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps { 


func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {

	depName := ctx.OtherModuleName(dep)

	thisModule, ok := ctx.Module().(android.ApexModule)

	if !ok {

		panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))

	}



	inVendorOrProduct := false

	bootstrap := false
@@ -3356,34 +3352,6 @@ func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool { 
		isNotInPlatform := dep.(android.ApexModule).NotInPlatform()



		useStubs = isNotInPlatform && !bootstrap



		if useStubs {

			// Another exception: if this module is a test for an APEX, then

			// it is linked with the non-stub variant of a module in the APEX

			// as if this is part of the APEX.

			testFor, _ := android.ModuleProvider(ctx, android.ApexTestForInfoProvider)

			for _, apexContents := range testFor.ApexContents {

				if apexContents.DirectlyInApex(depName) {

					useStubs = false

					break

				}

			}

		}

		if useStubs {

			// Yet another exception: If this module and the dependency are

			// available to the same APEXes then skip stubs between their

			// platform variants. This complements the test_for case above,

			// which avoids the stubs on a direct APEX library dependency, by

			// avoiding stubs for indirect test dependencies as well.

			//

			// TODO(b/183882457): This doesn't work if the two libraries have

			// only partially overlapping apex_available. For that test_for

			// modules would need to be split into APEX variants and resolved

			// separately for each APEX they have access to.

			if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {

				useStubs = false

			}

		}

	} else {

		// If building for APEX, use stubs when the parent is in any APEX that

		// the child is not in.

cc/cc_test.go

+0 −105
Original line number Diff line number Diff line
@@ -1505,111 +1505,6 @@ func TestVersionedStubs(t *testing.T) { 
	}

}



func TestStubsForLibraryInMultipleApexes(t *testing.T) {

	t.Parallel()

	ctx := testCc(t, `

		cc_library_shared {

			name: "libFoo",

			srcs: ["foo.c"],

			stubs: {

				symbol_file: "foo.map.txt",

				versions: ["current"],

			},

			apex_available: ["bar", "a1"],

		}



		cc_library_shared {

			name: "libBar",

			srcs: ["bar.c"],

			shared_libs: ["libFoo"],

			apex_available: ["a1"],

		}



		cc_library_shared {

			name: "libA1",

			srcs: ["a1.c"],

			shared_libs: ["libFoo"],

			apex_available: ["a1"],

		}



		cc_library_shared {

			name: "libBarA1",

			srcs: ["bara1.c"],

			shared_libs: ["libFoo"],

			apex_available: ["bar", "a1"],

		}



		cc_library_shared {

			name: "libAnyApex",

			srcs: ["anyApex.c"],

			shared_libs: ["libFoo"],

			apex_available: ["//apex_available:anyapex"],

		}



		cc_library_shared {

			name: "libBaz",

			srcs: ["baz.c"],

			shared_libs: ["libFoo"],

			apex_available: ["baz"],

		}



		cc_library_shared {

			name: "libQux",

			srcs: ["qux.c"],

			shared_libs: ["libFoo"],

			apex_available: ["qux", "bar"],

		}`)



	variants := ctx.ModuleVariantsForTests("libFoo")

	expectedVariants := []string{

		"android_arm64_armv8-a_shared",

		"android_arm64_armv8-a_shared_current",

		"android_arm_armv7-a-neon_shared",

		"android_arm_armv7-a-neon_shared_current",

	}

	variantsMismatch := false

	if len(variants) != len(expectedVariants) {

		variantsMismatch = true

	} else {

		for _, v := range expectedVariants {

			if !inList(v, variants) {

				variantsMismatch = false

			}

		}

	}

	if variantsMismatch {

		t.Errorf("variants of libFoo expected:\n")

		for _, v := range expectedVariants {

			t.Errorf("%q\n", v)

		}

		t.Errorf(", but got:\n")

		for _, v := range variants {

			t.Errorf("%q\n", v)

		}

	}



	linkAgainstFoo := []string{"libBarA1"}

	linkAgainstFooStubs := []string{"libBar", "libA1", "libBaz", "libQux", "libAnyApex"}



	libFooPath := "libFoo/android_arm64_armv8-a_shared/libFoo.so"

	for _, lib := range linkAgainstFoo {

		libLinkRule := ctx.ModuleForTests(lib, "android_arm64_armv8-a_shared").Rule("ld")

		libFlags := libLinkRule.Args["libFlags"]

		if !strings.Contains(libFlags, libFooPath) {

			t.Errorf("%q: %q is not found in %q", lib, libFooPath, libFlags)

		}

	}



	libFooStubPath := "libFoo/android_arm64_armv8-a_shared_current/libFoo.so"

	for _, lib := range linkAgainstFooStubs {

		libLinkRule := ctx.ModuleForTests(lib, "android_arm64_armv8-a_shared").Rule("ld")

		libFlags := libLinkRule.Args["libFlags"]

		if !strings.Contains(libFlags, libFooStubPath) {

			t.Errorf("%q: %q is not found in %q", lib, libFooStubPath, libFlags)

		}

	}

}



func TestVersioningMacro(t *testing.T) {

	t.Parallel()

	for _, tc := range []struct{ moduleName, expected string }{