}
            }
        }

        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() {

 */
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;

 * limitations under the License.
 */
package org.gradle.api.internal.capabilities;

/**
 * This special kind of capability is here only because of derived
 * variants: in case of platforms we want to make sure we can select
 * both the platform and library. For this we use different capabilities.
 * However, we still want to make sure we can select the platform component

    public DefaultResolvedArtifactResult(ComponentArtifactIdentifier identifier,
                                         AttributeContainer variantAttributes,
                                         ImmutableCapabilities capabilities,
                                         DisplayName variantDisplayName,
                                         Class<? extends Artifact> type,
                                         File file) {

 *
 * <p>Features are classified by their capabilities. Each variant of a feature provides at least
 * the same set of capabilities as the feature itself. Since all variants of a feature are derived
 * from the same sources, they all expose the same API or "content" and thus provide the same
 * capabilities. Some variants may expose additional capabilities than those of its owning feature,
 * for example with fat jars.</p>
 *

          "url": "producer-1.0.jar",
          "size": 261,
          "sha1": "29acdaf26447e93ce0c8af7357e6fd4e2d1db71d",
          "md5": "6c53fdd588deb0abfc636c382e25d92e"
        }
      ],
      "capabilities": [
        {
          "group": "org.gradle.demo",
          "name": "producer-mongodb-support",
          "version": "1.0"
        }
      ]
    },
    {
      "name": "mongodbSupportRuntime",

        ImmutableAttributes target,
        ImmutableCapabilities capabilities,
        TransformChain transformChain,
        TransformUpstreamDependenciesResolverFactory dependenciesResolverFactory,
        CalculatedValueContainerFactory calculatedValueContainerFactory
    ) {
        super(componentIdentifier, delegate, target, capabilities, transformChain, dependenciesResolverFactory, calculatedValueContainerFactory);
    }

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

import com.google.common.collect.Sets;
import org.gradle.api.capabilities.Capability;
import org.gradle.internal.Describables;
import org.gradle.internal.DisplayName;
import org.gradle.api.internal.capabilities.CapabilityInternal;
import org.gradle.util.internal.VersionNumber;

import java.util.Collection;
import java.util.Set;

/**

        try {
            if (seenArtifacts.add(artifact.getId())) {
                File file = artifact.getFile();
                this.artifacts.add(new DefaultResolvedArtifactResult(artifact.getId(), variantAttributes, capabilities, variantName, Artifact.class, file));
            }
        } catch (Exception t) {