</tr>
            <tr>
                <td>standardOutput</td>
                <td><literal>System.out</literal></td>
            </tr>
            <tr>
                <td>errorOutput</td>
                <td><literal>System.err</literal></td>
            </tr>
            <tr>
                <td>ignoreExitValue</td>
                <td><literal>false</literal></td>
            </tr>

        given:
        configureForVersion(version)

        when:
        executer.withStackTraceChecksDisabled()
        fails("runInDaemon")

        then:
        errorOutput.contains("Unsupported worker JDK version. Required: 8. Current: ${version.majorVersion}")

        where:
        // We can't test against Java 6 since the gradleApi dependencies are compiled to java 8.

        !outputWithoutFailure.contains("Build failed with an exception.")
        !outputWithoutFailure.contains("* What went wrong:")

        outputWithFailureAndNoDebugging.contains(buildFailed.errorOutput)

        where:
        level << [LogLevel.DEBUG, LogLevel.INFO, LogLevel.LIFECYCLE, LogLevel.WARN, LogLevel.QUIET]
    }

    def "reports task execution statistics on build failure with log level #level"() {

        then:
        outputContains("projects evaluated")
        output.matches("""(?s).*
1 actionable task: 1 executed.*
failure message: Execution failed for task ':t'.
.*""")

        errorOutput.contains("projects evaluated")
        result.error.matches("""(?s)projects evaluated

FAILURE: Build failed with an exception\\..*
BUILD FAILED in [ \\dms]+
notified
\$""")
    }

    }

    def "show reasonable error message for invalid configuration property"() {
        when:
        propertiesFile << "org.gradle.welcome=foo"
        fails()

        then:
        errorOutput.contains("Option org.gradle.welcome doesn't accept value 'foo'. Possible values are [ONCE, NEVER]")
    }

    def "abort rendering welcome message using configuration property"() {
        when:

assert configurations.names as List == ['repositories', 'someConf'] // side effect is that the configuration is actually created
assert repositories.size() == 1
"""

        expect:
        fails "help"
        errorOutput.contains("Could not find method maven() for arguments")
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)

                jacoco {
                    destinationFile = provider { null }
                }
            }
        """

        when:
        runAndFail("test")

        then:
        errorOutput.contains("JaCoCo destination file must not be null if output type is FILE")
    }

    def "jacoco plugin adds outgoing variants for default test suite"() {
        settingsFile << "rootProject.name = 'Test'"

    // expected
}
"""
        buildFile << 'task doStuff'

        when:
        run('doStuff')

        then:
        output.contains('quiet message')
        errorOutput.contains('error message')
    }

    private TestFile createBuildSrc() {
        return file('buildSrc/src/main/java/BuildSrcClass.java') << '''
            public class BuildSrcClass { }
        '''
    }

        testExecution.waitForAllPendingCalls()

        then:
        testExecution.release(DEFAULT_MAX_WORKERS)
        gradleHandle.waitForFailure()

        assert !gradleHandle.errorOutput.contains('No tests found for given includes:')
    }

    fun runDistributionBuild(checkoutDir: File, os: OutputStream) {
        execOps.exec {
            commandLine(*getBuildCommands())
            workingDir = checkoutDir
            standardOutput = os
            errorOutput = os
        }
    }

    private
    fun copyToFinalDestination(checkoutDir: File) {
        val baseVersion = commitBaseline.get().substringBefore("-")