"""

        producer.file('build.gradle') << """
            plugins {
                id('java-library')
            }

            configurations {
                consumable("nonLibrary") {
                    attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.class, Category.VERIFICATION))
                    }
                }
            }

====

Capabilities must be attached to _outgoing configurations_, which are <<declaring_dependencies.adoc#sec:resolvable-consumable-configs,consumable configurations>> of a component.

This example shows that we declare two capabilities:

1. `com.acme:my-library:1.0`, which corresponds to the _implicit capability_ of the library

This is where the <<variant_model.adoc#understanding-variant-selection,variant model>> of Gradle comes into play.

In Gradle, _producer variants_ are exposed via <<declaring_dependencies.adoc#sec:resolvable-consumable-configs,consumable configurations>>.

[[sub:strong-encapsulation]]
== Strong encapsulation

In order for a producer to compile a library, it needs all its _implementation dependencies_ on the compile classpath.

        return selectedConfiguration;
    }

    /**
     * Fails the resolution of the project dependency because the selected configuration is not consumable by
     * throwing the appropriate exception.
     *
     * This method is kind of ugly.  If we could get a hold of the ResolutionFailureHandler in this class, we could use the typical

        }
    }
    repositories {
        maven {
            name = "test"
            url = testRepoLocation.get().asFile.toURI()
        }
    }
}

val testRepoElements = configurations.consumable("testRepoElements") {
    outgoing.artifact(testRepoLocation) {
        builtBy( "publishMavenPublicationToTestRepository")
    }
    // TODO: De-duplicate this. See publish-public-libraries
    attributes {

        expect:
        succeeds("resolve")
    }

    def "buildscript resolvable configuration and consumable configuration from same project live in same resolved component"() {
        buildFile << """
            buildscript {
                configurations {
                    conf {

import org.gradle.api.internal.component.AbstractSoftwareComponentVariant;

import java.util.HashSet;
import java.util.Set;

/**
 * A {@link SoftwareComponentVariant} based on a consumable {@link Configuration}.
 */
public class ConfigurationSoftwareComponentVariant extends AbstractSoftwareComponentVariant {
    protected final String name;
    private final Configuration configuration;

     * A cache of the defined dependencies for dependency configurations. This tracks the cached internal
     * dependency representations for these types so when constructing leaf configuration metadata
     * (resolvable and consumable), these conversions do not need to be executed multiple times.
     */
    class DependencyCache {
        private final Map<String, DefaultLocalConfigurationMetadataBuilder.DependencyState> cache = new HashMap<>();

          jsonPath: .metadata.creationTimestamp
      "schema":
        "openAPIV3Schema":
          description: ServiceExport declares that the Service with the same name and
            namespace as this export should be consumable from other clusters.
          type: object
          properties:
            apiVersion:
              description: 'APIVersion defines the versioned schema of this representation

                    attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, "foo"))
                    }
                }
                consumable("cons") {
                    attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, "foo"))
                    }
                }
            }