cc/prebuilt_test.go - SHIFTPHONES/android_build_soong - Gitiles

 // Copyright 2019 Google Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package cc

 import (
 	"runtime"
 	"testing"

 	"android/soong/android"
 	"android/soong/bazel/cquery"

 	"github.com/google/blueprint"
 )

 var prepareForPrebuiltTest = android.GroupFixturePreparers(
 	prepareForCcTest,
 	android.PrepareForTestWithAndroidMk,
 )

 func testPrebuilt(t *testing.T, bp string, fs android.MockFS, handlers ...android.FixturePreparer) *android.TestContext {
 	t.Helper()
 	result := android.GroupFixturePreparers(
 		prepareForPrebuiltTest,
 		fs.AddToFixture(),
 		android.GroupFixturePreparers(handlers...),
 	).RunTestWithBp(t, bp)

 	return result.TestContext
 }

 type configCustomizer func(config android.Config)

 func TestPrebuilt(t *testing.T) {
 	bp := `
 		cc_library {
 			name: "liba",
 		}

 		cc_prebuilt_library_shared {
 			name: "liba",
 			srcs: ["liba.so"],
 		}

 		cc_library {
 			name: "libb",
 		}

 		cc_prebuilt_library_static {
 			name: "libb",
 			srcs: ["libb.a"],
 		}

 		cc_library_shared {
 			name: "libd",
 		}

 		cc_prebuilt_library_shared {
 			name: "libd",
 			srcs: ["libd.so"],
 		}

 		cc_library_static {
 			name: "libe",
 		}

 		cc_prebuilt_library_static {
 			name: "libe",
 			srcs: ["libe.a"],
 		}

 		cc_library {
 			name: "libf",
 		}

 		cc_prebuilt_library {
 			name: "libf",
 			static: {
 				srcs: ["libf.a"],
 			},
 			shared: {
 				srcs: ["libf.so"],
 			},
 		}

 		cc_object {
 			name: "crtx",
 		}

 		cc_prebuilt_object {
 			name: "crtx",
 			srcs: ["crtx.o"],
 		}
 	`

 	ctx := testPrebuilt(t, bp, map[string][]byte{
 		"liba.so": nil,
 		"libb.a":  nil,
 		"libd.so": nil,
 		"libe.a":  nil,
 		"libf.a":  nil,
 		"libf.so": nil,
 		"crtx.o":  nil,
 	})

 	// Verify that all the modules exist and that their dependencies were connected correctly
 	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()
 	libfStatic := ctx.ModuleForTests("libf", "android_arm64_armv8-a_static").Module()
 	libfShared := ctx.ModuleForTests("libf", "android_arm64_armv8-a_shared").Module()
 	crtx := ctx.ModuleForTests("crtx", "android_arm64_armv8-a").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()
 	prebuiltLibfStatic := ctx.ModuleForTests("prebuilt_libf", "android_arm64_armv8-a_static").Module()
 	prebuiltLibfShared := ctx.ModuleForTests("prebuilt_libf", "android_arm64_armv8-a_shared").Module()
 	prebuiltCrtx := ctx.ModuleForTests("prebuilt_crtx", "android_arm64_armv8-a").Module()

 	hasDep := func(m android.Module, wantDep android.Module) bool {
 		t.Helper()
 		var found bool
 		ctx.VisitDirectDeps(m, func(dep blueprint.Module) {
 			if dep == wantDep {
 				found = true
 			}
 		})
 		return found
 	}

 	if !hasDep(liba, prebuiltLiba) {
 		t.Errorf("liba missing dependency on prebuilt_liba")
 	}

 	if !hasDep(libb, prebuiltLibb) {
 		t.Errorf("libb missing dependency on prebuilt_libb")
 	}

 	if !hasDep(libd, prebuiltLibd) {
 		t.Errorf("libd missing dependency on prebuilt_libd")
 	}

 	if !hasDep(libe, prebuiltLibe) {
 		t.Errorf("libe missing dependency on prebuilt_libe")
 	}

 	if !hasDep(libfStatic, prebuiltLibfStatic) {
 		t.Errorf("libf static missing dependency on prebuilt_libf")
 	}

 	if !hasDep(libfShared, prebuiltLibfShared) {
 		t.Errorf("libf shared missing dependency on prebuilt_libf")
 	}

 	if !hasDep(crtx, prebuiltCrtx) {
 		t.Errorf("crtx missing dependency on prebuilt_crtx")
 	}
 }

 func TestPrebuiltLibraryShared(t *testing.T) {
 	ctx := testPrebuilt(t, `
 	cc_prebuilt_library_shared {
 		name: "libtest",
 		srcs: ["libf.so"],
     strip: {
         none: true,
     },
 	}
 	`, map[string][]byte{
 		"libf.so": nil,
 	})

 	shared := ctx.ModuleForTests("libtest", "android_arm64_armv8-a_shared").Module().(*Module)
 	assertString(t, shared.OutputFile().Path().Base(), "libtest.so")
 }

 func TestPrebuiltLibraryStatic(t *testing.T) {
 	ctx := testPrebuilt(t, `
 	cc_prebuilt_library_static {
 		name: "libtest",
 		srcs: ["libf.a"],
 	}
 	`, map[string][]byte{
 		"libf.a": nil,
 	})

 	static := ctx.ModuleForTests("libtest", "android_arm64_armv8-a_static").Module().(*Module)
 	assertString(t, static.OutputFile().Path().Base(), "libf.a")
 }

 func TestPrebuiltLibrary(t *testing.T) {
 	ctx := testPrebuilt(t, `
 	cc_prebuilt_library {
 		name: "libtest",
 		static: {
 			srcs: ["libf.a"],
 		},
 		shared: {
 			srcs: ["libf.so"],
 		},
     strip: {
         none: true,
     },
 	}
 	`, map[string][]byte{
 		"libf.a":  nil,
 		"libf.so": nil,
 	})

 	shared := ctx.ModuleForTests("libtest", "android_arm64_armv8-a_shared").Module().(*Module)
 	assertString(t, shared.OutputFile().Path().Base(), "libtest.so")

 	static := ctx.ModuleForTests("libtest", "android_arm64_armv8-a_static").Module().(*Module)
 	assertString(t, static.OutputFile().Path().Base(), "libf.a")
 }

 func TestPrebuiltLibraryStem(t *testing.T) {
 	ctx := testPrebuilt(t, `
 	cc_prebuilt_library {
 		name: "libfoo",
 		stem: "libbar",
 		static: {
 			srcs: ["libfoo.a"],
 		},
 		shared: {
 			srcs: ["libfoo.so"],
 		},
 		strip: {
 			none: true,
 		},
 	}
 	`, map[string][]byte{
 		"libfoo.a":  nil,
 		"libfoo.so": nil,
 	})

 	static := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_static").Module().(*Module)
 	assertString(t, static.OutputFile().Path().Base(), "libfoo.a")

 	shared := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_shared").Module().(*Module)
 	assertString(t, shared.OutputFile().Path().Base(), "libbar.so")
 }

 func TestPrebuiltLibrarySharedStem(t *testing.T) {
 	ctx := testPrebuilt(t, `
 	cc_prebuilt_library_shared {
 		name: "libfoo",
 		stem: "libbar",
 		srcs: ["libfoo.so"],
 		strip: {
 			none: true,
 		},
 	}
 	`, map[string][]byte{
 		"libfoo.so": nil,
 	})

 	shared := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_shared").Module().(*Module)
 	assertString(t, shared.OutputFile().Path().Base(), "libbar.so")
 }

 func TestPrebuiltSymlinkedHostBinary(t *testing.T) {
 	if runtime.GOOS != "linux" {
 		t.Skipf("Skipping host prebuilt testing that is only supported on linux not %s", runtime.GOOS)
 	}

 	ctx := testPrebuilt(t, `
 	cc_prebuilt_library_shared {
 		name: "libfoo",
 		device_supported: false,
 		host_supported: true,
 		target: {
 			linux_glibc_x86_64: {
 				srcs: ["linux_glibc_x86_64/lib64/libfoo.so"],
 			},
 		},
 	}

 	cc_prebuilt_binary {
 		name: "foo",
 		device_supported: false,
 		host_supported: true,
 		shared_libs: ["libfoo"],
 		target: {
 			linux_glibc_x86_64: {
 				srcs: ["linux_glibc_x86_64/bin/foo"],
 			},
 		},
 	}
 	`, map[string][]byte{
 		"libfoo.so": nil,
 		"foo":       nil,
 	})

 	fooRule := ctx.ModuleForTests("foo", "linux_glibc_x86_64").Rule("Symlink")
 	assertString(t, fooRule.Output.String(), "out/soong/.intermediates/foo/linux_glibc_x86_64/foo")
 	assertString(t, fooRule.Args["fromPath"], "$$PWD/linux_glibc_x86_64/bin/foo")

 	var libfooDep android.Path
 	for _, dep := range fooRule.Implicits {
 		if dep.Base() == "libfoo.so" {
 			libfooDep = dep
 			break
 		}
 	}
 	assertString(t, libfooDep.String(), "out/soong/.intermediates/libfoo/linux_glibc_x86_64_shared/libfoo.so")
 }

 func TestPrebuiltLibrarySanitized(t *testing.T) {
 	bp := `cc_prebuilt_library {
 	name: "libtest",
 		static: {
                         sanitized: { none: { srcs: ["libf.a"], }, hwaddress: { srcs: ["libf.hwasan.a"], }, },
 		},
 		shared: {
                         sanitized: { none: { srcs: ["libf.so"], }, hwaddress: { srcs: ["hwasan/libf.so"], }, },
 		},
 	}
 	cc_prebuilt_library_static {
 		name: "libtest_static",
                 sanitized: { none: { srcs: ["libf.a"], }, hwaddress: { srcs: ["libf.hwasan.a"], }, },
 	}
 	cc_prebuilt_library_shared {
 		name: "libtest_shared",
                 sanitized: { none: { srcs: ["libf.so"], }, hwaddress: { srcs: ["hwasan/libf.so"], }, },
 	}`

 	fs := map[string][]byte{
 		"libf.a":         nil,
 		"libf.hwasan.a":  nil,
 		"libf.so":        nil,
 		"hwasan/libf.so": nil,
 	}

 	// Without SANITIZE_TARGET.
 	ctx := testPrebuilt(t, bp, fs)

 	shared_rule := ctx.ModuleForTests("libtest", "android_arm64_armv8-a_shared").Rule("android/soong/cc.strip")
 	assertString(t, shared_rule.Input.String(), "libf.so")

 	static := ctx.ModuleForTests("libtest", "android_arm64_armv8-a_static").Module().(*Module)
 	assertString(t, static.OutputFile().Path().Base(), "libf.a")

 	shared_rule2 := ctx.ModuleForTests("libtest_shared", "android_arm64_armv8-a_shared").Rule("android/soong/cc.strip")
 	assertString(t, shared_rule2.Input.String(), "libf.so")

 	static2 := ctx.ModuleForTests("libtest_static", "android_arm64_armv8-a_static").Module().(*Module)
 	assertString(t, static2.OutputFile().Path().Base(), "libf.a")

 	// With SANITIZE_TARGET=hwaddress
 	ctx = testPrebuilt(t, bp, fs,
 		android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
 			variables.SanitizeDevice = []string{"hwaddress"}
 		}),
 	)

 	shared_rule = ctx.ModuleForTests("libtest", "android_arm64_armv8-a_shared_hwasan").Rule("android/soong/cc.strip")
 	assertString(t, shared_rule.Input.String(), "hwasan/libf.so")

 	static = ctx.ModuleForTests("libtest", "android_arm64_armv8-a_static_hwasan").Module().(*Module)
 	assertString(t, static.OutputFile().Path().Base(), "libf.hwasan.a")

 	shared_rule2 = ctx.ModuleForTests("libtest_shared", "android_arm64_armv8-a_shared_hwasan").Rule("android/soong/cc.strip")
 	assertString(t, shared_rule2.Input.String(), "hwasan/libf.so")

 	static2 = ctx.ModuleForTests("libtest_static", "android_arm64_armv8-a_static_hwasan").Module().(*Module)
 	assertString(t, static2.OutputFile().Path().Base(), "libf.hwasan.a")
 }

 func TestPrebuiltLibrarySharedWithBazelWithoutToc(t *testing.T) {
 	const bp = `
 cc_prebuilt_library_shared {
 	name: "foo",
 	srcs: ["foo.so"],
 	bazel_module: { label: "//foo/bar:bar" },
 }`
 	outBaseDir := "outputbase"
 	config := TestConfig(t.TempDir(), android.Android, nil, bp, nil)
 	config.BazelContext = android.MockBazelContext{
 		OutputBaseDir: outBaseDir,
 		LabelToCcInfo: map[string]cquery.CcInfo{
 			"//foo/bar:bar": cquery.CcInfo{
 				CcSharedLibraryFiles: []string{"foo.so"},
 			},
 		},
 	}
 	ctx := testCcWithConfig(t, config)
 	sharedFoo := ctx.ModuleForTests("foo", "android_arm_armv7-a-neon_shared").Module()
 	pathPrefix := outBaseDir + "/execroot/__main__/"

 	info := ctx.ModuleProvider(sharedFoo, SharedLibraryInfoProvider).(SharedLibraryInfo)
 	android.AssertPathRelativeToTopEquals(t, "prebuilt shared library",
 		pathPrefix+"foo.so", info.SharedLibrary)
 	android.AssertPathRelativeToTopEquals(t, "prebuilt's 'nullary' ToC",
 		pathPrefix+"foo.so", info.TableOfContents.Path())

 	outputFiles, err := sharedFoo.(android.OutputFileProducer).OutputFiles("")
 	if err != nil {
 		t.Errorf("Unexpected error getting cc_object outputfiles %s", err)
 	}
 	expectedOutputFiles := []string{pathPrefix + "foo.so"}
 	android.AssertDeepEquals(t, "output files", expectedOutputFiles, outputFiles.Strings())
 }

 func TestPrebuiltLibrarySharedWithBazelWithToc(t *testing.T) {
 	const bp = `
 cc_prebuilt_library_shared {
 	name: "foo",
 	srcs: ["foo.so"],
 	bazel_module: { label: "//foo/bar:bar" },
 }`
 	outBaseDir := "outputbase"
 	config := TestConfig(t.TempDir(), android.Android, nil, bp, nil)
 	config.BazelContext = android.MockBazelContext{
 		OutputBaseDir: outBaseDir,
 		LabelToCcInfo: map[string]cquery.CcInfo{
 			"//foo/bar:bar": cquery.CcInfo{
 				CcSharedLibraryFiles: []string{"foo.so"},
 				TocFile:              "toc",
 			},
 		},
 	}
 	ctx := testCcWithConfig(t, config)
 	sharedFoo := ctx.ModuleForTests("foo", "android_arm_armv7-a-neon_shared").Module()
 	pathPrefix := outBaseDir + "/execroot/__main__/"

 	info := ctx.ModuleProvider(sharedFoo, SharedLibraryInfoProvider).(SharedLibraryInfo)
 	android.AssertPathRelativeToTopEquals(t, "prebuilt shared library's ToC",
 		pathPrefix+"toc", info.TableOfContents.Path())
 	android.AssertPathRelativeToTopEquals(t, "prebuilt shared library",
 		pathPrefix+"foo.so", info.SharedLibrary)

 	outputFiles, err := sharedFoo.(android.OutputFileProducer).OutputFiles("")
 	if err != nil {
 		t.Errorf("Unexpected error getting cc_object outputfiles %s", err)
 	}
 	expectedOutputFiles := []string{pathPrefix + "foo.so"}
 	android.AssertDeepEquals(t, "output files", expectedOutputFiles, outputFiles.Strings())
 }

 func TestPrebuiltStubNoinstall(t *testing.T) {
 	testFunc := func(t *testing.T, bp string) {
 		result := android.GroupFixturePreparers(
 			prepareForPrebuiltTest,
 			android.PrepareForTestWithMakevars,
 		).RunTestWithBp(t, bp)

 		installRules := result.InstallMakeRulesForTesting(t)
 		var installedlibRule *android.InstallMakeRule
 		for i, rule := range installRules {
 			if rule.Target == "out/target/product/test_device/system/lib/installedlib.so" {
 				if installedlibRule != nil {
 					t.Errorf("Duplicate install rules for %s", rule.Target)
 				}
 				installedlibRule = &installRules[i]
 			}
 		}
 		if installedlibRule == nil {
 			t.Errorf("No install rule found for installedlib")
 			return
 		}

 		android.AssertStringListDoesNotContain(t,
 			"installedlib has install dependency on stub",
 			installedlibRule.Deps,
 			"out/target/product/test_device/system/lib/stublib.so")
 		android.AssertStringListDoesNotContain(t,
 			"installedlib has order-only install dependency on stub",
 			installedlibRule.OrderOnlyDeps,
 			"out/target/product/test_device/system/lib/stublib.so")
 	}

 	const prebuiltStublibBp = `
 		cc_prebuilt_library {
 			name: "stublib",
 			prefer: true,
 			srcs: ["foo.so"],
 			stubs: {
 				versions: ["1"],
 			},
 		}
 	`

 	const installedlibBp = `
 		cc_library {
 			name: "installedlib",
 			shared_libs: ["stublib"],
 		}
 	`

 	t.Run("prebuilt without source", func(t *testing.T) {
 		testFunc(t, prebuiltStublibBp+installedlibBp)
 	})

 	const disabledSourceStublibBp = `
 		cc_library {
 			name: "stublib",
 			enabled: false,
 			stubs: {
 				versions: ["1"],
 			},
 		}
 	`

 	t.Run("prebuilt with disabled source", func(t *testing.T) {
 		testFunc(t, disabledSourceStublibBp+prebuiltStublibBp+installedlibBp)
 	})
 }
	// Copyright 2019 Google Inc. All rights reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package cc

	import (
	"runtime"
	"testing"

	"android/soong/android"
	"android/soong/bazel/cquery"

	"github.com/google/blueprint"
	)

	var prepareForPrebuiltTest = android.GroupFixturePreparers(
	prepareForCcTest,
	android.PrepareForTestWithAndroidMk,
	)

	func testPrebuilt(t testing.T, bp string, fs android.MockFS, handlers ...android.FixturePreparer) android.TestContext {
	t.Helper()
	result := android.GroupFixturePreparers(
	prepareForPrebuiltTest,
	fs.AddToFixture(),
	android.GroupFixturePreparers(handlers...),
	).RunTestWithBp(t, bp)

	return result.TestContext
	}

	type configCustomizer func(config android.Config)

	func TestPrebuilt(t *testing.T) {
	bp := `
	cc_library {
	name: "liba",
	}

	cc_prebuilt_library_shared {
	name: "liba",
	srcs: ["liba.so"],
	}

	cc_library {
	name: "libb",
	}

	cc_prebuilt_library_static {
	name: "libb",
	srcs: ["libb.a"],
	}

	cc_library_shared {
	name: "libd",
	}

	cc_prebuilt_library_shared {
	name: "libd",
	srcs: ["libd.so"],
	}

	cc_library_static {
	name: "libe",
	}

	cc_prebuilt_library_static {
	name: "libe",
	srcs: ["libe.a"],
	}

	cc_library {
	name: "libf",
	}

	cc_prebuilt_library {
	name: "libf",
	static: {
	srcs: ["libf.a"],
	},
	shared: {
	srcs: ["libf.so"],
	},
	}

	cc_object {
	name: "crtx",
	}

	cc_prebuilt_object {
	name: "crtx",
	srcs: ["crtx.o"],
	}
	`

	ctx := testPrebuilt(t, bp, map[string][]byte{
	"liba.so": nil,
	"libb.a": nil,
	"libd.so": nil,
	"libe.a": nil,
	"libf.a": nil,
	"libf.so": nil,
	"crtx.o": nil,
	})

	// Verify that all the modules exist and that their dependencies were connected correctly
	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()
	libfStatic := ctx.ModuleForTests("libf", "android_arm64_armv8-a_static").Module()
	libfShared := ctx.ModuleForTests("libf", "android_arm64_armv8-a_shared").Module()
	crtx := ctx.ModuleForTests("crtx", "android_arm64_armv8-a").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()
	prebuiltLibfStatic := ctx.ModuleForTests("prebuilt_libf", "android_arm64_armv8-a_static").Module()
	prebuiltLibfShared := ctx.ModuleForTests("prebuilt_libf", "android_arm64_armv8-a_shared").Module()
	prebuiltCrtx := ctx.ModuleForTests("prebuilt_crtx", "android_arm64_armv8-a").Module()

	hasDep := func(m android.Module, wantDep android.Module) bool {
	t.Helper()
	var found bool
	ctx.VisitDirectDeps(m, func(dep blueprint.Module) {
	if dep == wantDep {
	found = true
	}
	})
	return found
	}

	if !hasDep(liba, prebuiltLiba) {
	t.Errorf("liba missing dependency on prebuilt_liba")
	}

	if !hasDep(libb, prebuiltLibb) {
	t.Errorf("libb missing dependency on prebuilt_libb")
	}

	if !hasDep(libd, prebuiltLibd) {
	t.Errorf("libd missing dependency on prebuilt_libd")
	}

	if !hasDep(libe, prebuiltLibe) {
	t.Errorf("libe missing dependency on prebuilt_libe")
	}

	if !hasDep(libfStatic, prebuiltLibfStatic) {
	t.Errorf("libf static missing dependency on prebuilt_libf")
	}

	if !hasDep(libfShared, prebuiltLibfShared) {
	t.Errorf("libf shared missing dependency on prebuilt_libf")
	}

	if !hasDep(crtx, prebuiltCrtx) {
	t.Errorf("crtx missing dependency on prebuilt_crtx")
	}
	}

	func TestPrebuiltLibraryShared(t *testing.T) {
	ctx := testPrebuilt(t, `
	cc_prebuilt_library_shared {
	name: "libtest",
	srcs: ["libf.so"],
	strip: {
	none: true,
	},
	}
	`, map[string][]byte{
	"libf.so": nil,
	})

	shared := ctx.ModuleForTests("libtest", "android_arm64_armv8-a_shared").Module().(*Module)
	assertString(t, shared.OutputFile().Path().Base(), "libtest.so")
	}

	func TestPrebuiltLibraryStatic(t *testing.T) {
	ctx := testPrebuilt(t, `
	cc_prebuilt_library_static {
	name: "libtest",
	srcs: ["libf.a"],
	}
	`, map[string][]byte{
	"libf.a": nil,
	})

	static := ctx.ModuleForTests("libtest", "android_arm64_armv8-a_static").Module().(*Module)
	assertString(t, static.OutputFile().Path().Base(), "libf.a")
	}

	func TestPrebuiltLibrary(t *testing.T) {
	ctx := testPrebuilt(t, `
	cc_prebuilt_library {
	name: "libtest",
	static: {
	srcs: ["libf.a"],
	},
	shared: {
	srcs: ["libf.so"],
	},
	strip: {
	none: true,
	},
	}
	`, map[string][]byte{
	"libf.a": nil,
	"libf.so": nil,
	})

	shared := ctx.ModuleForTests("libtest", "android_arm64_armv8-a_shared").Module().(*Module)
	assertString(t, shared.OutputFile().Path().Base(), "libtest.so")

	static := ctx.ModuleForTests("libtest", "android_arm64_armv8-a_static").Module().(*Module)
	assertString(t, static.OutputFile().Path().Base(), "libf.a")
	}

	func TestPrebuiltLibraryStem(t *testing.T) {
	ctx := testPrebuilt(t, `
	cc_prebuilt_library {
	name: "libfoo",
	stem: "libbar",
	static: {
	srcs: ["libfoo.a"],
	},
	shared: {
	srcs: ["libfoo.so"],
	},
	strip: {
	none: true,
	},
	}
	`, map[string][]byte{
	"libfoo.a": nil,
	"libfoo.so": nil,
	})

	static := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_static").Module().(*Module)
	assertString(t, static.OutputFile().Path().Base(), "libfoo.a")

	shared := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_shared").Module().(*Module)
	assertString(t, shared.OutputFile().Path().Base(), "libbar.so")
	}

	func TestPrebuiltLibrarySharedStem(t *testing.T) {
	ctx := testPrebuilt(t, `
	cc_prebuilt_library_shared {
	name: "libfoo",
	stem: "libbar",
	srcs: ["libfoo.so"],
	strip: {
	none: true,
	},
	}
	`, map[string][]byte{
	"libfoo.so": nil,
	})

	shared := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_shared").Module().(*Module)
	assertString(t, shared.OutputFile().Path().Base(), "libbar.so")
	}

	func TestPrebuiltSymlinkedHostBinary(t *testing.T) {
	if runtime.GOOS != "linux" {
	t.Skipf("Skipping host prebuilt testing that is only supported on linux not %s", runtime.GOOS)
	}

	ctx := testPrebuilt(t, `
	cc_prebuilt_library_shared {
	name: "libfoo",
	device_supported: false,
	host_supported: true,
	target: {
	linux_glibc_x86_64: {
	srcs: ["linux_glibc_x86_64/lib64/libfoo.so"],
	},
	},
	}

	cc_prebuilt_binary {
	name: "foo",
	device_supported: false,
	host_supported: true,
	shared_libs: ["libfoo"],
	target: {
	linux_glibc_x86_64: {
	srcs: ["linux_glibc_x86_64/bin/foo"],
	},
	},
	}
	`, map[string][]byte{
	"libfoo.so": nil,
	"foo": nil,
	})

	fooRule := ctx.ModuleForTests("foo", "linux_glibc_x86_64").Rule("Symlink")
	assertString(t, fooRule.Output.String(), "out/soong/.intermediates/foo/linux_glibc_x86_64/foo")
	assertString(t, fooRule.Args["fromPath"], "$$PWD/linux_glibc_x86_64/bin/foo")

	var libfooDep android.Path
	for _, dep := range fooRule.Implicits {
	if dep.Base() == "libfoo.so" {
	libfooDep = dep
	break
	}
	}
	assertString(t, libfooDep.String(), "out/soong/.intermediates/libfoo/linux_glibc_x86_64_shared/libfoo.so")
	}

	func TestPrebuiltLibrarySanitized(t *testing.T) {
	bp := `cc_prebuilt_library {
	name: "libtest",
	static: {
	sanitized: { none: { srcs: ["libf.a"], }, hwaddress: { srcs: ["libf.hwasan.a"], }, },
	},
	shared: {
	sanitized: { none: { srcs: ["libf.so"], }, hwaddress: { srcs: ["hwasan/libf.so"], }, },
	},
	}
	cc_prebuilt_library_static {
	name: "libtest_static",
	sanitized: { none: { srcs: ["libf.a"], }, hwaddress: { srcs: ["libf.hwasan.a"], }, },
	}
	cc_prebuilt_library_shared {
	name: "libtest_shared",
	sanitized: { none: { srcs: ["libf.so"], }, hwaddress: { srcs: ["hwasan/libf.so"], }, },
	}`

	fs := map[string][]byte{
	"libf.a": nil,
	"libf.hwasan.a": nil,
	"libf.so": nil,
	"hwasan/libf.so": nil,
	}

	// Without SANITIZE_TARGET.
	ctx := testPrebuilt(t, bp, fs)

	shared_rule := ctx.ModuleForTests("libtest", "android_arm64_armv8-a_shared").Rule("android/soong/cc.strip")
	assertString(t, shared_rule.Input.String(), "libf.so")

	static := ctx.ModuleForTests("libtest", "android_arm64_armv8-a_static").Module().(*Module)
	assertString(t, static.OutputFile().Path().Base(), "libf.a")

	shared_rule2 := ctx.ModuleForTests("libtest_shared", "android_arm64_armv8-a_shared").Rule("android/soong/cc.strip")
	assertString(t, shared_rule2.Input.String(), "libf.so")

	static2 := ctx.ModuleForTests("libtest_static", "android_arm64_armv8-a_static").Module().(*Module)
	assertString(t, static2.OutputFile().Path().Base(), "libf.a")

	// With SANITIZE_TARGET=hwaddress
	ctx = testPrebuilt(t, bp, fs,
	android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
	variables.SanitizeDevice = []string{"hwaddress"}
	}),
	)

	shared_rule = ctx.ModuleForTests("libtest", "android_arm64_armv8-a_shared_hwasan").Rule("android/soong/cc.strip")
	assertString(t, shared_rule.Input.String(), "hwasan/libf.so")

	static = ctx.ModuleForTests("libtest", "android_arm64_armv8-a_static_hwasan").Module().(*Module)
	assertString(t, static.OutputFile().Path().Base(), "libf.hwasan.a")

	shared_rule2 = ctx.ModuleForTests("libtest_shared", "android_arm64_armv8-a_shared_hwasan").Rule("android/soong/cc.strip")
	assertString(t, shared_rule2.Input.String(), "hwasan/libf.so")

	static2 = ctx.ModuleForTests("libtest_static", "android_arm64_armv8-a_static_hwasan").Module().(*Module)
	assertString(t, static2.OutputFile().Path().Base(), "libf.hwasan.a")
	}

	func TestPrebuiltLibrarySharedWithBazelWithoutToc(t *testing.T) {
	const bp = `
	cc_prebuilt_library_shared {
	name: "foo",
	srcs: ["foo.so"],
	bazel_module: { label: "//foo/bar:bar" },
	}`
	outBaseDir := "outputbase"
	config := TestConfig(t.TempDir(), android.Android, nil, bp, nil)
	config.BazelContext = android.MockBazelContext{
	OutputBaseDir: outBaseDir,
	LabelToCcInfo: map[string]cquery.CcInfo{
	"//foo/bar:bar": cquery.CcInfo{
	CcSharedLibraryFiles: []string{"foo.so"},
	},
	},
	}
	ctx := testCcWithConfig(t, config)
	sharedFoo := ctx.ModuleForTests("foo", "android_arm_armv7-a-neon_shared").Module()
	pathPrefix := outBaseDir + "/execroot/__main__/"

	info := ctx.ModuleProvider(sharedFoo, SharedLibraryInfoProvider).(SharedLibraryInfo)
	android.AssertPathRelativeToTopEquals(t, "prebuilt shared library",
	pathPrefix+"foo.so", info.SharedLibrary)
	android.AssertPathRelativeToTopEquals(t, "prebuilt's 'nullary' ToC",
	pathPrefix+"foo.so", info.TableOfContents.Path())

	outputFiles, err := sharedFoo.(android.OutputFileProducer).OutputFiles("")
	if err != nil {
	t.Errorf("Unexpected error getting cc_object outputfiles %s", err)
	}
	expectedOutputFiles := []string{pathPrefix + "foo.so"}
	android.AssertDeepEquals(t, "output files", expectedOutputFiles, outputFiles.Strings())
	}

	func TestPrebuiltLibrarySharedWithBazelWithToc(t *testing.T) {
	const bp = `
	cc_prebuilt_library_shared {
	name: "foo",
	srcs: ["foo.so"],
	bazel_module: { label: "//foo/bar:bar" },
	}`
	outBaseDir := "outputbase"
	config := TestConfig(t.TempDir(), android.Android, nil, bp, nil)
	config.BazelContext = android.MockBazelContext{
	OutputBaseDir: outBaseDir,
	LabelToCcInfo: map[string]cquery.CcInfo{
	"//foo/bar:bar": cquery.CcInfo{
	CcSharedLibraryFiles: []string{"foo.so"},
	TocFile: "toc",
	},
	},
	}
	ctx := testCcWithConfig(t, config)
	sharedFoo := ctx.ModuleForTests("foo", "android_arm_armv7-a-neon_shared").Module()
	pathPrefix := outBaseDir + "/execroot/__main__/"

	info := ctx.ModuleProvider(sharedFoo, SharedLibraryInfoProvider).(SharedLibraryInfo)
	android.AssertPathRelativeToTopEquals(t, "prebuilt shared library's ToC",
	pathPrefix+"toc", info.TableOfContents.Path())
	android.AssertPathRelativeToTopEquals(t, "prebuilt shared library",
	pathPrefix+"foo.so", info.SharedLibrary)

	outputFiles, err := sharedFoo.(android.OutputFileProducer).OutputFiles("")
	if err != nil {
	t.Errorf("Unexpected error getting cc_object outputfiles %s", err)
	}
	expectedOutputFiles := []string{pathPrefix + "foo.so"}
	android.AssertDeepEquals(t, "output files", expectedOutputFiles, outputFiles.Strings())
	}

	func TestPrebuiltStubNoinstall(t *testing.T) {
	testFunc := func(t *testing.T, bp string) {
	result := android.GroupFixturePreparers(
	prepareForPrebuiltTest,
	android.PrepareForTestWithMakevars,
	).RunTestWithBp(t, bp)

	installRules := result.InstallMakeRulesForTesting(t)
	var installedlibRule *android.InstallMakeRule
	for i, rule := range installRules {
	if rule.Target == "out/target/product/test_device/system/lib/installedlib.so" {
	if installedlibRule != nil {
	t.Errorf("Duplicate install rules for %s", rule.Target)
	}
	installedlibRule = &installRules[i]
	}
	}
	if installedlibRule == nil {
	t.Errorf("No install rule found for installedlib")
	return
	}

	android.AssertStringListDoesNotContain(t,
	"installedlib has install dependency on stub",
	installedlibRule.Deps,
	"out/target/product/test_device/system/lib/stublib.so")
	android.AssertStringListDoesNotContain(t,
	"installedlib has order-only install dependency on stub",
	installedlibRule.OrderOnlyDeps,
	"out/target/product/test_device/system/lib/stublib.so")
	}

	const prebuiltStublibBp = `
	cc_prebuilt_library {
	name: "stublib",
	prefer: true,
	srcs: ["foo.so"],
	stubs: {
	versions: ["1"],
	},
	}
	`

	const installedlibBp = `
	cc_library {
	name: "installedlib",
	shared_libs: ["stublib"],
	}
	`

	t.Run("prebuilt without source", func(t *testing.T) {
	testFunc(t, prebuiltStublibBp+installedlibBp)
	})

	const disabledSourceStublibBp = `
	cc_library {
	name: "stublib",
	enabled: false,
	stubs: {
	versions: ["1"],
	},
	}
	`

	t.Run("prebuilt with disabled source", func(t *testing.T) {
	testFunc(t, disabledSourceStublibBp+prebuiltStublibBp+installedlibBp)
	})
	}