ImmutableCapabilities capabilities = variantMetadataRules.applyCapabilitiesRules(variant, variant.getCapabilities());
        ImmutableList<? extends ComponentVariant.File> files = variantMetadataRules.applyVariantFilesMetadataRulesToFiles(variant, variant.getFiles(), id);
        boolean force = PlatformSupport.hasForcedDependencies(variant);

     * @return The transform chain which transforms the root variant to this variant.
     */
    TransformChain getTransformChain();

    /**
     * The single transform step which transforms the previous variant to this variant.
     */
    TransformStep getTransformStep();

    /**
     * @return The previous variant in the transform chain. If null, this variant uses the producer variant as its root.
     */
    @Nullable

        javaLibrary.parsedModuleMetadata.variant("apiElements").files[0].name == "publishTest-1.9.jar"
        javaLibrary.parsedModuleMetadata.variant("apiElements").files[0].url == "publishTest-1.9.jar"
        javaLibrary.parsedModuleMetadata.variant("runtimeElements").files[0].name == "publishTest-1.9.jar"
        javaLibrary.parsedModuleMetadata.variant("runtimeElements").files[0].url == "publishTest-1.9.jar"
    }

    %5 = "tf.Identity"(%4) {device = "/device:CPU:0"} : (tensor<!tf_type.variant>) -> tensor<!tf_type.variant>
    func.return %5 : tensor<!tf_type.variant>
  }
  // CHECK-LABEL: __inference_Dataset_map_lambda_160

        then:
        result == resolvedArtifactSet
        1 * attributeMatcher.matches(_, _, _) >> [variant]
        1 * variant.getArtifacts() >> resolvedArtifactSet
        0 * consumerProvidedVariantFinder._
    }

    def 'multiple match on variant results in ambiguous exception'() {
        given:
        def variantSet = variantSetOf([variant, otherVariant])

    @Override
    public void writeVariantResult(ResolvedGraphVariant variant, Encoder encoder) throws Exception {
        encoder.writeSmallLong(variant.getNodeId());
        VariantGraphResolveState state = variant.getResolveState();
        if (state.isAdHoc()) {
            writeVariantData(encoder, state);
        } else {
            writeVariantReference(encoder, variant, state);
        }
    }

        then:
        javaLibrary.parsedModuleMetadata.variant("apiElements") {
            noMoreDependencies()
        }
        javaLibrary.parsedModuleMetadata.variant("runtimeElements") {
            noMoreDependencies()
        }
        javaLibrary.parsedModuleMetadata.variant("featureApiElements") {
            noMoreDependencies()
        }
        javaLibrary.parsedModuleMetadata.variant("featureRuntimeElements") {

    }

    @Override
    String getIdeBuildTaskName(String variant) {
        return "install${variant.capitalize()}"
    }

    @Override
    List<String> getTasksToBuildFromIde(String variant) {
        return [":compile${variant.capitalize()}Cpp", ":link${variant.capitalize()}", ":install${variant.capitalize()}"]
    }

    @Override
    String getVisualStudioProjectName() {

     * can match this classified dependency to a proper variant.
     */
    def "reasonable behavior when a Maven library uses a classifier to select a Gradle variant"() {
        def gradleLibrary = mavenHttpRepo.module("org", "lib", "1.0")
                .adhocVariants()
                .variant("apiElements", ['org.gradle.usage': Usage.JAVA_API, 'groovy.runtime': 'classic'])

        def differentFrom = factory.createResolvedDependency(selector('requested'), newModule('xxx'), selectedModule, variant, false)
        def differentSelected = factory.createResolvedDependency(selector('requested'), fromModule, newModule('xxx'), variant, false)
        def differentConstraint = factory.createResolvedDependency(selector('requested'), fromModule, selectedModule, variant, true)

        then:
        dep.is(same)