local build_log="${docker_build_path}/build.log"
        if ! DOCKER_CLI_EXPERIMENTAL=enabled "${DOCKER[@]}" buildx build \
          -f "${docker_file_path}" \
          --platform linux/"${arch}" \
          --load ${docker_build_opts:+"${docker_build_opts}"} \
          -t "${docker_image_tag}" \
          --build-arg BASEIMAGE="${base_image}" \
          --build-arg SETCAP_IMAGE="${KUBE_BUILD_SETCAP_IMAGE}" \

                }
            }

            build.dependsOn resolve

            logger.lifecycle('from build.gradle')

            gradle.taskGraph.whenReady{
                logger.warn('warning from taskgraph')
            }
        """

        when:
        succeeds("build", '-I', 'init/init.gradle')

        then:

        outputContains build.expectedPropertyOutput()
        outputDoesNotContain "GradleProperties has not been loaded yet."

        where:
        build << GradlePropertiesIncludedBuildFixture.builds()
    }

    @Issue("https://github.com/gradle/gradle/issues/19184")
    def "system properties declared in properties of composite build"() {
        given:

					}

					// 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
			}
		}
	}

        // With included builds RUN_WORK event is not deterministic
        if (progressEvents[5].toString() == "Build phase: Run tasks started") {
            // Run root build tasks
            assertStartEventHas(progressEvents[5], "RUN_WORK", 0)
            // Run included build task
            assertStartEventHas(progressEvents[6], "RUN_WORK", 1)
        } else {
            // Run included build task

    api(project(":base-services"))
    api(project(":base-services-groovy"))
    api(project(":build-cache"))
    api(project(":build-cache-base"))
    api(project(":build-cache-local"))
    api(project(":build-cache-packaging"))
    api(project(":build-cache-spi"))
    api(project(":build-operations"))
    api(project(":build-option"))
    api(project(":cli"))
    api(project(":core-api"))
    api(project(":declarative-dsl-api"))

            println "user home dir: " + gradle.gradleUserHomeDir
            println "build script code source: " + getClass().protectionDomain.codeSource.location
        '''

        when:
        run 'otherBuild'

        then:
        output.contains("user home dir: $dir")
        output.contains("build script code source: ${dir.toURI()}")
    }

    def "nested build can have buildSrc"() {

                renderSectionTitle("Included builds");
                textOutput.println();
                renderer.startChildren();
                for (Path includedBuildIdentityPath : model.includedBuildIdentityPaths) {
                    renderer.visit(
                        text -> textOutput.text("Included build '" + includedBuildIdentityPath + "'"),

		if cachedCluster == nil {
			allFound = false
		}
		res = append(res, cachedCluster)
	}
	return res, allFound
}

// build does any final build operations needed, like marshaling etc.
func (mc *clusterWrapper) build() *cluster.Cluster {
	if mc == nil {
		return nil
	}
	// Marshall Http Protocol options if they exist.
	if mc.httpProtocolOptions != nil {

        file projectDir, "gradle.properties", generateGradleProperties(isRoot)

        file projectDir, config.dsl.fileNameFor('build'), generateBuildGradle(subProjectNumber)
    }

    static def generateLibProject(File projectDir) {
        file projectDir, KOTLIN.fileNameFor('build'), """
            plugins {
                id("java-library")
            }
        """.stripIndent()
    }