1// Copyright (C) 2019 The Android Open Source Project 2// 3// Licensed under the Apache License, Version 2.0 (the "License"); 4// you may not use this file except in compliance with the License. 5// You may obtain a copy of the License at 6// 7// http://www.apache.org/licenses/LICENSE-2.0 8// 9// Unless required by applicable law or agreed to in writing, software 10// distributed under the License is distributed on an "AS IS" BASIS, 11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12// See the License for the specific language governing permissions and 13// limitations under the License. 14 15package cc 16 17import ( 18 "encoding/json" 19 "path/filepath" 20 "testing" 21 22 "android/soong/android" 23 "android/soong/genrule" 24 "android/soong/multitree" 25 "android/soong/snapshot" 26) 27 28func RegisterRequiredBuildComponentsForTest(ctx android.RegistrationContext) { 29 RegisterPrebuiltBuildComponents(ctx) 30 RegisterCCBuildComponents(ctx) 31 RegisterBinaryBuildComponents(ctx) 32 RegisterLibraryBuildComponents(ctx) 33 RegisterLibraryHeadersBuildComponents(ctx) 34 RegisterLibraryStubBuildComponents(ctx) 35 36 multitree.RegisterApiImportsModule(ctx) 37 38 ctx.RegisterModuleType("cc_benchmark", BenchmarkFactory) 39 ctx.RegisterModuleType("cc_object", ObjectFactory) 40 ctx.RegisterModuleType("cc_genrule", GenRuleFactory) 41 ctx.RegisterModuleType("ndk_prebuilt_shared_stl", NdkPrebuiltSharedStlFactory) 42 ctx.RegisterModuleType("ndk_prebuilt_static_stl", NdkPrebuiltStaticStlFactory) 43 ctx.RegisterModuleType("ndk_library", NdkLibraryFactory) 44 ctx.RegisterModuleType("ndk_headers", ndkHeadersFactory) 45} 46 47func GatherRequiredDepsForTest(oses ...android.OsType) string { 48 ret := commonDefaultModules() 49 50 supportLinuxBionic := false 51 for _, os := range oses { 52 if os == android.Windows { 53 ret += withWindowsModules() 54 } 55 if os == android.LinuxBionic { 56 supportLinuxBionic = true 57 ret += withLinuxBionic() 58 } 59 } 60 61 if !supportLinuxBionic { 62 ret += withoutLinuxBionic() 63 } 64 65 return ret 66} 67 68func commonDefaultModules() string { 69 return ` 70 cc_defaults { 71 name: "toolchain_libs_defaults", 72 host_supported: true, 73 vendor_available: true, 74 product_available: true, 75 recovery_available: true, 76 no_libcrt: true, 77 sdk_version: "minimum", 78 nocrt: true, 79 system_shared_libs: [], 80 stl: "none", 81 check_elf_files: false, 82 sanitize: { 83 never: true, 84 }, 85 } 86 87 cc_prebuilt_library_static { 88 name: "libcompiler_rt-extras", 89 defaults: ["toolchain_libs_defaults"], 90 vendor_ramdisk_available: true, 91 srcs: [""], 92 } 93 94 cc_prebuilt_library_static { 95 name: "libclang_rt.builtins", 96 defaults: ["toolchain_libs_defaults"], 97 host_supported: true, 98 vendor_available: true, 99 vendor_ramdisk_available: true, 100 native_bridge_supported: true, 101 srcs: [""], 102 } 103 104 cc_prebuilt_library_shared { 105 name: "libclang_rt.hwasan", 106 defaults: ["toolchain_libs_defaults"], 107 srcs: [""], 108 } 109 110 cc_prebuilt_library_static { 111 name: "libunwind", 112 defaults: [ 113 "linux_bionic_supported", 114 "toolchain_libs_defaults", 115 ], 116 vendor_ramdisk_available: true, 117 native_bridge_supported: true, 118 srcs: [""], 119 } 120 121 cc_prebuilt_library_static { 122 name: "libclang_rt.fuzzer", 123 defaults: [ 124 "linux_bionic_supported", 125 "toolchain_libs_defaults", 126 ], 127 srcs: [""], 128 } 129 130 // Needed for sanitizer 131 cc_prebuilt_library_shared { 132 name: "libclang_rt.ubsan_standalone", 133 defaults: ["toolchain_libs_defaults"], 134 srcs: [""], 135 } 136 137 cc_prebuilt_library_static { 138 name: "libclang_rt.ubsan_standalone.static", 139 defaults: ["toolchain_libs_defaults"], 140 srcs: [""], 141 } 142 143 cc_prebuilt_library_static { 144 name: "libclang_rt.ubsan_minimal", 145 defaults: ["toolchain_libs_defaults"], 146 host_supported: true, 147 target: { 148 android_arm64: { 149 srcs: ["libclang_rt.ubsan_minimal.android_arm64.a"], 150 }, 151 android_arm: { 152 srcs: ["libclang_rt.ubsan_minimal.android_arm.a"], 153 }, 154 linux_glibc_x86_64: { 155 srcs: ["libclang_rt.ubsan_minimal.x86_64.a"], 156 }, 157 linux_glibc_x86: { 158 srcs: ["libclang_rt.ubsan_minimal.x86.a"], 159 }, 160 linux_musl_x86_64: { 161 srcs: ["libclang_rt.ubsan_minimal.x86_64.a"], 162 }, 163 linux_musl_x86: { 164 srcs: ["libclang_rt.ubsan_minimal.x86.a"], 165 }, 166 }, 167 } 168 169 cc_library { 170 name: "libc", 171 defaults: ["linux_bionic_supported"], 172 no_libcrt: true, 173 nocrt: true, 174 stl: "none", 175 system_shared_libs: [], 176 recovery_available: true, 177 stubs: { 178 versions: ["27", "28", "29"], 179 }, 180 llndk: { 181 symbol_file: "libc.map.txt", 182 }, 183 } 184 cc_library { 185 name: "libm", 186 defaults: ["linux_bionic_supported"], 187 no_libcrt: true, 188 nocrt: true, 189 stl: "none", 190 system_shared_libs: [], 191 recovery_available: true, 192 stubs: { 193 versions: ["27", "28", "29"], 194 }, 195 apex_available: [ 196 "//apex_available:platform", 197 "myapex" 198 ], 199 llndk: { 200 symbol_file: "libm.map.txt", 201 }, 202 } 203 204 // Coverage libraries 205 cc_library { 206 name: "libprofile-extras", 207 vendor_available: true, 208 vendor_ramdisk_available: true, 209 product_available: true, 210 recovery_available: true, 211 native_coverage: false, 212 system_shared_libs: [], 213 stl: "none", 214 } 215 cc_library { 216 name: "libprofile-clang-extras", 217 vendor_available: true, 218 vendor_ramdisk_available: true, 219 product_available: true, 220 recovery_available: true, 221 native_coverage: false, 222 system_shared_libs: [], 223 stl: "none", 224 } 225 cc_library { 226 name: "libprofile-extras_ndk", 227 vendor_available: true, 228 product_available: true, 229 native_coverage: false, 230 system_shared_libs: [], 231 stl: "none", 232 sdk_version: "current", 233 } 234 cc_library { 235 name: "libprofile-clang-extras_ndk", 236 vendor_available: true, 237 product_available: true, 238 native_coverage: false, 239 system_shared_libs: [], 240 stl: "none", 241 sdk_version: "current", 242 } 243 244 cc_library { 245 name: "libdl", 246 defaults: ["linux_bionic_supported"], 247 no_libcrt: true, 248 nocrt: true, 249 stl: "none", 250 system_shared_libs: [], 251 recovery_available: true, 252 stubs: { 253 versions: ["27", "28", "29"], 254 }, 255 apex_available: [ 256 "//apex_available:platform", 257 "myapex" 258 ], 259 llndk: { 260 symbol_file: "libdl.map.txt", 261 }, 262 } 263 cc_library { 264 name: "libft2", 265 no_libcrt: true, 266 nocrt: true, 267 system_shared_libs: [], 268 recovery_available: true, 269 llndk: { 270 symbol_file: "libft2.map.txt", 271 private: true, 272 } 273 } 274 cc_library { 275 name: "libc++_static", 276 no_libcrt: true, 277 nocrt: true, 278 system_shared_libs: [], 279 stl: "none", 280 vendor_available: true, 281 vendor_ramdisk_available: true, 282 product_available: true, 283 recovery_available: true, 284 host_supported: true, 285 min_sdk_version: "29", 286 apex_available: [ 287 "//apex_available:platform", 288 "//apex_available:anyapex", 289 ], 290 } 291 cc_library { 292 name: "libc++", 293 no_libcrt: true, 294 nocrt: true, 295 system_shared_libs: [], 296 stl: "none", 297 vendor_available: true, 298 product_available: true, 299 recovery_available: true, 300 host_supported: true, 301 min_sdk_version: "29", 302 vndk: { 303 enabled: true, 304 support_system_process: true, 305 }, 306 apex_available: [ 307 "//apex_available:platform", 308 "//apex_available:anyapex", 309 ], 310 } 311 cc_library { 312 name: "libc++demangle", 313 no_libcrt: true, 314 nocrt: true, 315 system_shared_libs: [], 316 stl: "none", 317 host_supported: false, 318 vendor_available: true, 319 vendor_ramdisk_available: true, 320 product_available: true, 321 recovery_available: true, 322 min_sdk_version: "29", 323 apex_available: [ 324 "//apex_available:platform", 325 "//apex_available:anyapex", 326 ], 327 } 328 329 cc_defaults { 330 name: "crt_defaults", 331 defaults: ["linux_bionic_supported"], 332 recovery_available: true, 333 vendor_available: true, 334 vendor_ramdisk_available: true, 335 product_available: true, 336 native_bridge_supported: true, 337 stl: "none", 338 min_sdk_version: "16", 339 crt: true, 340 system_shared_libs: [], 341 apex_available: [ 342 "//apex_available:platform", 343 "//apex_available:anyapex", 344 ], 345 } 346 347 cc_object { 348 name: "crtbegin_so", 349 defaults: ["crt_defaults"], 350 srcs: ["crtbegin_so.c"], 351 objs: ["crtbrand"], 352 } 353 354 cc_object { 355 name: "crtbegin_dynamic", 356 defaults: ["crt_defaults"], 357 srcs: ["crtbegin.c"], 358 objs: ["crtbrand"], 359 } 360 361 cc_object { 362 name: "crtbegin_static", 363 defaults: ["crt_defaults"], 364 srcs: ["crtbegin.c"], 365 objs: ["crtbrand"], 366 } 367 368 cc_object { 369 name: "crtend_so", 370 defaults: ["crt_defaults"], 371 srcs: ["crtend_so.c"], 372 objs: ["crtbrand"], 373 } 374 375 cc_object { 376 name: "crtend_android", 377 defaults: ["crt_defaults"], 378 srcs: ["crtend.c"], 379 objs: ["crtbrand"], 380 } 381 382 cc_object { 383 name: "crtbrand", 384 defaults: ["crt_defaults"], 385 srcs: ["crtbrand.c"], 386 } 387 388 cc_library { 389 name: "libprotobuf-cpp-lite", 390 } 391 392 cc_library { 393 name: "ndk_libunwind", 394 sdk_version: "minimum", 395 stl: "none", 396 system_shared_libs: [], 397 } 398 399 ndk_library { 400 name: "libc", 401 first_version: "minimum", 402 symbol_file: "libc.map.txt", 403 } 404 405 ndk_library { 406 name: "libm", 407 first_version: "minimum", 408 symbol_file: "libm.map.txt", 409 } 410 411 ndk_library { 412 name: "libdl", 413 first_version: "minimum", 414 symbol_file: "libdl.map.txt", 415 } 416 417 ndk_prebuilt_shared_stl { 418 name: "ndk_libc++_shared", 419 export_include_dirs: ["ndk_libc++_shared"], 420 } 421 422 ndk_prebuilt_static_stl { 423 name: "ndk_libandroid_support", 424 export_include_dirs: ["ndk_libandroid_support"], 425 } 426 427 cc_library_static { 428 name: "libgoogle-benchmark", 429 sdk_version: "current", 430 stl: "none", 431 system_shared_libs: [], 432 } 433 434 cc_library_static { 435 name: "note_memtag_heap_async", 436 } 437 438 cc_library_static { 439 name: "note_memtag_heap_sync", 440 } 441 442 cc_library { 443 name: "libc_musl", 444 host_supported: true, 445 no_libcrt: true, 446 nocrt: true, 447 system_shared_libs: [], 448 stl: "none", 449 } 450 ` 451} 452 453func withWindowsModules() string { 454 return ` 455 cc_prebuilt_library_static { 456 name: "libwinpthread", 457 host_supported: true, 458 enabled: false, 459 target: { 460 windows: { 461 enabled: true, 462 }, 463 }, 464 stl: "none", 465 srcs:[""], 466 } 467 ` 468} 469 470func withLinuxBionic() string { 471 return ` 472 cc_binary { 473 name: "linker", 474 defaults: ["linux_bionic_supported"], 475 recovery_available: true, 476 stl: "none", 477 nocrt: true, 478 static_executable: true, 479 native_coverage: false, 480 system_shared_libs: [], 481 } 482 483 cc_genrule { 484 name: "host_bionic_linker_script", 485 host_supported: true, 486 device_supported: false, 487 target: { 488 host: { 489 enabled: false, 490 }, 491 linux_bionic: { 492 enabled: true, 493 }, 494 }, 495 out: ["linker.script"], 496 } 497 498 cc_defaults { 499 name: "linux_bionic_supported", 500 host_supported: true, 501 target: { 502 host: { 503 enabled: false, 504 }, 505 linux_bionic: { 506 enabled: true, 507 }, 508 }, 509 } 510 ` 511} 512 513func withoutLinuxBionic() string { 514 return ` 515 cc_defaults { 516 name: "linux_bionic_supported", 517 } 518 ` 519} 520 521func GatherRequiredFilesForTest(fs map[string][]byte) { 522} 523 524// The directory in which cc linux bionic default modules will be defined. 525// 526// Placing them here ensures that their location does not conflict with default test modules 527// defined by other packages. 528const linuxBionicDefaultsPath = "defaults/cc/linux-bionic/Android.bp" 529 530// The directory in which the default cc common test modules will be defined. 531// 532// Placing them here ensures that their location does not conflict with default test modules 533// defined by other packages. 534const DefaultCcCommonTestModulesDir = "defaults/cc/common/" 535 536// Test fixture preparer that will register most cc build components. 537// 538// Singletons and mutators should only be added here if they are needed for a majority of cc 539// module types, otherwise they should be added under a separate preparer to allow them to be 540// selected only when needed to reduce test execution time. 541// 542// Module types do not have much of an overhead unless they are used so this should include as many 543// module types as possible. The exceptions are those module types that require mutators and/or 544// singletons in order to function in which case they should be kept together in a separate 545// preparer. 546var PrepareForTestWithCcBuildComponents = android.GroupFixturePreparers( 547 android.PrepareForTestWithAndroidBuildComponents, 548 android.FixtureRegisterWithContext(RegisterRequiredBuildComponentsForTest), 549 android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) { 550 ctx.RegisterModuleType("cc_fuzz", LibFuzzFactory) 551 ctx.RegisterModuleType("cc_test", TestFactory) 552 ctx.RegisterModuleType("cc_test_library", TestLibraryFactory) 553 ctx.RegisterModuleType("vndk_prebuilt_shared", VndkPrebuiltSharedFactory) 554 555 RegisterVndkLibraryTxtTypes(ctx) 556 }), 557 558 // Additional files needed in tests that disallow non-existent source files. 559 // This includes files that are needed by all, or at least most, instances of a cc module type. 560 android.MockFS{ 561 // Needed for ndk_prebuilt_(shared|static)_stl. 562 "prebuilts/ndk/current/sources/cxx-stl/llvm-libc++/libs": nil, 563 }.AddToFixture(), 564) 565 566// Preparer that will define default cc modules, e.g. standard prebuilt modules. 567var PrepareForTestWithCcDefaultModules = android.GroupFixturePreparers( 568 PrepareForTestWithCcBuildComponents, 569 570 // Additional files needed in tests that disallow non-existent source. 571 android.MockFS{ 572 "defaults/cc/common/libc.map.txt": nil, 573 "defaults/cc/common/libdl.map.txt": nil, 574 "defaults/cc/common/libm.map.txt": nil, 575 "defaults/cc/common/ndk_libandroid_support": nil, 576 "defaults/cc/common/ndk_libc++_shared": nil, 577 "defaults/cc/common/crtbegin_so.c": nil, 578 "defaults/cc/common/crtbegin.c": nil, 579 "defaults/cc/common/crtend_so.c": nil, 580 "defaults/cc/common/crtend.c": nil, 581 "defaults/cc/common/crtbrand.c": nil, 582 583 "defaults/cc/common/libclang_rt.ubsan_minimal.android_arm64.a": nil, 584 "defaults/cc/common/libclang_rt.ubsan_minimal.android_arm.a": nil, 585 "defaults/cc/common/libclang_rt.ubsan_minimal.x86_64.a": nil, 586 "defaults/cc/common/libclang_rt.ubsan_minimal.x86.a": nil, 587 }.AddToFixture(), 588 589 // Place the default cc test modules that are common to all platforms in a location that will not 590 // conflict with default test modules defined by other packages. 591 android.FixtureAddTextFile(DefaultCcCommonTestModulesDir+"Android.bp", commonDefaultModules()), 592 // Disable linux bionic by default. 593 android.FixtureAddTextFile(linuxBionicDefaultsPath, withoutLinuxBionic()), 594) 595 596// Prepare a fixture to use all cc module types, mutators and singletons fully. 597// 598// This should only be used by tests that want to run with as much of the build enabled as possible. 599var PrepareForIntegrationTestWithCc = android.GroupFixturePreparers( 600 android.PrepareForIntegrationTestWithAndroid, 601 genrule.PrepareForIntegrationTestWithGenrule, 602 PrepareForTestWithCcDefaultModules, 603) 604 605// The preparer to include if running a cc related test for windows. 606var PrepareForTestOnWindows = android.GroupFixturePreparers( 607 // Place the default cc test modules for windows platforms in a location that will not conflict 608 // with default test modules defined by other packages. 609 android.FixtureAddTextFile("defaults/cc/windows/Android.bp", withWindowsModules()), 610) 611 612// The preparer to include if running a cc related test for linux bionic. 613var PrepareForTestOnLinuxBionic = android.GroupFixturePreparers( 614 // Enable linux bionic 615 // 616 // Can be used after PrepareForTestWithCcDefaultModules to override its default behavior of 617 // disabling linux bionic, hence why this uses FixtureOverrideTextFile. 618 android.FixtureOverrideTextFile(linuxBionicDefaultsPath, withLinuxBionic()), 619) 620 621// This adds some additional modules and singletons which might negatively impact the performance 622// of tests so they are not included in the PrepareForIntegrationTestWithCc. 623var PrepareForTestWithCcIncludeVndk = android.GroupFixturePreparers( 624 PrepareForIntegrationTestWithCc, 625 android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) { 626 snapshot.VendorSnapshotImageSingleton.Init(ctx) 627 snapshot.RecoverySnapshotImageSingleton.Init(ctx) 628 RegisterVendorSnapshotModules(ctx) 629 RegisterRecoverySnapshotModules(ctx) 630 ctx.RegisterSingletonType("vndk-snapshot", VndkSnapshotSingleton) 631 }), 632) 633 634// PrepareForTestWithHostMusl sets the host configuration to musl libc instead of glibc. It also disables the test 635// on mac, which doesn't support musl libc, and adds musl modules. 636var PrepareForTestWithHostMusl = android.GroupFixturePreparers( 637 android.FixtureModifyConfig(android.ModifyTestConfigForMusl), 638 android.PrepareForSkipTestOnMac, 639 android.FixtureAddTextFile("external/musl/Android.bp", ` 640 cc_defaults { 641 name: "libc_musl_crt_defaults", 642 host_supported: true, 643 device_supported: false, 644 } 645 646 cc_object { 647 name: "libc_musl_crtbegin_so", 648 defaults: ["libc_musl_crt_defaults"], 649 } 650 651 cc_object { 652 name: "libc_musl_crtend_so", 653 defaults: ["libc_musl_crt_defaults"], 654 } 655 656 cc_object { 657 name: "libc_musl_crtbegin_dynamic", 658 defaults: ["libc_musl_crt_defaults"], 659 } 660 661 cc_object { 662 name: "libc_musl_crtbegin_static", 663 defaults: ["libc_musl_crt_defaults"], 664 } 665 666 cc_object { 667 name: "libc_musl_crtend", 668 defaults: ["libc_musl_crt_defaults"], 669 } 670 `), 671) 672 673// PrepareForTestWithFdoProfile registers module types to test with fdo_profile 674var PrepareForTestWithFdoProfile = android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) { 675 ctx.RegisterModuleType("soong_namespace", android.NamespaceFactory) 676 ctx.RegisterModuleType("fdo_profile", fdoProfileFactory) 677}) 678 679// TestConfig is the legacy way of creating a test Config for testing cc modules. 680// 681// See testCc for an explanation as to how to stop using this deprecated method. 682// 683// deprecated 684func TestConfig(buildDir string, os android.OsType, env map[string]string, 685 bp string, fs map[string][]byte) android.Config { 686 687 // add some modules that are required by the compiler and/or linker 688 bp = bp + GatherRequiredDepsForTest(os) 689 690 mockFS := map[string][]byte{} 691 692 GatherRequiredFilesForTest(mockFS) 693 694 for k, v := range fs { 695 mockFS[k] = v 696 } 697 698 return android.TestArchConfig(buildDir, env, bp, mockFS) 699} 700 701// CreateTestContext is the legacy way of creating a TestContext for testing cc modules. 702// 703// See testCc for an explanation as to how to stop using this deprecated method. 704// 705// deprecated 706func CreateTestContext(config android.Config) *android.TestContext { 707 ctx := android.NewTestArchContext(config) 708 genrule.RegisterGenruleBuildComponents(ctx) 709 ctx.RegisterModuleType("cc_fuzz", LibFuzzFactory) 710 ctx.RegisterModuleType("cc_test", TestFactory) 711 ctx.RegisterModuleType("cc_test_library", TestLibraryFactory) 712 ctx.RegisterModuleType("filegroup", android.FileGroupFactory) 713 ctx.RegisterModuleType("vndk_prebuilt_shared", VndkPrebuiltSharedFactory) 714 715 snapshot.VendorSnapshotImageSingleton.Init(ctx) 716 snapshot.RecoverySnapshotImageSingleton.Init(ctx) 717 RegisterVendorSnapshotModules(ctx) 718 RegisterRecoverySnapshotModules(ctx) 719 ctx.RegisterSingletonType("vndk-snapshot", VndkSnapshotSingleton) 720 RegisterVndkLibraryTxtTypes(ctx) 721 722 ctx.PreArchMutators(android.RegisterDefaultsPreArchMutators) 723 android.RegisterPrebuiltMutators(ctx) 724 RegisterRequiredBuildComponentsForTest(ctx) 725 726 return ctx 727} 728 729func checkSnapshotIncludeExclude(t *testing.T, ctx *android.TestContext, singleton android.TestingSingleton, moduleName, snapshotFilename, subDir, variant string, include bool, fake bool) { 730 t.Helper() 731 mod := ctx.ModuleForTests(moduleName, variant) 732 outputFiles := mod.OutputFiles(t, "") 733 if len(outputFiles) != 1 { 734 t.Errorf("%q must have single output\n", moduleName) 735 return 736 } 737 snapshotPath := filepath.Join(subDir, snapshotFilename) 738 739 if include { 740 out := singleton.Output(snapshotPath) 741 if fake { 742 if out.Rule == nil { 743 t.Errorf("Missing rule for module %q output file %q", moduleName, outputFiles[0]) 744 } 745 } else { 746 if out.Input.String() != outputFiles[0].String() { 747 t.Errorf("The input of snapshot %q must be %q, but %q", moduleName, out.Input.String(), outputFiles[0]) 748 } 749 } 750 } else { 751 out := singleton.MaybeOutput(snapshotPath) 752 if out.Rule != nil { 753 t.Errorf("There must be no rule for module %q output file %q", moduleName, outputFiles[0]) 754 } 755 } 756} 757 758func CheckSnapshot(t *testing.T, ctx *android.TestContext, singleton android.TestingSingleton, moduleName, snapshotFilename, subDir, variant string) { 759 t.Helper() 760 checkSnapshotIncludeExclude(t, ctx, singleton, moduleName, snapshotFilename, subDir, variant, true, false) 761} 762 763func CheckSnapshotExclude(t *testing.T, ctx *android.TestContext, singleton android.TestingSingleton, moduleName, snapshotFilename, subDir, variant string) { 764 t.Helper() 765 checkSnapshotIncludeExclude(t, ctx, singleton, moduleName, snapshotFilename, subDir, variant, false, false) 766} 767 768func CheckSnapshotRule(t *testing.T, ctx *android.TestContext, singleton android.TestingSingleton, moduleName, snapshotFilename, subDir, variant string) { 769 t.Helper() 770 checkSnapshotIncludeExclude(t, ctx, singleton, moduleName, snapshotFilename, subDir, variant, true, true) 771} 772 773func AssertExcludeFromVendorSnapshotIs(t *testing.T, ctx *android.TestContext, name string, expected bool, variant string) { 774 t.Helper() 775 m := ctx.ModuleForTests(name, variant).Module().(LinkableInterface) 776 if m.ExcludeFromVendorSnapshot() != expected { 777 t.Errorf("expected %q ExcludeFromVendorSnapshot to be %t", m.String(), expected) 778 } 779} 780 781func GetOutputPaths(ctx *android.TestContext, variant string, moduleNames []string) (paths android.Paths) { 782 for _, moduleName := range moduleNames { 783 module := ctx.ModuleForTests(moduleName, variant).Module().(*Module) 784 output := module.outputFile.Path().RelativeToTop() 785 paths = append(paths, output) 786 } 787 return paths 788} 789 790func AssertExcludeFromRecoverySnapshotIs(t *testing.T, ctx *android.TestContext, name string, expected bool, variant string) { 791 t.Helper() 792 m := ctx.ModuleForTests(name, variant).Module().(LinkableInterface) 793 if m.ExcludeFromRecoverySnapshot() != expected { 794 t.Errorf("expected %q ExcludeFromRecoverySnapshot to be %t", m.String(), expected) 795 } 796} 797 798func checkOverrides(t *testing.T, ctx *android.TestContext, singleton android.TestingSingleton, jsonPath string, expected []string) { 799 t.Helper() 800 out := singleton.MaybeOutput(jsonPath) 801 content := android.ContentFromFileRuleForTests(t, out) 802 803 var flags snapshotJsonFlags 804 if err := json.Unmarshal([]byte(content), &flags); err != nil { 805 t.Errorf("Error while unmarshalling json %q: %s", jsonPath, err.Error()) 806 return 807 } 808 809 for _, moduleName := range expected { 810 if !android.InList(moduleName, flags.Overrides) { 811 t.Errorf("expected %q to be in %q: %q", moduleName, flags.Overrides, content) 812 return 813 } 814 } 815} 816