Quelle  afdo_test.go   Sprache: unbekannt

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

package cc

import (
 "runtime"
 "strings"
 "testing"

 "android/soong/android"
)

func TestAfdoDeps(t *testing.T) {
 t.Parallel()
 bp := `
 cc_library_shared {
  name: "libTest",
  host_supported: true,
  srcs: ["test.c"],
  static_libs: ["libFoo"],
  afdo: true,
  lto: {
   thin: true,
  },
 }

 cc_library_static {
  name: "libFoo",
  host_supported: true,
  srcs: ["foo.c"],
  static_libs: ["libBar"],
 }

 cc_library_static {
  name: "libBar",
  host_supported: true,
  srcs: ["bar.c"],
 }
 `

 result := android.GroupFixturePreparers(
  PrepareForTestWithFdoProfile,
  prepareForCcTest,
  android.FixtureAddTextFile("afdo_profiles_package/libTest.afdo", ""),
  android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
   variables.AfdoProfiles = []string{
    "libTest://afdo_profiles_package:libTest_afdo",
   }
  }),
  android.MockFS{
   "afdo_profiles_package/Android.bp": []byte(`
    fdo_profile {
     name: "libTest_afdo",
     arch: {
      arm64: {
       profile: "libTest.afdo",
      },
     },
    }
   `),
  }.AddToFixture(),
 ).RunTestWithBp(t, bp)

 profileSampleCFlag := "-fprofile-sample-use=afdo_profiles_package/libTest.afdo"
 uniqueInternalLinkageNamesCFlag := "-funique-internal-linkage-names"
 afdoLtoLdFlag := "-Wl,-plugin-opt,-import-instr-limit=40"
 noAfdoLtoLdFlag := "-Wl,-plugin-opt,-import-instr-limit=5"

 libTest := result.ModuleForTests(t, "libTest", "android_arm64_armv8-a_shared")
 libFooAfdoVariant := result.ModuleForTests(t, "libFoo", "android_arm64_armv8-a_static_afdo-libTest")
 libBarAfdoVariant := result.ModuleForTests(t, "libBar", "android_arm64_armv8-a_static_afdo-libTest")

 // Check cFlags of afdo-enabled module and the afdo-variant of its static deps
 cFlags := libTest.Rule("cc").Args["cFlags"]
 if !strings.Contains(cFlags, profileSampleCFlag) {
  t.Errorf("Expected 'libTest' to enable afdo profile, but did not find %q in cflags %q", profileSampleCFlag, cFlags)
 }
 if !strings.Contains(cFlags, uniqueInternalLinkageNamesCFlag) {
  t.Errorf("Expected 'libTest' to enable afdo, but did not find %q in cflags %q", profileSampleCFlag, cFlags)
 }

 ldFlags := libTest.Rule("ld").Args["ldFlags"]
 if !strings.Contains(ldFlags, afdoLtoLdFlag) {
  t.Errorf("Expected 'libTest' to enable afdo, but did not find %q in ldflags %q", afdoLtoLdFlag, ldFlags)
 }

 cFlags = libFooAfdoVariant.Rule("cc").Args["cFlags"]
 if !strings.Contains(cFlags, profileSampleCFlag) {
  t.Errorf("Expected 'libFooAfdoVariant' to enable afdo profile, but did not find %q in cflags %q", profileSampleCFlag, cFlags)
 }
 if !strings.Contains(cFlags, uniqueInternalLinkageNamesCFlag) {
  t.Errorf("Expected 'libFooAfdoVariant' to enable afdo, but did not find %q in cflags %q", profileSampleCFlag, cFlags)
 }

 cFlags = libBarAfdoVariant.Rule("cc").Args["cFlags"]
 if !strings.Contains(cFlags, profileSampleCFlag) {
  t.Errorf("Expected 'libBarAfdoVariant' to enable afdo profile, but did not find %q in cflags %q", profileSampleCFlag, cFlags)
 }
 if !strings.Contains(cFlags, uniqueInternalLinkageNamesCFlag) {
  t.Errorf("Expected 'libBarAfdoVariant' to enable afdo, but did not find %q in cflags %q", profileSampleCFlag, cFlags)
 }

 // Check dependency edge from afdo-enabled module to static deps
 if !android.HasDirectDep(result, libTest.Module(), libFooAfdoVariant.Module()) {
  t.Errorf("libTest missing dependency on afdo variant of libFoo")
 }

 if !android.HasDirectDep(result, libFooAfdoVariant.Module(), libBarAfdoVariant.Module()) {
  t.Errorf("libTest missing dependency on afdo variant of libBar")
 }

 // Verify non-afdo variant exists and doesn't contain afdo
 libFoo := result.ModuleForTests(t, "libFoo", "android_arm64_armv8-a_static")
 libBar := result.ModuleForTests(t, "libBar", "android_arm64_armv8-a_static")

 cFlags = libFoo.Rule("cc").Args["cFlags"]
 if strings.Contains(cFlags, profileSampleCFlag) {
  t.Errorf("Expected 'libFoo' to not enable afdo profile, but found %q in cflags %q", profileSampleCFlag, cFlags)
 }
 if strings.Contains(cFlags, uniqueInternalLinkageNamesCFlag) {
  t.Errorf("Expected 'libFoo' to not enable afdo, but found %q in cflags %q", profileSampleCFlag, cFlags)
 }
 cFlags = libBar.Rule("cc").Args["cFlags"]
 if strings.Contains(cFlags, profileSampleCFlag) {
  t.Errorf("Expected 'libBar' to not enable afdo profile, but found %q in cflags %q", profileSampleCFlag, cFlags)
 }
 if strings.Contains(cFlags, uniqueInternalLinkageNamesCFlag) {
  t.Errorf("Expected 'libBar' to not enable afdo, but found %q in cflags %q", profileSampleCFlag, cFlags)
 }

 // Check dependency edges of static deps
 if android.HasDirectDep(result, libTest.Module(), libFoo.Module()) {
  t.Errorf("libTest should not depend on non-afdo variant of libFoo")
 }

 if !android.HasDirectDep(result, libFoo.Module(), libBar.Module()) {
  t.Errorf("libFoo missing dependency on non-afdo variant of libBar")
 }

 // Verify that the arm variant does not have FDO since the fdo_profile module only has a profile for arm64
 libTest32 := result.ModuleForTests(t, "libTest", "android_arm_armv7-a-neon_shared")
 libFooAfdoVariant32 := result.ModuleForTests(t, "libFoo", "android_arm_armv7-a-neon_static_afdo-libTest_lto-thin")
 libBarAfdoVariant32 := result.ModuleForTests(t, "libBar", "android_arm_armv7-a-neon_static_afdo-libTest_lto-thin")

 cFlags = libTest32.Rule("cc").Args["cFlags"]
 if strings.Contains(cFlags, profileSampleCFlag) {
  t.Errorf("Expected arm32 'libTest' not to enable afdo, but found %q in cflags %q", profileSampleCFlag, cFlags)
 }

 // TODO(b/324141705): when the fdo_profile module doesn't provide a source file the dependencies don't get
 //  -funique-internal-linkage-names but the module does.
 if !strings.Contains(cFlags, uniqueInternalLinkageNamesCFlag) {
  t.Errorf("Expected arm32 'libTest' to enable -funique-internal-linkage-names but did not find %q in cflags %q",
   uniqueInternalLinkageNamesCFlag, cFlags)
 }

 ldFlags = libTest32.Rule("ld").Args["ldFlags"]
 if !strings.Contains(ldFlags, noAfdoLtoLdFlag) {
  t.Errorf("Expected arm32 'libTest' to not enable afdo, but did not find %q in ldflags %q", noAfdoLtoLdFlag, ldFlags)
 }
 if strings.Contains(ldFlags, afdoLtoLdFlag) {
  t.Errorf("Expected arm32 'libTest' to not enable afdo, but found %q in ldflags %q", afdoLtoLdFlag, ldFlags)
 }

 // Check dependency edge from afdo-enabled module to static deps
 if !android.HasDirectDep(result, libTest32.Module(), libFooAfdoVariant32.Module()) {
  t.Errorf("arm32 libTest missing dependency on afdo variant of libFoo")
 }

 if !android.HasDirectDep(result, libFooAfdoVariant32.Module(), libBarAfdoVariant32.Module()) {
  t.Errorf("arm32 libTest missing dependency on afdo variant of libBar")
 }

 cFlags = libFooAfdoVariant32.Rule("cc").Args["cFlags"]
 if strings.Contains(cFlags, profileSampleCFlag) {
  t.Errorf("Expected arm32 'libFoo' to not enable afdo profile, but found %q in cflags %q", uniqueInternalLinkageNamesCFlag, cFlags)
 }
 if !strings.Contains(cFlags, uniqueInternalLinkageNamesCFlag) {
  t.Errorf("Expected arm32 'libFoo' to enable afdo, but did not find %q in cflags %q", uniqueInternalLinkageNamesCFlag, cFlags)
 }
 cFlags = libBarAfdoVariant32.Rule("cc").Args["cFlags"]
 if strings.Contains(cFlags, profileSampleCFlag) {
  t.Errorf("Expected arm32 'libBar' to not enable afdo profile, but found %q in cflags %q", uniqueInternalLinkageNamesCFlag, cFlags)
 }
 if !strings.Contains(cFlags, uniqueInternalLinkageNamesCFlag) {
  t.Errorf("Expected arm32 'libBar' to enable afdo, but did not find %q in cflags %q", uniqueInternalLinkageNamesCFlag, cFlags)
 }

 // Verify that the host variants don't enable afdo
 libTestHost := result.ModuleForTests(t, "libTest", result.Config.BuildOSTarget.String()+"_shared")
 libFooHost := result.ModuleForTests(t, "libFoo", result.Config.BuildOSTarget.String()+"_static_lto-thin")
 libBarHost := result.ModuleForTests(t, "libBar", result.Config.BuildOSTarget.String()+"_static_lto-thin")

 cFlags = libTestHost.Rule("cc").Args["cFlags"]
 if strings.Contains(cFlags, profileSampleCFlag) {
  t.Errorf("Expected host 'libTest' to not enable afdo profile, but found %q in cflags %q", profileSampleCFlag, cFlags)
 }

 if strings.Contains(cFlags, uniqueInternalLinkageNamesCFlag) {
  t.Errorf("Expected host 'libTest' to not enable afdo but found %q in cflags %q",
   uniqueInternalLinkageNamesCFlag, cFlags)
 }

 if runtime.GOOS != "darwin" {
  ldFlags := libTestHost.Rule("ld").Args["ldFlags"]
  if !strings.Contains(ldFlags, noAfdoLtoLdFlag) {
   t.Errorf("Expected host 'libTest' to not enable afdo, but did not find %q in ldflags %q", noAfdoLtoLdFlag, ldFlags)
  }
  if strings.Contains(ldFlags, afdoLtoLdFlag) {
   t.Errorf("Expected host 'libTest' to not enable afdo, but found %q in ldflags %q", afdoLtoLdFlag, ldFlags)
  }
 }

 // Check dependency edge from afdo-enabled module to static deps
 if !android.HasDirectDep(result, libTestHost.Module(), libFooHost.Module()) {
  t.Errorf("host libTest missing dependency on non-afdo variant of libFoo")
 }

 if !android.HasDirectDep(result, libFooHost.Module(), libBarHost.Module()) {
  t.Errorf("host libTest missing dependency on non-afdo variant of libBar")
 }

 cFlags = libFooHost.Rule("cc").Args["cFlags"]
 if strings.Contains(cFlags, profileSampleCFlag) {
  t.Errorf("Expected host 'libFoo' to not enable afdo profile, but found %q in cflags %q", uniqueInternalLinkageNamesCFlag, cFlags)
 }
 if strings.Contains(cFlags, uniqueInternalLinkageNamesCFlag) {
  t.Errorf("Expected host 'libFoo' to not enable afdo, but found %q in cflags %q", uniqueInternalLinkageNamesCFlag, cFlags)
 }
 cFlags = libBarHost.Rule("cc").Args["cFlags"]
 if strings.Contains(cFlags, profileSampleCFlag) {
  t.Errorf("Expected host 'libBar' to not enable afdo profile, but found %q in cflags %q", uniqueInternalLinkageNamesCFlag, cFlags)
 }
 if strings.Contains(cFlags, uniqueInternalLinkageNamesCFlag) {
  t.Errorf("Expected host 'libBar' to not enable afdo, but found %q in cflags %q", uniqueInternalLinkageNamesCFlag, cFlags)
 }
}

