def "reports imported BOM as a set of dependency constraints"() {
        def moduleC = mavenRepo.module('group', 'moduleC', '1.0').publish()
        def moduleB = mavenRepo.module('group', 'moduleB', '1.0').dependsOn(moduleC).publish()
        def moduleA = mavenRepo.module('group', 'moduleA', '2.0').dependsOn(moduleB).publish()
        mavenRepo.module('group', 'bom', '1.0')
                .hasType("pom")

        """

        when:
        parent.pom.expectGet()
        moduleA.pom.expectGet()
        moduleA.artifact.expectGet()
        moduleB.pom.expectGet()
        moduleB.artifact.expectGet()

        then:
        // have to run twice to trigger the failure, to parse the descriptor from the cache
        succeeds ":libs"

            root(':', ':test:') {
                module('org.test:moduleA:1.0') {
                    variant(varianName, expectedVariantAttributes)
                    module('org.test:moduleB:1.0') {
                        variant(varianName, expectedVariantAttributes)
                        if (usageAttribute.contains('runtime')) {
                            module('org.test:moduleD:1.0') {

    }

    String getRepoDeclaration() {
"""
repositories {
    ivy {
        url "$repo.uri"
    }
}
"""
    }

    def setup() {
        repo.directoryList("org.test", "moduleA").allowGet()
    }

        then:
        def appXml = new XmlSlurper().parse(
            file('unzipped/META-INF/application.xml'))
        def modules = appXml.module
        modules[0].ejb.text() == 'moduleA.jar'
        modules[1].web.'web-uri'.text() == 'moduleB.war'
    }

    void "uses content from application xml located #location"() {

        //Here we add a module with Gradle metadata which defines a variant that uses the same attributes declared in the build script (format: "custom").
        //The dependency to this module is then added using the rule and thus is matched correctly.
        mavenGradleRepo.module("org.test", "moduleC").withModuleMetadata().variant("anotherVariantWithFormatCustom", [format: "custom"]).publish()

        originalResult.rootIdeaProject.modules.name == ['buildA']

        def moduleA = originalResult.rootIdeaProject.modules[0]
        moduleA.dependencies.each {
            assert it instanceof IdeaModuleDependency
        }
        moduleA.dependencies.targetModuleName == ['buildB-b1', 'buildA-buildC', 'buildD-b1']

        originalResult.getIdeaProject('buildB').modules.name == ['buildB', 'buildB-b1', 'b2']

  into 'libs'
}
"""
        ivyRepo.module('org', 'projectA', '1.2')
            .dependsOn(organisation: 'org', module: 'projectB', revision: '1.5', revConstraint: '1.6')
            .dependsOn(organisation: 'org', module: 'projectC', revision: 'alpha-12')
            .publish()

        ivyRepo.module('org', 'projectB', '1.5')
            .publish()

        ivyRepo.module('org', 'projectB', '1.6')
            .publish()

        expect:
        succeeds "help"
    }

    def "does not watch files in #repositoryType file repositories"() {
        def repo = this."${repositoryType}"("repo")
        def moduleA = repo.module('group', 'projectA', '9.1')
        moduleA.publish()

        def projectDir = file("project")
        projectDir.file("build.gradle") << """
            configurations { implementation }

        traverses b, d

        def moduleA = DefaultModuleIdentifier.newId("group", "a")
        def moduleB = DefaultModuleIdentifier.newId("group", "b")
        moduleReplacements.participatesInReplacements(moduleA) >> true
        moduleReplacements.participatesInReplacements(moduleB) >> true
        moduleReplacements.getReplacementFor(moduleA) >> new ModuleReplacementsData.Replacement(moduleB, null)