From 7113d20774cd08b03fae4fb990bb15a791440152 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Wed, 20 Nov 2019 16:39:12 -0800 Subject: [PATCH] Use empty string for core image variant Use the empty string for the core image variant so that modules added to imageMutator do not change their build directory. Bug: 142286466 Test: m checkbuild Change-Id: Ida4534d9a4d6176236aaa480fed359ce27acfaa1 Merged-In: Ida4534d9a4d6176236aaa480fed359ce27acfaa1 (cherry picked from commit 72d685ee7f45e5393be44ae4159edf083ac918de) --- android/image.go | 2 +- android/prebuilt_etc_test.go | 14 ++-- apex/apex_test.go | 134 +++++++++++++++++------------------ cc/cc_test.go | 69 +++++++++--------- cc/gen_test.go | 8 +-- cc/genrule_test.go | 4 +- cc/library_test.go | 26 +++---- cc/prebuilt_test.go | 16 ++--- cc/proto_test.go | 4 +- java/java_test.go | 2 +- rust/rust_test.go | 2 +- sdk/cc_sdk_test.go | 56 +++++++-------- sysprop/sysprop_test.go | 18 ++--- xml/xml_test.go | 4 +- 14 files changed, 180 insertions(+), 179 deletions(-) diff --git a/android/image.go b/android/image.go index 8424cf8b5..5291ce3c5 100644 --- a/android/image.go +++ b/android/image.go @@ -42,7 +42,7 @@ const ( // CoreVariation is the variant used for framework-private libraries, or // SDK libraries. (which framework-private libraries can use), which // will be installed to the system image. - CoreVariation string = "core" + CoreVariation string = "" // RecoveryVariation means a module to be installed to recovery image. RecoveryVariation string = "recovery" diff --git a/android/prebuilt_etc_test.go b/android/prebuilt_etc_test.go index 6bb3ccf15..3c466a176 100644 --- a/android/prebuilt_etc_test.go +++ b/android/prebuilt_etc_test.go @@ -88,7 +88,7 @@ func TestPrebuiltEtcOutputPath(t *testing.T) { } `) - p := ctx.ModuleForTests("foo.conf", "android_arm64_armv8-a_core").Module().(*PrebuiltEtc) + p := ctx.ModuleForTests("foo.conf", "android_arm64_armv8-a").Module().(*PrebuiltEtc) if p.outputFilePath.Base() != "foo.installed.conf" { t.Errorf("expected foo.installed.conf, got %q", p.outputFilePath.Base()) } @@ -107,12 +107,12 @@ func TestPrebuiltEtcGlob(t *testing.T) { } `) - p := ctx.ModuleForTests("my_foo", "android_arm64_armv8-a_core").Module().(*PrebuiltEtc) + p := ctx.ModuleForTests("my_foo", "android_arm64_armv8-a").Module().(*PrebuiltEtc) if p.outputFilePath.Base() != "my_foo" { t.Errorf("expected my_foo, got %q", p.outputFilePath.Base()) } - p = ctx.ModuleForTests("my_bar", "android_arm64_armv8-a_core").Module().(*PrebuiltEtc) + p = ctx.ModuleForTests("my_bar", "android_arm64_armv8-a").Module().(*PrebuiltEtc) if p.outputFilePath.Base() != "bar.conf" { t.Errorf("expected bar.conf, got %q", p.outputFilePath.Base()) } @@ -141,7 +141,7 @@ func TestPrebuiltEtcAndroidMk(t *testing.T) { "LOCAL_TARGET_REQUIRED_MODULES": {"targetModA"}, } - mod := ctx.ModuleForTests("foo", "android_arm64_armv8-a_core").Module().(*PrebuiltEtc) + mod := ctx.ModuleForTests("foo", "android_arm64_armv8-a").Module().(*PrebuiltEtc) entries := AndroidMkEntriesForTest(t, config, "", mod)[0] for k, expectedValue := range expected { if value, ok := entries.EntryMap[k]; ok { @@ -178,7 +178,7 @@ func TestPrebuiltUserShareInstallDirPath(t *testing.T) { } `) - p := ctx.ModuleForTests("foo.conf", "android_arm64_armv8-a_core").Module().(*PrebuiltEtc) + p := ctx.ModuleForTests("foo.conf", "android_arm64_armv8-a").Module().(*PrebuiltEtc) expected := buildDir + "/target/product/test_device/system/usr/share/bar" if p.installDirPath.String() != expected { t.Errorf("expected %q, got %q", expected, p.installDirPath.String()) @@ -210,7 +210,7 @@ func TestPrebuiltFontInstallDirPath(t *testing.T) { } `) - p := ctx.ModuleForTests("foo.conf", "android_arm64_armv8-a_core").Module().(*PrebuiltEtc) + p := ctx.ModuleForTests("foo.conf", "android_arm64_armv8-a").Module().(*PrebuiltEtc) expected := buildDir + "/target/product/test_device/system/fonts" if p.installDirPath.String() != expected { t.Errorf("expected %q, got %q", expected, p.installDirPath.String()) @@ -245,7 +245,7 @@ func TestPrebuiltFirmwareDirPath(t *testing.T) { for _, tt := range tests { t.Run(tt.description, func(t *testing.T) { ctx, _ := testPrebuiltEtc(t, tt.config) - p := ctx.ModuleForTests("foo.conf", "android_arm64_armv8-a_core").Module().(*PrebuiltEtc) + p := ctx.ModuleForTests("foo.conf", "android_arm64_armv8-a").Module().(*PrebuiltEtc) if p.installDirPath.String() != tt.expectedPath { t.Errorf("expected %q, got %q", tt.expectedPath, p.installDirPath) } diff --git a/apex/apex_test.go b/apex/apex_test.go index 3aa72e391..6cf43373f 100644 --- a/apex/apex_test.go +++ b/apex/apex_test.go @@ -483,12 +483,12 @@ func TestBasicApex(t *testing.T) { ensureContains(t, apexRule.Output.String(), "myapex.apex.unsigned") // Ensure that apex variant is created for the direct dep - ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_core_shared_myapex") + ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_shared_myapex") ensureListContains(t, ctx.ModuleVariantsForTests("myjar"), "android_common_myapex") ensureListContains(t, ctx.ModuleVariantsForTests("myprebuiltjar"), "android_common_myapex") // Ensure that apex variant is created for the indirect dep - ensureListContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_core_shared_myapex") + ensureListContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_shared_myapex") ensureListContains(t, ctx.ModuleVariantsForTests("myotherjar"), "android_common_myapex") // Ensure that both direct and indirect deps are copied into apex @@ -499,9 +499,9 @@ func TestBasicApex(t *testing.T) { // .. but not for java libs ensureNotContains(t, copyCmds, "image.apex/javalib/myotherjar.jar") - // Ensure that the platform variant ends with _core_shared or _common - ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_core_shared") - ensureListContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_core_shared") + // Ensure that the platform variant ends with _shared or _common + ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_shared") + ensureListContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_shared") ensureListContains(t, ctx.ModuleVariantsForTests("myjar"), "android_common") ensureListContains(t, ctx.ModuleVariantsForTests("myotherjar"), "android_common") ensureListContains(t, ctx.ModuleVariantsForTests("myprebuiltjar"), "android_common") @@ -591,10 +591,10 @@ func TestBasicZipApex(t *testing.T) { ensureContains(t, zipApexRule.Output.String(), "myapex.zipapex.unsigned") // Ensure that APEX variant is created for the direct dep - ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_core_shared_myapex") + ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_shared_myapex") // Ensure that APEX variant is created for the indirect dep - ensureListContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_core_shared_myapex") + ensureListContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_shared_myapex") // Ensure that both direct and indirect deps are copied into apex ensureContains(t, copyCmds, "image.zipapex/lib64/mylib.so") @@ -665,24 +665,24 @@ func TestApexWithStubs(t *testing.T) { // Ensure that direct stubs dep is included ensureContains(t, copyCmds, "image.apex/lib64/mylib3.so") - mylibLdFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_core_shared_myapex").Rule("ld").Args["libFlags"] + mylibLdFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_shared_myapex").Rule("ld").Args["libFlags"] // Ensure that mylib is linking with the latest version of stubs for mylib2 - ensureContains(t, mylibLdFlags, "mylib2/android_arm64_armv8-a_core_shared_3_myapex/mylib2.so") + ensureContains(t, mylibLdFlags, "mylib2/android_arm64_armv8-a_shared_3_myapex/mylib2.so") // ... and not linking to the non-stub (impl) variant of mylib2 - ensureNotContains(t, mylibLdFlags, "mylib2/android_arm64_armv8-a_core_shared_myapex/mylib2.so") + ensureNotContains(t, mylibLdFlags, "mylib2/android_arm64_armv8-a_shared_myapex/mylib2.so") // Ensure that mylib is linking with the non-stub (impl) of mylib3 (because mylib3 is in the same apex) - ensureContains(t, mylibLdFlags, "mylib3/android_arm64_armv8-a_core_shared_myapex/mylib3.so") + ensureContains(t, mylibLdFlags, "mylib3/android_arm64_armv8-a_shared_myapex/mylib3.so") // .. and not linking to the stubs variant of mylib3 - ensureNotContains(t, mylibLdFlags, "mylib3/android_arm64_armv8-a_core_shared_12_myapex/mylib3.so") + ensureNotContains(t, mylibLdFlags, "mylib3/android_arm64_armv8-a_shared_12_myapex/mylib3.so") // Ensure that stubs libs are built without -include flags - mylib2Cflags := ctx.ModuleForTests("mylib2", "android_arm64_armv8-a_core_static_myapex").Rule("cc").Args["cFlags"] + mylib2Cflags := ctx.ModuleForTests("mylib2", "android_arm64_armv8-a_static_myapex").Rule("cc").Args["cFlags"] ensureNotContains(t, mylib2Cflags, "-include ") // Ensure that genstub is invoked with --apex - ensureContains(t, "--apex", ctx.ModuleForTests("mylib2", "android_arm64_armv8-a_core_static_3_myapex").Rule("genStubSrc").Args["flags"]) + ensureContains(t, "--apex", ctx.ModuleForTests("mylib2", "android_arm64_armv8-a_static_3_myapex").Rule("genStubSrc").Args["flags"]) } func TestApexWithExplicitStubsDependency(t *testing.T) { @@ -739,14 +739,14 @@ func TestApexWithExplicitStubsDependency(t *testing.T) { // Ensure that dependency of stubs is not included ensureNotContains(t, copyCmds, "image.apex/lib64/libbar.so") - mylibLdFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_core_shared_myapex").Rule("ld").Args["libFlags"] + mylibLdFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_shared_myapex").Rule("ld").Args["libFlags"] // Ensure that mylib is linking with version 10 of libfoo - ensureContains(t, mylibLdFlags, "libfoo/android_arm64_armv8-a_core_shared_10_myapex/libfoo.so") + ensureContains(t, mylibLdFlags, "libfoo/android_arm64_armv8-a_shared_10_myapex/libfoo.so") // ... and not linking to the non-stub (impl) variant of libfoo - ensureNotContains(t, mylibLdFlags, "libfoo/android_arm64_armv8-a_core_shared_myapex/libfoo.so") + ensureNotContains(t, mylibLdFlags, "libfoo/android_arm64_armv8-a_shared_myapex/libfoo.so") - libFooStubsLdFlags := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_core_shared_10_myapex").Rule("ld").Args["libFlags"] + libFooStubsLdFlags := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_shared_10_myapex").Rule("ld").Args["libFlags"] // Ensure that libfoo stubs is not linking to libbar (since it is a stubs) ensureNotContains(t, libFooStubsLdFlags, "libbar.so") @@ -952,45 +952,45 @@ func TestApexWithSystemLibsStubs(t *testing.T) { // Ensure that libc is not included (since it has stubs and not listed in native_shared_libs) ensureNotContains(t, copyCmds, "image.apex/lib64/bionic/libc.so") - mylibLdFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_core_shared_myapex").Rule("ld").Args["libFlags"] - mylibCFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_core_static_myapex").Rule("cc").Args["cFlags"] - mylibSharedCFlags := ctx.ModuleForTests("mylib_shared", "android_arm64_armv8-a_core_shared_myapex").Rule("cc").Args["cFlags"] + mylibLdFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_shared_myapex").Rule("ld").Args["libFlags"] + mylibCFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_static_myapex").Rule("cc").Args["cFlags"] + mylibSharedCFlags := ctx.ModuleForTests("mylib_shared", "android_arm64_armv8-a_shared_myapex").Rule("cc").Args["cFlags"] // For dependency to libc // Ensure that mylib is linking with the latest version of stubs - ensureContains(t, mylibLdFlags, "libc/android_arm64_armv8-a_core_shared_29_myapex/libc.so") + ensureContains(t, mylibLdFlags, "libc/android_arm64_armv8-a_shared_29_myapex/libc.so") // ... and not linking to the non-stub (impl) variant - ensureNotContains(t, mylibLdFlags, "libc/android_arm64_armv8-a_core_shared_myapex/libc.so") + ensureNotContains(t, mylibLdFlags, "libc/android_arm64_armv8-a_shared_myapex/libc.so") // ... Cflags from stub is correctly exported to mylib ensureContains(t, mylibCFlags, "__LIBC_API__=29") ensureContains(t, mylibSharedCFlags, "__LIBC_API__=29") // For dependency to libm // Ensure that mylib is linking with the non-stub (impl) variant - ensureContains(t, mylibLdFlags, "libm/android_arm64_armv8-a_core_shared_myapex/libm.so") + ensureContains(t, mylibLdFlags, "libm/android_arm64_armv8-a_shared_myapex/libm.so") // ... and not linking to the stub variant - ensureNotContains(t, mylibLdFlags, "libm/android_arm64_armv8-a_core_shared_29_myapex/libm.so") + ensureNotContains(t, mylibLdFlags, "libm/android_arm64_armv8-a_shared_29_myapex/libm.so") // ... and is not compiling with the stub ensureNotContains(t, mylibCFlags, "__LIBM_API__=29") ensureNotContains(t, mylibSharedCFlags, "__LIBM_API__=29") // For dependency to libdl // Ensure that mylib is linking with the specified version of stubs - ensureContains(t, mylibLdFlags, "libdl/android_arm64_armv8-a_core_shared_27_myapex/libdl.so") + ensureContains(t, mylibLdFlags, "libdl/android_arm64_armv8-a_shared_27_myapex/libdl.so") // ... and not linking to the other versions of stubs - ensureNotContains(t, mylibLdFlags, "libdl/android_arm64_armv8-a_core_shared_28_myapex/libdl.so") - ensureNotContains(t, mylibLdFlags, "libdl/android_arm64_armv8-a_core_shared_29_myapex/libdl.so") + ensureNotContains(t, mylibLdFlags, "libdl/android_arm64_armv8-a_shared_28_myapex/libdl.so") + ensureNotContains(t, mylibLdFlags, "libdl/android_arm64_armv8-a_shared_29_myapex/libdl.so") // ... and not linking to the non-stub (impl) variant - ensureNotContains(t, mylibLdFlags, "libdl/android_arm64_armv8-a_core_shared_myapex/libdl.so") + ensureNotContains(t, mylibLdFlags, "libdl/android_arm64_armv8-a_shared_myapex/libdl.so") // ... Cflags from stub is correctly exported to mylib ensureContains(t, mylibCFlags, "__LIBDL_API__=27") ensureContains(t, mylibSharedCFlags, "__LIBDL_API__=27") // Ensure that libBootstrap is depending on the platform variant of bionic libs - libFlags := ctx.ModuleForTests("libBootstrap", "android_arm64_armv8-a_core_shared").Rule("ld").Args["libFlags"] - ensureContains(t, libFlags, "libc/android_arm64_armv8-a_core_shared/libc.so") - ensureContains(t, libFlags, "libm/android_arm64_armv8-a_core_shared/libm.so") - ensureContains(t, libFlags, "libdl/android_arm64_armv8-a_core_shared/libdl.so") + libFlags := ctx.ModuleForTests("libBootstrap", "android_arm64_armv8-a_shared").Rule("ld").Args["libFlags"] + ensureContains(t, libFlags, "libc/android_arm64_armv8-a_shared/libc.so") + ensureContains(t, libFlags, "libm/android_arm64_armv8-a_shared/libm.so") + ensureContains(t, libFlags, "libdl/android_arm64_armv8-a_shared/libdl.so") } func TestFilesInSubDir(t *testing.T) { @@ -1101,8 +1101,8 @@ func TestUseVendor(t *testing.T) { ensureContains(t, inputsString, "android_arm64_armv8-a_vendor.VER_shared_myapex/mylib2.so") // ensure that the apex does not include core variants - ensureNotContains(t, inputsString, "android_arm64_armv8-a_core_shared_myapex/mylib.so") - ensureNotContains(t, inputsString, "android_arm64_armv8-a_core_shared_myapex/mylib2.so") + ensureNotContains(t, inputsString, "android_arm64_armv8-a_shared_myapex/mylib.so") + ensureNotContains(t, inputsString, "android_arm64_armv8-a_shared_myapex/mylib2.so") } func TestUseVendorRestriction(t *testing.T) { @@ -1195,10 +1195,10 @@ func TestStaticLinking(t *testing.T) { } `) - ldFlags := ctx.ModuleForTests("not_in_apex", "android_arm64_armv8-a_core").Rule("ld").Args["libFlags"] + ldFlags := ctx.ModuleForTests("not_in_apex", "android_arm64_armv8-a").Rule("ld").Args["libFlags"] // Ensure that not_in_apex is linking with the static variant of mylib - ensureContains(t, ldFlags, "mylib/android_arm64_armv8-a_core_static/mylib.a") + ensureContains(t, ldFlags, "mylib/android_arm64_armv8-a_static/mylib.a") } func TestKeys(t *testing.T) { @@ -1285,19 +1285,19 @@ func TestMacro(t *testing.T) { `) // non-APEX variant does not have __ANDROID_APEX(_NAME)__ defined - mylibCFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_core_static").Rule("cc").Args["cFlags"] + mylibCFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_static").Rule("cc").Args["cFlags"] ensureNotContains(t, mylibCFlags, "-D__ANDROID_APEX__") ensureNotContains(t, mylibCFlags, "-D__ANDROID_APEX_MYAPEX__") ensureNotContains(t, mylibCFlags, "-D__ANDROID_APEX_OTHERAPEX__") // APEX variant has __ANDROID_APEX(_NAME)__ defined - mylibCFlags = ctx.ModuleForTests("mylib", "android_arm64_armv8-a_core_static_myapex").Rule("cc").Args["cFlags"] + mylibCFlags = ctx.ModuleForTests("mylib", "android_arm64_armv8-a_static_myapex").Rule("cc").Args["cFlags"] ensureContains(t, mylibCFlags, "-D__ANDROID_APEX__") ensureContains(t, mylibCFlags, "-D__ANDROID_APEX_MYAPEX__") ensureNotContains(t, mylibCFlags, "-D__ANDROID_APEX_OTHERAPEX__") // APEX variant has __ANDROID_APEX(_NAME)__ defined - mylibCFlags = ctx.ModuleForTests("mylib", "android_arm64_armv8-a_core_static_otherapex").Rule("cc").Args["cFlags"] + mylibCFlags = ctx.ModuleForTests("mylib", "android_arm64_armv8-a_static_otherapex").Rule("cc").Args["cFlags"] ensureContains(t, mylibCFlags, "-D__ANDROID_APEX__") ensureNotContains(t, mylibCFlags, "-D__ANDROID_APEX_MYAPEX__") ensureContains(t, mylibCFlags, "-D__ANDROID_APEX_OTHERAPEX__") @@ -1345,7 +1345,7 @@ func TestHeaderLibsDependency(t *testing.T) { } `) - cFlags := ctx.ModuleForTests("otherlib", "android_arm64_armv8-a_core_static").Rule("cc").Args["cFlags"] + cFlags := ctx.ModuleForTests("otherlib", "android_arm64_armv8-a_static").Rule("cc").Args["cFlags"] // Ensure that the include path of the header lib is exported to 'otherlib' ensureContains(t, cFlags, "-Imy_include") @@ -1971,13 +1971,13 @@ func TestNonTestApex(t *testing.T) { ensureContains(t, apexRule.Output.String(), "myapex.apex.unsigned") // Ensure that apex variant is created for the direct dep - ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_core_shared_myapex") + ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_shared_myapex") // Ensure that both direct and indirect deps are copied into apex ensureContains(t, copyCmds, "image.apex/lib64/mylib_common.so") - // Ensure that the platform variant ends with _core_shared - ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_core_shared") + // Ensure that the platform variant ends with _shared + ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_shared") if !android.InAnyApex("mylib_common") { t.Log("Found mylib_common not in any apex!") @@ -2022,13 +2022,13 @@ func TestTestApex(t *testing.T) { ensureContains(t, apexRule.Output.String(), "myapex.apex.unsigned") // Ensure that apex variant is created for the direct dep - ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common_test"), "android_arm64_armv8-a_core_shared_myapex") + ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common_test"), "android_arm64_armv8-a_shared_myapex") // Ensure that both direct and indirect deps are copied into apex ensureContains(t, copyCmds, "image.apex/lib64/mylib_common_test.so") - // Ensure that the platform variant ends with _core_shared - ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common_test"), "android_arm64_armv8-a_core_shared") + // Ensure that the platform variant ends with _shared + ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common_test"), "android_arm64_armv8-a_shared") if android.InAnyApex("mylib_common_test") { t.Log("Found mylib_common_test in some apex!") @@ -2101,19 +2101,19 @@ func TestApexWithTarget(t *testing.T) { ensureContains(t, apexRule.Output.String(), "myapex.apex.unsigned") // Ensure that apex variant is created for the direct dep - ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_core_shared_myapex") - ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_core_shared_myapex") - ensureListNotContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_core_shared_myapex") + ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_shared_myapex") + ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_shared_myapex") + ensureListNotContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_shared_myapex") // Ensure that both direct and indirect deps are copied into apex ensureContains(t, copyCmds, "image.apex/lib64/mylib.so") ensureContains(t, copyCmds, "image.apex/lib64/mylib_common.so") ensureNotContains(t, copyCmds, "image.apex/lib64/mylib2.so") - // Ensure that the platform variant ends with _core_shared - ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_core_shared") - ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_core_shared") - ensureListContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_core_shared") + // Ensure that the platform variant ends with _shared + ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_shared") + ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_shared") + ensureListContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_shared") } func TestApexWithShBinary(t *testing.T) { @@ -2527,8 +2527,8 @@ func TestApexUsesOtherApex(t *testing.T) { apexRule2 := module2.Rule("apexRule") copyCmds2 := apexRule2.Args["copy_commands"] - ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_core_shared_myapex") - ensureListContains(t, ctx.ModuleVariantsForTests("libcommon"), "android_arm64_armv8-a_core_shared_commonapex") + ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_shared_myapex") + ensureListContains(t, ctx.ModuleVariantsForTests("libcommon"), "android_arm64_armv8-a_shared_commonapex") ensureContains(t, copyCmds1, "image.apex/lib64/mylib.so") ensureContains(t, copyCmds2, "image.apex/lib64/libcommon.so") ensureNotContains(t, copyCmds1, "image.apex/lib64/libcommon.so") @@ -2694,7 +2694,7 @@ func TestApexWithApps(t *testing.T) { // JNI libraries are embedded inside APK appZipRule := ctx.ModuleForTests("AppFoo", "android_common_myapex").Rule("zip") - libjniOutput := ctx.ModuleForTests("libjni", "android_arm64_armv8-a_core_shared_myapex").Module().(*cc.Module).OutputFile() + libjniOutput := ctx.ModuleForTests("libjni", "android_arm64_armv8-a_shared_myapex").Module().(*cc.Module).OutputFile() ensureListContains(t, appZipRule.Implicits.Strings(), libjniOutput.String()) // ... uncompressed if args := appZipRule.Args["jarArgs"]; !strings.Contains(args, "-L 0") { @@ -2906,10 +2906,10 @@ func TestApexAvailable(t *testing.T) { }`) // check that libfoo and libbar are created only for myapex, but not for the platform - ensureListContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_core_shared_myapex") - ensureListNotContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_core_shared") - ensureListContains(t, ctx.ModuleVariantsForTests("libbar"), "android_arm64_armv8-a_core_shared_myapex") - ensureListNotContains(t, ctx.ModuleVariantsForTests("libbar"), "android_arm64_armv8-a_core_shared") + ensureListContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_shared_myapex") + ensureListNotContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_shared") + ensureListContains(t, ctx.ModuleVariantsForTests("libbar"), "android_arm64_armv8-a_shared_myapex") + ensureListNotContains(t, ctx.ModuleVariantsForTests("libbar"), "android_arm64_armv8-a_shared") ctx, _ = testApex(t, ` apex { @@ -2931,8 +2931,8 @@ func TestApexAvailable(t *testing.T) { }`) // check that libfoo is created only for the platform - ensureListNotContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_core_shared_myapex") - ensureListContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_core_shared") + ensureListNotContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_shared_myapex") + ensureListContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_shared") ctx, _ = testApex(t, ` apex { @@ -2958,11 +2958,11 @@ func TestApexAvailable(t *testing.T) { }`) // shared variant of libfoo is only available to myapex - ensureListContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_core_shared_myapex") - ensureListNotContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_core_shared") + ensureListContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_shared_myapex") + ensureListNotContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_shared") // but the static variant is available to both myapex and the platform - ensureListContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_core_static_myapex") - ensureListContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_core_static") + ensureListContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_static_myapex") + ensureListContains(t, ctx.ModuleVariantsForTests("libfoo"), "android_arm64_armv8-a_static") } func TestOverrideApex(t *testing.T) { diff --git a/cc/cc_test.go b/cc/cc_test.go index f378f710b..92c1e3ba7 100644 --- a/cc/cc_test.go +++ b/cc/cc_test.go @@ -112,7 +112,7 @@ func testCcError(t *testing.T, pattern string, bp string) { } const ( - coreVariant = "android_arm64_armv8-a_core_shared" + coreVariant = "android_arm64_armv8-a_shared" vendorVariant = "android_arm64_armv8-a_vendor.VER_shared" recoveryVariant = "android_arm64_armv8-a_recovery_shared" ) @@ -1906,7 +1906,7 @@ func TestStaticLibDepReordering(t *testing.T) { `) - variant := "android_arm64_armv8-a_core_static" + variant := "android_arm64_armv8-a_static" moduleA := ctx.ModuleForTests("a", variant).Module().(*Module) actual := moduleA.depsInLinkOrder expected := getOutputPaths(ctx, variant, []string{"c", "b", "d"}) @@ -1940,7 +1940,7 @@ func TestStaticLibDepReorderingWithShared(t *testing.T) { `) - variant := "android_arm64_armv8-a_core_static" + variant := "android_arm64_armv8-a_static" moduleA := ctx.ModuleForTests("a", variant).Module().(*Module) actual := moduleA.depsInLinkOrder expected := getOutputPaths(ctx, variant, []string{"c", "b"}) @@ -2052,7 +2052,7 @@ func TestRuntimeLibs(t *testing.T) { ctx := testCc(t, runtimeLibAndroidBp) // runtime_libs for core variants use the module names without suffixes. - variant := "android_arm64_armv8-a_core_shared" + variant := "android_arm64_armv8-a_shared" module := ctx.ModuleForTests("libvendor_available2", variant).Module().(*Module) checkRuntimeLibs(t, []string{"libvendor_available1"}, module) @@ -2074,7 +2074,7 @@ func TestRuntimeLibs(t *testing.T) { func TestExcludeRuntimeLibs(t *testing.T) { ctx := testCc(t, runtimeLibAndroidBp) - variant := "android_arm64_armv8-a_core_shared" + variant := "android_arm64_armv8-a_shared" module := ctx.ModuleForTests("libvendor_available3", variant).Module().(*Module) checkRuntimeLibs(t, []string{"libvendor_available1"}, module) @@ -2088,7 +2088,7 @@ func TestRuntimeLibsNoVndk(t *testing.T) { // If DeviceVndkVersion is not defined, then runtime_libs are copied as-is. - variant := "android_arm64_armv8-a_core_shared" + variant := "android_arm64_armv8-a_shared" module := ctx.ModuleForTests("libvendor_available2", variant).Module().(*Module) checkRuntimeLibs(t, []string{"libvendor_available1"}, module) @@ -2123,12 +2123,12 @@ func TestStaticLibDepExport(t *testing.T) { ctx := testCc(t, staticLibAndroidBp) // Check the shared version of lib2. - variant := "android_arm64_armv8-a_core_shared" + variant := "android_arm64_armv8-a_shared" module := ctx.ModuleForTests("lib2", variant).Module().(*Module) checkStaticLibs(t, []string{"lib1", "libc++demangle", "libclang_rt.builtins-aarch64-android", "libatomic", "libgcc_stripped"}, module) // Check the static version of lib2. - variant = "android_arm64_armv8-a_core_static" + variant = "android_arm64_armv8-a_static" module = ctx.ModuleForTests("lib2", variant).Module().(*Module) // libc++_static is linked additionally. checkStaticLibs(t, []string{"lib1", "libc++_static", "libc++demangle", "libclang_rt.builtins-aarch64-android", "libatomic", "libgcc_stripped"}, module) @@ -2256,28 +2256,29 @@ func TestVendorPublicLibraries(t *testing.T) { } `) - variant := "android_arm64_armv8-a_core_shared" + coreVariant := "android_arm64_armv8-a_shared" + vendorVariant := "android_arm64_armv8-a_vendor.VER_shared" // test if header search paths are correctly added // _static variant is used since _shared reuses *.o from the static variant - cc := ctx.ModuleForTests("libsystem", strings.Replace(variant, "_shared", "_static", 1)).Rule("cc") + cc := ctx.ModuleForTests("libsystem", strings.Replace(coreVariant, "_shared", "_static", 1)).Rule("cc") cflags := cc.Args["cFlags"] if !strings.Contains(cflags, "-Imy_include") { t.Errorf("cflags for libsystem must contain -Imy_include, but was %#v.", cflags) } // test if libsystem is linked to the stub - ld := ctx.ModuleForTests("libsystem", variant).Rule("ld") + ld := ctx.ModuleForTests("libsystem", coreVariant).Rule("ld") libflags := ld.Args["libFlags"] - stubPaths := getOutputPaths(ctx, variant, []string{"libvendorpublic" + vendorPublicLibrarySuffix}) + stubPaths := getOutputPaths(ctx, coreVariant, []string{"libvendorpublic" + vendorPublicLibrarySuffix}) if !strings.Contains(libflags, stubPaths[0].String()) { t.Errorf("libflags for libsystem must contain %#v, but was %#v", stubPaths[0], libflags) } // test if libvendor is linked to the real shared lib - ld = ctx.ModuleForTests("libvendor", strings.Replace(variant, "_core", "_vendor.VER", 1)).Rule("ld") + ld = ctx.ModuleForTests("libvendor", vendorVariant).Rule("ld") libflags = ld.Args["libFlags"] - stubPaths = getOutputPaths(ctx, strings.Replace(variant, "_core", "_vendor.VER", 1), []string{"libvendorpublic"}) + stubPaths = getOutputPaths(ctx, vendorVariant, []string{"libvendorpublic"}) if !strings.Contains(libflags, stubPaths[0].String()) { t.Errorf("libflags for libvendor must contain %#v, but was %#v", stubPaths[0], libflags) } @@ -2338,14 +2339,14 @@ func TestVersionedStubs(t *testing.T) { variants := ctx.ModuleVariantsForTests("libFoo") expectedVariants := []string{ - "android_arm64_armv8-a_core_shared", - "android_arm64_armv8-a_core_shared_1", - "android_arm64_armv8-a_core_shared_2", - "android_arm64_armv8-a_core_shared_3", - "android_arm_armv7-a-neon_core_shared", - "android_arm_armv7-a-neon_core_shared_1", - "android_arm_armv7-a-neon_core_shared_2", - "android_arm_armv7-a-neon_core_shared_3", + "android_arm64_armv8-a_shared", + "android_arm64_armv8-a_shared_1", + "android_arm64_armv8-a_shared_2", + "android_arm64_armv8-a_shared_3", + "android_arm_armv7-a-neon_shared", + "android_arm_armv7-a-neon_shared_1", + "android_arm_armv7-a-neon_shared_2", + "android_arm_armv7-a-neon_shared_3", } variantsMismatch := false if len(variants) != len(expectedVariants) { @@ -2368,14 +2369,14 @@ func TestVersionedStubs(t *testing.T) { } } - libBarLinkRule := ctx.ModuleForTests("libBar", "android_arm64_armv8-a_core_shared").Rule("ld") + libBarLinkRule := ctx.ModuleForTests("libBar", "android_arm64_armv8-a_shared").Rule("ld") libFlags := libBarLinkRule.Args["libFlags"] - libFoo1StubPath := "libFoo/android_arm64_armv8-a_core_shared_1/libFoo.so" + libFoo1StubPath := "libFoo/android_arm64_armv8-a_shared_1/libFoo.so" if !strings.Contains(libFlags, libFoo1StubPath) { t.Errorf("%q is not found in %q", libFoo1StubPath, libFlags) } - libBarCompileRule := ctx.ModuleForTests("libBar", "android_arm64_armv8-a_core_shared").Rule("cc") + libBarCompileRule := ctx.ModuleForTests("libBar", "android_arm64_armv8-a_shared").Rule("cc") cFlags := libBarCompileRule.Args["cFlags"] libFoo1VersioningMacro := "-D__LIBFOO_API__=1" if !strings.Contains(cFlags, libFoo1VersioningMacro) { @@ -2391,7 +2392,7 @@ func TestStaticExecutable(t *testing.T) { static_executable: true, }`) - variant := "android_arm64_armv8-a_core" + variant := "android_arm64_armv8-a" binModuleRule := ctx.ModuleForTests("static_test", variant).Rule("ld") libFlags := binModuleRule.Args["libFlags"] systemStaticLibs := []string{"libc.a", "libm.a"} @@ -2434,9 +2435,9 @@ func TestStaticDepsOrderWithStubs(t *testing.T) { }, }`) - mybin := ctx.ModuleForTests("mybin", "android_arm64_armv8-a_core").Module().(*Module) + mybin := ctx.ModuleForTests("mybin", "android_arm64_armv8-a").Module().(*Module) actual := mybin.depsInLinkOrder - expected := getOutputPaths(ctx, "android_arm64_armv8-a_core_static", []string{"libB", "libC"}) + expected := getOutputPaths(ctx, "android_arm64_armv8-a_static", []string{"libB", "libC"}) if !reflect.DeepEqual(actual, expected) { t.Errorf("staticDeps orderings were not propagated correctly"+ @@ -2475,7 +2476,7 @@ func TestFuzzTarget(t *testing.T) { srcs: ["foo.c"], }`) - variant := "android_arm64_armv8-a_core" + variant := "android_arm64_armv8-a" ctx.ModuleForTests("fuzz_smoke_test", variant).Rule("cc") } @@ -2550,24 +2551,24 @@ func TestDefaults(t *testing.T) { return ret } - shared := ctx.ModuleForTests("libshared", "android_arm64_armv8-a_core_shared").Rule("ld") + shared := ctx.ModuleForTests("libshared", "android_arm64_armv8-a_shared").Rule("ld") if g, w := pathsToBase(shared.Inputs), []string{"foo.o", "baz.o"}; !reflect.DeepEqual(w, g) { t.Errorf("libshared ld rule wanted %q, got %q", w, g) } - bothShared := ctx.ModuleForTests("libboth", "android_arm64_armv8-a_core_shared").Rule("ld") + bothShared := ctx.ModuleForTests("libboth", "android_arm64_armv8-a_shared").Rule("ld") if g, w := pathsToBase(bothShared.Inputs), []string{"foo.o", "baz.o"}; !reflect.DeepEqual(w, g) { t.Errorf("libboth ld rule wanted %q, got %q", w, g) } - binary := ctx.ModuleForTests("binary", "android_arm64_armv8-a_core").Rule("ld") + binary := ctx.ModuleForTests("binary", "android_arm64_armv8-a").Rule("ld") if g, w := pathsToBase(binary.Inputs), []string{"foo.o"}; !reflect.DeepEqual(w, g) { t.Errorf("binary ld rule wanted %q, got %q", w, g) } - static := ctx.ModuleForTests("libstatic", "android_arm64_armv8-a_core_static").Rule("ar") + static := ctx.ModuleForTests("libstatic", "android_arm64_armv8-a_static").Rule("ar") if g, w := pathsToBase(static.Inputs), []string{"foo.o", "bar.o"}; !reflect.DeepEqual(w, g) { t.Errorf("libstatic ar rule wanted %q, got %q", w, g) } - bothStatic := ctx.ModuleForTests("libboth", "android_arm64_armv8-a_core_static").Rule("ar") + bothStatic := ctx.ModuleForTests("libboth", "android_arm64_armv8-a_static").Rule("ar") if g, w := pathsToBase(bothStatic.Inputs), []string{"foo.o", "bar.o"}; !reflect.DeepEqual(w, g) { t.Errorf("libboth ar rule wanted %q, got %q", w, g) } diff --git a/cc/gen_test.go b/cc/gen_test.go index ceecf1c16..4b9a36e6b 100644 --- a/cc/gen_test.go +++ b/cc/gen_test.go @@ -31,8 +31,8 @@ func TestGen(t *testing.T) { ], }`) - aidl := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_shared").Rule("aidl") - libfoo := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_shared").Module().(*Module) + aidl := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Rule("aidl") + libfoo := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Module().(*Module) if !inList("-I"+filepath.Dir(aidl.Output.String()), libfoo.flags.Local.CommonFlags) { t.Errorf("missing aidl includes in global flags") @@ -55,8 +55,8 @@ func TestGen(t *testing.T) { ], }`) - aidl := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_shared").Rule("aidl") - libfoo := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_shared").Module().(*Module) + aidl := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Rule("aidl") + libfoo := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Module().(*Module) if !inList("-I"+filepath.Dir(aidl.Output.String()), libfoo.flags.Local.CommonFlags) { t.Errorf("missing aidl includes in global flags") diff --git a/cc/genrule_test.go b/cc/genrule_test.go index 9f159e54d..785e3e1e4 100644 --- a/cc/genrule_test.go +++ b/cc/genrule_test.go @@ -74,13 +74,13 @@ func TestArchGenruleCmd(t *testing.T) { t.Fatal(errs) } - gen := ctx.ModuleForTests("gen", "android_arm_armv7-a-neon_core").Output("out_arm") + gen := ctx.ModuleForTests("gen", "android_arm_armv7-a-neon").Output("out_arm") expected := []string{"foo"} if !reflect.DeepEqual(expected, gen.Inputs.Strings()) { t.Errorf(`want arm inputs %v, got %v`, expected, gen.Inputs.Strings()) } - gen = ctx.ModuleForTests("gen", "android_arm64_armv8-a_core").Output("out_arm64") + gen = ctx.ModuleForTests("gen", "android_arm64_armv8-a").Output("out_arm64") expected = []string{"bar"} if !reflect.DeepEqual(expected, gen.Inputs.Strings()) { t.Errorf(`want arm64 inputs %v, got %v`, expected, gen.Inputs.Strings()) diff --git a/cc/library_test.go b/cc/library_test.go index f8d893465..b8d889544 100644 --- a/cc/library_test.go +++ b/cc/library_test.go @@ -27,8 +27,8 @@ func TestLibraryReuse(t *testing.T) { srcs: ["foo.c", "baz.o"], }`) - libfooShared := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_shared").Rule("ld") - libfooStatic := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_static").Output("libfoo.a") + libfooShared := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Rule("ld") + libfooStatic := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_static").Output("libfoo.a") if len(libfooShared.Inputs) != 2 { t.Fatalf("unexpected inputs to libfoo shared: %#v", libfooShared.Inputs.Strings()) @@ -56,8 +56,8 @@ func TestLibraryReuse(t *testing.T) { }, }`) - libfooShared := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_shared").Rule("ld") - libfooStatic := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_static").Output("libfoo.a") + libfooShared := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Rule("ld") + libfooStatic := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_static").Output("libfoo.a") if len(libfooShared.Inputs) != 1 { t.Fatalf("unexpected inputs to libfoo shared: %#v", libfooShared.Inputs.Strings()) @@ -82,8 +82,8 @@ func TestLibraryReuse(t *testing.T) { }, }`) - libfooShared := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_shared").Rule("ld") - libfooStatic := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_static").Output("libfoo.a") + libfooShared := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Rule("ld") + libfooStatic := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_static").Output("libfoo.a") if len(libfooShared.Inputs) != 2 { t.Fatalf("unexpected inputs to libfoo shared: %#v", libfooShared.Inputs.Strings()) @@ -108,8 +108,8 @@ func TestLibraryReuse(t *testing.T) { }, }`) - libfooShared := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_shared").Rule("ld") - libfooStatic := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_static").Output("libfoo.a") + libfooShared := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Rule("ld") + libfooStatic := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_static").Output("libfoo.a") if len(libfooShared.Inputs) != 1 { t.Fatalf("unexpected inputs to libfoo shared: %#v", libfooShared.Inputs.Strings()) @@ -134,8 +134,8 @@ func TestLibraryReuse(t *testing.T) { }, }`) - libfooShared := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_shared").Rule("ld") - libfooStatic := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_static").Output("libfoo.a") + libfooShared := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Rule("ld") + libfooStatic := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_static").Output("libfoo.a") if len(libfooShared.Inputs) != 1 { t.Fatalf("unexpected inputs to libfoo shared: %#v", libfooShared.Inputs.Strings()) @@ -165,8 +165,8 @@ func TestLibraryReuse(t *testing.T) { }, }`) - libfooShared := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_shared").Rule("ld") - libfooStatic := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_static").Output("libfoo.a") + libfooShared := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Rule("ld") + libfooStatic := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_static").Output("libfoo.a") if len(libfooShared.Inputs) != 3 { t.Fatalf("unexpected inputs to libfoo shared: %#v", libfooShared.Inputs.Strings()) @@ -180,7 +180,7 @@ func TestLibraryReuse(t *testing.T) { t.Errorf("static objects not reused for shared library") } - libfoo := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_shared").Module().(*Module) + libfoo := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Module().(*Module) if !inList("-DGOOGLE_PROTOBUF_NO_RTTI", libfoo.flags.Local.CFlags) { t.Errorf("missing protobuf cflags") } diff --git a/cc/prebuilt_test.go b/cc/prebuilt_test.go index 72f9f4ac3..7ddf6eb84 100644 --- a/cc/prebuilt_test.go +++ b/cc/prebuilt_test.go @@ -87,15 +87,15 @@ func TestPrebuilt(t *testing.T) { android.FailIfErrored(t, errs) // Verify that all the modules exist and that their dependencies were connected correctly - liba := ctx.ModuleForTests("liba", "android_arm64_armv8-a_core_shared").Module() - libb := ctx.ModuleForTests("libb", "android_arm64_armv8-a_core_static").Module() - libd := ctx.ModuleForTests("libd", "android_arm64_armv8-a_core_shared").Module() - libe := ctx.ModuleForTests("libe", "android_arm64_armv8-a_core_static").Module() + liba := ctx.ModuleForTests("liba", "android_arm64_armv8-a_shared").Module() + libb := ctx.ModuleForTests("libb", "android_arm64_armv8-a_static").Module() + libd := ctx.ModuleForTests("libd", "android_arm64_armv8-a_shared").Module() + libe := ctx.ModuleForTests("libe", "android_arm64_armv8-a_static").Module() - prebuiltLiba := ctx.ModuleForTests("prebuilt_liba", "android_arm64_armv8-a_core_shared").Module() - prebuiltLibb := ctx.ModuleForTests("prebuilt_libb", "android_arm64_armv8-a_core_static").Module() - prebuiltLibd := ctx.ModuleForTests("prebuilt_libd", "android_arm64_armv8-a_core_shared").Module() - prebuiltLibe := ctx.ModuleForTests("prebuilt_libe", "android_arm64_armv8-a_core_static").Module() + prebuiltLiba := ctx.ModuleForTests("prebuilt_liba", "android_arm64_armv8-a_shared").Module() + prebuiltLibb := ctx.ModuleForTests("prebuilt_libb", "android_arm64_armv8-a_static").Module() + prebuiltLibd := ctx.ModuleForTests("prebuilt_libd", "android_arm64_armv8-a_shared").Module() + prebuiltLibe := ctx.ModuleForTests("prebuilt_libe", "android_arm64_armv8-a_static").Module() hasDep := func(m android.Module, wantDep android.Module) bool { t.Helper() diff --git a/cc/proto_test.go b/cc/proto_test.go index 4f0de7801..f8bbd2643 100644 --- a/cc/proto_test.go +++ b/cc/proto_test.go @@ -29,7 +29,7 @@ func TestProto(t *testing.T) { srcs: ["a.proto"], }`) - proto := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_shared").Output("proto/a.pb.cc") + proto := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Output("proto/a.pb.cc") if cmd := proto.RuleParams.Command; !strings.Contains(cmd, "--cpp_out=") { t.Errorf("expected '--cpp_out' in %q", cmd) @@ -53,7 +53,7 @@ func TestProto(t *testing.T) { buildOS := android.BuildOs.String() - proto := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_core_shared").Output("proto/a.pb.cc") + proto := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Output("proto/a.pb.cc") foobar := ctx.ModuleForTests("protoc-gen-foobar", buildOS+"_x86_64") cmd := proto.RuleParams.Command diff --git a/java/java_test.go b/java/java_test.go index f4b92e381..4a549e6c8 100644 --- a/java/java_test.go +++ b/java/java_test.go @@ -1177,7 +1177,7 @@ func TestJavaSdkLibrary(t *testing.T) { ctx.ModuleForTests("foo"+sdkDocsSuffix, "android_common") ctx.ModuleForTests("foo"+sdkDocsSuffix+sdkSystemApiSuffix, "android_common") ctx.ModuleForTests("foo"+sdkDocsSuffix+sdkTestApiSuffix, "android_common") - ctx.ModuleForTests("foo"+sdkXmlFileSuffix, "android_arm64_armv8-a_core") + ctx.ModuleForTests("foo"+sdkXmlFileSuffix, "android_arm64_armv8-a") ctx.ModuleForTests("foo.api.public.28", "") ctx.ModuleForTests("foo.api.system.28", "") ctx.ModuleForTests("foo.api.test.28", "") diff --git a/rust/rust_test.go b/rust/rust_test.go index 91c2f0956..01b89dbe2 100644 --- a/rust/rust_test.go +++ b/rust/rust_test.go @@ -245,7 +245,7 @@ func TestNoStdlibs(t *testing.T) { srcs: ["foo.rs"], no_stdlibs: true, }`) - module := ctx.ModuleForTests("fizz-buzz", "android_arm64_armv8-a_core").Module().(*Module) + module := ctx.ModuleForTests("fizz-buzz", "android_arm64_armv8-a").Module().(*Module) if android.InList("libstd", module.Properties.AndroidMkDylibs) { t.Errorf("no_stdlibs did not suppress dependency on libstd") diff --git a/sdk/cc_sdk_test.go b/sdk/cc_sdk_test.go index 53109ec1a..08751e444 100644 --- a/sdk/cc_sdk_test.go +++ b/sdk/cc_sdk_test.go @@ -50,8 +50,8 @@ func TestSdkIsCompileMultilibBoth(t *testing.T) { } `) - armOutput := result.Module("sdkmember", "android_arm_armv7-a-neon_core_shared").(*cc.Module).OutputFile() - arm64Output := result.Module("sdkmember", "android_arm64_armv8-a_core_shared").(*cc.Module).OutputFile() + armOutput := result.Module("sdkmember", "android_arm_armv7-a-neon_shared").(*cc.Module).OutputFile() + arm64Output := result.Module("sdkmember", "android_arm64_armv8-a_shared").(*cc.Module).OutputFile() var inputs []string buildParams := result.Module("mysdk", "android_common").BuildParamsForTests() @@ -132,11 +132,11 @@ func TestBasicSdkWithCc(t *testing.T) { } `) - sdkMemberV1 := result.ModuleForTests("sdkmember_mysdk_1", "android_arm64_armv8-a_core_shared_myapex").Rule("toc").Output - sdkMemberV2 := result.ModuleForTests("sdkmember_mysdk_2", "android_arm64_armv8-a_core_shared_myapex2").Rule("toc").Output + sdkMemberV1 := result.ModuleForTests("sdkmember_mysdk_1", "android_arm64_armv8-a_shared_myapex").Rule("toc").Output + sdkMemberV2 := result.ModuleForTests("sdkmember_mysdk_2", "android_arm64_armv8-a_shared_myapex2").Rule("toc").Output - cpplibForMyApex := result.ModuleForTests("mycpplib", "android_arm64_armv8-a_core_shared_myapex") - cpplibForMyApex2 := result.ModuleForTests("mycpplib", "android_arm64_armv8-a_core_shared_myapex2") + cpplibForMyApex := result.ModuleForTests("mycpplib", "android_arm64_armv8-a_shared_myapex") + cpplibForMyApex2 := result.ModuleForTests("mycpplib", "android_arm64_armv8-a_shared_myapex2") // Depending on the uses_sdks value, different libs are linked ensureListContains(t, pathsToStrings(cpplibForMyApex.Rule("ld").Implicits), sdkMemberV1.String()) @@ -174,10 +174,10 @@ func TestSnapshotWithCcDuplicateHeaders(t *testing.T) { result.CheckSnapshot("mysdk", "android_common", "", checkAllCopyRules(` include/Test.h -> include/include/Test.h -.intermediates/mynativelib1/android_arm64_armv8-a_core_shared/mynativelib1.so -> arm64/lib/mynativelib1.so -.intermediates/mynativelib1/android_arm_armv7-a-neon_core_shared/mynativelib1.so -> arm/lib/mynativelib1.so -.intermediates/mynativelib2/android_arm64_armv8-a_core_shared/mynativelib2.so -> arm64/lib/mynativelib2.so -.intermediates/mynativelib2/android_arm_armv7-a-neon_core_shared/mynativelib2.so -> arm/lib/mynativelib2.so +.intermediates/mynativelib1/android_arm64_armv8-a_shared/mynativelib1.so -> arm64/lib/mynativelib1.so +.intermediates/mynativelib1/android_arm_armv7-a-neon_shared/mynativelib1.so -> arm/lib/mynativelib1.so +.intermediates/mynativelib2/android_arm64_armv8-a_shared/mynativelib2.so -> arm64/lib/mynativelib2.so +.intermediates/mynativelib2/android_arm_armv7-a-neon_shared/mynativelib2.so -> arm/lib/mynativelib2.so `), ) } @@ -253,9 +253,9 @@ sdk_snapshot { `), checkAllCopyRules(` include/Test.h -> include/include/Test.h -.intermediates/mynativelib/android_arm64_armv8-a_core_shared/mynativelib.so -> arm64/lib/mynativelib.so +.intermediates/mynativelib/android_arm64_armv8-a_shared/mynativelib.so -> arm64/lib/mynativelib.so arm64/include/Arm64Test.h -> arm64/include/arm64/include/Arm64Test.h -.intermediates/mynativelib/android_arm_armv7-a-neon_core_shared/mynativelib.so -> arm/lib/mynativelib.so`), +.intermediates/mynativelib/android_arm_armv7-a-neon_shared/mynativelib.so -> arm/lib/mynativelib.so`), ) } @@ -328,14 +328,14 @@ sdk_snapshot { `), checkAllCopyRules(` include/Test.h -> include/include/Test.h -.intermediates/mynativelib/android_arm64_armv8-a_core_shared/mynativelib.so -> arm64/lib/mynativelib.so -.intermediates/mynativelib/android_arm64_armv8-a_core_shared/gen/aidl/aidl/foo/bar/Test.h -> arm64/include_gen/mynativelib/aidl/foo/bar/Test.h -.intermediates/mynativelib/android_arm64_armv8-a_core_shared/gen/aidl/aidl/foo/bar/BnTest.h -> arm64/include_gen/mynativelib/aidl/foo/bar/BnTest.h -.intermediates/mynativelib/android_arm64_armv8-a_core_shared/gen/aidl/aidl/foo/bar/BpTest.h -> arm64/include_gen/mynativelib/aidl/foo/bar/BpTest.h -.intermediates/mynativelib/android_arm_armv7-a-neon_core_shared/mynativelib.so -> arm/lib/mynativelib.so -.intermediates/mynativelib/android_arm_armv7-a-neon_core_shared/gen/aidl/aidl/foo/bar/Test.h -> arm/include_gen/mynativelib/aidl/foo/bar/Test.h -.intermediates/mynativelib/android_arm_armv7-a-neon_core_shared/gen/aidl/aidl/foo/bar/BnTest.h -> arm/include_gen/mynativelib/aidl/foo/bar/BnTest.h -.intermediates/mynativelib/android_arm_armv7-a-neon_core_shared/gen/aidl/aidl/foo/bar/BpTest.h -> arm/include_gen/mynativelib/aidl/foo/bar/BpTest.h +.intermediates/mynativelib/android_arm64_armv8-a_shared/mynativelib.so -> arm64/lib/mynativelib.so +.intermediates/mynativelib/android_arm64_armv8-a_shared/gen/aidl/aidl/foo/bar/Test.h -> arm64/include_gen/mynativelib/aidl/foo/bar/Test.h +.intermediates/mynativelib/android_arm64_armv8-a_shared/gen/aidl/aidl/foo/bar/BnTest.h -> arm64/include_gen/mynativelib/aidl/foo/bar/BnTest.h +.intermediates/mynativelib/android_arm64_armv8-a_shared/gen/aidl/aidl/foo/bar/BpTest.h -> arm64/include_gen/mynativelib/aidl/foo/bar/BpTest.h +.intermediates/mynativelib/android_arm_armv7-a-neon_shared/mynativelib.so -> arm/lib/mynativelib.so +.intermediates/mynativelib/android_arm_armv7-a-neon_shared/gen/aidl/aidl/foo/bar/Test.h -> arm/include_gen/mynativelib/aidl/foo/bar/Test.h +.intermediates/mynativelib/android_arm_armv7-a-neon_shared/gen/aidl/aidl/foo/bar/BnTest.h -> arm/include_gen/mynativelib/aidl/foo/bar/BnTest.h +.intermediates/mynativelib/android_arm_armv7-a-neon_shared/gen/aidl/aidl/foo/bar/BpTest.h -> arm/include_gen/mynativelib/aidl/foo/bar/BpTest.h `), ) } @@ -503,14 +503,14 @@ sdk_snapshot { `), checkAllCopyRules(` include/Test.h -> include/include/Test.h -.intermediates/mynativelib/android_arm64_armv8-a_core_static/mynativelib.a -> arm64/lib/mynativelib.a -.intermediates/mynativelib/android_arm64_armv8-a_core_static/gen/aidl/aidl/foo/bar/Test.h -> arm64/include_gen/mynativelib/aidl/foo/bar/Test.h -.intermediates/mynativelib/android_arm64_armv8-a_core_static/gen/aidl/aidl/foo/bar/BnTest.h -> arm64/include_gen/mynativelib/aidl/foo/bar/BnTest.h -.intermediates/mynativelib/android_arm64_armv8-a_core_static/gen/aidl/aidl/foo/bar/BpTest.h -> arm64/include_gen/mynativelib/aidl/foo/bar/BpTest.h -.intermediates/mynativelib/android_arm_armv7-a-neon_core_static/mynativelib.a -> arm/lib/mynativelib.a -.intermediates/mynativelib/android_arm_armv7-a-neon_core_static/gen/aidl/aidl/foo/bar/Test.h -> arm/include_gen/mynativelib/aidl/foo/bar/Test.h -.intermediates/mynativelib/android_arm_armv7-a-neon_core_static/gen/aidl/aidl/foo/bar/BnTest.h -> arm/include_gen/mynativelib/aidl/foo/bar/BnTest.h -.intermediates/mynativelib/android_arm_armv7-a-neon_core_static/gen/aidl/aidl/foo/bar/BpTest.h -> arm/include_gen/mynativelib/aidl/foo/bar/BpTest.h +.intermediates/mynativelib/android_arm64_armv8-a_static/mynativelib.a -> arm64/lib/mynativelib.a +.intermediates/mynativelib/android_arm64_armv8-a_static/gen/aidl/aidl/foo/bar/Test.h -> arm64/include_gen/mynativelib/aidl/foo/bar/Test.h +.intermediates/mynativelib/android_arm64_armv8-a_static/gen/aidl/aidl/foo/bar/BnTest.h -> arm64/include_gen/mynativelib/aidl/foo/bar/BnTest.h +.intermediates/mynativelib/android_arm64_armv8-a_static/gen/aidl/aidl/foo/bar/BpTest.h -> arm64/include_gen/mynativelib/aidl/foo/bar/BpTest.h +.intermediates/mynativelib/android_arm_armv7-a-neon_static/mynativelib.a -> arm/lib/mynativelib.a +.intermediates/mynativelib/android_arm_armv7-a-neon_static/gen/aidl/aidl/foo/bar/Test.h -> arm/include_gen/mynativelib/aidl/foo/bar/Test.h +.intermediates/mynativelib/android_arm_armv7-a-neon_static/gen/aidl/aidl/foo/bar/BnTest.h -> arm/include_gen/mynativelib/aidl/foo/bar/BnTest.h +.intermediates/mynativelib/android_arm_armv7-a-neon_static/gen/aidl/aidl/foo/bar/BpTest.h -> arm/include_gen/mynativelib/aidl/foo/bar/BpTest.h `), ) } diff --git a/sysprop/sysprop_test.go b/sysprop/sysprop_test.go index 81f4c5376..7b906731f 100644 --- a/sysprop/sysprop_test.go +++ b/sysprop/sysprop_test.go @@ -295,10 +295,10 @@ func TestSyspropLibrary(t *testing.T) { } for _, variant := range []string{ - "android_arm_armv7-a-neon_core_shared", - "android_arm_armv7-a-neon_core_static", - "android_arm64_armv8-a_core_shared", - "android_arm64_armv8-a_core_static", + "android_arm_armv7-a-neon_shared", + "android_arm_armv7-a-neon_static", + "android_arm64_armv8-a_shared", + "android_arm64_armv8-a_static", } { ctx.ModuleForTests("libsysprop-platform", variant) @@ -310,17 +310,17 @@ func TestSyspropLibrary(t *testing.T) { ctx.ModuleForTests("sysprop-vendor", "android_common") // Check for exported includes - coreVariant := "android_arm64_armv8-a_core_static" + coreVariant := "android_arm64_armv8-a_static" vendorVariant := "android_arm64_armv8-a_vendor.VER_static" - platformInternalPath := "libsysprop-platform/android_arm64_armv8-a_core_static/gen/sysprop/include" - platformPublicCorePath := "libsysprop-platform/android_arm64_armv8-a_core_static/gen/sysprop/public/include" + platformInternalPath := "libsysprop-platform/android_arm64_armv8-a_static/gen/sysprop/include" + platformPublicCorePath := "libsysprop-platform/android_arm64_armv8-a_static/gen/sysprop/public/include" platformPublicVendorPath := "libsysprop-platform/android_arm64_armv8-a_vendor.VER_static/gen/sysprop/public/include" - platformOnProductPath := "libsysprop-platform-on-product/android_arm64_armv8-a_core_static/gen/sysprop/public/include" + platformOnProductPath := "libsysprop-platform-on-product/android_arm64_armv8-a_static/gen/sysprop/public/include" vendorInternalPath := "libsysprop-vendor/android_arm64_armv8-a_vendor.VER_static/gen/sysprop/include" - vendorPublicPath := "libsysprop-vendor/android_arm64_armv8-a_core_static/gen/sysprop/public/include" + vendorPublicPath := "libsysprop-vendor/android_arm64_armv8-a_static/gen/sysprop/public/include" platformClient := ctx.ModuleForTests("cc-client-platform", coreVariant) platformFlags := platformClient.Rule("cc").Args["cFlags"] diff --git a/xml/xml_test.go b/xml/xml_test.go index f42ba7762..0a1156670 100644 --- a/xml/xml_test.go +++ b/xml/xml_test.go @@ -104,7 +104,7 @@ func TestPrebuiltEtcXml(t *testing.T) { {rule: "xmllint-minimal", input: "baz.xml"}, } { t.Run(tc.schemaType, func(t *testing.T) { - rule := ctx.ModuleForTests(tc.input, "android_arm64_armv8-a_core").Rule(tc.rule) + rule := ctx.ModuleForTests(tc.input, "android_arm64_armv8-a").Rule(tc.rule) assertEqual(t, "input", tc.input, rule.Input.String()) if tc.schemaType != "" { assertEqual(t, "schema", tc.schema, rule.Args[tc.schemaType]) @@ -112,6 +112,6 @@ func TestPrebuiltEtcXml(t *testing.T) { }) } - m := ctx.ModuleForTests("foo.xml", "android_arm64_armv8-a_core").Module().(*prebuiltEtcXml) + m := ctx.ModuleForTests("foo.xml", "android_arm64_armv8-a").Module().(*prebuiltEtcXml) assertEqual(t, "installDir", buildDir+"/target/product/test_device/system/etc", m.InstallDirPath().String()) }