func TestAfdoEnabledOnStaticDepNoAfdo(t *testing.T) {
 t.Parallel()
 bp := `
 cc_library_shared {
  name: "libTest",
  srcs: ["foo.c"],
  static_libs: ["libFoo"],
 }

 cc_library_static {
  name: "libFoo",
  srcs: ["foo.c"],
  static_libs: ["libBar"],
  afdo: true, // TODO(b/256670524): remove support for enabling afdo from static only libraries, this can only propagate from shared libraries/binaries
 }

 cc_library_static {
  name: "libBar",
 }
 `

 result := android.GroupFixturePreparers(
  prepareForCcTest,
  PrepareForTestWithFdoProfile,
  android.FixtureAddTextFile("toolchain/pgo-profiles/sampling/libFoo.afdo", ""),
  android.MockFS{
   "afdo_profiles_package/Android.bp": []byte(`
    soong_namespace {
    }
    fdo_profile {
     name: "libFoo_afdo",
     profile: "libFoo.afdo",
    }
   `),
  }.AddToFixture(),
 ).RunTestWithBp(t, bp)

 libTest := result.ModuleForTests(t, "libTest", "android_arm64_armv8-a_shared").Module()
 libFoo := result.ModuleForTests(t, "libFoo", "android_arm64_armv8-a_static")
 libBar := result.ModuleForTests(t, "libBar", "android_arm64_armv8-a_static").Module()

 if !android.HasDirectDep(result, libTest, libFoo.Module()) {
  t.Errorf("libTest missing dependency on non-afdo variant of libFoo")
 }

 if !android.HasDirectDep(result, libFoo.Module(), libBar) {
  t.Errorf("libFoo missing dependency on non-afdo variant of libBar")
 }

 fooVariants := result.ModuleVariantsForTests("foo")
 for _, v := range fooVariants {
  if strings.Contains(v, "afdo-") {
   t.Errorf("Expected no afdo variant of 'foo', got %q", v)
  }
 }

 cFlags := libFoo.Rule("cc").Args["cFlags"]
 if w := "-fprofile-sample-accurate"; strings.Contains(cFlags, w) {
  t.Errorf("Expected 'foo' to not enable afdo, but found %q in cflags %q", w, cFlags)
 }

 barVariants := result.ModuleVariantsForTests("bar")
 for _, v := range barVariants {
  if strings.Contains(v, "afdo-") {
   t.Errorf("Expected no afdo variant of 'bar', got %q", v)
  }
 }
}

func TestAfdoEnabledWithRuntimeDepNoAfdo(t *testing.T) {
 bp := `
 cc_library {
  name: "libTest",
  srcs: ["foo.c"],
  runtime_libs: ["libFoo"],
  afdo: true,
 }

 cc_library {
  name: "libFoo",
 }
 `

 result := android.GroupFixturePreparers(
  prepareForCcTest,
  PrepareForTestWithFdoProfile,
  android.FixtureAddTextFile("afdo_profiles_package/libTest.afdo", ""),
  android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
   variables.AfdoProfiles = []string{
    "libTest://afdo_profiles_package:libTest_afdo",
   }
  }),
  android.MockFS{
   "afdo_profiles_package/Android.bp": []byte(`
    fdo_profile {
     name: "libTest_afdo",
     profile: "libTest.afdo",
    }
   `),
  }.AddToFixture(),
 ).RunTestWithBp(t, bp)

 libFooVariants := result.ModuleVariantsForTests("libFoo")
 for _, v := range libFooVariants {
  if strings.Contains(v, "afdo-") {
   t.Errorf("Expected no afdo variant of 'foo', got %q", v)
  }
 }
}

func TestAfdoEnabledWithMultiArchs(t *testing.T) {
 bp := `
 cc_library_shared {
  name: "foo",
  srcs: ["test.c"],
  afdo: true,
  compile_multilib: "both",
 }
`
 result := android.GroupFixturePreparers(
  PrepareForTestWithFdoProfile,
  prepareForCcTest,
  android.FixtureAddTextFile("afdo_profiles_package/foo_arm.afdo", ""),
  android.FixtureAddTextFile("afdo_profiles_package/foo_arm64.afdo", ""),
  android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
   variables.AfdoProfiles = []string{
    "foo://afdo_profiles_package:foo_afdo",
   }
  }),
  android.MockFS{
   "afdo_profiles_package/Android.bp": []byte(`
    soong_namespace {
    }
    fdo_profile {
     name: "foo_afdo",
     arch: {
      arm: {
       profile: "foo_arm.afdo",
      },
      arm64: {
       profile: "foo_arm64.afdo",
      }
     }
    }
   `),
  }.AddToFixture(),
 ).RunTestWithBp(t, bp)

 fooArm := result.ModuleForTests(t, "foo", "android_arm_armv7-a-neon_shared")
 fooArmCFlags := fooArm.Rule("cc").Args["cFlags"]
 if w := "-fprofile-sample-use=afdo_profiles_package/foo_arm.afdo"; !strings.Contains(fooArmCFlags, w) {
  t.Errorf("Expected 'foo' to enable afdo, but did not find %q in cflags %q", w, fooArmCFlags)
 }

 fooArm64 := result.ModuleForTests(t, "foo", "android_arm64_armv8-a_shared")
 fooArm64CFlags := fooArm64.Rule("cc").Args["cFlags"]
 if w := "-fprofile-sample-use=afdo_profiles_package/foo_arm64.afdo"; !strings.Contains(fooArm64CFlags, w) {
  t.Errorf("Expected 'foo' to enable afdo, but did not find %q in cflags %q", w, fooArm64CFlags)
 }
}

