'org.test:moduleB:1.0' {
                expectResolve()
            }
        }

        then:
        succeeds 'checkDep'
        def expectedLibraryAttributes = expectedJavaLibraryAttributes(useMaven() || gradleMetadataPublished)
        resolve.expectGraph {
            root(':', ':test:') {
                module('org.test:moduleA:1.0') {
                    variant('jdk8Runtime', expectedLibraryAttributes)

        System.getProperty(GRADLE_METADATA) == "true"
    }

    static boolean useIvy() {
        System.getProperty(REPOSITORY_TYPE) == "ivy"
    }

    static boolean useMaven() {
        System.getProperty(REPOSITORY_TYPE) == "maven"
    }

        GradleMetadataResolveInterceptor.useIvy()
    }

    boolean useMaven() {
        !useIvy()
    }

    boolean isGradleMetadataPublished() {
        GradleMetadataResolveInterceptor.isGradleMetadataPublished()
    }

    boolean usesJavaLibraryVariants() {
        GradleMetadataResolveInterceptor.isGradleMetadataPublished() || useMaven()
    }

    String getTestConfiguration() { 'conf' }

        succeeds ":checkDeps"

        // We are resolving with "legacy" metadata: always gives default configuration, unless we derive Java library variants for maven repositories
        resolve.expectDefaultConfiguration(useMaven() ? "runtime" : "default")
        resolve.expectGraph {
            root(":", ":test:") {
                edge("org.test:projectA:1.+", "org.test:projectA:1.2")
            }
        }
    }

class ComponentOverrideMetadataResolveIntegrationTest extends AbstractModuleDependencyResolveTest {

    def "can combine artifact notation and constraints"() {
        resolve.expectDefaultConfiguration(useMaven() ? 'runtime' : 'default')

        given:
        repository {
            'org:foo:1.0' {
                withModule {
                    undeclaredArtifact(type: 'distribution-tgz')
                }

        System.getProperty(GRADLE_METADATA) == "true"
    }

    static boolean useIvy() {
        System.getProperty(REPOSITORY_TYPE) == "ivy"
    }

    static boolean useMaven() {
        System.getProperty(REPOSITORY_TYPE) == "maven"
    }

                allowAll()
                expectGetArtifact()
            }
        }

        when:
        run 'checkDeps'

        then:
        def expectedVariant = useMaven() ? 'runtime' : 'default'
        resolve.expectDefaultConfiguration(expectedVariant).expectGraph {
            root(":", ":test:") {
                module("org:first-level:1.0")
                module("org:foo:1.0")

            }
        }
    }

    def "rule is applied only once"() {
        given:
        withDefaultVariantToTest()
        int invalidCount = 2
        if (GradleMetadataResolveRunner.useMaven() && !GradleMetadataResolveRunner.gradleMetadataPublished) {
            // for Maven with experimental, we use variant aware matching which will (today) involve another round
            // of execution of the rule

        then:
        repositoryInteractions {
            'group:projectA' {
                expectHeadVersionListing()
            }
            'group:projectB' {
                if (GradleMetadataResolveRunner.useMaven()) {
                    expectHeadVersionListing()
                }
                expectVersionListing()
            }
            'group:projectB:2.3' {
                withModule {

        when:
        allowAllRepositoryInteractions()
        fails ':checkDeps'

        then:
        def coreVariant = GradleMetadataResolveRunner.gradleMetadataPublished || GradleMetadataResolveRunner.useMaven() ? 'runtime' : 'default'
        failure.assertHasCause """Cannot find a version of 'org:databind' that satisfies the version constraints:
   Dependency path ':test:unspecified' --> 'org:databind:{strictly 2.7.9}'