",maxRawSize="          + server.maxRawSize +
            ",sessionKey=0x"        + Hexdump.toHexString( server.sessionKey, 8 ) +
            ",capabilities=0x"      + Hexdump.toHexString( server.capabilities, 8 ) +
            ",serverTime="          + new Date( server.serverTime ) +
            ",serverTimeZone="      + server.serverTimeZone +

        'module("org.test:platform")'           | 'project(":")'
    }

    def "preserves the requested capabilities when performing a composite substitution"() {
        buildA.buildFile << """
            dependencies {
                implementation('org.test:buildB:1.0') {
                    capabilities {
                        requireCapability 'org.test:buildB-test-fixtures'
                    }
                }

import org.gradle.api.artifacts.PublishArtifact;
import org.gradle.api.attributes.HasAttributes;
import org.gradle.api.capabilities.Capability;

import java.util.Set;

/**
 * A software component variant, which has a number of artifacts,
 * dependencies, constraints and capabilities, and that can be
 * published to various formats (Gradle metadata, POM, ivy.xml, ...)
 *
 * @since 5.3
 */

            this.dependencies = dependencies;
            this.dependencyConstraints = dependencyConstraints;
            this.files = files;
            this.capabilities = capabilities;
            this.dependencyMetadata = ImmutableList.copyOf(dependencyMetadata);
            this.externalVariant = externalVariant;
        }

        @Override
        public String getName() {
            return name;

        boolean useMigrationRoleForElementsConfigurations,
        boolean extendProductionCode
    ) {
        this.name = name;
        this.sourceSet = sourceSet;
        this.capabilities = capabilities;
        this.project = project;
        this.extendProductionCode = extendProductionCode;

        // TODO: Deprecate allowing user to extend main feature.

                    assert result.variant.capabilities.size() == 1
                    assert result.variant.capabilities[0].group == 'org.external'
                    assert result.variant.capabilities[0].name == 'external-lib'
                    assert result.variant.capabilities[0].version == '1.0'

                    // Check project artifact

                }
            }
        }

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

        when:
        repositoryInteractions {
            'org:foo:1.0' {

    public LocalVariantMetadata(String name, Identifier identifier, DisplayName displayName, ImmutableAttributes attributes, ImmutableCapabilities capabilities, CalculatedValue<ImmutableList<LocalComponentArtifactMetadata>> artifacts) {
        super(name, identifier, displayName, attributes, ImmutableList.of(), capabilities);
        this.artifacts = artifacts;
    }

    public LocalVariantMetadata prepareToResolveArtifacts() {

    }

    public ImmutableCapabilities applyCapabilitiesRules(VariantResolveMetadata variant, ImmutableCapabilities capabilities) {
        if (capabilitiesRules == null) {
            return capabilities;
        }

        DefaultMutableCapabilitiesMetadata mutableCapabilities;
        if (capabilities.asSet().isEmpty()) {
            // we must add the implicit capability here because it is assumed that if there's a rule

 */
package org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.conflicts;

import org.gradle.api.Describable;
import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.api.capabilities.Capability;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.builder.NodeState;

import java.util.Collection;