succeeds("run")

        then:
        def output = result.groupedOutput.task(':run').output
        output.contains(EXPECTED_OUTPUT)
        def errorOutput = errorsShouldAppearOnStdout() ? output : result.getError()
        errorOutput.contains(EXPECTED_ERROR)
    }

    def "JavaExec task output is grouped with its task output"() {
        given:

    private final OutputStream errorOutput;
    private final boolean readErrorStream;
    private final CountDownLatch completed;
    private Executor executor;
    private volatile ExecOutputHandleRunner standardOutputReader;
    private volatile ExecOutputHandleRunner standardErrorReader;

    public OutputStreamsForwarder(OutputStream standardOutput, OutputStream errorOutput, boolean readErrorStream) {

        ((targetStream == "System.out") ? output : errorOutput).contains("Hello, Gradle")

        where:
        task       | taskProperty     | sourceStream | targetStream
        "exec"     | "standardOutput" | "System.out" | "System.out"
        "exec"     | "standardOutput" | "System.out" | "System.err"
        "exec"     | "errorOutput"    | "System.err" | "System.out"
        "exec"     | "errorOutput"    | "System.err" | "System.err"

        if (outputStream == null) {
            throw new IllegalArgumentException("outputStream == null!");
        }
        errorOutput = outputStream;
        return this;
    }

    public OutputStream getErrorOutput() {
        return errorOutput;
    }

        execOps.exec {
            executable = javaExecutable.get().asFile.absolutePath
            args = ["-version"]
            standardOutput = outputBytes
            errorOutput = outputBytes
        }
        assert outputBytes.toString("UTF-8").contains("version \"11"):
            "unexpected '${javaExecutable.get().asFile.absolutePath} -version' output"
    }
}

        execOps.exec {
            executable = javaExecutable.get().asFile.absolutePath
            args = listOf("-version")
            standardOutput = outputBytes
            errorOutput = outputBytes
        }
        require(outputBytes.toString("UTF-8").contains("version \"11")) {
            "unexpected '${javaExecutable.get().asFile.absolutePath} -version' output"
        }
    }
}

        fails "customTask"

        failureHasCause(~/Failed to store cache entry $CACHE_KEY_PATTERN for task ':customTask': Could not pack tree 'output': Expected '${escapeString(file('build/output'))}' to be a file/)
        errorOutput =~ /Could not pack tree 'output'/
        def cacheKey = cacheOperations.getCacheKeyForTask(":customTask")
        !localCache.hasCacheEntry(cacheKey)
        localCache.listCacheTempFiles().empty
    }

        execOps.exec {
            commandLine = ["git", "clone", "--no-checkout", remoteUri, checkoutDir.absolutePath]
            errorOutput = System.out
        }
        execOps.exec {
            commandLine = ["git", "checkout", ref]
            workingDir = checkoutDir
            errorOutput = System.out
        }
        return checkoutDir
    }

        given:
        file("settings$settingScriptExtension") << use

        when:
        fails 'help'

        then:
        errorOutput.contains("plugins")

        where:
        settingScriptExtension | use
        '.gradle.kts'          | "plugins { } \n plugins { }"
    }

        builder.standardOutput = new ByteArrayOutputStream()
        builder.errorOutput = new ByteArrayOutputStream()

        def result = builder.run()
        result.assertNormalExitValue()

        assert builder.standardOutput.toString().contains('Greetings from the sample application.')
        assert builder.errorOutput.toString() == ''
    }