server.stop()
    }

    @Override
    void expectPluginMarkerMissing(String pluginId, String pluginVersion) {
        module(pluginId, pluginId + PLUGIN_MARKER_SUFFIX, pluginVersion).with {
            pom.expectGetMissing()
            artifact.expectHeadMissing()
        }
    }

    @Override
    void expectPluginMarkerBroken(String pluginId, String pluginVersion) {

        buildFile << """
            dependencies {
                api "org:main:1.0"
            }
        """

        when:
        mainModule.ivy.expectGet()
        mainModule.moduleMetadata.expectGetMissing()
        mainModule.artifact.expectGet()

        run ':checkDeps'

        then:
        // falls back to Ivy file, since we have one
        resolve.expectGraph {
            root(":", ":test:") {

        def missingProjectB = repo1.module('group', 'projectB')
        def projectB = repo2.module('group', 'projectB').publish()

        when:
        projectA.pom.expectGet()

        missingProjectB.pom.expectGetMissing()
        projectB.pom.expectGet()

        projectA.artifact.expectGet()
        projectB.artifact.expectGet()

        then:
        succeeds 'retrieve'

        failure.assertHasCause("Could not write to resource '${module.artifact.uri}")
    }

    def expectPublication() {
        module.artifact.expectPublish()
        module.rootMetaData.expectGetMissing()
        module.rootMetaData.expectPublish()
        module.pom.expectPublish()
        module.moduleMetadata.expectPublish()
    }

    def verifyPublications() {

        def module = ivyHttpRepo.module('group', 'projectA', '1.2').extendsFrom(organisation: 'group', module: 'parent', revision: 'a').publish()

        when:
        module.ivy.expectGet()
        parent.ivy.expectGetMissing()

        then:
        fails "checkDeps"
        failedResolve.assertFailurePresent(failure)
        failure
            .assertResolutionFailure(":compile")

        buildFile << """
            dependencies {
                api "org:main:1.0"
            }
        """

        when:
        mainModule.pom.expectGet()
        mainModule.moduleMetadata.expectGetMissing()
        mainModule.artifact.expectGet()

        run ':checkDeps'

        then:
        // falls back to POM file, since we have one
        resolve.expectGraph {
            root(":", ":test:") {

}
configurations { compile }
dependencies { compile 'org:child:1.0' }
"""
        failedResolve.prepare()

        when:
        child.pom.expectGet()
        parent.pom.expectGetMissing()

        and:
        fails 'checkDeps'

        then:
        failedResolve.assertFailurePresent(failure)
        failure.assertResolutionFailure(':compile')

                conf "org:foo:1.0"
                conf "org:bar:1.0"
            }
        """

        when:
        mod1.ivy.expectGet()
        mod1.artifact.expectGet()

        mod2Maven.pom.expectGetMissing()

        mod2Ivy.ivy.expectGet()
        mod2Ivy.artifact.expectGet()

        run 'checkDeps'

        then:
        resolve.expectGraph {
            root(':', ':test:') {

        failureHasCause("Could not GET '$repo1.uri/group/projectA/1.0/ivy-1.0.xml'")
        failureHasCause('Read timed out')

        when:
        server.resetExpectations()
        module1.ivy.expectGetMissing()
        module2.ivy.expectGet()
        module2.jar.expectDownload()

        then:
        succeeds('checkDeps')
        resolve.expectGraph {
            root(":", ":test:") {

    compile 'org:test2:2.0'
}

task show {
    doLast {
        ${expression}.collect { it.name }
    }
}
"""

        given:
        mavenHttpRepo.getModuleMetaData('org', 'test').expectGetMissing()
        def m = mavenHttpRepo.module('org', 'test2', '2.0').publish()
        m.pom.expectGetBroken()

        when:
        maybeExpectDeprecation(expression)
        fails 'show'

        then: