* @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.

        withModule("jaxen:jaxen", JaxenCapabilitiesRule)
    }
    implementation("jaxen:jaxen:1.1.3")
    runtimeOnly("jaxen:jaxen:1.1.3") {
        capabilities { requireCapability("jaxen:jaxen-dom4j") }
    }
}
// end::jaxen-dependencies[]


// tag::guava-rule[]
@CacheableRule
abstract class GuavaRule implements ComponentMetadataRule {

            }
        """)

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

        when:
        executer.withArguments(ENABLE_CLI)

        withModule<JaxenCapabilitiesRule>("jaxen:jaxen")
    }
    implementation("jaxen:jaxen:1.1.3")
    runtimeOnly("jaxen:jaxen:1.1.3") {
        capabilities { requireCapability("jaxen:jaxen-dom4j") }
    }
}
// end::jaxen-dependencies[]


// tag::guava-rule[]
@CacheableRule
abstract class GuavaRule: ComponentMetadataRule {

        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:

                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);

                    attributes {
                        attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage, 'java-api'))
                    }
                    capabilities {
                        requireCapability('org:lib-fixtures')
                    }
                }
            }
        """

        when:
        succeeds ':checkDeps'

        then:
        resolve.expectGraph {

                }
            }

            dependencies {
                deps(project) {
                    capabilities {
                        requireCapability(project.provider(() -> value))
                    }
                }
            }

            value = "com:final:1.0"

            task resolve {

                              endorseStrictVersions: attributes.endorseStrictVersions, reason: attributes.reason,
                              requireCapability: attributes.requireCapability
        ]
        return this
    }

                    capabilities {
                        requireCapability('o:n:e')
                    }
                }
                implementation(project(':producer')) {
                    capabilities {
                        requireCapability('o:n:e')
                        requireCapability('g:one-preferred:v')
                    }
                }
            }