e.cause instanceof RuntimeException
        e.cause.message == 'broken'
    }
}

class SomeType {
    final Object result

    SomeType(CharSequence result) {
        this.result = result
    }
}

class BrokenType {
    BrokenType(Boolean checked) {
        throw checked ? new Exception("broken") : new RuntimeException("broken")
    }
}

class SomeTypeWithMultipleConstructors {

}

model {
    components {
        main(NativeExecutableSpec)
    }
}
         """

        and:
        helloWorldApp.writeSources(file("src/main"))
        file("src/main/rc/broken.rc") << """
        #include <stdio.h>

        NOT A VALID RESOURCE
"""

        when:
        run "mainExecutable"

        then:
        notExecuted(":compileMainExecutableMainRc")
    }

        given:
        buildFile << """
model {
    components {
        main(NativeExecutableSpec)
    }
}
        """

        and:
        file("src/main/asm/broken.s") << """
.section    __TEXT,__text,regular,pure_instructions
.globl  _sum
.align  4, 0x90
_sum:
pushl
"""

        expect:
        fails "mainExecutable"

                documentationRoot = project.layout.projectDirectory.dir('docsRoot')
                javadocRoot = documentationRoot.dir('javadoc')
            }
        """
    }

    def "finds broken section links"() {
        given:
        sampleDoc << """
=== Dead Section Links
This section doesn't exist: <<missing_section>>
Also see this one, which is another dead link: <<other_missing_section>>
        """

        result.result

        then:
        def e = thrown(ArtifactNotFoundException)
        result.failure == e
    }

    def "can have failure result"() {
        def failure = new ArtifactResolveException("broken")

        when:
        result.failed(failure)

        then:
        result.failure == failure
        result.hasResult()

        when:
        result.result

        then:

        then:
        plugin.assertEndOfBuildWithFailure(output, null)
        failure.assertHasDescription("broken")

        when:
        fails succeedingTaskName, "-Dbuild-listener-failure"

        then:
        plugin.assertEndOfBuildWithFailure(output, null)
        failure.assertHasDescription("broken")
    }

        server.resetExpectations()
        and:
        run 'retrieve'

        then:
        file('libs/projectA-1.5.jar').assertHasNotChangedSince(snapshot)
    }

    def "reports and recovers from broken maven-metadata.xml and directory listing"() {
        given:
        mavenHttpRepo.module('group', 'projectA', '1.0').publish()
        def projectA = mavenHttpRepo.module('group', 'projectA', '1.5').publish()

import org.gradle.internal.service.ServiceRegistry
import spock.lang.Specification

class RepositoryChainComponentMetaDataResolverTest extends Specification {
    final org.gradle.internal.Factory<String> broken = { "broken" }
    final metaData = metaData("1.2")
    final componentState = Stub(ModuleComponentGraphResolveState) {
        getLegacyMetadata() >> metaData
    }

            public class Junit4Test {
                @Test
                public void ok() {
                }

                @Test
                @Ignore
                public void broken() {
                    throw new RuntimeException();
                }

                public void helpermethod() {
                }
            }
        """.stripIndent()

        file("buildSrc/build.gradle") << """
            gradle.buildFinished {
                println "buildSrc finished"
                throw new RuntimeException("broken")
            }
        """
        buildFile << """
            gradle.buildFinished { result ->
                println "root build finished"
                assert result.failure != null
            }