$lastOutput

Error:
${gradle.errorOutput}

Look for additional thread dump files in the following folder: $temporaryFolder
""")
        }

        def out = buildOutputSoFar()
        def err = gradle.errorOutput.substring(errorOutputBuildMarker)
        standardOutputBuildMarker = gradle.standardOutput.length()
        errorOutputBuildMarker = gradle.errorOutput.length()

        parseResults(out, err)

        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() == ''
    }

            </tr>
            <tr>
                <td>standardInput</td>
            </tr>
            <tr>
                <td>standardOutput</td>
            </tr>
            <tr>
                <td>errorOutput</td>
            </tr>
            <tr>
                <td>ignoreExitValue</td>
            </tr>
            <tr>
                <td>executionResult</td>
            </tr>
        </table>
    </section>

            ByteArrayOutputStream errorOutput = new ByteArrayOutputStream();
            String mainClassname = Files.getNameWithoutExtension(probe.getName());
            exec.args("-Xmx32m", "-Xms32m", "-cp", ".", mainClassname);
            exec.setStandardOutput(out);
            exec.setErrorOutput(errorOutput);
            exec.setIgnoreExitValue(true);

    @Override
    public OutputStream getErrorOutput() {
        return streamsSpec.getErrorOutput();
    }

    @Override
    public JavaExecSpec setErrorOutput(OutputStream errorOutput) {
        streamsSpec.setErrorOutput(errorOutput);
        return this;
    }

    @Override
    public ListProperty<String> getJvmArguments() {
        return jvmArguments;
    }

    @Override

            action.execute(spec)
            spec.standardOutput.write("output".getBytes(Charset.defaultCharset()))
            spec.standardOutput.close()
            spec.errorOutput.write("error".getBytes(Charset.defaultCharset()))
            spec.errorOutput.close()
            return Stub(ExecResult) {
                getExitValue() >> 0
            }
        }

        when:

        }

        def targetJdk = selectJdk(target)

        when:
        withInstallations(currentJdk, otherJdk).run(":javadoc")

        then:
        executedAndNotSkipped(":javadoc")
        errorOutput.contains(targetJdk.javaVersion.toString())

        where:
        // Some cases are skipped, because the executable (when configured) must match the resulting toolchain, otherwise the build fails

        file("broken.jar").text = "this is not a jar"
        file("src/main/${language.name}/Main.${language.name}") << "public class Main {}"

        expect:
        fails(language.compileTaskName)
        errorOutput.contains("zip END header not found")
    }

        when:
        fails ":compileJava"

        then:
        errorOutput.contains("> Could not resolve all dependencies for configuration ':compileClasspath'.")
        errorOutput.contains("   > Dependency verification cannot be performed")
        errorOutput.contains("      > Unable to read dependency verification metadata from")

            ${mavenCentralRepository()}
        """

        file("src/main/java/org/gradle/ruleusing/Class1.java") << breakingDefaultRulesCode()

        expect:
        fails(":pmdMain")
        errorOutput.contains("PMD rule violations were found")
    }

    private static breakingDefaultRulesCode() {
        """
            package org.gradle.ruleusing;

            public final class Class1 {