given:
        def scriptFailure = new GradleScriptException("broken", new RuntimeException())
        def otherFailure1 = new RuntimeException("broken")
        def otherFailure2 = new RuntimeException("broken")
        def failure = new ProjectConfigurationException("broken", [scriptFailure, otherFailure1, otherFailure2])
        def analyser = analyser()
        def result = []

            include "child"
        """
        file("child/build.gradle") << """
            class Broken extends DefaultTask {
                Broken() {
                    throw new RuntimeException("broken task")
                }
            }
            tasks.create("broken", Broken)
        """

        expect:
        fails()
        failure.assertHasLineNumber(4)

Expected: A failure description which is a string starting with "broken!"
     but: failure descriptions were []''')

        when:
        failure.assertHasCause("broken!")

        then:
        def e3 = thrown(AssertionError)
        e3.message.trim().startsWith('''No matching cause found
Expected: A cause which is a string starting with "broken!"
     but: causes were []''')

        when:

        """
        file("child/build.gradle") << """
            class Broken extends DefaultTask {
                Broken() {
                    throw new RuntimeException("broken task")
                }
            }
            tasks.register("broken", Broken)
        """

        expect:
        fails("broken")
        failure.assertHasDescription("A problem occurred configuring project ':child'.")

	if a != b {
		panic("broken equality: a != b")
	}

	m[a] = 1
	m[b] = 2
	if len(m) == 2 {
		panic("broken hash: len(m) == 2")
	}
	if m[a] != 2 {
		panic("m[a] != 2")
	}
}

func test3() {
	var a, b USmall
	copy((*[12]byte)(unsafe.Pointer(&a))[:], "hello world!")
	a.A, a.B = 1, 2
	b.A, b.B = 1, 2
	if a != b {
		panic("broken equality: a != b")
	}
}

func test4() {

-- go.mod --
module m

-- x.go --
package x

-- x_test.go --
package x
import "testing"
import _ "net/http"
func Test(t *testing.T) {}

-- broken/go.mod --
module broken
-- broken/http.go --
package broken

import (
	_ "net/http"
	_ "golang.org/x/net/http2/hpack"
)

-- importcmd/go.mod --
module importcmd
-- importcmd/x.go --
package importcmd

 */
class TokenLookup {
    private Set<Expression> broken;
    private Multimap<Expression, Expression> tokensFor;

    boolean isUnresolved(Expression expression) {
        return broken != null && broken.contains(expression);
    }

    void unresolved(Expression expression) {
        if (broken == null) {
            broken = new HashSet<Expression>();
        }
        broken.add(expression);
    }

        result.testClass('org.gradle.BrokenTest')
            .assertTestCount(2, 2, 0)
            .assertTestFailed('failure', equalTo(failureAssertionError('failed')))
            .assertTestFailed('broken', equalTo('java.lang.IllegalStateException: html: <> cdata: ]]>'))

		wantOldText     = "[T] and [U] are types, and [T.M] is a method, but [V] is a broken link.\n[rand.Int] and [crand.Reader] are things. [G.M1] and [G.M2] are generic methods.\n"
		wantSynopsis    = "T and U are types, and T.M is a method, but [V] is a broken link."

            task other
            task broken(type: SomeTask)
        """

        when:
        configurationCacheRunLenient "broken"

        then:
        problems.assertResultHasProblems(result) {
            withTotalProblemsCount(6)
            withUniqueProblems(