p1 := a1.Package
		if p1 != nil {
			if a1.built != "" || a1.buildID != "" {
				buildID := a1.buildID
				if buildID == "" {
					buildID = b.buildID(a1.built)
				}
				fmt.Fprintf(h, "packagefile %s=%s\n", p1.ImportPath, contentID(buildID))
			}
			// Because we put package main's full action ID into the binary's build ID,
			// we must also put the full action ID into the binary's action ID hash.

        def build1 = singleProjectBuild("build1") {
            buildFile << "task foo1"
        }
        def build2 = singleProjectBuild("build2") {
            buildFile << "task foo2"
        }

        when:
        def allProgress = new CopyOnWriteArrayList<String>()

        concurrent.start {
            def connector = toolingApi.connector(build1)

    }

    PerformanceTestHistory mockCrossBuildHistory() {
        BuildDisplayInfo info1 = buildDisplayInfo('build1')
        CrossBuildPerformanceResults result1  = crossBuildResults(startTime: 100)
        result1.buildResult(info1).addAll(measuredOperations([1]))

        BuildDisplayInfo info2 = buildDisplayInfo('build2')
        CrossBuildPerformanceResults result2  = crossBuildResults(startTime: 200)

        buildB.file("foo/.gitkeepdir").touch()
        buildB.file("bar/.gitkeepdir").touch()
        buildB.settingsFile << """
            rootProject.name = 'B'
            include 'foo', 'bar'
        """
        buildB.buildFile << """
            allprojects {
                apply plugin: 'java'
                group = 'org.test'
                version = '1.0'
            }
        """

  # command to reattempt build a few times in the case of failure (b/302558736)
  set +e
  for i in $(seq 1 5)
  do
    docker build \
    --build-arg REQUIREMENTS_FILE=jax.requirements.txt \
    --target=$target \
    --cache-from "$IMAGE" \
    -t "$IMAGE" -t "$AR_IMAGE" . && break
  done
  final=$?
  if [ $final -ne 0 ]; then
    exit $final
  fi
  set -e

            rootProject.name = 'buildB'
        """
        repo.file("build.gradle") << """
            apply plugin: 'java'
            group = 'org.test'
        """
        repo.commit("version 2")
        repo.createLightWeightTag("2.0")
    }

    @ToBeFixedForConfigurationCache
    def "source dependency builds are not visible to main build"() {
        given:
        buildFile << """

        def loadOps = operations.all(LoadBuildBuildOperationType)
        loadOps.size() == 2
        loadOps[0].displayName == "Load build"
        loadOps[0].details.buildPath == ":"
        loadOps[0].parentId == root.id
        loadOps[1].displayName == "Load build (:buildB)"
        loadOps[1].details.buildPath == ":buildB"
        loadOps[1].parentId == resolve.id

        def buildIdentifiedEvents = operations.progress(BuildIdentifiedProgressDetails)

    match_all = [
        ":is_cuda_enabled",
        ":windows",
    ],
)

# Config setting to use in select()s to distinguish open source build from
# google internal build on configurable attributes.
#
# For non-configurable distinction between OSS and Google builds, see
# `if_oss()` and `if_google()` macros in tensorflow.bzl.
config_setting(
    name = "oss",
    flag_values = {":oss_setting": "True"},

        when:
        def build = executer.withTasks("help").withArguments("--info").start()

        then:
        build.waitForFinish()

        and:
        daemons.daemons.size() == 2

        and:
        !build.standardOutput.contains(DaemonMessages.WAITING_ON_CANCELED)
    }

    def "starts a new daemon when daemons with canceled builds do not become available"() {
        buildFile << """

description = "Provides a set of plugins that are shared between the Gradle and build-logic builds"

tasks.register("check") {
    dependsOn(subprojects.map { "${it.name}:check" })