mavenRepo.module('org.test', 'parent', '2.0').dependsOn('org.test', 'dep', '2.0').publishPom()
        mavenRepo.module('org.test', 'parent', '2.1').dependsOn('org.test', 'dep', '2.1').publishPom()
        mavenRepo.module('org.test', 'parent', '3.0').dependsOn('org.test', 'dep', '3.0').publishPom()
        mavenRepo.module('org.test', 'dep', '2.1').publish()

            rootProject.name = 'test'
        """
    }

    def "follows relocation to another group"() {
        given:
        def original = mavenHttpRepo.module("groupA", "projectA", "1.2").publishPom()
        original.pomFile.text = """
<project>
    <groupId>groupA</groupId>
    <artifactId>projectA</artifactId>
    <version>1.2</version>
    <distributionManagement>
        <relocation>

    }

    def "ignores missing jar artifact for pom with packaging of type 'pom'"() {
        when:
        buildWithDependencies("compile 'group:projectA:1.0'")
        projectARepo1.hasPackaging("pom").publishPom()

        and:
        projectARepo1.pom.expectGet()
        projectARepo1.artifact.expectHeadMissing()

        and:
        run 'retrieve'

        then:
        file('libs').assertDoesNotExist()

                project.task('pluginTask')
            """

        pluginRepo.module(GROUP, ARTIFACT, VERSION).dependsOn(GROUP, ARTIFACT + "2", VERSION).publishPom()

        when:
        buildScript """
            $USE

            def ops = []

            plugins.withId('$PLUGIN_ID') {
              ops << "withId 1"
            }

        return t();
    }

    @Override
    public T publish() {
        backingModule.publish();
        return t();
    }

    @Override
    public T publishPom() {
        backingModule.publishPom();
        return t();
    }

    @Override
    public T publishWithChangedContent() {
        backingModule.publishWithChangedContent();
        return t();
    }

     *
     * @return this
     */
    MavenModule publish()

    /**
     * Publishes the pom.xml only
     */
    MavenModule publishPom()

    /**
     * Publishes the pom.xml plus main artifact, plus any additional artifacts for this module, with different content (and size) to any
     * previous publication.
     */

    def publishPomWithRelocation(String groupId, String artifactId, String relocationGroupId, String relocationArtifactId, String relocationVersion = null) {
        def module = mavenHttpRepo.module(groupId, artifactId, '1.0').publishPom()
        def relocation = relocationGroupId ? "<groupId>${relocationGroupId}</groupId>" : ''
        relocation += relocationArtifactId ? "<artifactId>${relocationArtifactId}</artifactId>" : ''

        def abModule = publishPlugin(pluginAB, repoB).pluginModule
        (publishPlugin(pluginA, repoA).pluginModule as MavenModule)
            .dependsOn(abModule.group, abModule.module, abModule.version)
            .publishPom()

        and:
        use(repoB, repoA)

        and:
        buildFile << """
            plugins {
                id "$pluginA" version "1.0"
            }
        """

    }

    void prepareToExecute() {
        buildFile << generateManagedBuildScript()
        buildFile << getPluginDescriptors(pluginIds)
        projectDir.file('settings.gradle').write("")
    }

    void publishTo(GradleExecuter executer, TestFile testFile, String buildScript = "") {
        prepareToExecute()
        buildFile << buildScript
        buildFile << """
            jar {
                archiveFileName = "$testFile.name"

        plugin1Builder.publishTo(executer, plugin1Jar)
        def plugin1ClassName = "${plugin1Builder.packageName}.MySettingsPlugin1"

        def plugin2Builder = new PluginBuilder(file("plugin2"))
        plugin2Builder.addSettingsPlugin("", "test.plugin2", "MySettingsPlugin2")
        def plugin2Jar = file("plugin2.jar")
        plugin2Builder.publishTo(executer, plugin2Jar)