this.executer = executer
        this.testDir = testDir
    }

    String initScriptContent() {
    }

    void afterBuild() {
    }

    Statement apply(Statement base, FrameworkMethod method, Object target) {
        def temporaryFolder = testDir.testDirectory
        def initFile = temporaryFolder.file(this.getClass().getSimpleName() + "-init.gradle")

            }
        """
        executer.requireIsolatedDaemons()
        executer.requireDaemon()

        when:
        // Message is UTF-8
        executer.useOnlyRequestedJvmOpts()
        executer.withBuildJvmOpts("-Dfile.encoding=CP1250")
        succeeds("writer")
        then:
        file("build/message.txt").text == "? ? ? ?"

        when:
        executer.withBuildJvmOpts("-Dfile.encoding=UTF-8")

    def "does not configure build when action does not query any models"() {
        setupBuild()

        when:
        def model = withConnection {
            def executer = action(new NoOpAction())
            collectOutputs(executer)
            executer.run()
        }

        then:
        model == "result"

        and:
        assertHasConfigureSuccessfulLogging()
        result.assertNotOutput(prefix)
    }

import org.gradle.api.Action
import org.gradle.integtests.fixtures.executer.AbstractGradleExecuter
import org.gradle.integtests.fixtures.executer.ExecutionFailure
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.integtests.fixtures.executer.GradleDistribution
import org.gradle.integtests.fixtures.executer.OutputScrapingExecutionResult

        when:
        GradleExecuter executer = prepareWrapperExecuter(current, previous).withWarningMode(null)

        then:
        checkWrapperWorksWith(executer, previous)

        cleanup:
        cleanupDaemons(executer, previous)
    }

    void checkWrapperWorksWith(GradleExecuter executer, GradleDistribution executionVersion) {
        def result = executer.usingExecutable('gradlew').withTasks('hello').run()

        executer.withArguments(
            "wrapper",
            "--gradle-distribution-url",
            distributionUri.toString(),
        )
        keyStore.trustStoreArguments.each {
            executer.withArgument(it)
        }
        executer.run()
    }

    GradleExecuter getWrapperExecuter() {
        executer.requireOwnGradleUserHomeDir()
        executer.requireIsolatedDaemons()
        executer.beforeExecute {

import org.gradle.integtests.fixtures.executer.AbstractGradleExecuter
import org.gradle.integtests.fixtures.executer.ExecutionFailure
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.integtests.fixtures.executer.GradleDistribution
import org.gradle.integtests.fixtures.executer.GradleExecuter

        String expectedJavaHome = "-PexpectedJavaHome=${javaHome}"

        then:
        // Handle JAVA_HOME specified
        executer.withJavaHome(javaHome).withArguments(expectedJavaHome).withTasks('checkJavaHome').run()

        // Handle JAVA_HOME with trailing separator
        executer.withJavaHome(javaHome + File.separator).withArguments(expectedJavaHome).withTasks('checkJavaHome').run()

        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) {