}
            }

            gradle.buildFinished {
                file("output.txt").text = output.toString()
            }
        """

        when:
        executer.withArguments("--debug")
        run("log")
        def captured = file("output.txt").text

        then:
        captured.contains("[DEBUG] [org.gradle.api.Task] debug")

                .withProjectDir(testProjectDir.root)
                .withArguments(task, "--stacktrace")
                .withPluginClasspath()
                .build()
    }

    fun runTaskWithFailure(task: String): BuildResult {
        return GradleRunner.create()
                .withProjectDir(testProjectDir.root)
                .withArguments(task, "--stacktrace")
                .withPluginClasspath()

        return SwiftPmRunner.create(swiftc)
            .withProjectDir(testDirectory)
            .withArguments("build")
            .build()
    }

    ExecOutput swiftPmBuildFails() {
        return SwiftPmRunner.create(swiftc)
                .withProjectDir(testDirectory)
                .withArguments("build")
                .buildAndFails()
    }

        executer.requireDaemon()
        executer.requireIsolatedDaemons()

        when:
        executer.withArguments("-D$NATIVE_SERVICES_OPTION=$firstRunNativeServicesOption")
        succeeds()

        then:
        daemons.daemon.becomesIdle()

        when:
        executer.withArguments("-D$NATIVE_SERVICES_OPTION=$secondRunNativeServicesOption")
        succeeds()

        then:

            plugins {
                id 'org.example.my-plugin'
            }
        """

        when:
        runner()
            .withArguments('--configuration-cache', 'myTask')    // <1>
            .build()

        and:
        def result = runner()
            .withArguments('--configuration-cache', 'myTask')    // <2>
            .build()

        then:

apply plugin: 'cpp'

model {
    toolChains {
        ${toolChain.id} {
            eachPlatform {
                cppCompiler.withArguments { args ->
                    Collections.replaceAll(args, "CUSTOM", "-DFRENCH")
                }
                linker.withArguments { args ->
                    args.remove "CUSTOM"
                }
            }
        }
    }
    components {

        """

        then:
        def handle1 = executer.withArguments(':a:build', '-i').start()
        poll(120) {
            assert handle1.standardOutput.contains('waiting for file...')
        }
        //first build is waiting for file, so the lock should be releasable now (for example: the task history lock)

        and:
        def handle2 = executer.withArguments('b:build', '-is').start()
        handle2.waitForFinish()

        given:
        prepareWrapper()
        def gradleUserHome = testDirectory.file('some-custom-user-home')

        when:
        def executer = wrapperExecuter.withGradleUserHomeDir(null)
        executer.withArguments("-Dgradle.user.home=$gradleUserHome.absolutePath")
        executer.run()

        then:
        installationIn gradleUserHome
    }

    @Issue('https://issues.gradle.org/browse/GRADLE-2802')

task retrieve(type: Sync) {
    from configurations.compile
    into 'libs'
}
"""
        and:
        module.pom.expectDownload()
        module.artifact.expectDownload()

        when:
        executer.withArguments(
                "-Dorg.gradle.s3.endpoint=${server.uri}",
                "-Dhttp.proxyHost=localhost",
                "-Dhttp.proxyPort=${proxyServer.port}",
                "-Dhttp.nonProxyHosts=foo",

        javaProject(file("a"))
        javaProject(file("b"), """
            dependencies {
                implementation(project(':a'))
            }
        """)

        when:
        executer.withArguments(ENABLE_CLI)
        runBuildAction(new FetchCustomModelForEachProjectInParallel())

        then:
        fixture.assertStateStored {
            projectsConfigured(":buildSrc", ":", ":a", ":b")