func TestMultipleAfdoRDeps(t *testing.T) {
 t.Parallel()
 bp := `
 cc_library_shared {
  name: "libTest",
  srcs: ["test.c"],
  static_libs: ["libFoo"],
  afdo: true,
 }

 cc_library_shared {
  name: "libBar",
  srcs: ["bar.c"],
  static_libs: ["libFoo"],
  afdo: true,
 }

 cc_library_static {
  name: "libFoo",
  srcs: ["foo.c"],
 }
 `

 result := android.GroupFixturePreparers(
  PrepareForTestWithFdoProfile,
  prepareForCcTest,
  android.FixtureAddTextFile("afdo_profiles_package/libTest.afdo", ""),
  android.FixtureAddTextFile("afdo_profiles_package/libBar.afdo", ""),
  android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
   variables.AfdoProfiles = []string{
    "libTest://afdo_profiles_package:libTest_afdo",
    "libBar://afdo_profiles_package:libBar_afdo",
   }
  }),
  android.MockFS{
   "afdo_profiles_package/Android.bp": []byte(`
    fdo_profile {
     name: "libTest_afdo",
     profile: "libTest.afdo",
    }
    fdo_profile {
     name: "libBar_afdo",
     profile: "libBar.afdo",
    }
   `),
  }.AddToFixture(),
 ).RunTestWithBp(t, bp)

 expectedCFlagLibTest := "-fprofile-sample-use=afdo_profiles_package/libTest.afdo"
 expectedCFlagLibBar := "-fprofile-sample-use=afdo_profiles_package/libBar.afdo"

 libTest := result.ModuleForTests(t, "libTest", "android_arm64_armv8-a_shared")
 libFooAfdoVariantWithLibTest := result.ModuleForTests(t, "libFoo", "android_arm64_armv8-a_static_afdo-libTest")

 libBar := result.ModuleForTests(t, "libBar", "android_arm64_armv8-a_shared")
 libFooAfdoVariantWithLibBar := result.ModuleForTests(t, "libFoo", "android_arm64_armv8-a_static_afdo-libBar")

 // Check cFlags of afdo-enabled module and the afdo-variant of its static deps
 cFlags := libTest.Rule("cc").Args["cFlags"]
 if !strings.Contains(cFlags, expectedCFlagLibTest) {
  t.Errorf("Expected 'libTest' to enable afdo, but did not find %q in cflags %q", expectedCFlagLibTest, cFlags)
 }
 cFlags = libBar.Rule("cc").Args["cFlags"]
 if !strings.Contains(cFlags, expectedCFlagLibBar) {
  t.Errorf("Expected 'libTest' to enable afdo, but did not find %q in cflags %q", expectedCFlagLibBar, cFlags)
 }

 cFlags = libFooAfdoVariantWithLibTest.Rule("cc").Args["cFlags"]
 if !strings.Contains(cFlags, expectedCFlagLibTest) {
  t.Errorf("Expected 'libFooAfdoVariantWithLibTest' to enable afdo, but did not find %q in cflags %q", expectedCFlagLibTest, cFlags)
 }

 cFlags = libFooAfdoVariantWithLibBar.Rule("cc").Args["cFlags"]
 if !strings.Contains(cFlags, expectedCFlagLibBar) {
  t.Errorf("Expected 'libBarAfdoVariant' to enable afdo, but did not find %q in cflags %q", expectedCFlagLibBar, cFlags)
 }

 // Check dependency edges of static deps
 if !android.HasDirectDep(result, libTest.Module(), libFooAfdoVariantWithLibTest.Module()) {
  t.Errorf("libTest missing dependency on afdo variant of libFoo")
 }

 if !android.HasDirectDep(result, libBar.Module(), libFooAfdoVariantWithLibBar.Module()) {
  t.Errorf("libFoo missing dependency on non-afdo variant of libBar")
 }
}

