*/

package org.gradle.integtests.fixtures.executer;

public class UnexpectedBuildFailure extends RuntimeException {
    public UnexpectedBuildFailure(String message) {
        super(message);
    }

    public UnexpectedBuildFailure(Throwable e) {
        super(e);
    }

    public UnexpectedBuildFailure(String message, Throwable e) {
        super(message, e);
    }

/**
 * Thrown when executing a build that was expected to succeed, but failed.
 *
 * @since 2.6
 * @see GradleRunner#build()
 */
public class UnexpectedBuildFailure extends UnexpectedBuildResultException {
    public UnexpectedBuildFailure(String message, BuildResult buildResult) {
        super(message, buildResult);
    }

        1 * execHandle.getCommand() >> EXEC_HANDLE_CMD
        1 * execHandle.getArguments() >> EXEC_HANDLE_ARGS
        1 * execResult.toString() >> executionResultMessage
        def t = thrown(UnexpectedBuildFailure)
        normaliseLineSeparators(t.message) == createUnexpectedBuildFailureMessage('failed', executionResultMessage)
    }

    def "wait for failure for failed execution"() {
        when:

        if (!gradle.isRunning()) {
            throw new UnexpectedBuildFailure("Gradle has exited")
        }
        waitForBuild()
        throwOnBuildFailure()
        result
    }

    private void throwOnBuildFailure() {
        if (result instanceof ExecutionFailure) {
            throw new UnexpectedBuildFailure("""build was expected to succeed but failed:
-- STDOUT --
${result.output}

        try {
            createExecuter(args, flags).withArgument("--rerun-tasks").run();
        } catch (UnexpectedBuildFailure e) {
            UnexpectedBuildFailure tweakedException = new UnexpectedBuildFailure("Failed to rerun the build when reusing the configuration cache entry.\n" + e.getMessage());
            tweakedException.setStackTrace(e.getStackTrace());

        given:
        buildScript helloWorldTask()

        when:
        runner('helloWorld', '--unknown').build()

        then:
        thrown UnexpectedBuildFailure
    }

    def "treats invalid argument as build failure and does not throw if expected"() {
        given:
        buildScript helloWorldTask()

        when:

                }
            }
        """

        when:
        def runner = this.runner('helloWorld')
        runner.build()

        then:
        UnexpectedBuildFailure t = thrown(UnexpectedBuildFailure)
        String expectedMessage = """Unexpected build execution failure in ${testDirectory.canonicalPath} with arguments ${runner.arguments}

Output:
$t.buildResult.output"""

        if (result instanceof ExecutionFailure) {
            throw new UnexpectedBuildFailure("build was expected to succeed but failed")
        }
        failure = null
        result
    }

    ExecutionFailure fails() {
        waitForBuild()
        if (!(result instanceof ExecutionFailure)) {
            throw new UnexpectedBuildFailure("build was expected to fail but succeeded")
        }

 */

package gradlebuild.binarycompatibility

import org.gradle.kotlin.dsl.*
import org.gradle.testkit.runner.BuildResult
import org.gradle.testkit.runner.GradleRunner
import org.gradle.testkit.runner.UnexpectedBuildFailure
import org.hamcrest.CoreMatchers
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Rule
import org.junit.rules.TemporaryFolder

import org.gradle.integtests.fixtures.executer.GradleExecuter
import org.gradle.integtests.fixtures.executer.GradleHandle
import org.gradle.integtests.fixtures.executer.UnexpectedBuildFailure
import spock.lang.Specification


class ContinuousIntegrationTestFixtureTest extends Specification {
    def gradleExecuter = Stub(GradleExecuter)

    def "successful build should be parsed"() {