buildFile.writelns("apply plugin: 'java'")
        testFile("src/main/java/org/gradle/broken.java") << "broken"

        ExecutionFailure failure = executer.withTasks("build").runWithFailure()

        failure.assertHasDescription("Execution failed for task ':compileJava'.")
        failure.assertHasCause("Compilation failed; see the compiler error output for details.")
    }

    @Test

    def setup() {
        NativeServicesTestFixture.initialize()
    }

    def "has non zero exit code on build failure"() {
        ExecutionFailure failure = executer.withTasks('unknown').runWithFailure()
        failure.assertHasDescription("Task 'unknown' not found in root project 'commandLine'.")
    }

    def createProject() {
        buildFile """
            import org.gradle.internal.jvm.Jvm

                .withTasks("compileJava")
                .requireOwnGradleUserHomeDir("needs to be able to provision fresh toolchains")
                .withToolchainDownloadEnabled()
                .runWithFailure()

        then:
        failure.assertHasDescription("Could not determine the dependencies of task ':compileJava'.")
               .assertHasCause("Could not resolve all dependencies for configuration ':compileClasspath'.")

        prepareWrapper(new URI(gradleBin))

        and:
        file(WRAPPER_PROPERTIES_PATH) << 'distributionSha256Sum=bad'

        when:
        def failure = wrapperExecuter.withStackTraceChecksDisabled().runWithFailure()
        def f = new File(file("user-home/wrapper/dists/gradle-bin").listFiles()[0], "gradle-bin.zip")

        then:
        failure.error.contains("""
Verification of Gradle distribution failed!

        50.times {
            executer.usingProjectDirectory(projectdir)
                    .withTasks("tasks")
                    .runWithFailure()
        }
    }

        given:
        prepareWrapper()

        expect:
        def failure = wrapperExecuter.withTasks("wrapper", "--gradle-version", badVersion).runWithFailure()

        and:
        failure.assertHasDescription("Invalid version specified for argument '--gradle-version'")

${mavenCentralRepository()}
dependencies { testImplementation 'org.testng:testng:6.3.1' }

test {
    reports.html.required = false
    useTestNG()
}
"""
        when:
        executer.withTasks('test').runWithFailure().assertTestsFailed()

        then:
        !new TestNGExecutionResult(file(".")).hasTestNGXmlResults()
        new JUnitXmlTestExecutionResult(file(".")).hasJUnitXmlResults()
    }

        }
    }
"""
    }

    void "has non-zero exit code on build failure"() {
        given:
        prepareWrapper()

        when:
        def failure = wrapperExecuter.withTasks('unknown').runWithFailure()

        then:
        failure.assertThatDescription(CoreMatchers.startsWith("Task 'unknown' not found in root project"))
    }

    @Issue("https://github.com/gradle/gradle/issues/16055")

        given:
        precompiledGroovyPluginBuiltWith(version(getCurrent()))

        when:
        def result = pluginTaskExecutedWith(version(getPrevious())).runWithFailure()

        then:
        result.assertHasDescription("An exception occurred applying plugin request [id: '$PLUGIN_ID', version: '1.0']")
        result.assertHasCause("Failed to apply plugin [id '$PLUGIN_ID']")

        return BuildOperationsAssertions(buildOperations, output, true)
    }

    protected
    fun configureProjectAndExpectCompileFailure(expectedFailure: String) {
        val error = executer.runWithFailure().error
        MatcherAssert.assertThat(error, CoreMatchers.containsString(expectedFailure))
    }