func TestAfdoDepsWithoutProfile(t *testing.T) {
 t.Parallel()
 bp := `
 cc_library_shared {
  name: "libTest",
  srcs: ["test.c"],
  static_libs: ["libFoo"],
  afdo: true,
 }

 cc_library_static {
  name: "libFoo",
  srcs: ["foo.c"],
  static_libs: ["libBar"],
 }

 cc_library_static {
  name: "libBar",
  srcs: ["bar.c"],
 }
 `

 result := android.GroupFixturePreparers(
  PrepareForTestWithFdoProfile,
  prepareForCcTest,
 ).RunTestWithBp(t, bp)

 // Even without a profile path, the afdo enabled libraries should be built with
 // -funique-internal-linkage-names.
 expectedCFlag := "-funique-internal-linkage-names"

 libTest := result.ModuleForTests(t, "libTest", "android_arm64_armv8-a_shared")
 libFooAfdoVariant := result.ModuleForTests(t, "libFoo", "android_arm64_armv8-a_static_afdo-libTest")
 libBarAfdoVariant := result.ModuleForTests(t, "libBar", "android_arm64_armv8-a_static_afdo-libTest")

 // Check cFlags of afdo-enabled module and the afdo-variant of its static deps
 cFlags := libTest.Rule("cc").Args["cFlags"]
 if !strings.Contains(cFlags, expectedCFlag) {
  t.Errorf("Expected 'libTest' to enable afdo, but did not find %q in cflags %q", expectedCFlag, cFlags)
 }

 cFlags = libFooAfdoVariant.Rule("cc").Args["cFlags"]
 if !strings.Contains(cFlags, expectedCFlag) {
  t.Errorf("Expected 'libFooAfdoVariant' to enable afdo, but did not find %q in cflags %q", expectedCFlag, cFlags)
 }

 cFlags = libBarAfdoVariant.Rule("cc").Args["cFlags"]
 if !strings.Contains(cFlags, expectedCFlag) {
  t.Errorf("Expected 'libBarAfdoVariant' to enable afdo, but did not find %q in cflags %q", expectedCFlag, cFlags)
 }
 // Check dependency edge from afdo-enabled module to static deps
 if !android.HasDirectDep(result, libTest.Module(), libFooAfdoVariant.Module()) {
  t.Errorf("libTest missing dependency on afdo variant of libFoo")
 }

 if !android.HasDirectDep(result, libFooAfdoVariant.Module(), libBarAfdoVariant.Module()) {
  t.Errorf("libTest missing dependency on afdo variant of libBar")
 }

 // Verify non-afdo variant exists and doesn't contain afdo
 libFoo := result.ModuleForTests(t, "libFoo", "android_arm64_armv8-a_static")
 libBar := result.ModuleForTests(t, "libBar", "android_arm64_armv8-a_static")

 cFlags = libFoo.Rule("cc").Args["cFlags"]
 if strings.Contains(cFlags, expectedCFlag) {
  t.Errorf("Expected 'libFoo' to not enable afdo, but found %q in cflags %q", expectedCFlag, cFlags)
 }
 cFlags = libBar.Rule("cc").Args["cFlags"]
 if strings.Contains(cFlags, expectedCFlag) {
  t.Errorf("Expected 'libBar' to not enable afdo, but found %q in cflags %q", expectedCFlag, cFlags)
 }

 // Check dependency edges of static deps
 if android.HasDirectDep(result, libTest.Module(), libFoo.Module()) {
  t.Errorf("libTest should not depend on non-afdo variant of libFoo")
 }

 if !android.HasDirectDep(result, libFoo.Module(), libBar.Module()) {
  t.Errorf("libFoo missing dependency on non-afdo variant of libBar")
 }
}

