.printWorkingDir()
            .writeTo(testDirectory, "script")

        def workingDir = testDirectory.createDir("workdir")

        buildFile """
            def execProvider = providers.exec {
                ${cmdToExecConfig(*testScript.commandLine)}
                workingDir("${TextUtil.escapeString(workingDir.path)}")
            }

            println(execProvider.standardOutput.asText.get())

    def exec() {
        File testFile = tmpDir.file("someFile")

        when:
        ExecResult result = factory.exec { spec ->
            spec.executable = "touch"
            spec.workingDir = tmpDir.getTestDirectory()
            spec.args testFile.name
        }

        then:
        testFile.isFile()
        result.exitValue == 0
    }

    @Requires(UnitTestPreconditions.NotWindows)

            </tr>
            <tr>
                <td>executable</td>
                <td><filename>java</filename> executable for current JVM</td>
            </tr>
            <tr>
                <td>workingDir</td>
                <td><literal>project.projectDir</literal></td>
            </tr>
            <tr>
                <td>environment</td>
                <td>Current process' environment</td>
            </tr>

            </tr>
            <tr>
                <td>classpath</td>
                <td><literal>project.sourceSets.test.runtimeClasspath</literal></td>
            </tr>
            <tr>
                <td>workingDir</td>
                <td><literal>project.projectDir</literal></td>
            </tr>
            <tr>
                <td>scanForTestClasses</td>
                <td><literal>true</literal></td>
            </tr>

            }
        """

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

        }
    }

    private DaemonStartupInfo startProcess(List<String> args, File workingDir, File gradleUserHome, InputStream stdInput) {
        LOGGER.debug("Starting daemon process: workingDir = {}, daemonArgs: {}", workingDir, args);
        Timer clock = Time.startTimer();
        try {
            GFileUtils.mkdirs(workingDir);

            DaemonOutputConsumer outputConsumer = new DaemonOutputConsumer();

        options.executable == null
        !options.environment.empty
    }

    def resolvesWorkingDirectoryOnGet() {
        when:
        options.workingDir = 12

        then:
        1 * resolver.resolve(12) >> baseDir
        options.workingDir == baseDir
    }

    def convertsEnvironmentToString() {
        when:
        options.environment = [key1: 12, key2: "${1+2}", key3: null]

        then:

    @Subject factory = new WorkerDaemonFactory(clientsManager, buildOperationRunner, workerDaemonClientCancellationHandler)

    def workingDir = new File("some-dir")
    def projectCacheDir = new File("some-cache-dir")
    def options = Stub(DaemonForkOptions)
    def requirement = new ForkedWorkerRequirement(workingDir, projectCacheDir, options)
    def spec = Stub(IsolatedParametersActionExecutionSpec)

    def setup() {

        System.getenv("TEST_ENV_2") == null
    }

    @Requires(UnitTestPreconditions.WorkingDir)
    def "can get working directory of current process"() {
        expect:
        env.processDir.canonicalFile == new File('.').canonicalFile
    }

    @Requires(UnitTestPreconditions.WorkingDir)
    def "can get set working directory of current process"() {

        super(testClass);
    }

    @Override
    protected CommandExecutor selectExecutor(ExecutionMetadata executionMetadata, File workingDir, Command command) {
        return new IntegrationTestSamplesExecutor(workingDir, command.isExpectFailure());
    }

    @Nullable
    @Override
    protected File getImplicitSamplesRootDir() {