buildFile << """
            repositories {
                maven {
                    url = uri('${remoteRepo.uri}')
                    metadataSources { gradleMetadata() }
                }
            }
            dependencies {
                implementation "group:thing1:1.2"
                implementation "group:thing2:1.2"
            }
        """
    }

The following metadata sources are supported:

.Supported metadata sources
[%header%autowidth,compact]
|===
| Metadata source | Description | Order | Maven | Ivy / flat dir

| `gradleMetadata()`
| Look for Gradle `.module` files
| 1st
| yes
| yes

| `mavenPom()`
| Look for Maven `.pom` files
| 2nd
| yes
| yes

| `ivyDescriptor()`
| Look for `ivy.xml` files

    public final static String GRADLE_METADATA = "org.gradle.internal.resolution.testWithGradleMetadata"
    public final static String REPOSITORY_TYPE = "org.gradle.internal.resolution.testRepositoryType"

    GradleMetadataResolveInterceptor(Class<?> target) {
        super(target, [
                (GRADLE_METADATA): booleanFeature("Gradle metadata"),

import org.gradle.integtests.resolve.AbstractModuleDependencyResolveTest

class CapabilitiesConflictResolutionIntegrationTest extends AbstractModuleDependencyResolveTest {

    @RequiredFeature(feature = GradleMetadataResolveRunner.GRADLE_METADATA, value = "true")
    def "reasonable error message when a user rule throws an exception (#rule)"() {
        given:
        repository {
            'org:testA:1.0' {
                variant('runtime') {

@CompileStatic
class GradleMetadataResolveRunner  {
    public final static String GRADLE_METADATA = "org.gradle.internal.resolution.testWithGradleMetadata"
    public final static String REPOSITORY_TYPE = "org.gradle.internal.resolution.testRepositoryType"

    static boolean isGradleMetadataPublished() {
        System.getProperty(GRADLE_METADATA) == "true"
    }

    static boolean useIvy() {

                }
            }
        """

        expect:
        succeeds("resolve")
    }

    @RequiredFeature(feature = GradleMetadataResolveRunner.GRADLE_METADATA, value = "true")
    @Unroll("Selects variant #expectedVariant using custom attribute value #attributeValue")
    def "attribute value is used during selection"() {
        given:
        repository {

                    module('org.test:moduleB:1.0')
                }
            }
        }
    }

    @RequiredFeature(feature = GradleMetadataResolveRunner.GRADLE_METADATA, value = "true")
    def "capabilities of base are preserved"() {
        given:
        repository {
            'org.test:moduleA:1.0' {
                variant('special-variant') {

class ClasspathDependenciesAttributesIntegrationTest extends AbstractModuleDependencyResolveTest {

    def pluginBuilder = new PluginBuilder(file('plugin'))

    @RequiredFeature(feature = GradleMetadataResolveRunner.GRADLE_METADATA, value = "false")
    @RequiredFeature(feature = GradleMetadataResolveRunner.REPOSITORY_TYPE, value = "maven")

            }
        }

        then:
        checkDependencies()
    }

    // this test doesn't make sense with Gradle metadata
    @RequiredFeature(feature=GradleMetadataResolveRunner.GRADLE_METADATA, value="false")
    // only test one combination
    @RequiredFeature(feature=GradleMetadataResolveRunner.REPOSITORY_TYPE, value="ivy")
    def "maven module is not affected by rule requiring ivy module descriptor input"() {

    boolean featureAvailable() {
        gradleMetadataPublished
    }

    @RequiredFeature(feature = GradleMetadataResolveRunner.GRADLE_METADATA, value="false")
    void "published dependency constraint is ignored when Gradle module metadata is not available"() {
        given:
        repository {
            'org:foo:1.0'()
            'org:foo:1.1'()