}

					// Poison a.Target to catch uses later in the build.
					a.Target = "DO NOT USE - main build pseudo-cache Target"
					a.built = "DO NOT USE - main build pseudo-cache built"
					if a.json != nil {
						a.json.BuildID = a.buildID
					}
					return true
				}
				// Otherwise restore old build ID for main build.
				a.buildID = oldBuildID
			}
		}
	}

}
"""
        includedBuilds << buildB
    }

    def "passes init-script arg to included build"() {
        given:
        [buildA, buildB].each {
            it.buildFile << """
    assert gradle.startParameter.initScripts.size() == 1
    assert project.initProperty == "foo"
"""
        }

        when:
        execute(buildA, ":jar", ["-I../gradle-user-home/init.gradle"])

        then:

    }

    def "includes build identifier in dependency report with #display"() {
        dependency "org.test:buildB:1.0"

        createDirs("buildB", "buildB/buildSrc", "buildB/buildSrc/b1", "buildB/buildSrc/b2")
        buildB.file("buildSrc/settings.gradle") << """
            $settings
            include 'b1', 'b2'
        """
        buildB.file("buildSrc/build.gradle") << """

        """.stripIndent()

        dependency 'org.test:buildB:1.0'

        BuildTestFile buildB = singleProjectBuild("buildB") {
            buildFile << """
                apply plugin: 'java'
            """.stripIndent()
        }
        includedBuilds << buildB

        buildA.file('version.txt') << '3.3'
        buildB.file('version.txt') << '3.4'

        executer.withGradleUserHomeDir(file('gradle-user-home'))

        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 << """