implementation(project(":producer"))

    // But we also want to use its MySQL support
    runtimeOnly(project(":producer")) {
        capabilities {
            requireCapability("org.gradle.demo:producer-mysql-support")
        }
    }
}

    implementation('org.gradle.demo:producer:1.0')

    // But we also want to use its MongoDB support
    runtimeOnly('org.gradle.demo:producer:1.0') {
        capabilities {
            requireCapability("org.gradle.demo:producer-mongodb-support")
        }
    }
}

                }
            }
            dependencies {
                implementation(project(':')) {
                    capabilities {
                        requireCapability("org:consumer-producer")
                    }
                }
            }
        """
    }

    @Override
    protected producingAutomaticModuleNameSetting() {
        buildFile << """

    public ProjectTestFixtures(Project project) {
        this.project = project;
    }

    @Override
    public void execute(ModuleDependencyCapabilitiesHandler capabilities) {
        capabilities.requireCapability(new ProjectDerivedCapability(project, TEST_FIXTURES_FEATURE_NAME));
    }

                    attribute('custom', 'c1')
                    capability('alt')
                }
            }
            'org:bar:1.0' {
                dependsOn([group: 'org', artifact: 'foo', version: '1.0', requireCapability: 'org.test:alt'])
            }
        }

        buildFile << """
            dependencies {
                conf('org:bar:1.0')
            }
        """

        when:

        }

        buildFile << """
            dependencies {
                conf('org:foo:1.0')
                conf('org:foo:1.0') {
                    capabilities {
                        requireCapability('org:feature-1')
                    }
                }
            }
        """

        when:
        repositoryInteractions {
            'org:foo:1.0' {
                expectResolve()

     * @param capabilityNotation the capability {@linkplain ConfigurationPublications#capability(Object) notation} (e.g. group:name:version), {@linkplain Provider Providers} of any notation are also accepted
     */
    void requireCapability(Object capabilityNotation);

    /**
     * Requires multiple capabilities. The selected variants MUST provide ALL of them
     * to be selected.

            }
        """)

        javaProject(file("b"), """
            dependencies {
                implementation(project(":a")) {
                    capabilities {
                        requireCapability("group:a-feature")
                    }
                }
            }
        """)

        when:
        executer.withArguments(ENABLE_CLI)

                String name = dependency.getName() + TestFixturesSupport.TEST_FIXTURES_CAPABILITY_APPENDIX;
                dependency.capabilities(capabilities -> {
                    capabilities.requireCapability(new DefaultImmutableCapability(group, name, null));
                });
            } else if (dependency instanceof ProjectDependency) {
                ProjectDependency projectDependency = Cast.uncheckedCast(dependency);

        buildFile << """
            apply plugin: 'java-library'

            dependencies {
                api("com.acme.external:external:1.0") {
                    capabilities {
                        requireCapability("org:$capability")
                    }
                }
            }
        """
        def resolve = new ResolveTestFixture(buildFile, "compileClasspath")
        resolve.prepare()

        when: