*         <td>"solaris", "sunos"</td>
 *     </tr>
 * </table>
 */
public interface OperatingSystem extends Named {
    @Input
    @Override
    String getName();

    /**
     * Returns a human-consumable display name for this operating system.
     */
    @Internal
    String getDisplayName();

    /**
     * Is this the current OS?
     */
    @Internal
    boolean isCurrent();

    /**

`assemble` — _lifecycle task_::
Plugins and build authors should attach tasks that produce distributions and other consumable artifacts to this lifecycle task. For example, `jar` produces the consumable artifact for Java libraries. Attach tasks to this lifecycle task using `assemble.dependsOn(__task__)`.

`build` — _lifecycle task_::
_Depends on_: `check`, `assemble`
+

 */
public interface ConfigurationMetadataFactory {

    /**
     * Visit all configurations in this component that can be selected in a dependency graph.
     *
     * <p>This includes all consumable configurations with and without attributes. Configurations visited
     * by this method may not be suitable for selection via attribute matching.</p>
     */

        return convertToId(getDisplayName());
    }

    static String convertToId(String displayName) {
        return displayName.replaceAll("[^a-zA-Z0-9]", "-");
    }

    /**
     * A human consumable display name for this performance test.
     */
    default String getDisplayName() {
        return getExperiment().getDisplayName();
    }

    PerformanceExperiment getExperiment();

    /**

     * a human each child operation of a given operation.
     */
    String getName();

    /**
     * Returns a human consumable display name for the operation. This display name should generally provide enough context
     * to uniquely identify the operation to a human.
     *
     * @return The display name of the operation
     */

        """

        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.

        }
    }
    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 {

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;