executer.inDirectory(relativeDir).run()

        then:
        noExceptionThrown()
    }

    @Requires(UnitTestPreconditions.CaseInsensitiveFs)
    def "canonicalizes working directory on case insensitive file system"() {
        testProject()

        when:
        def mixedCaseDir = new File(testDirectory, "JAVA/QuickStart")
        executer.inDirectory(mixedCaseDir).run()

        println 'finished the nap...'
    }
}
"""

        when:
        def sleeper = executer.withArguments('-i').withTasks('sleep').start()

        then:
        poll(60) {
            assert readLog(executer.daemonBaseDir).contains("taking a nap...")
        }

        when:
        executer.withArguments("--stop").run()

        then:
        sleeper.waitForFailure()

        poll(5, 1) {

        this.executer = executer
        this.testDir = testDir
    }

    String initScriptContent() {
    }

    void afterBuild() {
    }

    Statement apply(Statement base, FrameworkMethod method, Object target) {
        configureExecuter(executer)
        return base
    }

    void configureExecuter(GradleExecuter executer) {

        def executer = buildContext.distribution(gradleVersion).executer(temporaryFolder, getBuildContext())
        executer.inDirectory(projectDir)
        executer.withTasks(tasks)
        executers << executer
        executer
    }

        """

        when:
        run("installDist")

        def out = new ByteArrayOutputStream()
        def executer = new ScriptExecuter()
        executer.workingDir = testDirectory
        executer.standardOutput = out
        executer.commandLine = "build/install/test/bin/test"
        def result = executer.run()
        then:
        result.assertNormalExitValue()

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.executer.ExecutionFailure

class InternalGradleFailuresIntegrationTest extends AbstractIntegrationSpec {

    def setup() {
        executer.requireIsolatedDaemons()
        executer.requireOwnGradleUserHomeDir()
        executer.requireDaemon()

        buildScript """
            task hello() {
                doLast {

        when:
        executer.withJavaHome(AvailableJavaHomes.differentJdk.javaHome)
        executer.withArguments("--stop").run()

        then:
        stopsSingleDaemon()
    }

    def "reports exact number of daemons stopped and keeps console output clean"() {
        given:
        executer.noExtraLogging()
        executer.run()

        when:

import org.gradle.integtests.fixtures.executer.GradleHandle
import org.gradle.test.fixtures.ConcurrentTestUtil

abstract class DaemonIntegrationSpec extends AbstractIntegrationSpec {
    def setup() {
        executer.requireDaemon()
        executer.requireIsolatedDaemons()
    }

    void stopDaemonsNow() {
        result = executer.withArguments("--stop", "--info").run()
    }

        // Gradle needs to be isolated so that msbuild does not leave behind daemons
        assert executer.distribution.gradleHomeDir != null
        assert !executer.usesSharedDaemons()
        def executer = new MSBuildExecutor(testDirectory, toolChain)
        executer.withArgument('/p:Platform=Win32')
        return executer
    }

    protected SolutionFile solutionFile(String path) {
        return solutionFile(file(path))

        }
    }

    def "forTasks sets empty list correctly"() {
        when:
        executer.forTasks([])

        then:
        executer.operationParamsBuilder.tasks == []

        when:
        executer.forTasks(Collections.emptySet())

        then:
        executer.operationParamsBuilder.tasks == []
    }