<title>Properties</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>variantName</td>
            </tr>
            <tr>
                <td>showAll</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>

        elements.add(failure)
    }

    override fun visitArtifact(variantName: DisplayName, variantAttributes: AttributeContainer, capabilities: ImmutableCapabilities, artifact: ResolvableArtifact) {
        if (artifacts.add(artifact)) {
            elements.add(FixedFileArtifactSpec(artifact.id, variantAttributes, capabilities, variantName, artifact.file))
        }
    }

            configurations.compileClasspath {
                resolutionStrategy.capabilitiesResolution.all { details ->
                    def selection =
                        details.candidates.find { it.variantName.endsWith('PrefApiElements') }
                    println("Selecting \$selection from \${details.candidates}")
                    details.select(selection)
                }
            }

    @Shared
        defaultVariant

    protected static <T> VariantMetadataRules.VariantAction<T> variantAction(String variantName, Action<? super T> action) {
        new VariantMetadataRules.VariantAction<T>(variantName, action)
    }

    private DefaultAttributesSchema createSchema() {

        if (index == -1) {
            return null;
        }
        if (index == read.size()) {
            ComponentIdentifier owner = componentIdentifierSerializer.read(decoder);
            String variantName = decoder.readString();
            AttributeContainer attributes = attributeContainerSerializer.read(decoder);
            ImmutableCapabilities capabilities = readCapabilities(decoder);
            read.add(null);

        return visitor.prepareForVisit(source);
    }

    public void visitFile(File file) {
        visitor.visitFile(file);
    }

    @Override
    public void visitArtifact(DisplayName variantName, AttributeContainer variantAttributes, ImmutableCapabilities capabilities, ResolvableArtifact artifact) {
        visitor.visitFile(artifact.getFile());
    }

    @Override
    public void visitFailure(Throwable failure) {

    private final Set<File> files = new LinkedHashSet<>();
    private final Set<Throwable> failures = new LinkedHashSet<>();

    @Override
    public void visitArtifact(DisplayName variantName, AttributeContainer variantAttributes, ImmutableCapabilities capabilities, ResolvableArtifact artifact) {
        try {
            File file = artifact.getFile();
            this.files.add(file);

        return variantMetadataRules;
    }

    @Override
    public MutableComponentVariant addVariant(String variantName, ImmutableAttributes attributes) {
        return addVariant(new MutableVariantImpl(variantName, attributes));
    }

    @Override
    public MutableComponentVariant addVariant(MutableComponentVariant variant) {
        if (newVariants == null) {

    void addCapability(Capability capability);

    ImmutableAttributes getAttributes();

    void setAttributes(ImmutableAttributes updatedAttributes);

    MutableComponentVariant copy(String variantName, ImmutableAttributes attributes, Capability capability);

    boolean isAvailableExternally();

    void setAvailableExternally(boolean availableExternally);

            configurations.all {
                resolutionStrategy {
                   capabilitiesResolution.withCapability('org:testB') {
                      select(candidates.find { it.variantName == 'runtimeAlt'})
                      because "we want runtimeAlt with 'special'"
                   }
                }
            }
        """

        when:
        repositoryInteractions {