func TestAfdoIncompleteCoverage(t *testing.T) {
 t.Parallel()
 bp := `
 cc_library_shared {
  name: "libTestWithCompleteCoverage",
  srcs: ["test.c"],
  afdo: true,
 }

 cc_library_shared {
  name: "libTestWithIncompleteCoverage",
  srcs: ["test.c"],
  afdo: true,
 }
 `

 result := android.GroupFixturePreparers(
  PrepareForTestWithFdoProfile,
  prepareForCcTest,
  android.FixtureAddTextFile("afdo_profiles_package/libTestWithCompleteCoverage.afdo", ""),
  android.FixtureAddTextFile("afdo_profiles_package/libTestWithIncompleteCoverage.afdo", ""),
  android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
   variables.AfdoProfiles = []string{
    "libTestWithCompleteCoverage://afdo_profiles_package:libTestWithCompleteCoverage_afdo",
    "libTestWithIncompleteCoverage://afdo_profiles_package:libTestWithIncompleteCoverage_afdo",
   }
  }),
  android.MockFS{
   "afdo_profiles_package/Android.bp": []byte(`
    fdo_profile {
     name: "libTestWithCompleteCoverage_afdo",
     arch: {
      arm64: {
       profile: "libTestWithCompleteCoverage.afdo",
      },
     },
    }
    fdo_profile {
     name: "libTestWithIncompleteCoverage_afdo",
     arch: {
      arm64: {
       profile: "libTestWithIncompleteCoverage.afdo",
      },
     },
     incomplete_coverage: true,
    }
   `),
  }.AddToFixture(),
 ).RunTestWithBp(t, bp)

 profileSampleAccurateFlag := "-fprofile-sample-accurate"
 profileSampleInaccurateFlag := "-fno-profile-sample-accurate"

 // Test module with complete coverage (default)
 libComplete := result.ModuleForTests(t, "libTestWithCompleteCoverage", "android_arm64_armv8-a_shared")
 cFlagsComplete := libComplete.Rule("cc").Args["cFlags"]
 if !strings.Contains(cFlagsComplete, profileSampleAccurateFlag) {
  t.Errorf("Expected 'libTestWithCompleteCoverage' to have %q in cflags %q", profileSampleAccurateFlag, cFlagsComplete)
 }
 ldFlagsComplete := libComplete.Rule("ld").Args["ldFlags"]
 if !strings.Contains(ldFlagsComplete, profileSampleAccurateFlag) {
  t.Errorf("Expected 'libTestWithCompleteCoverage' to have %q in ldflags %q", profileSampleAccurateFlag, ldFlagsComplete)
 }

 // Test module with incomplete coverage
 libIncomplete := result.ModuleForTests(t, "libTestWithIncompleteCoverage", "android_arm64_armv8-a_shared")
 cFlagsIncomplete := libIncomplete.Rule("cc").Args["cFlags"]
 if !strings.Contains(cFlagsIncomplete, profileSampleInaccurateFlag) {
  t.Errorf("Expected 'libTestWithIncompleteCoverage' to have %q in cflags %q", profileSampleInaccurateFlag, cFlagsIncomplete)
 }
 ldFlagsIncomplete := libIncomplete.Rule("ld").Args["ldFlags"]
 if !strings.Contains(ldFlagsIncomplete, profileSampleInaccurateFlag) {
  t.Errorf("Expected 'libTestWithIncompleteCoverage' to have %q in ldflags %q", profileSampleInaccurateFlag, ldFlagsIncomplete)
 }
}