}
    }

    def "can resolve remote dependencies"() {
        def repo = new MavenHttpRepository(server, mavenRepo)
        repo.module("org.gradle", "a", "1.0").publish().allowAll()
        server.start()

        when:
        project = ProjectBuilder.builder().build()
        project.with {
            repositories {
                maven { url repo.uri }
            }

"""
repositories {
    ivy {
        url "$ivyHttpRepo.uri"
    }
}
"""
    }

    def setup() {
        repo.module('org.test', 'projectA', '1.0').withStatus("silver").publish().allowAll()
    }

    def "module with custom status can be resolved by adapting status scheme"() {
        buildFile <<
                """
class StatusRule implements ComponentMetadataRule {

        return getArtifact(type: 'module')
    }

    MetaDataArtifact getRootMetaData() {
        return new MetaDataArtifact(server, moduleRootUriPath, backingModule)
    }

    MavenHttpModule allowAll() {
        server.allowGetOrHead(uriPath, backingModule.moduleDir)
        return this
    }

    void missing() {
        server.allowGetOrHeadMissing(pomPath)
        server.allowGetOrHeadMissing(metaDataPath)

        repositoryInteractions {
            group("org") {
                module("a") {
                    version("1") {
                        expectGetMetadata()
                        allowAll()
                    }
                }
            }
        }
        succeeds 'checkDeps'
        resolve.expectGraph {
            root(":", ":test:") {
                module("org:a:1") {

        keyStore = TestKeyStore.init(file("keystore"))
        server.start()

        ivyRemoteRepo = new IvyHttpRepository(server, "/repo", ivyRepo)
        module = ivyRemoteRepo.module('org.gradle', 'publish', '2').allowAll()
    }

    def "publish with server certificate"() {
        given:
        keyStore.enableSslWithServerCert(server)
        initBuild()

        when:
        expectPublication()

    abstract HttpRepository getRepo()
    abstract String getRepoDeclaration()

    def moduleA = getRepo().module('org.test', 'moduleA', '1.0')

    def setup() {
        moduleA.publish()
        moduleA.allowAll()
    }

    def "changing dependency doesn't affect changing flag"() {
        buildFile <<
"""
$repoDeclaration
configurations {
    modules
}

class VerifyingRule implements ComponentMetadataRule {

    IvyModuleHttpArtifact getArtifact(Map<String, ?> options = [:]) {
        def artifact = backingModule.moduleArtifact(options)
        return new IvyModuleHttpArtifact(server, prefix, artifact)
    }

    IvyHttpModule allowAll() {
        server.allowGetOrHead(prefix, backingModule.moduleDir)
        return this
    }

    IvyModuleHttpArtifact getIvy() {
        return new IvyModuleHttpArtifact(server, prefix, backingModule.ivy)
    }

    void publishPlugin(String impl, String version) {
        pluginBuilder.addPlugin(impl, PLUGIN_ID, "TestPlugin${version.replace('.', '_')}")
        pluginBuilder.publishAs(GROUP, ARTIFACT, version, pluginRepo, executer).allowAll()
    }

            PluginBuilder(file("plugin")).run {
                addSettingsPlugin("println '*42*'", "test.MySettingsPlugin", "MySettingsPlugin")
                publishAs("g", "m", "1.0", pluginPortal, createExecuter()).allowAll()
            }

            withSettings(
                """
                plugins {
                    id("test.MySettingsPlugin").version("1.0")
                }
                """
            )

    </configurations>
    <publications>
        <artifact conf="*" ext="jar" name="io" type="jar"/>
    </publications>
</ivy-module>"""

        and:
        module.allowAll()

        and:
        buildFile << """
repositories {
    if (gradle.gradleVersion == '${current.version.version}' || ${previous.fullySupportsIvyRepository}) {
        ivy { url "${ivyHttpRepo.uri}" }