}

    def 'resolve maven module with non-existing custom packaging artifact - applies java plugin'() {
        given:
        buildFile.text = '''plugins {
            id 'java'
        }
        '''.stripIndent() + buildFile.text

        buildFile << """
            dependencies {
                // this POM declares packaging of 'hk2-jar', but the artifact is 'jar'

    }

    def "notices changes to build scripts that do not change the file length"() {
        buildFile.text = "task log { doLast { println 'counter: __' } }"
        int before = buildFile.length()

        expect:
        (10..40).each {
            buildFile.text = "task log { doLast { println 'counter: $it' } }"
            assert buildFile.length() == before

            succeeds('log')

        def buildB = singleProjectBuild("buildB") {
            buildFile << """
                assert gradle.includedBuilds.empty
            """
        }
        validationTask(buildB.buildFile, "broken1", """
            assert gradle.includedBuilds.empty
            gradle.includedBuild("buildA")
        """)
        validationTask(buildB.buildFile, "broken2", """
            assert gradle.includedBuilds.empty

    BuildTestFile buildC
    ResolveTestFixture resolve
    def buildArgs = []

    def setup() {
        resolve = new ResolveTestFixture(buildA.buildFile).expectDefaultConfiguration("runtimeElements")
        buildB = multiProjectBuild("buildB", ['b1', 'b2']) {
            buildFile << """
                allprojects {
                    apply plugin: 'java-library'
                    version "2.0"
                }
"""
        }

        buildFile << """
            test {
                sources = files("src")
            }
        """

        when:
        execute "test"
        then:
        result.assertTaskNotSkipped(":test")

        when:
        assert file("src").renameTo(file("source"))
        buildFile << """
            test {

    }

    def "can use GradleRunner to test"() {
        when:
        buildFile << gradleTestKitDependency()
        file("src/test/groovy/Test.groovy") << successfulSpockTest('Test')

        then:
        succeeds 'build'
    }

    def "can use GradleRunner to test concurrently"() {
        when:
        buildFile << gradleTestKitDependency() << """
            test {
                maxParallelForks = 3

            this.settingsFile = file("$buildName/settings${fileExtension}")
            this.buildFile = file("$buildName/build${fileExtension}")

            settingsFile << """
                rootProject.name = "$buildName"
            """
            buildFile << """
                plugins {
                    $pluginPluginId
                }
                repositories {

 */
class ResolveFailureTestFixture {
    String config
    private final TestFile buildFile

    ResolveFailureTestFixture(TestFile buildFile, String config = "compile") {
        this.buildFile = buildFile
        this.config = config
    }

    void prepare(String config = this.config) {
        buildFile << """
            allprojects {
                tasks.register("checkDeps") {

    def "setup"() {
        buildFile << """
@Managed
interface SampleBinary extends BinarySpec {
    String getVersion()
    void setVersion(String version)
}
"""
    }

    def "custom managed binary type can be registered and created"() {
        when:
        buildWithCustomBinaryPlugin()

        and:
        buildFile << '''
model {
    tasks {
        checkModel(Task) {

        module = getMavenS3Repo().module("org.gradle", "test", artifactVersion)
    }

    def "resolves a maven snapshot module stored in S3"() {
        setup:
        module.publish()

        buildFile << mavenAwsRepoDsl()
        buildFile << """
configurations { compile }

dependencies{
    compile 'org.gradle:test:1.45-SNAPSHOT'
}

task retrieve(type: Sync) {
    from configurations.compile
    into 'libs'
}
"""