diff --git a/cc/Android.bp b/cc/Android.bp index 9e4b76351..93d9aa2d8 100644 --- a/cc/Android.bp +++ b/cc/Android.bp @@ -111,7 +111,6 @@ bootstrap_go_package { "test_data_test.go", "tidy_test.go", "vendor_public_library_test.go", - "vendor_snapshot_test.go", ], pluginFor: ["soong_build"], } diff --git a/cc/vendor_snapshot_test.go b/cc/vendor_snapshot_test.go deleted file mode 100644 index 0a5543146..000000000 --- a/cc/vendor_snapshot_test.go +++ /dev/null @@ -1,1751 +0,0 @@ -// Copyright 2021 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 ( - "android/soong/android" - "fmt" - "path/filepath" - "reflect" - "strings" - "testing" -) - -func checkJsonContents(t *testing.T, ctx *android.TestContext, snapshotSingleton android.TestingSingleton, jsonPath string, key string, value string) { - jsonOut := snapshotSingleton.MaybeOutput(jsonPath) - if jsonOut.Rule == nil { - t.Errorf("%q expected but not found", jsonPath) - return - } - content := android.ContentFromFileRuleForTests(t, ctx, jsonOut) - if !strings.Contains(content, fmt.Sprintf("%q:%q", key, value)) { - t.Errorf("%q must include %q:%q but it only has %v", jsonPath, key, value, jsonOut.Args["content"]) - } -} - -func TestVendorSnapshotCapture(t *testing.T) { - bp := ` - cc_library { - name: "libvndk", - vendor_available: true, - product_available: true, - vndk: { - enabled: true, - }, - nocrt: true, - } - - cc_library { - name: "libvendor", - vendor: true, - nocrt: true, - } - - cc_library { - name: "libvendor_override", - vendor: true, - nocrt: true, - overrides: ["libvendor"], - } - - cc_library { - name: "libvendor_available", - vendor_available: true, - nocrt: true, - min_sdk_version: "29", - } - - cc_library_headers { - name: "libvendor_headers", - vendor_available: true, - nocrt: true, - } - - cc_binary { - name: "vendor_bin", - vendor: true, - nocrt: true, - } - - cc_binary { - name: "vendor_available_bin", - vendor_available: true, - nocrt: true, - } - - cc_binary { - name: "vendor_bin_override", - vendor: true, - nocrt: true, - overrides: ["vendor_bin"], - } - - cc_prebuilt_library_static { - name: "libb", - vendor_available: true, - srcs: ["libb.a"], - nocrt: true, - no_libcrt: true, - stl: "none", - } - - cc_object { - name: "obj", - vendor_available: true, - } - - cc_library { - name: "libllndk", - llndk: { - symbol_file: "libllndk.map.txt", - }, - } -` - - config := TestConfig(t.TempDir(), android.Android, nil, bp, nil) - config.TestProductVariables.DeviceVndkVersion = StringPtr("current") - config.TestProductVariables.Platform_vndk_version = StringPtr("29") - ctx := testCcWithConfig(t, config) - - // Check Vendor snapshot output. - - snapshotDir := "vendor-snapshot" - snapshotVariantPath := filepath.Join("out/soong", snapshotDir, "arm64") - snapshotSingleton := ctx.SingletonForTests("vendor-snapshot") - - var jsonFiles []string - - for _, arch := range [][]string{ - []string{"arm64", "armv8-a"}, - []string{"arm", "armv7-a-neon"}, - } { - archType := arch[0] - archVariant := arch[1] - archDir := fmt.Sprintf("arch-%s-%s", archType, archVariant) - - // For shared libraries, only non-VNDK vendor_available modules are captured - sharedVariant := fmt.Sprintf("android_vendor.29_%s_%s_shared", archType, archVariant) - sharedDir := filepath.Join(snapshotVariantPath, archDir, "shared") - CheckSnapshot(t, ctx, snapshotSingleton, "libvendor", "libvendor.so", sharedDir, sharedVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "libvendor_available", "libvendor_available.so", sharedDir, sharedVariant) - jsonFiles = append(jsonFiles, - filepath.Join(sharedDir, "libvendor.so.json"), - filepath.Join(sharedDir, "libvendor_available.so.json")) - - // LLNDK modules are not captured - CheckSnapshotExclude(t, ctx, snapshotSingleton, "libllndk", "libllndk.so", sharedDir, sharedVariant) - - // For static libraries, all vendor:true and vendor_available modules (including VNDK) are captured. - // Also cfi variants are captured, except for prebuilts like toolchain_library - staticVariant := fmt.Sprintf("android_vendor.29_%s_%s_static", archType, archVariant) - staticCfiVariant := fmt.Sprintf("android_vendor.29_%s_%s_static_cfi", archType, archVariant) - staticDir := filepath.Join(snapshotVariantPath, archDir, "static") - CheckSnapshot(t, ctx, snapshotSingleton, "libb", "libb.a", staticDir, staticVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "libvndk", "libvndk.a", staticDir, staticVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "libvndk", "libvndk.cfi.a", staticDir, staticCfiVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "libvendor", "libvendor.a", staticDir, staticVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "libvendor", "libvendor.cfi.a", staticDir, staticCfiVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "libvendor_available", "libvendor_available.a", staticDir, staticVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "libvendor_available", "libvendor_available.cfi.a", staticDir, staticCfiVariant) - jsonFiles = append(jsonFiles, - filepath.Join(staticDir, "libb.a.json"), - filepath.Join(staticDir, "libvndk.a.json"), - filepath.Join(staticDir, "libvndk.cfi.a.json"), - filepath.Join(staticDir, "libvendor.a.json"), - filepath.Join(staticDir, "libvendor.cfi.a.json"), - filepath.Join(staticDir, "libvendor_available.a.json"), - filepath.Join(staticDir, "libvendor_available.cfi.a.json")) - - checkJsonContents(t, ctx, snapshotSingleton, filepath.Join(staticDir, "libb.a.json"), "MinSdkVersion", "apex_inherit") - checkJsonContents(t, ctx, snapshotSingleton, filepath.Join(staticDir, "libvendor_available.a.json"), "MinSdkVersion", "29") - - // For binary executables, all vendor:true and vendor_available modules are captured. - if archType == "arm64" { - binaryVariant := fmt.Sprintf("android_vendor.29_%s_%s", archType, archVariant) - binaryDir := filepath.Join(snapshotVariantPath, archDir, "binary") - CheckSnapshot(t, ctx, snapshotSingleton, "vendor_bin", "vendor_bin", binaryDir, binaryVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "vendor_available_bin", "vendor_available_bin", binaryDir, binaryVariant) - jsonFiles = append(jsonFiles, - filepath.Join(binaryDir, "vendor_bin.json"), - filepath.Join(binaryDir, "vendor_available_bin.json")) - - checkOverrides(t, ctx, snapshotSingleton, filepath.Join(binaryDir, "vendor_bin_override.json"), []string{"vendor_bin"}) - } - - // For header libraries, all vendor:true and vendor_available modules are captured. - headerDir := filepath.Join(snapshotVariantPath, archDir, "header") - jsonFiles = append(jsonFiles, filepath.Join(headerDir, "libvendor_headers.json")) - - // For object modules, all vendor:true and vendor_available modules are captured. - objectVariant := fmt.Sprintf("android_vendor.29_%s_%s", archType, archVariant) - objectDir := filepath.Join(snapshotVariantPath, archDir, "object") - CheckSnapshot(t, ctx, snapshotSingleton, "obj", "obj.o", objectDir, objectVariant) - jsonFiles = append(jsonFiles, filepath.Join(objectDir, "obj.o.json")) - - checkOverrides(t, ctx, snapshotSingleton, filepath.Join(sharedDir, "libvendor_override.so.json"), []string{"libvendor"}) - } - - for _, jsonFile := range jsonFiles { - // verify all json files exist - if snapshotSingleton.MaybeOutput(jsonFile).Rule == nil { - t.Errorf("%q expected but not found", jsonFile) - } - } - - // fake snapshot should have all outputs in the normal snapshot. - fakeSnapshotSingleton := ctx.SingletonForTests("vendor-fake-snapshot") - for _, output := range snapshotSingleton.AllOutputs() { - fakeOutput := strings.Replace(output, "/vendor-snapshot/", "/fake/vendor-snapshot/", 1) - if fakeSnapshotSingleton.MaybeOutput(fakeOutput).Rule == nil { - t.Errorf("%q expected but not found", fakeOutput) - } - } -} - -func TestVendorSnapshotDirected(t *testing.T) { - bp := ` - cc_library_shared { - name: "libvendor", - vendor: true, - nocrt: true, - } - - cc_library_shared { - name: "libvendor_available", - vendor_available: true, - nocrt: true, - } - - genrule { - name: "libfoo_gen", - cmd: "", - out: ["libfoo.so"], - } - - cc_prebuilt_library_shared { - name: "libfoo", - vendor: true, - prefer: true, - srcs: [":libfoo_gen"], - } - - cc_library_shared { - name: "libfoo", - vendor: true, - nocrt: true, - } -` - config := TestConfig(t.TempDir(), android.Android, nil, bp, nil) - config.TestProductVariables.DeviceVndkVersion = StringPtr("current") - config.TestProductVariables.Platform_vndk_version = StringPtr("29") - config.TestProductVariables.DirectedVendorSnapshot = true - config.TestProductVariables.VendorSnapshotModules = make(map[string]bool) - config.TestProductVariables.VendorSnapshotModules["libvendor"] = true - config.TestProductVariables.VendorSnapshotModules["libfoo"] = true - ctx := testCcWithConfig(t, config) - - // Check Vendor snapshot output. - - snapshotDir := "vendor-snapshot" - snapshotVariantPath := filepath.Join("out/soong", snapshotDir, "arm64") - snapshotSingleton := ctx.SingletonForTests("vendor-snapshot") - - var includeJsonFiles []string - - for _, arch := range [][]string{ - []string{"arm64", "armv8-a"}, - []string{"arm", "armv7-a-neon"}, - } { - archType := arch[0] - archVariant := arch[1] - archDir := fmt.Sprintf("arch-%s-%s", archType, archVariant) - - sharedVariant := fmt.Sprintf("android_vendor.29_%s_%s_shared", archType, archVariant) - sharedDir := filepath.Join(snapshotVariantPath, archDir, "shared") - - // Included modules - CheckSnapshot(t, ctx, snapshotSingleton, "libvendor", "libvendor.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "libvendor.so.json")) - // Check that snapshot captures "prefer: true" prebuilt - CheckSnapshot(t, ctx, snapshotSingleton, "prebuilt_libfoo", "libfoo.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "libfoo.so.json")) - - // Excluded modules. Modules not included in the directed vendor snapshot - // are still include as fake modules. - CheckSnapshotRule(t, ctx, snapshotSingleton, "libvendor_available", "libvendor_available.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "libvendor_available.so.json")) - } - - // Verify that each json file for an included module has a rule. - for _, jsonFile := range includeJsonFiles { - if snapshotSingleton.MaybeOutput(jsonFile).Rule == nil { - t.Errorf("include json file %q not found", jsonFile) - } - } -} - -func TestVendorSnapshotUse(t *testing.T) { - frameworkBp := ` - cc_library { - name: "libvndk", - vendor_available: true, - product_available: true, - vndk: { - enabled: true, - }, - nocrt: true, - } - - cc_library { - name: "libvendor", - vendor: true, - nocrt: true, - no_libcrt: true, - stl: "none", - system_shared_libs: [], - } - - cc_library { - name: "libvendor_available", - vendor_available: true, - nocrt: true, - no_libcrt: true, - stl: "none", - system_shared_libs: [], - } - - cc_library { - name: "lib32", - vendor: true, - nocrt: true, - no_libcrt: true, - stl: "none", - system_shared_libs: [], - compile_multilib: "32", - } - - cc_library { - name: "lib64", - vendor: true, - nocrt: true, - no_libcrt: true, - no_crt_pad_segment: true, - stl: "none", - system_shared_libs: [], - compile_multilib: "64", - } - - cc_library { - name: "libllndk", - llndk: { - symbol_file: "libllndk.map.txt", - }, - } - - cc_binary { - name: "bin", - vendor: true, - nocrt: true, - no_libcrt: true, - stl: "none", - system_shared_libs: [], - } - - cc_binary { - name: "bin32", - vendor: true, - nocrt: true, - no_libcrt: true, - stl: "none", - system_shared_libs: [], - compile_multilib: "32", - } -` - - vndkBp := ` - vndk_prebuilt_shared { - name: "libvndk", - version: "31", - target_arch: "arm64", - vendor_available: true, - product_available: true, - vndk: { - enabled: true, - }, - arch: { - arm64: { - srcs: ["libvndk.so"], - export_include_dirs: ["include/libvndk"], - }, - arm: { - srcs: ["libvndk.so"], - export_include_dirs: ["include/libvndk"], - }, - }, - } - - // old snapshot module which has to be ignored - vndk_prebuilt_shared { - name: "libvndk", - version: "26", - target_arch: "arm64", - vendor_available: true, - product_available: true, - vndk: { - enabled: true, - }, - arch: { - arm64: { - srcs: ["libvndk.so"], - export_include_dirs: ["include/libvndk"], - }, - arm: { - srcs: ["libvndk.so"], - export_include_dirs: ["include/libvndk"], - }, - }, - } - - // different arch snapshot which has to be ignored - vndk_prebuilt_shared { - name: "libvndk", - version: "31", - target_arch: "arm", - vendor_available: true, - product_available: true, - vndk: { - enabled: true, - }, - arch: { - arm: { - srcs: ["libvndk.so"], - export_include_dirs: ["include/libvndk"], - }, - }, - } - - vndk_prebuilt_shared { - name: "libllndk", - version: "31", - target_arch: "arm64", - vendor_available: true, - product_available: true, - arch: { - arm64: { - srcs: ["libllndk.so"], - }, - arm: { - srcs: ["libllndk.so"], - }, - }, - } -` - - vendorProprietaryBp := ` - cc_library { - name: "libvendor_without_snapshot", - vendor: true, - nocrt: true, - no_libcrt: true, - no_crt_pad_segment: true, - stl: "none", - system_shared_libs: [], - } - - cc_library_shared { - name: "libclient", - vendor: true, - nocrt: true, - no_libcrt: true, - no_crt_pad_segment: true, - stl: "none", - system_shared_libs: [], - shared_libs: ["libvndk", "libvendor_available", "libllndk"], - static_libs: ["libvendor", "libvendor_without_snapshot"], - arch: { - arm64: { - shared_libs: ["lib64"], - }, - arm: { - shared_libs: ["lib32"], - }, - }, - srcs: ["client.cpp"], - } - - cc_library_shared { - name: "libclient_cfi", - vendor: true, - nocrt: true, - no_libcrt: true, - no_crt_pad_segment: true, - stl: "none", - system_shared_libs: [], - static_libs: ["libvendor"], - sanitize: { - cfi: true, - }, - srcs: ["client.cpp"], - } - - cc_library_shared { - name: "libvndkext", - vendor: true, - nocrt: true, - no_libcrt: true, - no_crt_pad_segment: true, - stl: "none", - system_shared_libs: [], - vndk: { - extends: "libvndk", - enabled: true, - } - } - - cc_binary { - name: "bin_without_snapshot", - vendor: true, - nocrt: true, - no_libcrt: true, - stl: "libc++_static", - system_shared_libs: [], - static_libs: ["libvndk"], - srcs: ["bin.cpp"], - } - - vendor_snapshot { - name: "vendor_snapshot", - version: "31", - arch: { - arm64: { - vndk_libs: [ - "libvndk", - "libllndk", - ], - static_libs: [ - "libc++_static", - "libc++demangle", - "libunwind", - "libvendor", - "libvendor_available", - "libvndk", - "lib64", - ], - shared_libs: [ - "libvendor", - "libvendor_override", - "libvendor_available", - "lib64", - ], - binaries: [ - "bin", - "bin_override", - ], - }, - arm: { - vndk_libs: [ - "libvndk", - "libllndk", - ], - static_libs: [ - "libvendor", - "libvendor_available", - "libvndk", - "lib32", - ], - shared_libs: [ - "libvendor", - "libvendor_override", - "libvendor_available", - "lib32", - ], - binaries: [ - "bin32", - ], - }, - } - } - - vendor_snapshot_static { - name: "libvndk", - version: "31", - target_arch: "arm64", - compile_multilib: "both", - vendor: true, - arch: { - arm64: { - src: "libvndk.a", - }, - arm: { - src: "libvndk.a", - }, - }, - shared_libs: ["libvndk"], - export_shared_lib_headers: ["libvndk"], - } - - vendor_snapshot_shared { - name: "libvendor", - version: "31", - target_arch: "arm64", - compile_multilib: "both", - vendor: true, - no_crt_pad_segment: true, - shared_libs: [ - "libvendor_without_snapshot", - "libvendor_available", - "libvndk", - ], - arch: { - arm64: { - src: "libvendor.so", - export_include_dirs: ["include/libvendor"], - }, - arm: { - src: "libvendor.so", - export_include_dirs: ["include/libvendor"], - }, - }, - } - - vendor_snapshot_shared { - name: "libvendor_override", - version: "31", - target_arch: "arm64", - compile_multilib: "both", - vendor: true, - no_crt_pad_segment: true, - overrides: ["libvendor"], - shared_libs: [ - "libvendor_without_snapshot", - "libvendor_available", - "libvndk", - ], - arch: { - arm64: { - src: "override/libvendor.so", - export_include_dirs: ["include/libvendor"], - }, - arm: { - src: "override/libvendor.so", - export_include_dirs: ["include/libvendor"], - }, - }, - } - - vendor_snapshot_static { - name: "lib32", - version: "31", - target_arch: "arm64", - compile_multilib: "32", - vendor: true, - arch: { - arm: { - src: "lib32.a", - }, - }, - } - - vendor_snapshot_shared { - name: "lib32", - version: "31", - target_arch: "arm64", - compile_multilib: "32", - vendor: true, - no_crt_pad_segment: true, - arch: { - arm: { - src: "lib32.so", - }, - }, - } - - vendor_snapshot_static { - name: "lib64", - version: "31", - target_arch: "arm64", - compile_multilib: "64", - vendor: true, - arch: { - arm64: { - src: "lib64.a", - }, - }, - } - - vendor_snapshot_shared { - name: "lib64", - version: "31", - target_arch: "arm64", - compile_multilib: "64", - vendor: true, - no_crt_pad_segment: true, - arch: { - arm64: { - src: "lib64.so", - }, - }, - } - - vendor_snapshot_static { - name: "libvendor", - version: "31", - target_arch: "arm64", - compile_multilib: "both", - vendor: true, - arch: { - arm64: { - cfi: { - src: "libvendor.cfi.a", - export_include_dirs: ["include/libvendor_cfi"], - }, - src: "libvendor.a", - export_include_dirs: ["include/libvendor"], - }, - arm: { - cfi: { - src: "libvendor.cfi.a", - export_include_dirs: ["include/libvendor_cfi"], - }, - src: "libvendor.a", - export_include_dirs: ["include/libvendor"], - }, - }, - } - - vendor_snapshot_shared { - name: "libvendor_available", - version: "31", - target_arch: "arm64", - compile_multilib: "both", - vendor: true, - no_crt_pad_segment: true, - arch: { - arm64: { - src: "libvendor_available.so", - export_include_dirs: ["include/libvendor"], - }, - arm: { - src: "libvendor_available.so", - export_include_dirs: ["include/libvendor"], - }, - }, - } - - vendor_snapshot_static { - name: "libvendor_available", - version: "31", - target_arch: "arm64", - compile_multilib: "both", - vendor: true, - arch: { - arm64: { - src: "libvendor_available.a", - export_include_dirs: ["include/libvendor"], - }, - arm: { - src: "libvendor_available.so", - export_include_dirs: ["include/libvendor"], - }, - }, - } - - vendor_snapshot_static { - name: "libc++_static", - version: "31", - target_arch: "arm64", - compile_multilib: "64", - vendor: true, - arch: { - arm64: { - src: "libc++_static.a", - }, - }, - } - - vendor_snapshot_static { - name: "libc++demangle", - version: "31", - target_arch: "arm64", - compile_multilib: "64", - vendor: true, - arch: { - arm64: { - src: "libc++demangle.a", - }, - }, - } - - vendor_snapshot_static { - name: "libunwind", - version: "31", - target_arch: "arm64", - compile_multilib: "64", - vendor: true, - arch: { - arm64: { - src: "libunwind.a", - }, - }, - } - - vendor_snapshot_binary { - name: "bin", - version: "31", - target_arch: "arm64", - compile_multilib: "64", - vendor: true, - arch: { - arm64: { - src: "bin", - }, - }, - symlinks: ["binfoo", "binbar"], - } - - vendor_snapshot_binary { - name: "bin_override", - version: "31", - target_arch: "arm64", - compile_multilib: "64", - vendor: true, - overrides: ["bin"], - arch: { - arm64: { - src: "override/bin", - }, - }, - symlinks: ["binfoo", "binbar"], - } - - vendor_snapshot_binary { - name: "bin32", - version: "31", - target_arch: "arm64", - compile_multilib: "32", - vendor: true, - arch: { - arm: { - src: "bin32", - }, - }, - } - - // old snapshot module which has to be ignored - vendor_snapshot_binary { - name: "bin", - version: "26", - target_arch: "arm64", - compile_multilib: "first", - vendor: true, - arch: { - arm64: { - src: "bin", - }, - }, - } - - // different arch snapshot which has to be ignored - vendor_snapshot_binary { - name: "bin", - version: "31", - target_arch: "arm", - compile_multilib: "first", - vendor: true, - arch: { - arm64: { - src: "bin", - }, - }, - } -` - depsBp := GatherRequiredDepsForTest(android.Android) - - mockFS := map[string][]byte{ - "deps/Android.bp": []byte(depsBp), - "framework/Android.bp": []byte(frameworkBp), - "framework/symbol.txt": nil, - "vendor/Android.bp": []byte(vendorProprietaryBp), - "vendor/bin": nil, - "vendor/override/bin": nil, - "vendor/bin32": nil, - "vendor/bin.cpp": nil, - "vendor/client.cpp": nil, - "vendor/include/libvndk/a.h": nil, - "vendor/include/libvendor/b.h": nil, - "vendor/include/libvendor_cfi/c.h": nil, - "vendor/libc++_static.a": nil, - "vendor/libc++demangle.a": nil, - "vendor/libunwind.a": nil, - "vendor/libvndk.a": nil, - "vendor/libvendor.a": nil, - "vendor/libvendor.cfi.a": nil, - "vendor/libvendor.so": nil, - "vendor/override/libvendor.so": nil, - "vendor/lib32.a": nil, - "vendor/lib32.so": nil, - "vendor/lib64.a": nil, - "vendor/lib64.so": nil, - "vndk/Android.bp": []byte(vndkBp), - "vndk/include/libvndk/a.h": nil, - "vndk/libvndk.so": nil, - "vndk/libllndk.so": nil, - } - - config := TestConfig(t.TempDir(), android.Android, nil, "", mockFS) - config.TestProductVariables.DeviceVndkVersion = StringPtr("31") - config.TestProductVariables.Platform_vndk_version = StringPtr("32") - ctx := CreateTestContext(config) - ctx.Register() - - _, errs := ctx.ParseFileList(".", []string{"deps/Android.bp", "framework/Android.bp", "vendor/Android.bp", "vndk/Android.bp"}) - android.FailIfErrored(t, errs) - _, errs = ctx.PrepareBuildActions(config) - android.FailIfErrored(t, errs) - - sharedVariant := "android_vendor.31_arm64_armv8-a_shared" - staticVariant := "android_vendor.31_arm64_armv8-a_static" - binaryVariant := "android_vendor.31_arm64_armv8-a" - - sharedCfiVariant := "android_vendor.31_arm64_armv8-a_shared_cfi" - staticCfiVariant := "android_vendor.31_arm64_armv8-a_static_cfi" - - shared32Variant := "android_vendor.31_arm_armv7-a-neon_shared" - binary32Variant := "android_vendor.31_arm_armv7-a-neon" - - // libclient uses libvndk.vndk.31.arm64, libvendor.vendor_static.31.arm64, libvendor_without_snapshot - libclientCcFlags := ctx.ModuleForTests("libclient", sharedVariant).Rule("cc").Args["cFlags"] - for _, includeFlags := range []string{ - "-Ivndk/include/libvndk", // libvndk - "-Ivendor/include/libvendor", // libvendor - } { - if !strings.Contains(libclientCcFlags, includeFlags) { - t.Errorf("flags for libclient must contain %#v, but was %#v.", - includeFlags, libclientCcFlags) - } - } - - libclientLdFlags := ctx.ModuleForTests("libclient", sharedVariant).Rule("ld").Args["libFlags"] - for _, input := range [][]string{ - []string{sharedVariant, "libvndk.vndk.31.arm64"}, - []string{sharedVariant, "libllndk.vndk.31.arm64"}, - []string{staticVariant, "libvendor.vendor_static.31.arm64"}, - []string{staticVariant, "libvendor_without_snapshot"}, - } { - outputPaths := GetOutputPaths(ctx, input[0] /* variant */, []string{input[1]} /* module name */) - if !strings.Contains(libclientLdFlags, outputPaths[0].String()) { - t.Errorf("libflags for libclient must contain %#v, but was %#v", outputPaths[0], libclientLdFlags) - } - - } - - libclientAndroidMkSharedLibs := ctx.ModuleForTests("libclient", sharedVariant).Module().(*Module).Properties.AndroidMkSharedLibs - if g, w := libclientAndroidMkSharedLibs, []string{"libvndk.vendor", "libvendor_available.vendor", "libllndk.vendor", "lib64"}; !reflect.DeepEqual(g, w) { - t.Errorf("wanted libclient AndroidMkSharedLibs %q, got %q", w, g) - } - - libclientAndroidMkStaticLibs := ctx.ModuleForTests("libclient", sharedVariant).Module().(*Module).Properties.AndroidMkStaticLibs - if g, w := libclientAndroidMkStaticLibs, []string{"libvendor", "libvendor_without_snapshot"}; !reflect.DeepEqual(g, w) { - t.Errorf("wanted libclient AndroidMkStaticLibs %q, got %q", w, g) - } - - libclient32AndroidMkSharedLibs := ctx.ModuleForTests("libclient", shared32Variant).Module().(*Module).Properties.AndroidMkSharedLibs - if g, w := libclient32AndroidMkSharedLibs, []string{"libvndk.vendor", "libvendor_available.vendor", "libllndk.vendor", "lib32"}; !reflect.DeepEqual(g, w) { - t.Errorf("wanted libclient32 AndroidMkSharedLibs %q, got %q", w, g) - } - - // libclient_cfi uses libvendor.vendor_static.31.arm64's cfi variant - libclientCfiCcFlags := ctx.ModuleForTests("libclient_cfi", sharedCfiVariant).Rule("cc").Args["cFlags"] - if !strings.Contains(libclientCfiCcFlags, "-Ivendor/include/libvendor_cfi") { - t.Errorf("flags for libclient_cfi must contain %#v, but was %#v.", - "-Ivendor/include/libvendor_cfi", libclientCfiCcFlags) - } - - libclientCfiLdFlags := ctx.ModuleForTests("libclient_cfi", sharedCfiVariant).Rule("ld").Args["libFlags"] - libvendorCfiOutputPaths := GetOutputPaths(ctx, staticCfiVariant, []string{"libvendor.vendor_static.31.arm64"}) - if !strings.Contains(libclientCfiLdFlags, libvendorCfiOutputPaths[0].String()) { - t.Errorf("libflags for libclientCfi must contain %#v, but was %#v", libvendorCfiOutputPaths[0], libclientCfiLdFlags) - } - - // bin_without_snapshot uses libvndk.vendor_static.31.arm64 (which reexports vndk's exported headers) - binWithoutSnapshotCcFlags := ctx.ModuleForTests("bin_without_snapshot", binaryVariant).Rule("cc").Args["cFlags"] - if !strings.Contains(binWithoutSnapshotCcFlags, "-Ivndk/include/libvndk") { - t.Errorf("flags for bin_without_snapshot must contain %#v, but was %#v.", - "-Ivendor/include/libvndk", binWithoutSnapshotCcFlags) - } - - binWithoutSnapshotLdFlags := ctx.ModuleForTests("bin_without_snapshot", binaryVariant).Rule("ld").Args["libFlags"] - libVndkStaticOutputPaths := GetOutputPaths(ctx, staticVariant, []string{"libvndk.vendor_static.31.arm64"}) - if !strings.Contains(binWithoutSnapshotLdFlags, libVndkStaticOutputPaths[0].String()) { - t.Errorf("libflags for bin_without_snapshot must contain %#v, but was %#v", - libVndkStaticOutputPaths[0], binWithoutSnapshotLdFlags) - } - - // libvendor.so is installed by libvendor.vendor_shared.31.arm64 - ctx.ModuleForTests("libvendor.vendor_shared.31.arm64", sharedVariant).Output("libvendor.so") - - // lib64.so is installed by lib64.vendor_shared.31.arm64 - ctx.ModuleForTests("lib64.vendor_shared.31.arm64", sharedVariant).Output("lib64.so") - - // lib32.so is installed by lib32.vendor_shared.31.arm64 - ctx.ModuleForTests("lib32.vendor_shared.31.arm64", shared32Variant).Output("lib32.so") - - // libvendor_available.so is installed by libvendor_available.vendor_shared.31.arm64 - ctx.ModuleForTests("libvendor_available.vendor_shared.31.arm64", sharedVariant).Output("libvendor_available.so") - - // libvendor_without_snapshot.so is installed by libvendor_without_snapshot - ctx.ModuleForTests("libvendor_without_snapshot", sharedVariant).Output("libvendor_without_snapshot.so") - - // bin is installed by bin.vendor_binary.31.arm64 - bin64Module := ctx.ModuleForTests("bin.vendor_binary.31.arm64", binaryVariant) - bin64Module.Output("bin") - - // also test symlinks - bin64MkEntries := android.AndroidMkEntriesForTest(t, ctx, bin64Module.Module()) - bin64KatiSymlinks := bin64MkEntries[0].EntryMap["LOCAL_SOONG_INSTALL_SYMLINKS"] - - // Either AndroidMk entries contain symlinks, or symlinks should be installed by Soong - for _, symlink := range []string{"binfoo", "binbar"} { - if inList(symlink, bin64KatiSymlinks) { - continue - } - - bin64Module.Output(symlink) - } - - // bin32 is installed by bin32.vendor_binary.31.arm64 - ctx.ModuleForTests("bin32.vendor_binary.31.arm64", binary32Variant).Output("bin32") - - // bin_without_snapshot is installed by bin_without_snapshot - ctx.ModuleForTests("bin_without_snapshot", binaryVariant).Output("bin_without_snapshot") - - // libvendor, libvendor_available and bin don't have vendor.31 variant - libvendorVariants := ctx.ModuleVariantsForTests("libvendor") - if inList(sharedVariant, libvendorVariants) { - t.Errorf("libvendor must not have variant %#v, but it does", sharedVariant) - } - - libvendorAvailableVariants := ctx.ModuleVariantsForTests("libvendor_available") - if inList(sharedVariant, libvendorAvailableVariants) { - t.Errorf("libvendor_available must not have variant %#v, but it does", sharedVariant) - } - - binVariants := ctx.ModuleVariantsForTests("bin") - if inList(binaryVariant, binVariants) { - t.Errorf("bin must not have variant %#v, but it does", sharedVariant) - } - - // test overrides property - binOverrideModule := ctx.ModuleForTests("bin_override.vendor_binary.31.arm64", binaryVariant) - binOverrideModule.Output("bin") - binOverrideMkEntries := android.AndroidMkEntriesForTest(t, ctx, binOverrideModule.Module()) - binOverrideEntry := binOverrideMkEntries[0].EntryMap["LOCAL_OVERRIDES_MODULES"] - if !inList("bin", binOverrideEntry) { - t.Errorf("bin_override must override bin but was %q\n", binOverrideEntry) - } - - libvendorOverrideModule := ctx.ModuleForTests("libvendor_override.vendor_shared.31.arm64", sharedVariant) - libvendorOverrideModule.Output("libvendor.so") - libvendorOverrideMkEntries := android.AndroidMkEntriesForTest(t, ctx, libvendorOverrideModule.Module()) - libvendorOverrideEntry := libvendorOverrideMkEntries[0].EntryMap["LOCAL_OVERRIDES_MODULES"] - if !inList("libvendor", libvendorOverrideEntry) { - t.Errorf("libvendor_override must override libvendor but was %q\n", libvendorOverrideEntry) - } -} - -func TestVendorSnapshotSanitizer(t *testing.T) { - bp := ` - vendor_snapshot { - name: "vendor_snapshot", - version: "28", - arch: { - arm64: { - static_libs: [ - "libsnapshot", - "note_memtag_heap_sync", - ], - objects: [ - "snapshot_object", - ], - vndk_libs: [ - "libclang_rt.hwasan", - ], - }, - }, - } - - vendor_snapshot_static { - name: "libsnapshot", - vendor: true, - target_arch: "arm64", - version: "28", - arch: { - arm64: { - src: "libsnapshot.a", - cfi: { - src: "libsnapshot.cfi.a", - }, - hwasan: { - src: "libsnapshot.hwasan.a", - }, - }, - }, - } - - vendor_snapshot_static { - name: "note_memtag_heap_sync", - vendor: true, - target_arch: "arm64", - version: "28", - arch: { - arm64: { - src: "note_memtag_heap_sync.a", - }, - }, - } - - vndk_prebuilt_shared { - name: "libclang_rt.hwasan", - version: "28", - target_arch: "arm64", - vendor_available: true, - product_available: true, - vndk: { - enabled: true, - }, - arch: { - arm64: { - srcs: ["libclang_rt.hwasan.so"], - }, - }, - } - - vendor_snapshot_object { - name: "snapshot_object", - vendor: true, - target_arch: "arm64", - version: "28", - arch: { - arm64: { - src: "snapshot_object.o", - }, - }, - stl: "none", - } - - cc_test { - name: "vstest", - gtest: false, - vendor: true, - compile_multilib: "64", - nocrt: true, - no_libcrt: true, - stl: "none", - static_libs: ["libsnapshot"], - system_shared_libs: [], - } -` - - mockFS := map[string][]byte{ - "vendor/Android.bp": []byte(bp), - "vendor/libc++demangle.a": nil, - "vendor/libclang_rt.hwasan.so": nil, - "vendor/libsnapshot.a": nil, - "vendor/libsnapshot.cfi.a": nil, - "vendor/libsnapshot.hwasan.a": nil, - "vendor/note_memtag_heap_sync.a": nil, - "vendor/snapshot_object.o": nil, - } - - config := TestConfig(t.TempDir(), android.Android, nil, "", mockFS) - config.TestProductVariables.DeviceVndkVersion = StringPtr("28") - config.TestProductVariables.Platform_vndk_version = StringPtr("29") - config.TestProductVariables.SanitizeDevice = []string{"hwaddress"} - ctx := testCcWithConfig(t, config) - - // Check non-cfi, cfi and hwasan variant. - staticVariant := "android_vendor.28_arm64_armv8-a_static" - staticCfiVariant := "android_vendor.28_arm64_armv8-a_static_cfi" - staticHwasanVariant := "android_vendor.28_arm64_armv8-a_static_hwasan" - staticHwasanCfiVariant := "android_vendor.28_arm64_armv8-a_static_hwasan_cfi" - - staticModule := ctx.ModuleForTests("libsnapshot.vendor_static.28.arm64", staticVariant).Module().(*Module) - assertString(t, staticModule.outputFile.Path().Base(), "libsnapshot.a") - - staticCfiModule := ctx.ModuleForTests("libsnapshot.vendor_static.28.arm64", staticCfiVariant).Module().(*Module) - assertString(t, staticCfiModule.outputFile.Path().Base(), "libsnapshot.cfi.a") - - staticHwasanModule := ctx.ModuleForTests("libsnapshot.vendor_static.28.arm64", staticHwasanVariant).Module().(*Module) - assertString(t, staticHwasanModule.outputFile.Path().Base(), "libsnapshot.hwasan.a") - - staticHwasanCfiModule := ctx.ModuleForTests("libsnapshot.vendor_static.28.arm64", staticHwasanCfiVariant).Module().(*Module) - if !staticHwasanCfiModule.HiddenFromMake() || !staticHwasanCfiModule.PreventInstall() { - t.Errorf("Hwasan and Cfi cannot enabled at the same time.") - } - - snapshotObjModule := ctx.ModuleForTests("snapshot_object.vendor_object.28.arm64", "android_vendor.28_arm64_armv8-a").Module() - snapshotObjMkEntries := android.AndroidMkEntriesForTest(t, ctx, snapshotObjModule) - // snapshot object must not add ".hwasan" suffix - assertString(t, snapshotObjMkEntries[0].EntryMap["LOCAL_MODULE"][0], "snapshot_object") -} - -func TestVendorSnapshotExclude(t *testing.T) { - - // This test verifies that the exclude_from_vendor_snapshot property - // makes its way from the Android.bp source file into the module data - // structure. It also verifies that modules are correctly included or - // excluded in the vendor snapshot based on their path (framework or - // vendor) and the exclude_from_vendor_snapshot property. - - frameworkBp := ` - cc_library_shared { - name: "libinclude", - srcs: ["src/include.cpp"], - vendor_available: true, - } - cc_library_shared { - name: "libexclude", - srcs: ["src/exclude.cpp"], - vendor: true, - exclude_from_vendor_snapshot: true, - } - cc_library_shared { - name: "libavailable_exclude", - srcs: ["src/exclude.cpp"], - vendor_available: true, - exclude_from_vendor_snapshot: true, - } - ` - - vendorProprietaryBp := ` - cc_library_shared { - name: "libvendor", - srcs: ["vendor.cpp"], - vendor: true, - } - ` - - depsBp := GatherRequiredDepsForTest(android.Android) - - mockFS := map[string][]byte{ - "deps/Android.bp": []byte(depsBp), - "framework/Android.bp": []byte(frameworkBp), - "framework/include.cpp": nil, - "framework/exclude.cpp": nil, - "device/Android.bp": []byte(vendorProprietaryBp), - "device/vendor.cpp": nil, - } - - config := TestConfig(t.TempDir(), android.Android, nil, "", mockFS) - config.TestProductVariables.DeviceVndkVersion = StringPtr("current") - config.TestProductVariables.Platform_vndk_version = StringPtr("29") - ctx := CreateTestContext(config) - ctx.Register() - - _, errs := ctx.ParseFileList(".", []string{"deps/Android.bp", "framework/Android.bp", "device/Android.bp"}) - android.FailIfErrored(t, errs) - _, errs = ctx.PrepareBuildActions(config) - android.FailIfErrored(t, errs) - - // Test an include and exclude framework module. - AssertExcludeFromVendorSnapshotIs(t, ctx, "libinclude", false, vendorVariant) - AssertExcludeFromVendorSnapshotIs(t, ctx, "libexclude", true, vendorVariant) - AssertExcludeFromVendorSnapshotIs(t, ctx, "libavailable_exclude", true, vendorVariant) - - // A vendor module is excluded, but by its path, not the - // exclude_from_vendor_snapshot property. - AssertExcludeFromVendorSnapshotIs(t, ctx, "libvendor", false, vendorVariant) - - // Verify the content of the vendor snapshot. - - snapshotDir := "vendor-snapshot" - snapshotVariantPath := filepath.Join("out/soong", snapshotDir, "arm64") - snapshotSingleton := ctx.SingletonForTests("vendor-snapshot") - - var includeJsonFiles []string - var excludeJsonFiles []string - - for _, arch := range [][]string{ - []string{"arm64", "armv8-a"}, - []string{"arm", "armv7-a-neon"}, - } { - archType := arch[0] - archVariant := arch[1] - archDir := fmt.Sprintf("arch-%s-%s", archType, archVariant) - - sharedVariant := fmt.Sprintf("android_vendor.29_%s_%s_shared", archType, archVariant) - sharedDir := filepath.Join(snapshotVariantPath, archDir, "shared") - - // Included modules - CheckSnapshot(t, ctx, snapshotSingleton, "libinclude", "libinclude.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "libinclude.so.json")) - - // Excluded modules - CheckSnapshotExclude(t, ctx, snapshotSingleton, "libexclude", "libexclude.so", sharedDir, sharedVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(sharedDir, "libexclude.so.json")) - CheckSnapshotExclude(t, ctx, snapshotSingleton, "libvendor", "libvendor.so", sharedDir, sharedVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(sharedDir, "libvendor.so.json")) - CheckSnapshotExclude(t, ctx, snapshotSingleton, "libavailable_exclude", "libavailable_exclude.so", sharedDir, sharedVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(sharedDir, "libavailable_exclude.so.json")) - } - - // Verify that each json file for an included module has a rule. - for _, jsonFile := range includeJsonFiles { - if snapshotSingleton.MaybeOutput(jsonFile).Rule == nil { - t.Errorf("include json file %q not found", jsonFile) - } - } - - // Verify that each json file for an excluded module has no rule. - for _, jsonFile := range excludeJsonFiles { - if snapshotSingleton.MaybeOutput(jsonFile).Rule != nil { - t.Errorf("exclude json file %q found", jsonFile) - } - } -} - -func TestVendorSnapshotExcludeInVendorProprietaryPathErrors(t *testing.T) { - - // This test verifies that using the exclude_from_vendor_snapshot - // property on a module in a vendor proprietary path generates an - // error. These modules are already excluded, so we prohibit using the - // property in this way, which could add to confusion. - - vendorProprietaryBp := ` - cc_library_shared { - name: "libvendor", - srcs: ["vendor.cpp"], - vendor: true, - exclude_from_vendor_snapshot: true, - } - ` - - depsBp := GatherRequiredDepsForTest(android.Android) - - mockFS := map[string][]byte{ - "deps/Android.bp": []byte(depsBp), - "device/Android.bp": []byte(vendorProprietaryBp), - "device/vendor.cpp": nil, - } - - config := TestConfig(t.TempDir(), android.Android, nil, "", mockFS) - config.TestProductVariables.DeviceVndkVersion = StringPtr("current") - config.TestProductVariables.Platform_vndk_version = StringPtr("29") - ctx := CreateTestContext(config) - ctx.Register() - - _, errs := ctx.ParseFileList(".", []string{"deps/Android.bp", "device/Android.bp"}) - android.FailIfErrored(t, errs) - - _, errs = ctx.PrepareBuildActions(config) - android.CheckErrorsAgainstExpectations(t, errs, []string{ - `module "libvendor\{.+,image:vendor.+,arch:arm64_.+\}" in vendor proprietary path "device" may not use "exclude_from_vendor_snapshot: true"`, - `module "libvendor\{.+,image:vendor.+,arch:arm_.+\}" in vendor proprietary path "device" may not use "exclude_from_vendor_snapshot: true"`, - `module "libvendor\{.+,image:vendor.+,arch:arm64_.+\}" in vendor proprietary path "device" may not use "exclude_from_vendor_snapshot: true"`, - `module "libvendor\{.+,image:vendor.+,arch:arm_.+\}" in vendor proprietary path "device" may not use "exclude_from_vendor_snapshot: true"`, - `module "libvendor\{.+,image:vendor.+,arch:arm64_.+\}" in vendor proprietary path "device" may not use "exclude_from_vendor_snapshot: true"`, - `module "libvendor\{.+,image:vendor.+,arch:arm_.+\}" in vendor proprietary path "device" may not use "exclude_from_vendor_snapshot: true"`, - }) -} - -func TestRecoverySnapshotCapture(t *testing.T) { - bp := ` - cc_library { - name: "libvndk", - vendor_available: true, - recovery_available: true, - product_available: true, - vndk: { - enabled: true, - }, - nocrt: true, - } - - cc_library { - name: "librecovery", - recovery: true, - nocrt: true, - } - - cc_library { - name: "librecovery_available", - recovery_available: true, - nocrt: true, - } - - cc_library_headers { - name: "librecovery_headers", - recovery_available: true, - nocrt: true, - } - - cc_binary { - name: "recovery_bin", - recovery: true, - nocrt: true, - } - - cc_binary { - name: "recovery_available_bin", - recovery_available: true, - nocrt: true, - } - - cc_prebuilt_library_static { - name: "libb", - recovery_available: true, - srcs: ["libb.a"], - nocrt: true, - no_libcrt: true, - stl: "none", - } - - cc_object { - name: "obj", - recovery_available: true, - } -` - config := TestConfig(t.TempDir(), android.Android, nil, bp, nil) - config.TestProductVariables.RecoverySnapshotVersion = StringPtr("current") - config.TestProductVariables.Platform_vndk_version = StringPtr("29") - ctx := testCcWithConfig(t, config) - - // Check Recovery snapshot output. - - snapshotDir := "recovery-snapshot" - snapshotVariantPath := filepath.Join("out/soong", snapshotDir, "arm64") - snapshotSingleton := ctx.SingletonForTests("recovery-snapshot") - - var jsonFiles []string - - for _, arch := range [][]string{ - []string{"arm64", "armv8-a"}, - } { - archType := arch[0] - archVariant := arch[1] - archDir := fmt.Sprintf("arch-%s-%s", archType, archVariant) - - // For shared libraries, only recovery_available modules are captured. - sharedVariant := fmt.Sprintf("android_recovery_%s_%s_shared", archType, archVariant) - sharedDir := filepath.Join(snapshotVariantPath, archDir, "shared") - CheckSnapshot(t, ctx, snapshotSingleton, "libvndk", "libvndk.so", sharedDir, sharedVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "librecovery", "librecovery.so", sharedDir, sharedVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "librecovery_available", "librecovery_available.so", sharedDir, sharedVariant) - jsonFiles = append(jsonFiles, - filepath.Join(sharedDir, "libvndk.so.json"), - filepath.Join(sharedDir, "librecovery.so.json"), - filepath.Join(sharedDir, "librecovery_available.so.json")) - - // For static libraries, all recovery:true and recovery_available modules are captured. - staticVariant := fmt.Sprintf("android_recovery_%s_%s_static", archType, archVariant) - staticDir := filepath.Join(snapshotVariantPath, archDir, "static") - CheckSnapshot(t, ctx, snapshotSingleton, "libb", "libb.a", staticDir, staticVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "librecovery", "librecovery.a", staticDir, staticVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "librecovery_available", "librecovery_available.a", staticDir, staticVariant) - jsonFiles = append(jsonFiles, - filepath.Join(staticDir, "libb.a.json"), - filepath.Join(staticDir, "librecovery.a.json"), - filepath.Join(staticDir, "librecovery_available.a.json")) - - // For binary executables, all recovery:true and recovery_available modules are captured. - if archType == "arm64" { - binaryVariant := fmt.Sprintf("android_recovery_%s_%s", archType, archVariant) - binaryDir := filepath.Join(snapshotVariantPath, archDir, "binary") - CheckSnapshot(t, ctx, snapshotSingleton, "recovery_bin", "recovery_bin", binaryDir, binaryVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "recovery_available_bin", "recovery_available_bin", binaryDir, binaryVariant) - jsonFiles = append(jsonFiles, - filepath.Join(binaryDir, "recovery_bin.json"), - filepath.Join(binaryDir, "recovery_available_bin.json")) - } - - // For header libraries, all vendor:true and vendor_available modules are captured. - headerDir := filepath.Join(snapshotVariantPath, archDir, "header") - jsonFiles = append(jsonFiles, filepath.Join(headerDir, "librecovery_headers.json")) - - // For object modules, all vendor:true and vendor_available modules are captured. - objectVariant := fmt.Sprintf("android_recovery_%s_%s", archType, archVariant) - objectDir := filepath.Join(snapshotVariantPath, archDir, "object") - CheckSnapshot(t, ctx, snapshotSingleton, "obj", "obj.o", objectDir, objectVariant) - jsonFiles = append(jsonFiles, filepath.Join(objectDir, "obj.o.json")) - } - - for _, jsonFile := range jsonFiles { - // verify all json files exist - if snapshotSingleton.MaybeOutput(jsonFile).Rule == nil { - t.Errorf("%q expected but not found", jsonFile) - } - } -} - -func TestRecoverySnapshotExclude(t *testing.T) { - // This test verifies that the exclude_from_recovery_snapshot property - // makes its way from the Android.bp source file into the module data - // structure. It also verifies that modules are correctly included or - // excluded in the recovery snapshot based on their path (framework or - // vendor) and the exclude_from_recovery_snapshot property. - - frameworkBp := ` - cc_library_shared { - name: "libinclude", - srcs: ["src/include.cpp"], - recovery_available: true, - } - cc_library_shared { - name: "libexclude", - srcs: ["src/exclude.cpp"], - recovery: true, - exclude_from_recovery_snapshot: true, - } - cc_library_shared { - name: "libavailable_exclude", - srcs: ["src/exclude.cpp"], - recovery_available: true, - exclude_from_recovery_snapshot: true, - } - ` - - vendorProprietaryBp := ` - cc_library_shared { - name: "librecovery", - srcs: ["recovery.cpp"], - recovery: true, - } - ` - - depsBp := GatherRequiredDepsForTest(android.Android) - - mockFS := map[string][]byte{ - "deps/Android.bp": []byte(depsBp), - "framework/Android.bp": []byte(frameworkBp), - "framework/include.cpp": nil, - "framework/exclude.cpp": nil, - "device/Android.bp": []byte(vendorProprietaryBp), - "device/recovery.cpp": nil, - } - - config := TestConfig(t.TempDir(), android.Android, nil, "", mockFS) - config.TestProductVariables.RecoverySnapshotVersion = StringPtr("current") - config.TestProductVariables.Platform_vndk_version = StringPtr("29") - ctx := CreateTestContext(config) - ctx.Register() - - _, errs := ctx.ParseFileList(".", []string{"deps/Android.bp", "framework/Android.bp", "device/Android.bp"}) - android.FailIfErrored(t, errs) - _, errs = ctx.PrepareBuildActions(config) - android.FailIfErrored(t, errs) - - // Test an include and exclude framework module. - AssertExcludeFromRecoverySnapshotIs(t, ctx, "libinclude", false, recoveryVariant) - AssertExcludeFromRecoverySnapshotIs(t, ctx, "libexclude", true, recoveryVariant) - AssertExcludeFromRecoverySnapshotIs(t, ctx, "libavailable_exclude", true, recoveryVariant) - - // A recovery module is excluded, but by its path, not the - // exclude_from_recovery_snapshot property. - AssertExcludeFromRecoverySnapshotIs(t, ctx, "librecovery", false, recoveryVariant) - - // Verify the content of the recovery snapshot. - - snapshotDir := "recovery-snapshot" - snapshotVariantPath := filepath.Join("out/soong", snapshotDir, "arm64") - snapshotSingleton := ctx.SingletonForTests("recovery-snapshot") - - var includeJsonFiles []string - var excludeJsonFiles []string - - for _, arch := range [][]string{ - []string{"arm64", "armv8-a"}, - } { - archType := arch[0] - archVariant := arch[1] - archDir := fmt.Sprintf("arch-%s-%s", archType, archVariant) - - sharedVariant := fmt.Sprintf("android_recovery_%s_%s_shared", archType, archVariant) - sharedDir := filepath.Join(snapshotVariantPath, archDir, "shared") - - // Included modules - CheckSnapshot(t, ctx, snapshotSingleton, "libinclude", "libinclude.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "libinclude.so.json")) - - // Excluded modules - CheckSnapshotExclude(t, ctx, snapshotSingleton, "libexclude", "libexclude.so", sharedDir, sharedVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(sharedDir, "libexclude.so.json")) - CheckSnapshotExclude(t, ctx, snapshotSingleton, "librecovery", "librecovery.so", sharedDir, sharedVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(sharedDir, "librecovery.so.json")) - CheckSnapshotExclude(t, ctx, snapshotSingleton, "libavailable_exclude", "libavailable_exclude.so", sharedDir, sharedVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(sharedDir, "libavailable_exclude.so.json")) - } - - // Verify that each json file for an included module has a rule. - for _, jsonFile := range includeJsonFiles { - if snapshotSingleton.MaybeOutput(jsonFile).Rule == nil { - t.Errorf("include json file %q not found", jsonFile) - } - } - - // Verify that each json file for an excluded module has no rule. - for _, jsonFile := range excludeJsonFiles { - if snapshotSingleton.MaybeOutput(jsonFile).Rule != nil { - t.Errorf("exclude json file %q found", jsonFile) - } - } -} - -func TestRecoverySnapshotDirected(t *testing.T) { - bp := ` - cc_library_shared { - name: "librecovery", - recovery: true, - nocrt: true, - } - - cc_library_shared { - name: "librecovery_available", - recovery_available: true, - nocrt: true, - } - - genrule { - name: "libfoo_gen", - cmd: "", - out: ["libfoo.so"], - } - - cc_prebuilt_library_shared { - name: "libfoo", - recovery: true, - prefer: true, - srcs: [":libfoo_gen"], - } - - cc_library_shared { - name: "libfoo", - recovery: true, - nocrt: true, - } -` - config := TestConfig(t.TempDir(), android.Android, nil, bp, nil) - config.TestProductVariables.DeviceVndkVersion = StringPtr("current") - config.TestProductVariables.RecoverySnapshotVersion = StringPtr("current") - config.TestProductVariables.Platform_vndk_version = StringPtr("29") - config.TestProductVariables.DirectedRecoverySnapshot = true - config.TestProductVariables.RecoverySnapshotModules = make(map[string]bool) - config.TestProductVariables.RecoverySnapshotModules["librecovery"] = true - config.TestProductVariables.RecoverySnapshotModules["libfoo"] = true - ctx := testCcWithConfig(t, config) - - // Check recovery snapshot output. - - snapshotDir := "recovery-snapshot" - snapshotVariantPath := filepath.Join("out/soong", snapshotDir, "arm64") - snapshotSingleton := ctx.SingletonForTests("recovery-snapshot") - - var includeJsonFiles []string - - for _, arch := range [][]string{ - []string{"arm64", "armv8-a"}, - } { - archType := arch[0] - archVariant := arch[1] - archDir := fmt.Sprintf("arch-%s-%s", archType, archVariant) - - sharedVariant := fmt.Sprintf("android_recovery_%s_%s_shared", archType, archVariant) - sharedDir := filepath.Join(snapshotVariantPath, archDir, "shared") - - // Included modules - CheckSnapshot(t, ctx, snapshotSingleton, "librecovery", "librecovery.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "librecovery.so.json")) - // Check that snapshot captures "prefer: true" prebuilt - CheckSnapshot(t, ctx, snapshotSingleton, "prebuilt_libfoo", "libfoo.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "libfoo.so.json")) - - // Excluded modules. Modules not included in the directed recovery snapshot - // are still include as fake modules. - CheckSnapshotRule(t, ctx, snapshotSingleton, "librecovery_available", "librecovery_available.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "librecovery_available.so.json")) - } - - // Verify that each json file for an included module has a rule. - for _, jsonFile := range includeJsonFiles { - if snapshotSingleton.MaybeOutput(jsonFile).Rule == nil { - t.Errorf("include json file %q not found", jsonFile) - } - } -} - -func TestSnapshotInRelativeInstallPath(t *testing.T) { - bp := ` - cc_library { - name: "libvendor_available", - vendor_available: true, - nocrt: true, - } - - cc_library { - name: "libvendor_available_var", - vendor_available: true, - stem: "libvendor_available", - relative_install_path: "var", - nocrt: true, - } -` - - config := TestConfig(t.TempDir(), android.Android, nil, bp, nil) - config.TestProductVariables.DeviceVndkVersion = StringPtr("current") - config.TestProductVariables.Platform_vndk_version = StringPtr("29") - ctx := testCcWithConfig(t, config) - - // Check Vendor snapshot output. - - snapshotDir := "vendor-snapshot" - snapshotVariantPath := filepath.Join("out/soong", snapshotDir, "arm64") - snapshotSingleton := ctx.SingletonForTests("vendor-snapshot") - - var jsonFiles []string - - for _, arch := range [][]string{ - []string{"arm64", "armv8-a"}, - []string{"arm", "armv7-a-neon"}, - } { - archType := arch[0] - archVariant := arch[1] - archDir := fmt.Sprintf("arch-%s-%s", archType, archVariant) - - // For shared libraries, only non-VNDK vendor_available modules are captured - sharedVariant := fmt.Sprintf("android_vendor.29_%s_%s_shared", archType, archVariant) - sharedDir := filepath.Join(snapshotVariantPath, archDir, "shared") - sharedDirVar := filepath.Join(sharedDir, "var") - CheckSnapshot(t, ctx, snapshotSingleton, "libvendor_available", "libvendor_available.so", sharedDir, sharedVariant) - CheckSnapshot(t, ctx, snapshotSingleton, "libvendor_available_var", "libvendor_available.so", sharedDirVar, sharedVariant) - jsonFiles = append(jsonFiles, - filepath.Join(sharedDir, "libvendor_available.so.json"), - filepath.Join(sharedDirVar, "libvendor_available.so.json")) - } - - for _, jsonFile := range jsonFiles { - // verify all json files exist - if snapshotSingleton.MaybeOutput(jsonFile).Rule == nil { - t.Errorf("%q expected but not found", jsonFile) - } - } - - // fake snapshot should have all outputs in the normal snapshot. - fakeSnapshotSingleton := ctx.SingletonForTests("vendor-fake-snapshot") - for _, output := range snapshotSingleton.AllOutputs() { - fakeOutput := strings.Replace(output, "/vendor-snapshot/", "/fake/vendor-snapshot/", 1) - if fakeSnapshotSingleton.MaybeOutput(fakeOutput).Rule == nil { - t.Errorf("%q expected but not found", fakeOutput) - } - } -} diff --git a/rust/Android.bp b/rust/Android.bp index 637042d45..c5e94a006 100644 --- a/rust/Android.bp +++ b/rust/Android.bp @@ -62,7 +62,6 @@ bootstrap_go_package { "sanitize_test.go", "source_provider_test.go", "test_test.go", - "vendor_snapshot_test.go", ], pluginFor: ["soong_build"], } diff --git a/rust/vendor_snapshot_test.go b/rust/vendor_snapshot_test.go deleted file mode 100644 index a6ed0e5f2..000000000 --- a/rust/vendor_snapshot_test.go +++ /dev/null @@ -1,1573 +0,0 @@ -// Copyright 2021 The Android Open Source Project -// -// 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 rust - -import ( - "fmt" - "path/filepath" - "reflect" - "strings" - "testing" - - "android/soong/android" - "android/soong/cc" -) - -func TestVendorSnapshotCapture(t *testing.T) { - bp := ` - rust_ffi { - name: "libffivendor_available", - crate_name: "ffivendor_available", - srcs: ["lib.rs"], - vendor_available: true, - export_include_dirs: ["rust_headers/"], - } - - rust_ffi { - name: "libffivendor", - crate_name: "ffivendor", - srcs: ["lib.rs"], - vendor: true, - export_include_dirs: ["rust_headers/"], - } - - rust_library { - name: "librustvendor_available", - crate_name: "rustvendor_available", - srcs: ["lib.rs"], - vendor_available: true, - } - - rust_library { - name: "librustvendor", - crate_name: "rustvendor", - srcs: ["lib.rs"], - vendor: true, - } - - rust_binary { - name: "vendor_available_bin", - vendor_available: true, - srcs: ["srcs/lib.rs"], - } - - rust_binary { - name: "vendor_bin", - vendor: true, - srcs: ["srcs/lib.rs"], - } - ` - skipTestIfOsNotSupported(t) - result := android.GroupFixturePreparers( - prepareForRustTest, - rustMockedFiles.AddToFixture(), - android.FixtureModifyProductVariables( - func(variables android.FixtureProductVariables) { - variables.DeviceVndkVersion = StringPtr("current") - variables.Platform_vndk_version = StringPtr("29") - }, - ), - ).RunTestWithBp(t, bp) - ctx := result.TestContext - - // Check Vendor snapshot output. - - snapshotDir := "vendor-snapshot" - snapshotVariantPath := filepath.Join("out/soong", snapshotDir, "arm64") - snapshotSingleton := ctx.SingletonForTests("vendor-snapshot") - var jsonFiles []string - for _, arch := range [][]string{ - []string{"arm64", "armv8-a"}, - []string{"arm", "armv7-a-neon"}, - } { - archType := arch[0] - archVariant := arch[1] - archDir := fmt.Sprintf("arch-%s-%s", archType, archVariant) - - // For shared libraries, only non-VNDK vendor_available modules are captured - sharedVariant := fmt.Sprintf("android_vendor.29_%s_%s_shared", archType, archVariant) - sharedDir := filepath.Join(snapshotVariantPath, archDir, "shared") - cc.CheckSnapshot(t, ctx, snapshotSingleton, "libffivendor_available", "libffivendor_available.so", sharedDir, sharedVariant) - jsonFiles = append(jsonFiles, - filepath.Join(sharedDir, "libffivendor_available.so.json")) - - // For static libraries, all vendor:true and vendor_available modules (including VNDK) are captured. - staticVariant := fmt.Sprintf("android_vendor.29_%s_%s_static", archType, archVariant) - staticDir := filepath.Join(snapshotVariantPath, archDir, "static") - cc.CheckSnapshot(t, ctx, snapshotSingleton, "libffivendor_available", "libffivendor_available.a", staticDir, staticVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "libffivendor", "libffivendor.a", staticDir, staticVariant) - jsonFiles = append(jsonFiles, - filepath.Join(staticDir, "libffivendor_available.a.json")) - jsonFiles = append(jsonFiles, - filepath.Join(staticDir, "libffivendor.a.json")) - - // For rlib libraries, all vendor:true and vendor_available modules (including VNDK) are captured. - rlibVariant := fmt.Sprintf("android_vendor.29_%s_%s_rlib_dylib-std", archType, archVariant) - rlibDir := filepath.Join(snapshotVariantPath, archDir, "rlib") - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librustvendor_available", "librustvendor_available.rlib", rlibDir, rlibVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librustvendor", "librustvendor.rlib", rlibDir, rlibVariant) - jsonFiles = append(jsonFiles, - filepath.Join(rlibDir, "librustvendor_available.rlib.json")) - jsonFiles = append(jsonFiles, - filepath.Join(rlibDir, "librustvendor.rlib.json")) - - // For rlib libraries, all rlib-std variants vendor:true and vendor_available modules (including VNDK) are captured. - rlibStdVariant := fmt.Sprintf("android_vendor.29_%s_%s_rlib_rlib-std", archType, archVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librustvendor_available", "librustvendor_available.rlib-std.rlib", rlibDir, rlibStdVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librustvendor", "librustvendor.rlib-std.rlib", rlibDir, rlibStdVariant) - jsonFiles = append(jsonFiles, - filepath.Join(rlibDir, "librustvendor_available.rlib.json")) - jsonFiles = append(jsonFiles, - filepath.Join(rlibDir, "librustvendor.rlib.json")) - - // For dylib libraries, all vendor:true and vendor_available modules (including VNDK) are captured. - dylibVariant := fmt.Sprintf("android_vendor.29_%s_%s_dylib", archType, archVariant) - dylibDir := filepath.Join(snapshotVariantPath, archDir, "dylib") - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librustvendor_available", "librustvendor_available.dylib.so", dylibDir, dylibVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librustvendor", "librustvendor.dylib.so", dylibDir, dylibVariant) - jsonFiles = append(jsonFiles, - filepath.Join(dylibDir, "librustvendor_available.dylib.so.json")) - jsonFiles = append(jsonFiles, - filepath.Join(dylibDir, "librustvendor.dylib.so.json")) - - // For binary executables, all vendor:true and vendor_available modules are captured. - if archType == "arm64" { - binaryVariant := fmt.Sprintf("android_vendor.29_%s_%s", archType, archVariant) - binaryDir := filepath.Join(snapshotVariantPath, archDir, "binary") - cc.CheckSnapshot(t, ctx, snapshotSingleton, "vendor_available_bin", "vendor_available_bin", binaryDir, binaryVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "vendor_bin", "vendor_bin", binaryDir, binaryVariant) - jsonFiles = append(jsonFiles, - filepath.Join(binaryDir, "vendor_available_bin.json")) - jsonFiles = append(jsonFiles, - filepath.Join(binaryDir, "vendor_bin.json")) - } - } - - for _, jsonFile := range jsonFiles { - // verify all json files exist - if snapshotSingleton.MaybeOutput(jsonFile).Rule == nil { - t.Errorf("%q expected but not found; #%v", jsonFile, jsonFiles) - } - } - - // fake snapshot should have all outputs in the normal snapshot. - fakeSnapshotSingleton := ctx.SingletonForTests("vendor-fake-snapshot") - - for _, output := range snapshotSingleton.AllOutputs() { - fakeOutput := strings.Replace(output, "/vendor-snapshot/", "/fake/vendor-snapshot/", 1) - if fakeSnapshotSingleton.MaybeOutput(fakeOutput).Rule == nil { - t.Errorf("%q expected but not found", fakeOutput) - } - } -} - -func TestVendorSnapshotDirected(t *testing.T) { - bp := ` - rust_ffi_shared { - name: "libffivendor_available", - crate_name: "ffivendor_available", - srcs: ["lib.rs"], - vendor_available: true, - } - - rust_library { - name: "librustvendor_available", - crate_name: "rustvendor_available", - srcs: ["lib.rs"], - vendor_available: true, - } - - rust_ffi_shared { - name: "libffivendor_exclude", - crate_name: "ffivendor_exclude", - srcs: ["lib.rs"], - vendor_available: true, - } - - rust_library { - name: "librustvendor_exclude", - crate_name: "rustvendor_exclude", - srcs: ["lib.rs"], - vendor_available: true, - } -` - ctx := testRustVndk(t, bp) - ctx.Config().TestProductVariables.VendorSnapshotModules = make(map[string]bool) - ctx.Config().TestProductVariables.VendorSnapshotModules["librustvendor_available"] = true - ctx.Config().TestProductVariables.VendorSnapshotModules["libffivendor_available"] = true - ctx.Config().TestProductVariables.DirectedVendorSnapshot = true - - // Check Vendor snapshot output. - - snapshotDir := "vendor-snapshot" - snapshotVariantPath := filepath.Join("out/soong", snapshotDir, "arm64") - snapshotSingleton := ctx.SingletonForTests("vendor-snapshot") - - var includeJsonFiles []string - - for _, arch := range [][]string{ - []string{"arm64", "armv8-a"}, - []string{"arm", "armv7-a-neon"}, - } { - archType := arch[0] - archVariant := arch[1] - archDir := fmt.Sprintf("arch-%s-%s", archType, archVariant) - - sharedVariant := fmt.Sprintf("android_vendor.29_%s_%s_shared", archType, archVariant) - rlibVariant := fmt.Sprintf("android_vendor.29_%s_%s_rlib_dylib-std", archType, archVariant) - rlibRlibStdVariant := fmt.Sprintf("android_vendor.29_%s_%s_rlib_rlib-std", archType, archVariant) - sharedDir := filepath.Join(snapshotVariantPath, archDir, "shared") - rlibDir := filepath.Join(snapshotVariantPath, archDir, "rlib") - dylibVariant := fmt.Sprintf("android_vendor.29_%s_%s_dylib", archType, archVariant) - dylibDir := filepath.Join(snapshotVariantPath, archDir, "dylib") - - // Included modules - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librustvendor_available", "librustvendor_available.rlib", rlibDir, rlibVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librustvendor_available", "librustvendor_available.rlib-std.rlib", rlibDir, rlibRlibStdVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librustvendor_available", "librustvendor_available.dylib.so", dylibDir, dylibVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "libffivendor_available", "libffivendor_available.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(rlibDir, "librustvendor_available.rlib.json")) - includeJsonFiles = append(includeJsonFiles, filepath.Join(rlibDir, "librustvendor_available.rlib-std.rlib.json")) - includeJsonFiles = append(includeJsonFiles, filepath.Join(dylibDir, "librustvendor_available.dylib.so.json")) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "libffivendor_available.so.json")) - - // Excluded modules. Modules not included in the directed vendor snapshot - // are still include as fake modules. - cc.CheckSnapshotRule(t, ctx, snapshotSingleton, "librustvendor_exclude", "librustvendor_exclude.rlib", rlibDir, rlibVariant) - cc.CheckSnapshotRule(t, ctx, snapshotSingleton, "librustvendor_exclude", "librustvendor_exclude.rlib-std.rlib", rlibDir, rlibRlibStdVariant) - cc.CheckSnapshotRule(t, ctx, snapshotSingleton, "librustvendor_exclude", "librustvendor_exclude.dylib.so", dylibDir, dylibVariant) - cc.CheckSnapshotRule(t, ctx, snapshotSingleton, "libffivendor_exclude", "libffivendor_exclude.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(rlibDir, "librustvendor_exclude.rlib.json")) - includeJsonFiles = append(includeJsonFiles, filepath.Join(rlibDir, "librustvendor_exclude.rlib-std.rlib.json")) - includeJsonFiles = append(includeJsonFiles, filepath.Join(dylibDir, "librustvendor_exclude.dylib.so.json")) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "libffivendor_exclude.so.json")) - } - - // Verify that each json file for an included module has a rule. - for _, jsonFile := range includeJsonFiles { - if snapshotSingleton.MaybeOutput(jsonFile).Rule == nil { - t.Errorf("include json file %q not found", jsonFile) - } - } -} - -func TestVendorSnapshotExclude(t *testing.T) { - - // This test verifies that the exclude_from_vendor_snapshot property - // makes its way from the Android.bp source file into the module data - // structure. It also verifies that modules are correctly included or - // excluded in the vendor snapshot based on their path (framework or - // vendor) and the exclude_from_vendor_snapshot property. - - frameworkBp := ` - rust_ffi_shared { - name: "libinclude", - crate_name: "include", - srcs: ["include.rs"], - vendor_available: true, - } - - rust_ffi_shared { - name: "libexclude", - crate_name: "exclude", - srcs: ["exclude.rs"], - vendor: true, - exclude_from_vendor_snapshot: true, - } - - rust_ffi_shared { - name: "libavailable_exclude", - crate_name: "available_exclude", - srcs: ["lib.rs"], - vendor_available: true, - exclude_from_vendor_snapshot: true, - } - - rust_library { - name: "librust_include", - crate_name: "rust_include", - srcs: ["include.rs"], - vendor_available: true, - } - - rust_library { - name: "librust_exclude", - crate_name: "rust_exclude", - srcs: ["exclude.rs"], - vendor: true, - exclude_from_vendor_snapshot: true, - } - - rust_library { - name: "librust_available_exclude", - crate_name: "rust_available_exclude", - srcs: ["lib.rs"], - vendor_available: true, - exclude_from_vendor_snapshot: true, - } - ` - - mockFS := map[string][]byte{ - "framework/Android.bp": []byte(frameworkBp), - "framework/include.rs": nil, - "framework/exclude.rs": nil, - } - - ctx := testRustVndkFs(t, "", mockFS) - - // Test an include and exclude framework module. - cc.AssertExcludeFromVendorSnapshotIs(t, ctx, "libinclude", false, sharedVendorVariant) - cc.AssertExcludeFromVendorSnapshotIs(t, ctx, "libexclude", true, sharedVendorVariant) - cc.AssertExcludeFromVendorSnapshotIs(t, ctx, "libavailable_exclude", true, sharedVendorVariant) - - cc.AssertExcludeFromVendorSnapshotIs(t, ctx, "librust_include", false, rlibVendorVariant) - cc.AssertExcludeFromVendorSnapshotIs(t, ctx, "librust_exclude", true, rlibVendorVariant) - cc.AssertExcludeFromVendorSnapshotIs(t, ctx, "librust_available_exclude", true, rlibVendorVariant) - - cc.AssertExcludeFromVendorSnapshotIs(t, ctx, "librust_include", false, rlibDylibStdVendorVariant) - cc.AssertExcludeFromVendorSnapshotIs(t, ctx, "librust_exclude", true, rlibDylibStdVendorVariant) - cc.AssertExcludeFromVendorSnapshotIs(t, ctx, "librust_available_exclude", true, rlibDylibStdVendorVariant) - - cc.AssertExcludeFromVendorSnapshotIs(t, ctx, "librust_include", false, dylibVendorVariant) - cc.AssertExcludeFromVendorSnapshotIs(t, ctx, "librust_exclude", true, dylibVendorVariant) - cc.AssertExcludeFromVendorSnapshotIs(t, ctx, "librust_available_exclude", true, dylibVendorVariant) - - // Verify the content of the vendor snapshot. - - snapshotDir := "vendor-snapshot" - snapshotVariantPath := filepath.Join("out/soong", snapshotDir, "arm64") - snapshotSingleton := ctx.SingletonForTests("vendor-snapshot") - - var includeJsonFiles []string - var excludeJsonFiles []string - - for _, arch := range [][]string{ - []string{"arm64", "armv8-a"}, - []string{"arm", "armv7-a-neon"}, - } { - archType := arch[0] - archVariant := arch[1] - archDir := fmt.Sprintf("arch-%s-%s", archType, archVariant) - - sharedVariant := fmt.Sprintf("android_vendor.29_%s_%s_shared", archType, archVariant) - sharedDir := filepath.Join(snapshotVariantPath, archDir, "shared") - - rlibVariant := fmt.Sprintf("android_vendor.29_%s_%s_rlib_dylib-std", archType, archVariant) - rlibRlibStdVariant := fmt.Sprintf("android_vendor.29_%s_%s_rlib_rlib-std", archType, archVariant) - rlibDir := filepath.Join(snapshotVariantPath, archDir, "rlib") - dylibVariant := fmt.Sprintf("android_vendor.29_%s_%s_dylib", archType, archVariant) - dylibDir := filepath.Join(snapshotVariantPath, archDir, "dylib") - - // Included modules - cc.CheckSnapshot(t, ctx, snapshotSingleton, "libinclude", "libinclude.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "libinclude.so.json")) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librust_include", "librust_include.rlib", rlibDir, rlibVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(rlibDir, "librust_include.rlib.json")) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librust_include", "librust_include.rlib-std.rlib", rlibDir, rlibRlibStdVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(rlibDir, "librust_include.rlib-std.rlib.json")) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librust_include", "librust_include.dylib.so", dylibDir, dylibVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(dylibDir, "librust_include.dylib.so.json")) - - // Excluded modules - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "libexclude", "libexclude.so", sharedDir, sharedVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(sharedDir, "libexclude.so.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "libavailable_exclude", "libavailable_exclude.so", sharedDir, sharedVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(sharedDir, "libavailable_exclude.so.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "librust_exclude", "librust_exclude.rlib", rlibDir, rlibVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(rlibDir, "librust_exclude.rlib.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "librust_available_exclude", "librust_available_exclude.rlib", rlibDir, rlibVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(rlibDir, "librust_available_exclude.rlib.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "librust_available_exclude", "librust_available_exclude.rlib-std.rlib", rlibDir, rlibRlibStdVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(rlibDir, "librust_available_exclude.rlib.rlib-std.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "librust_exclude", "librust_exclude.dylib.so", dylibDir, dylibVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(dylibDir, "librust_exclude.dylib.so.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "librust_available_exclude", "librust_available_exclude.dylib.so", dylibDir, dylibVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(dylibDir, "librust_available_exclude.dylib.so.json")) - } - - // Verify that each json file for an included module has a rule. - for _, jsonFile := range includeJsonFiles { - if snapshotSingleton.MaybeOutput(jsonFile).Rule == nil { - t.Errorf("include json file %q not found", jsonFile) - } - } - - // Verify that each json file for an excluded module has no rule. - for _, jsonFile := range excludeJsonFiles { - if snapshotSingleton.MaybeOutput(jsonFile).Rule != nil { - t.Errorf("exclude json file %q found", jsonFile) - } - } -} - -func TestVendorSnapshotUse(t *testing.T) { - frameworkBp := ` - cc_library { - name: "libvndk", - vendor_available: true, - product_available: true, - vndk: { - enabled: true, - }, - nocrt: true, - } - - cc_library { - name: "libvendor", - vendor: true, - nocrt: true, - no_libcrt: true, - stl: "none", - system_shared_libs: [], - } - - cc_library { - name: "libvendor_available", - vendor_available: true, - nocrt: true, - no_libcrt: true, - stl: "none", - system_shared_libs: [], - } - - cc_library { - name: "lib32", - vendor: true, - nocrt: true, - no_libcrt: true, - stl: "none", - system_shared_libs: [], - compile_multilib: "32", - } - - cc_library { - name: "lib64", - vendor: true, - nocrt: true, - no_libcrt: true, - stl: "none", - system_shared_libs: [], - compile_multilib: "64", - } - - rust_binary { - name: "bin", - vendor: true, - srcs: ["bin.rs"], - } - - rust_binary { - name: "bin32", - vendor: true, - compile_multilib: "32", - srcs: ["bin.rs"], - } - - rust_library { - name: "librust_vendor_available", - crate_name: "rust_vendor", - vendor_available: true, - srcs: ["client.rs"], - } - -` - - vndkBp := ` - vndk_prebuilt_shared { - name: "libvndk", - version: "30", - target_arch: "arm64", - vendor_available: true, - product_available: true, - vndk: { - enabled: true, - }, - arch: { - arm64: { - srcs: ["libvndk.so"], - export_include_dirs: ["include/libvndk"], - }, - arm: { - srcs: ["libvndk.so"], - export_include_dirs: ["include/libvndk"], - }, - }, - } - - // old snapshot module which has to be ignored - vndk_prebuilt_shared { - name: "libvndk", - version: "26", - target_arch: "arm64", - vendor_available: true, - product_available: true, - vndk: { - enabled: true, - }, - arch: { - arm64: { - srcs: ["libvndk.so"], - export_include_dirs: ["include/libvndk"], - }, - arm: { - srcs: ["libvndk.so"], - export_include_dirs: ["include/libvndk"], - }, - }, - } - - // different arch snapshot which has to be ignored - vndk_prebuilt_shared { - name: "libvndk", - version: "30", - target_arch: "arm", - vendor_available: true, - product_available: true, - vndk: { - enabled: true, - }, - arch: { - arm: { - srcs: ["libvndk.so"], - export_include_dirs: ["include/libvndk"], - }, - }, - } -` - - vendorProprietaryBp := ` - cc_library { - name: "libvendor_without_snapshot", - vendor: true, - nocrt: true, - no_libcrt: true, - no_crt_pad_segment: true, - stl: "none", - system_shared_libs: [], - } - - rust_ffi_shared { - name: "libclient", - crate_name: "client", - vendor: true, - shared_libs: ["libvndk", "libvendor_available"], - static_libs: ["libvendor", "libvendor_without_snapshot"], - rustlibs: ["librust_vendor_available"], - arch: { - arm64: { - shared_libs: ["lib64"], - }, - arm: { - shared_libs: ["lib32"], - }, - }, - srcs: ["client.rs"], - } - - rust_library { - name: "libclient_rust", - crate_name: "client_rust", - vendor: true, - shared_libs: ["libvndk", "libvendor_available"], - static_libs: ["libvendor", "libvendor_without_snapshot"], - rustlibs: ["librust_vendor_available"], - arch: { - arm64: { - shared_libs: ["lib64"], - }, - arm: { - shared_libs: ["lib32"], - }, - }, - srcs: ["client.rs"], - } - - rust_binary { - name: "bin_without_snapshot", - vendor: true, - static_libs: ["libvndk"], - srcs: ["bin.rs"], - rustlibs: ["librust_vendor_available"], - } - - vendor_snapshot { - name: "vendor_snapshot", - version: "30", - arch: { - arm64: { - vndk_libs: [ - "libvndk", - ], - static_libs: [ - "libvendor", - "libvndk", - "libclang_rt.builtins", - "note_memtag_heap_sync", - ], - shared_libs: [ - "libvendor_available", - "lib64", - ], - rlibs: [ - "libstd", - "librust_vendor_available", - "librust_vendor_available.rlib-std" - ], - dylibs: [ - "libstd", - "librust_vendor_available", - ], - binaries: [ - "bin", - ], - objects: [ - "crtend_so", - "crtbegin_so", - "crtbegin_dynamic", - "crtend_android" - ], - }, - arm: { - vndk_libs: [ - "libvndk", - ], - static_libs: [ - "libvendor", - "libvndk", - "libclang_rt.builtins", - ], - shared_libs: [ - "libvendor_available", - "lib32", - ], - rlibs: [ - "libstd", - "librust_vendor_available", - ], - dylibs: [ - "libstd", - "librust_vendor_available", - ], - binaries: [ - "bin32", - ], - objects: [ - "crtend_so", - "crtbegin_so", - "crtbegin_dynamic", - "crtend_android" - ], - - }, - } - } - - vendor_snapshot_object { - name: "crtend_so", - version: "30", - target_arch: "arm64", - vendor: true, - stl: "none", - crt: true, - arch: { - arm64: { - src: "crtend_so.o", - }, - arm: { - src: "crtend_so.o", - }, - }, - } - - vendor_snapshot_object { - name: "crtbegin_so", - version: "30", - target_arch: "arm64", - vendor: true, - stl: "none", - crt: true, - arch: { - arm64: { - src: "crtbegin_so.o", - }, - arm: { - src: "crtbegin_so.o", - }, - }, - } - - vendor_snapshot_rlib { - name: "libstd", - version: "30", - target_arch: "arm64", - vendor: true, - sysroot: true, - arch: { - arm64: { - src: "libstd.rlib", - }, - arm: { - src: "libstd.rlib", - }, - }, - } - - vendor_snapshot_rlib { - name: "librust_vendor_available", - version: "30", - target_arch: "arm64", - vendor: true, - arch: { - arm64: { - src: "librust_vendor_available.rlib", - }, - arm: { - src: "librust_vendor_available.rlib", - }, - }, - } - - vendor_snapshot_rlib { - name: "librust_vendor_available.rlib-std", - version: "30", - target_arch: "arm64", - vendor: true, - arch: { - arm64: { - src: "librust_vendor_available.rlib-std.rlib", - }, - arm: { - src: "librust_vendor_available.rlib-std.rlib", - }, - }, - } - - vendor_snapshot_dylib { - name: "libstd", - version: "30", - target_arch: "arm64", - vendor: true, - sysroot: true, - arch: { - arm64: { - src: "libstd.dylib.so", - }, - arm: { - src: "libstd.dylib.so", - }, - }, - } - - vendor_snapshot_dylib { - name: "librust_vendor_available", - version: "30", - target_arch: "arm64", - vendor: true, - arch: { - arm64: { - src: "librust_vendor_available.dylib.so", - }, - arm: { - src: "librust_vendor_available.dylib.so", - }, - }, - } - - vendor_snapshot_object { - name: "crtend_android", - version: "30", - target_arch: "arm64", - vendor: true, - stl: "none", - crt: true, - arch: { - arm64: { - src: "crtend_so.o", - }, - arm: { - src: "crtend_so.o", - }, - }, - } - - vendor_snapshot_object { - name: "crtbegin_dynamic", - version: "30", - target_arch: "arm64", - vendor: true, - stl: "none", - crt: true, - arch: { - arm64: { - src: "crtbegin_so.o", - }, - arm: { - src: "crtbegin_so.o", - }, - }, - } - - vendor_snapshot_static { - name: "libvndk", - version: "30", - target_arch: "arm64", - compile_multilib: "both", - vendor: true, - arch: { - arm64: { - src: "libvndk.a", - }, - arm: { - src: "libvndk.a", - }, - }, - shared_libs: ["libvndk"], - export_shared_lib_headers: ["libvndk"], - } - - vendor_snapshot_static { - name: "libclang_rt.builtins", - version: "30", - target_arch: "arm64", - vendor: true, - arch: { - arm: { - src: "libclang_rt.builtins-arm-android.a", - }, - arm64: { - src: "libclang_rt.builtins-aarch64-android.a", - }, - }, - } - - vendor_snapshot_shared { - name: "lib32", - version: "30", - target_arch: "arm64", - compile_multilib: "32", - vendor: true, - no_crt_pad_segment: true, - arch: { - arm: { - src: "lib32.so", - }, - }, - } - - vendor_snapshot_shared { - name: "lib64", - version: "30", - target_arch: "arm64", - compile_multilib: "64", - vendor: true, - no_crt_pad_segment: true, - arch: { - arm64: { - src: "lib64.so", - }, - }, - } - vendor_snapshot_shared { - name: "liblog", - version: "30", - target_arch: "arm64", - compile_multilib: "64", - vendor: true, - no_crt_pad_segment: true, - arch: { - arm64: { - src: "liblog.so", - }, - }, - } - - vendor_snapshot_static { - name: "libvendor", - version: "30", - target_arch: "arm64", - compile_multilib: "both", - vendor: true, - arch: { - arm64: { - src: "libvendor.a", - export_include_dirs: ["include/libvendor"], - }, - arm: { - src: "libvendor.a", - export_include_dirs: ["include/libvendor"], - }, - }, - } - - vendor_snapshot_shared { - name: "libvendor_available", - version: "30", - target_arch: "arm64", - compile_multilib: "both", - vendor: true, - no_crt_pad_segment: true, - arch: { - arm64: { - src: "libvendor_available.so", - export_include_dirs: ["include/libvendor"], - }, - arm: { - src: "libvendor_available.so", - export_include_dirs: ["include/libvendor"], - }, - }, - } - - vendor_snapshot_binary { - name: "bin", - version: "30", - target_arch: "arm64", - compile_multilib: "64", - vendor: true, - arch: { - arm64: { - src: "bin", - }, - }, - } - - vendor_snapshot_binary { - name: "bin32", - version: "30", - target_arch: "arm64", - compile_multilib: "32", - vendor: true, - arch: { - arm: { - src: "bin32", - }, - }, - } - - // Test sanitizers use the snapshot libraries - rust_binary { - name: "memtag_binary", - srcs: ["vendor/bin.rs"], - vendor: true, - compile_multilib: "64", - sanitize: { - memtag_heap: true, - diag: { - memtag_heap: true, - } - }, - } - - // old snapshot module which has to be ignored - vendor_snapshot_binary { - name: "bin", - version: "26", - target_arch: "arm64", - compile_multilib: "first", - vendor: true, - arch: { - arm64: { - src: "bin", - }, - }, - } - - // different arch snapshot which has to be ignored - vendor_snapshot_binary { - name: "bin", - version: "30", - target_arch: "arm", - compile_multilib: "first", - vendor: true, - arch: { - arm64: { - src: "bin", - }, - }, - } - - vendor_snapshot_static { - name: "note_memtag_heap_sync", - vendor: true, - target_arch: "arm64", - version: "30", - arch: { - arm64: { - src: "note_memtag_heap_sync.a", - }, - }, - } - -` - - mockFS := android.MockFS{ - "framework/Android.bp": []byte(frameworkBp), - "framework/bin.rs": nil, - "note_memtag_heap_sync.a": nil, - "vendor/Android.bp": []byte(vendorProprietaryBp), - "vendor/bin": nil, - "vendor/bin32": nil, - "vendor/bin.rs": nil, - "vendor/client.rs": nil, - "vendor/include/libvndk/a.h": nil, - "vendor/include/libvendor/b.h": nil, - "vendor/libvndk.a": nil, - "vendor/libvendor.a": nil, - "vendor/libvendor.so": nil, - "vendor/lib32.so": nil, - "vendor/lib64.so": nil, - "vendor/liblog.so": nil, - "vendor/libstd.rlib": nil, - "vendor/librust_vendor_available.rlib": nil, - "vendor/librust_vendor_available.rlib-std.rlib": nil, - "vendor/libstd.dylib.so": nil, - "vendor/librust_vendor_available.dylib.so": nil, - "vendor/crtbegin_so.o": nil, - "vendor/crtend_so.o": nil, - "vendor/libclang_rt.builtins-aarch64-android.a": nil, - "vendor/libclang_rt.builtins-arm-android.a": nil, - "vndk/Android.bp": []byte(vndkBp), - "vndk/include/libvndk/a.h": nil, - "vndk/libvndk.so": nil, - } - - sharedVariant := "android_vendor.30_arm64_armv8-a_shared" - rlibVariant := "android_vendor.30_arm64_armv8-a_rlib_dylib-std" - rlibRlibStdVariant := "android_vendor.30_arm64_armv8-a_rlib_rlib-std" - dylibVariant := "android_vendor.30_arm64_armv8-a_dylib" - staticVariant := "android_vendor.30_arm64_armv8-a_static" - binaryVariant := "android_vendor.30_arm64_armv8-a" - - shared32Variant := "android_vendor.30_arm_armv7-a-neon_shared" - binary32Variant := "android_vendor.30_arm_armv7-a-neon" - - ctx := testRustVndkFsVersions(t, "", mockFS, "30", "current", "31") - - // libclient uses libvndk.vndk.30.arm64, libvendor.vendor_static.30.arm64, libvendor_without_snapshot - libclientLdFlags := ctx.ModuleForTests("libclient", sharedVariant).Rule("rustc").Args["linkFlags"] - for _, input := range [][]string{ - []string{sharedVariant, "libvndk.vndk.30.arm64"}, - []string{staticVariant, "libvendor.vendor_static.30.arm64"}, - []string{staticVariant, "libvendor_without_snapshot"}, - } { - outputPaths := cc.GetOutputPaths(ctx, input[0] /* variant */, []string{input[1]} /* module name */) - if !strings.Contains(libclientLdFlags, outputPaths[0].String()) { - t.Errorf("libflags for libclient must contain %#v, but was %#v", outputPaths[0], libclientLdFlags) - } - } - - libclientAndroidMkSharedLibs := ctx.ModuleForTests("libclient", sharedVariant).Module().(*Module).transitiveAndroidMkSharedLibs.ToList() - if g, w := libclientAndroidMkSharedLibs, []string{"libvndk.vendor", "libvendor_available.vendor", "lib64", "liblog.vendor", "libc.vendor", "libm.vendor", "libdl.vendor"}; !reflect.DeepEqual(g, w) { - t.Errorf("wanted libclient AndroidMkSharedLibs %q, got %q", w, g) - } - - libclientAndroidMkStaticLibs := ctx.ModuleForTests("libclient", sharedVariant).Module().(*Module).Properties.AndroidMkStaticLibs - if g, w := libclientAndroidMkStaticLibs, []string{"libvendor", "libvendor_without_snapshot", "libclang_rt.builtins.vendor"}; !reflect.DeepEqual(g, w) { - t.Errorf("wanted libclient AndroidMkStaticLibs %q, got %q", w, g) - } - - libclientAndroidMkDylibs := ctx.ModuleForTests("libclient", sharedVariant).Module().(*Module).Properties.AndroidMkDylibs - if g, w := libclientAndroidMkDylibs, []string{"librust_vendor_available.vendor", "libstd.vendor"}; !reflect.DeepEqual(g, w) { - t.Errorf("wanted libclient libclientAndroidMkDylibs %q, got %q", w, libclientAndroidMkDylibs) - } - - libclient32AndroidMkSharedLibs := ctx.ModuleForTests("libclient", shared32Variant).Module().(*Module).transitiveAndroidMkSharedLibs.ToList() - if g, w := libclient32AndroidMkSharedLibs, []string{"libvndk.vendor", "libvendor_available.vendor", "lib32", "liblog.vendor", "libc.vendor", "libm.vendor", "libdl.vendor"}; !reflect.DeepEqual(g, w) { - t.Errorf("wanted libclient32 AndroidMkSharedLibs %q, got %q", w, g) - } - - libclientRustAndroidMkRlibs := ctx.ModuleForTests("libclient_rust", rlibVariant).Module().(*Module).Properties.AndroidMkRlibs - if g, w := libclientRustAndroidMkRlibs, []string{"librust_vendor_available.vendor"}; !reflect.DeepEqual(g, w) { - t.Errorf("wanted rlib libclient libclientAndroidMkRlibs %q, got %q", w, g) - } - - libclientRlibStdRustAndroidMkRlibs := ctx.ModuleForTests("libclient_rust", rlibRlibStdVariant).Module().(*Module).Properties.AndroidMkRlibs - if g, w := libclientRlibStdRustAndroidMkRlibs, []string{"librust_vendor_available.vendor.rlib-std", "libstd.vendor"}; !reflect.DeepEqual(g, w) { - t.Errorf("wanted rlib libclient libclientAndroidMkRlibs %q, got %q", w, g) - } - - libclientRustDylibAndroidMkDylibs := ctx.ModuleForTests("libclient_rust", dylibVariant).Module().(*Module).Properties.AndroidMkDylibs - if g, w := libclientRustDylibAndroidMkDylibs, []string{"librust_vendor_available.vendor", "libstd.vendor"}; !reflect.DeepEqual(g, w) { - t.Errorf("wanted dylib libclient libclientRustDylibAndroidMkDylibs %q, got %q", w, g) - } - - // rust vendor snapshot must have ".vendor" suffix in AndroidMk - librustVendorAvailableSnapshotModule := ctx.ModuleForTests("librust_vendor_available.vendor_rlib.30.arm64", rlibVariant).Module() - librustVendorSnapshotMkName := android.AndroidMkEntriesForTest(t, ctx, librustVendorAvailableSnapshotModule)[0].EntryMap["LOCAL_MODULE"][0] - expectedRustVendorSnapshotName := "librust_vendor_available.vendor" - if librustVendorSnapshotMkName != expectedRustVendorSnapshotName { - t.Errorf("Unexpected rust vendor snapshot name in AndroidMk: %q, expected: %q\n", librustVendorSnapshotMkName, expectedRustVendorSnapshotName) - } - - librustVendorAvailableDylibSnapshotModule := ctx.ModuleForTests("librust_vendor_available.vendor_dylib.30.arm64", dylibVariant).Module() - librustVendorSnapshotDylibMkName := android.AndroidMkEntriesForTest(t, ctx, librustVendorAvailableDylibSnapshotModule)[0].EntryMap["LOCAL_MODULE"][0] - expectedRustVendorDylibSnapshotName := "librust_vendor_available.vendor" - if librustVendorSnapshotDylibMkName != expectedRustVendorDylibSnapshotName { - t.Errorf("Unexpected rust vendor snapshot name in AndroidMk: %q, expected: %q\n", librustVendorSnapshotDylibMkName, expectedRustVendorDylibSnapshotName) - } - - rustVendorBinModule := ctx.ModuleForTests("bin_without_snapshot", binaryVariant).Module() - rustVendorBinMkDylibName := android.AndroidMkEntriesForTest(t, ctx, rustVendorBinModule)[0].EntryMap["LOCAL_DYLIB_LIBRARIES"][0] - if rustVendorBinMkDylibName != expectedRustVendorSnapshotName { - t.Errorf("Unexpected rust rlib name in AndroidMk: %q, expected: %q\n", rustVendorBinMkDylibName, expectedRustVendorSnapshotName) - } - - binWithoutSnapshotLdFlags := ctx.ModuleForTests("bin_without_snapshot", binaryVariant).Rule("rustc").Args["linkFlags"] - libVndkStaticOutputPaths := cc.GetOutputPaths(ctx, staticVariant, []string{"libvndk.vendor_static.30.arm64"}) - if !strings.Contains(binWithoutSnapshotLdFlags, libVndkStaticOutputPaths[0].String()) { - t.Errorf("libflags for bin_without_snapshot must contain %#v, but was %#v", - libVndkStaticOutputPaths[0], binWithoutSnapshotLdFlags) - } - - // bin is installed by bin.vendor_binary.30.arm64 - ctx.ModuleForTests("bin.vendor_binary.30.arm64", binaryVariant).Output("bin") - - // bin32 is installed by bin32.vendor_binary.30.arm64 - ctx.ModuleForTests("bin32.vendor_binary.30.arm64", binary32Variant).Output("bin32") - - // bin_without_snapshot is installed by bin_without_snapshot - ctx.ModuleForTests("bin_without_snapshot", binaryVariant).Output("bin_without_snapshot") - - // libvendor, libvendor_available and bin don't have vendor.30 variant - libvendorVariants := ctx.ModuleVariantsForTests("libvendor") - if android.InList(sharedVariant, libvendorVariants) { - t.Errorf("libvendor must not have variant %#v, but it does", sharedVariant) - } - - libvendorAvailableVariants := ctx.ModuleVariantsForTests("libvendor_available") - if android.InList(sharedVariant, libvendorAvailableVariants) { - t.Errorf("libvendor_available must not have variant %#v, but it does", sharedVariant) - } - - binVariants := ctx.ModuleVariantsForTests("bin") - if android.InList(binaryVariant, binVariants) { - t.Errorf("bin must not have variant %#v, but it does", sharedVariant) - } - - memtagStaticLibs := ctx.ModuleForTests("memtag_binary", "android_vendor.30_arm64_armv8-a").Module().(*Module).Properties.AndroidMkStaticLibs - if g, w := memtagStaticLibs, []string{"libclang_rt.builtins.vendor", "note_memtag_heap_sync.vendor"}; !reflect.DeepEqual(g, w) { - t.Errorf("wanted memtag_binary AndroidMkStaticLibs %q, got %q", w, g) - } -} - -func TestRecoverySnapshotCapture(t *testing.T) { - bp := ` - rust_ffi { - name: "librecovery", - recovery: true, - srcs: ["foo.rs"], - crate_name: "recovery", - } - - rust_ffi { - name: "librecovery_available", - recovery_available: true, - srcs: ["foo.rs"], - crate_name: "recovery_available", - } - - rust_library { - name: "librecovery_rustlib", - recovery: true, - srcs: ["foo.rs"], - crate_name: "recovery_rustlib", - } - - rust_library { - name: "librecovery_available_rustlib", - recovery_available: true, - srcs: ["foo.rs"], - crate_name: "recovery_available_rustlib", - } - - rust_binary { - name: "recovery_bin", - recovery: true, - srcs: ["foo.rs"], - } - - rust_binary { - name: "recovery_available_bin", - recovery_available: true, - srcs: ["foo.rs"], - } - -` - // Check Recovery snapshot output. - - ctx := testRustRecoveryFsVersions(t, bp, rustMockedFiles, "", "29", "current") - snapshotDir := "recovery-snapshot" - snapshotVariantPath := filepath.Join("out/soong", snapshotDir, "arm64") - snapshotSingleton := ctx.SingletonForTests("recovery-snapshot") - - var jsonFiles []string - - for _, arch := range [][]string{ - []string{"arm64", "armv8-a"}, - } { - archType := arch[0] - archVariant := arch[1] - archDir := fmt.Sprintf("arch-%s-%s", archType, archVariant) - - // For shared libraries, all recovery:true and recovery_available modules are captured. - sharedVariant := fmt.Sprintf("android_recovery_%s_%s_shared", archType, archVariant) - sharedDir := filepath.Join(snapshotVariantPath, archDir, "shared") - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery", "librecovery.so", sharedDir, sharedVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery_available", "librecovery_available.so", sharedDir, sharedVariant) - jsonFiles = append(jsonFiles, - filepath.Join(sharedDir, "librecovery.so.json"), - filepath.Join(sharedDir, "librecovery_available.so.json")) - - // For static libraries, all recovery:true and recovery_available modules are captured. - staticVariant := fmt.Sprintf("android_recovery_%s_%s_static", archType, archVariant) - staticDir := filepath.Join(snapshotVariantPath, archDir, "static") - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery", "librecovery.a", staticDir, staticVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery_available", "librecovery_available.a", staticDir, staticVariant) - jsonFiles = append(jsonFiles, - filepath.Join(staticDir, "librecovery.a.json"), - filepath.Join(staticDir, "librecovery_available.a.json")) - - // For rlib libraries, all recovery:true and recovery_available modules are captured. - rlibVariant := fmt.Sprintf("android_recovery_%s_%s_rlib_dylib-std", archType, archVariant) - rlibDir := filepath.Join(snapshotVariantPath, archDir, "rlib") - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery_rustlib", "librecovery_rustlib.rlib", rlibDir, rlibVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery_available_rustlib", "librecovery_available_rustlib.rlib", rlibDir, rlibVariant) - jsonFiles = append(jsonFiles, - filepath.Join(rlibDir, "librecovery_rustlib.rlib.json"), - filepath.Join(rlibDir, "librecovery_available_rustlib.rlib.json")) - - rlibRlibStdVariant := fmt.Sprintf("android_recovery_%s_%s_rlib_rlib-std", archType, archVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery_rustlib", "librecovery_rustlib.rlib-std.rlib", rlibDir, rlibRlibStdVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery_available_rustlib", "librecovery_available_rustlib.rlib-std.rlib", rlibDir, rlibRlibStdVariant) - jsonFiles = append(jsonFiles, - filepath.Join(rlibDir, "librecovery_rustlib.rlib-std.rlib.json"), - filepath.Join(rlibDir, "librecovery_available_rustlib.rlib-std.rlib.json")) - - // For dylib libraries, all recovery:true and recovery_available modules are captured. - dylibVariant := fmt.Sprintf("android_recovery_%s_%s_dylib", archType, archVariant) - dylibDir := filepath.Join(snapshotVariantPath, archDir, "dylib") - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery_rustlib", "librecovery_rustlib.dylib.so", dylibDir, dylibVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery_available_rustlib", "librecovery_available_rustlib.dylib.so", dylibDir, dylibVariant) - jsonFiles = append(jsonFiles, - filepath.Join(dylibDir, "librecovery_rustlib.dylib.so.json"), - filepath.Join(dylibDir, "librecovery_available_rustlib.dylib.so.json")) - - // For binary executables, all recovery:true and recovery_available modules are captured. - if archType == "arm64" { - binaryVariant := fmt.Sprintf("android_recovery_%s_%s", archType, archVariant) - binaryDir := filepath.Join(snapshotVariantPath, archDir, "binary") - cc.CheckSnapshot(t, ctx, snapshotSingleton, "recovery_bin", "recovery_bin", binaryDir, binaryVariant) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "recovery_available_bin", "recovery_available_bin", binaryDir, binaryVariant) - jsonFiles = append(jsonFiles, - filepath.Join(binaryDir, "recovery_bin.json"), - filepath.Join(binaryDir, "recovery_available_bin.json")) - } - } - - for _, jsonFile := range jsonFiles { - // verify all json files exist - if snapshotSingleton.MaybeOutput(jsonFile).Rule == nil { - t.Errorf("%q expected but not found", jsonFile) - } - } -} - -func TestRecoverySnapshotExclude(t *testing.T) { - // This test verifies that the exclude_from_recovery_snapshot property - // makes its way from the Android.bp source file into the module data - // structure. It also verifies that modules are correctly included or - // excluded in the recovery snapshot based on their path (framework or - // vendor) and the exclude_from_recovery_snapshot property. - - frameworkBp := ` - rust_ffi_shared { - name: "libinclude", - srcs: ["src/include.rs"], - recovery_available: true, - crate_name: "include", - } - rust_ffi_shared { - name: "libexclude", - srcs: ["src/exclude.rs"], - recovery: true, - exclude_from_recovery_snapshot: true, - crate_name: "exclude", - } - rust_ffi_shared { - name: "libavailable_exclude", - srcs: ["src/exclude.rs"], - recovery_available: true, - exclude_from_recovery_snapshot: true, - crate_name: "available_exclude", - } - rust_library { - name: "libinclude_rustlib", - srcs: ["src/include.rs"], - recovery_available: true, - crate_name: "include_rustlib", - } - rust_library { - name: "libexclude_rustlib", - srcs: ["src/exclude.rs"], - recovery: true, - exclude_from_recovery_snapshot: true, - crate_name: "exclude_rustlib", - } - rust_library { - name: "libavailable_exclude_rustlib", - srcs: ["src/exclude.rs"], - recovery_available: true, - exclude_from_recovery_snapshot: true, - crate_name: "available_exclude_rustlib", - } - ` - - vendorProprietaryBp := ` - rust_ffi_shared { - name: "librecovery", - srcs: ["recovery.rs"], - recovery: true, - crate_name: "recovery", - } - rust_library { - name: "librecovery_rustlib", - srcs: ["recovery.rs"], - recovery: true, - crate_name: "recovery_rustlib", - } - ` - - mockFS := map[string][]byte{ - "framework/Android.bp": []byte(frameworkBp), - "framework/include.rs": nil, - "framework/exclude.rs": nil, - "device/Android.bp": []byte(vendorProprietaryBp), - "device/recovery.rs": nil, - } - - ctx := testRustRecoveryFsVersions(t, "", mockFS, "", "29", "current") - - // Test an include and exclude framework module. - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "libinclude", false, sharedRecoveryVariant) - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "libexclude", true, sharedRecoveryVariant) - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "libavailable_exclude", true, sharedRecoveryVariant) - - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "libinclude_rustlib", false, rlibRecoveryVariant) - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "libexclude_rustlib", true, rlibRecoveryVariant) - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "libavailable_exclude_rustlib", true, rlibRlibStdRecoveryVariant) - - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "libinclude_rustlib", false, rlibRlibStdRecoveryVariant) - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "libexclude_rustlib", true, rlibRlibStdRecoveryVariant) - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "libavailable_exclude_rustlib", true, rlibRlibStdRecoveryVariant) - - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "libinclude_rustlib", false, dylibRecoveryVariant) - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "libexclude_rustlib", true, dylibRecoveryVariant) - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "libavailable_exclude_rustlib", true, dylibRecoveryVariant) - - // A recovery module is excluded, but by its path not the exclude_from_recovery_snapshot property - // ('device/' and 'vendor/' are default excluded). See snapshot/recovery_snapshot.go for more detail. - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "librecovery", false, sharedRecoveryVariant) - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "librecovery_rustlib", false, rlibRecoveryVariant) - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "librecovery_rustlib", false, rlibRlibStdRecoveryVariant) - cc.AssertExcludeFromRecoverySnapshotIs(t, ctx, "librecovery_rustlib", false, dylibRecoveryVariant) - - // Verify the content of the recovery snapshot. - - snapshotDir := "recovery-snapshot" - snapshotVariantPath := filepath.Join("out/soong", snapshotDir, "arm64") - snapshotSingleton := ctx.SingletonForTests("recovery-snapshot") - - var includeJsonFiles []string - var excludeJsonFiles []string - - for _, arch := range [][]string{ - []string{"arm64", "armv8-a"}, - } { - archType := arch[0] - archVariant := arch[1] - archDir := fmt.Sprintf("arch-%s-%s", archType, archVariant) - - sharedVariant := fmt.Sprintf("android_recovery_%s_%s_shared", archType, archVariant) - rlibVariant := fmt.Sprintf("android_recovery_%s_%s_rlib_dylib-std", archType, archVariant) - rlibRlibStdVariant := fmt.Sprintf("android_recovery_%s_%s_rlib_rlib-std", archType, archVariant) - dylibVariant := fmt.Sprintf("android_recovery_%s_%s_dylib", archType, archVariant) - sharedDir := filepath.Join(snapshotVariantPath, archDir, "shared") - rlibDir := filepath.Join(snapshotVariantPath, archDir, "rlib") - dylibDir := filepath.Join(snapshotVariantPath, archDir, "dylib") - - // Included modules - - cc.CheckSnapshot(t, ctx, snapshotSingleton, "libinclude", "libinclude.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "libinclude.so.json")) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "libinclude_rustlib", "libinclude_rustlib.rlib", rlibDir, rlibVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(rlibDir, "libinclude_rustlib.rlib.json")) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "libinclude_rustlib", "libinclude_rustlib.rlib-std.rlib", rlibDir, rlibRlibStdVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(rlibDir, "libinclude_rustlib.rlib-std.rlib.json")) - - // Excluded modules - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "libexclude", "libexclude.so", sharedDir, sharedVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(sharedDir, "libexclude.so.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "librecovery", "librecovery.so", sharedDir, sharedVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(sharedDir, "librecovery.so.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "libavailable_exclude", "libavailable_exclude.so", sharedDir, sharedVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(sharedDir, "libavailable_exclude.so.json")) - - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "libexclude_rustlib", "libexclude_rustlib.rlib", rlibDir, rlibVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(rlibDir, "libexclude_rustlib.rlib.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "librecovery_rustlib", "librecovery_rustlib.rlib", rlibDir, rlibVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(rlibDir, "librecovery_rustlib.rlib.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "libavailable_exclude_rustlib", "libavailable_exclude_rustlib.rlib", rlibDir, rlibVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(rlibDir, "libavailable_exclude_rustlib.rlib.json")) - - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "libexclude_rustlib", "libexclude_rustlib.rlib-std.rlib", rlibDir, rlibRlibStdVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(rlibDir, "libexclude_rustlib.rlib-std.rlib.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "librecovery_rustlib", "librecovery_rustlib.rlib-std.rlib", rlibDir, rlibRlibStdVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(rlibDir, "librecovery_rustlib.rlib-std.rlib.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "libavailable_exclude_rustlib", "libavailable_exclude_rustlib.rlib-std.rlib", rlibDir, rlibRlibStdVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(rlibDir, "libavailable_exclude_rustlib.rlib-std.rlib.json")) - - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "libexclude_rustlib", "libexclude_rustlib.dylib.so", dylibDir, dylibVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(rlibDir, "libexclude_rustlib.dylib.so.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "librecovery_rustlib", "librecovery_rustlib.dylib.so", dylibDir, dylibVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(rlibDir, "librecovery_rustlib.dylib.so.json")) - cc.CheckSnapshotExclude(t, ctx, snapshotSingleton, "libavailable_exclude_rustlib", "libavailable_exclude_rustlib.dylib.so", dylibDir, dylibVariant) - excludeJsonFiles = append(excludeJsonFiles, filepath.Join(rlibDir, "libavailable_exclude_rustlib.dylib.so.json")) - } - - // Verify that each json file for an included module has a rule. - for _, jsonFile := range includeJsonFiles { - if snapshotSingleton.MaybeOutput(jsonFile).Rule == nil { - t.Errorf("include json file %q not found", jsonFile) - } - } - - // Verify that each json file for an excluded module has no rule. - for _, jsonFile := range excludeJsonFiles { - if snapshotSingleton.MaybeOutput(jsonFile).Rule != nil { - t.Errorf("exclude json file %q found", jsonFile) - } - } -} - -func TestRecoverySnapshotDirected(t *testing.T) { - bp := ` - rust_ffi_shared { - name: "librecovery", - recovery: true, - crate_name: "recovery", - srcs: ["foo.rs"], - } - - rust_ffi_shared { - name: "librecovery_available", - recovery_available: true, - crate_name: "recovery_available", - srcs: ["foo.rs"], - } - - rust_library { - name: "librecovery_rustlib", - recovery: true, - crate_name: "recovery", - srcs: ["foo.rs"], - } - - rust_library { - name: "librecovery_available_rustlib", - recovery_available: true, - crate_name: "recovery_available", - srcs: ["foo.rs"], - } - - /* TODO: Uncomment when Rust supports the "prefer" property for prebuilts - rust_library_rlib { - name: "libfoo_rlib", - recovery: true, - crate_name: "foo", - } - - rust_prebuilt_rlib { - name: "libfoo_rlib", - recovery: true, - prefer: true, - srcs: ["libfoo.rlib"], - crate_name: "foo", - } - */ -` - ctx := testRustRecoveryFsVersions(t, bp, rustMockedFiles, "current", "29", "current") - ctx.Config().TestProductVariables.RecoverySnapshotModules = make(map[string]bool) - ctx.Config().TestProductVariables.RecoverySnapshotModules["librecovery"] = true - ctx.Config().TestProductVariables.RecoverySnapshotModules["librecovery_rustlib"] = true - ctx.Config().TestProductVariables.DirectedRecoverySnapshot = true - - // Check recovery snapshot output. - snapshotDir := "recovery-snapshot" - snapshotVariantPath := filepath.Join("out/soong", snapshotDir, "arm64") - snapshotSingleton := ctx.SingletonForTests("recovery-snapshot") - - var includeJsonFiles []string - - for _, arch := range [][]string{ - []string{"arm64", "armv8-a"}, - } { - archType := arch[0] - archVariant := arch[1] - archDir := fmt.Sprintf("arch-%s-%s", archType, archVariant) - - sharedVariant := fmt.Sprintf("android_recovery_%s_%s_shared", archType, archVariant) - rlibVariant := fmt.Sprintf("android_recovery_%s_%s_rlib_dylib-std", archType, archVariant) - rlibRlibStdVariant := fmt.Sprintf("android_recovery_%s_%s_rlib_rlib-std", archType, archVariant) - dylibVariant := fmt.Sprintf("android_recovery_%s_%s_dylib", archType, archVariant) - sharedDir := filepath.Join(snapshotVariantPath, archDir, "shared") - rlibDir := filepath.Join(snapshotVariantPath, archDir, "rlib") - dylibDir := filepath.Join(snapshotVariantPath, archDir, "dylib") - - // Included modules - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery", "librecovery.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "librecovery.so.json")) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery_rustlib", "librecovery_rustlib.rlib", rlibDir, rlibVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(rlibDir, "librecovery_rustlib.rlib.json")) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery_rustlib", "librecovery_rustlib.rlib-std.rlib", rlibDir, rlibRlibStdVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(rlibDir, "librecovery_rustlib.rlib-std.rlib.json")) - cc.CheckSnapshot(t, ctx, snapshotSingleton, "librecovery_rustlib", "librecovery_rustlib.dylib.so", dylibDir, dylibVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(dylibDir, "librecovery_rustlib.dylib.so.json")) - - // TODO: When Rust supports the "prefer" property for prebuilts, perform this check. - /* - // Check that snapshot captures "prefer: true" prebuilt - cc.CheckSnapshot(t, ctx, snapshotSingleton, "prebuilt_libfoo_rlib", "libfoo_rlib.rlib", rlibDir, rlibVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "libfoo_rlib.rlib.json")) - */ - - // Excluded modules. Modules not included in the directed recovery snapshot - // are still included as fake modules. - cc.CheckSnapshotRule(t, ctx, snapshotSingleton, "librecovery_available", "librecovery_available.so", sharedDir, sharedVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(sharedDir, "librecovery_available.so.json")) - cc.CheckSnapshotRule(t, ctx, snapshotSingleton, "librecovery_available_rustlib", "librecovery_available_rustlib.rlib", rlibDir, rlibVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(rlibDir, "librecovery_available_rustlib.rlib.json")) - cc.CheckSnapshotRule(t, ctx, snapshotSingleton, "librecovery_available_rustlib", "librecovery_available_rustlib.rlib-std.rlib", rlibDir, rlibRlibStdVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(rlibDir, "librecovery_available_rustlib.rlib-std.rlib.json")) - cc.CheckSnapshotRule(t, ctx, snapshotSingleton, "librecovery_available_rustlib", "librecovery_available_rustlib.dylib.so", dylibDir, dylibVariant) - includeJsonFiles = append(includeJsonFiles, filepath.Join(dylibDir, "librecovery_available_rustlib.dylib.so.json")) - } - - // Verify that each json file for an included module has a rule. - for _, jsonFile := range includeJsonFiles { - if snapshotSingleton.MaybeOutput(jsonFile).Rule == nil { - t.Errorf("include json file %q not found, %#v", jsonFile, includeJsonFiles) - } - } -}