settingsFile << """
            rootProject.name = 'test'
            sourceControl {
                vcsMappings {
                    withModule("broken") {
                        from(GitVersionControlSpec) {
                        }
                    }
                }
            }
        """

        expect:
        fails('assemble')

        descriptor.versions == ['1.2', '1.3'] as Set
    }

    def "can mark as failed"() {
        org.gradle.internal.Factory<String> broken = { "too bad" }
        def failure = new ModuleVersionResolveException(newSelector(DefaultModuleIdentifier.newId("a", "b"), "c"), broken)

        when:
        descriptor.failed(failure)

        then:
        descriptor.state == Failed
        descriptor.failure == failure

    @org.testng.annotations.Test
    public void passingTest() {
    }

    @org.testng.annotations.Test(expectedExceptions = RuntimeException.class)
    public void expectedFailTest() {
        throw new RuntimeException("broken");
    }

        // maybe killed here
        if (parameters.broken.get()) {
            Runtime.runtime.halt(1)
        }
        def two = outputs.file("two")
        two.text = "two"
    }
}

dependencies {
    registerTransform(ToColor) {
        from.attribute(type, "jar")
        to.attribute(type, "red")
        parameters {
            color = Color.Red

	RepairDeletePods         = "repair-delete-pods"
	RepairRepairPods         = "repair-repair-pods"
	RepairLabelPods          = "repair-label-pods"
	RepairLabelKey           = "repair-broken-pod-label-key"
	RepairLabelValue         = "repair-broken-pod-label-value"
	RepairNodeName           = "repair-node-name"
	RepairSidecarAnnotation  = "repair-sidecar-annotation"
	RepairInitContainerName  = "repair-init-container-name"

        then:
        locator.localMavenRepository == repo2
    }

    def "throws exception on broken global settings file with decent error message"() {
        given:
        def settingsFile = locations.globalSettingsFile
        settingsFile << "broken content"
        when:
        locator.localMavenRepository
        then:
        def ex = thrown(CannotLocateLocalMavenRepositoryException);

}

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")
    }

        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 {

        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>>
        """