}
        """
    }

    @Override
    List<String> getPluginList() {
        ['objective-c']
    }

    SourceFile getBrokenFile() {
        return sourceFile("objc", "broken.m", """'broken""")
    }

    @Override
    String getSourceSetType() {
        return "ObjectiveCSourceSet"
    }

    }

    def "build fails when compilation fails"() {
        given:
        makeSingleProject()

        and:
        file("src/main/swift/broken.swift") << "broken!"

        expect:
        fails "assemble"
        failure.assertHasDescription("Execution failed for task '$developmentBinaryCompileTask'.")
        failure.assertHasCause("A build operation failed.")

        then:
        succeeds("test")

        when:
        testSourceFile << " broken "

        then:
        buildTriggeredAndFailed()
        failureDescriptionStartsWith("Execution failed for task ':compileTestJava'.")

        when:
        sourceFile << " broken "

        then:
        buildTriggeredAndFailed()

        ex.evaluationCycle.size() == 2
        // Have to use reference check because owner's equals is broken
        ex.evaluationCycle[0] === owner
        ex.evaluationCycle[1] === owner

        where:
        evaluator << [evaluateInLambda(), evaluateInBlock()]
    }

    def "can handle owner with broken equals in tryEvaluate"() {
        given:
        owner.equals(_) >> { false }

        when:

        when:
        buildScript '''
            class ThrowingRule extends RuleSource {
                @Mutate
                void badRule(Task echo) {
                    throw new RuntimeException("I'm broken")
                }
            }

            class Rules extends RuleSource {
                @Mutate
                void addTasks(ModelMap<Task> tasks) {

        then:
        output.value == '[message]\n'
    }

    def formatsException() {
        when:
        output.exception(new RuntimeException('broken'))

        then:
        output.value == 'java.lang.RuntimeException: broken\n{stacktrace}\n'
    }

    def canMixInStyleInformation() {
        when:
        output.style(Style.Info).text('info test').style(Style.Normal)

        then:

        1 * details.producerValue >> "value2"
        1 * details.compatible()
    }

    static class BrokenRule implements AttributeCompatibilityRule<String> {
        static failure = new RuntimeException("broken")

        @Override
        void execute(CompatibilityCheckDetails<String> details) {
            throw failure
        }
    }

    def "wraps failure to execute rule"() {

            }
        """
    }

    @Override
    List<String> getPluginList() {
        ['objective-cpp']
    }

    SourceFile getBrokenFile() {
        return sourceFile("objcpp", "broken.mm", """'broken""")
    }

    @Override
    String getSourceSetType() {
        return "ObjectiveCppSourceSet"
    }

        when:
        processor.testClassFinished(null)

        then:
        1 * target.completed(1, {it.endTime == 1300})
        0 * target._
    }

    def "synthesises a broken test when test class fails and no tests have been started"() {
        def failure = TestFailure.fromTestFrameworkFailure(new RuntimeException())

        given:
        idGenerator.generateId() >>> [1, 2]

        and:

        """
        file("inc/settings.gradle") << """
            include 'sub'
        """
        file("inc/sub/build.gradle") << """
            gradle.buildFinished { }
            tasks.register('broken') {
                inputs.property('p', project).optional(true)
                doLast { t -> t.project }
            }
        """

        when:
        configurationCacheFails ":inc:sub:broken"