given:
        buildFile << """
            task broken() {
                doLast {
                    println "Hello"
                }
                timeout = Duration.ofMillis(-1)
            }
            """

        expect:
        2.times {
            fails "broken"
            failure.assertHasDescription("Execution failed for task ':broken'.")

// errorcheck

// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// issue 5172: spurious warn about type conversion on broken type inside go and defer

package main

type foo struct {
	x bar // ERROR "undefined"
}

type T struct{}

func (t T) Bar() {}

func main() {
	var f foo
	go f.bar()    // ERROR "undefined"

        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) {

        0 * visitor._
    }

    @Requires(UnitTestPreconditions.Jdk11OrLater)
    def "throws FileException on badly formed JAR"() {
        def visitor = Mock(ClasspathEntryVisitor)
        def file = tmpDir.file("broken").createFile()

        when:
        walker.visit(file, visitor)

        then:
        thrown(FileException)

        0 * visitor._
    }

        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"() {

// and the call to f smashed the register.

func f(n int) int {
	s := 0
	for i := 0; i < n; i++ {
		s += i>>1
	}
	return s
}

func main() {
	x := -f(100)
	if x != -2450 {
		println(x)
		panic("broken")
	}

            }
        """
    }

    @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: