def location = URI.create("scheme:name")
        def failure = new RuntimeException()

        expect:
        def e = ResourceExceptions.failure(location, "broken", failure)
        e instanceof ResourceException
        e.location == location
        e.message == "broken"
        e.cause == failure
    }

    def "wraps failure with different location"() {
        def location = URI.create("scheme:name")

    }

    def "transports exception with broken methods"() {
        def broken = new CompletelyBrokenException()

        when:
        def transported = transport(broken)

        then:
        transported.class == CompletelyBrokenException
    }

    def "transports unserializable exception with broken methods"() {
        def broken = new CompletelyBrokenException() {

            withProblem("Task `:declared` of type `Broken`: cannot deserialize object of type 'org.gradle.api.artifacts.ConfigurationContainer' as these are not supported with the configuration cache.")

        e.message == 'No result has been specified.'
    }

    def "cannot get id when resolve failed"() {
        org.gradle.internal.Factory<String> broken = { "too bad" }
        def failure = new ModuleVersionResolveException(newSelector(DefaultModuleIdentifier.newId("a", "b"), "c"), broken)

        when:
        result.failed(failure)
        result.moduleVersionId

        then:
        ModuleVersionResolveException e = thrown()

        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'.")

 */
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: ]]>'))