Variant legacy (l)
--------------------------------------------------
My custom legacy configuration""")

        and:
        hasLegacyLegend()
        doesNotHaveIncubatingLegend()
        doesNotPromptForRerunToFindMoreConfigurations()
    }

    def "if single outgoing variant with no attributes or artifacts present, task reports it"() {
        given:

        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])

           metadata = ""} : (tensor<*x!tf_type.variant>, tensor<i32>) -> tensor<!tf_type.variant>
  %6 = "tf.BatchDatasetV2"(%5, %0, %1) {device = "",
           output_shapes = [#tf_type.shape<>],
           output_types = [i32],
           parallel_copy = false,
           metadata = ""} : (tensor<!tf_type.variant>, tensor<i64>, tensor<i1>) -> tensor<!tf_type.variant>
  func.return %6 : tensor<!tf_type.variant>
}

        mainMetadata.variant("debugStaticRuntime").availableAt.coords == "some.group:test_debug_static:1.2"
        mainMetadata.variant("releaseSharedLink").availableAt.coords == "some.group:test_release_shared:1.2"
        mainMetadata.variant("releaseSharedRuntime").availableAt.coords == "some.group:test_release_shared:1.2"

        when:
        variant.artifacts

        then:
        1 * rule.execute(_)

        when:
        variant.artifacts
        variant.artifacts
        variant.artifacts

        then:
        0 * rule.execute(_)

        where:
        metadataType | metadata
        "maven"      | mavenComponentMetadata()
        "ivy"        | ivyComponentMetadata()

        when:
        run "publish"

        then:
        javaLibrary.parsedModuleMetadata.variant("apiElements") {
            noMoreDependencies()
        }
        javaLibrary.parsedModuleMetadata.variant("runtimeElements") {
            noMoreDependencies()
        }
        javaLibrary.parsedModuleMetadata.variant("optionalFeatureRuntimeElements") {
            dependency('org', 'optionaldep', '1.0')

        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'])

    return VariantBinaryAddFunc(
        cc_ctx, cc_a.scalar<Variant>()(), cc_b.scalar<Variant>()(),
        cc_out->scalar<Variant>().data(), binary_add_func);
  } else {
    binary_add_func(ctx, a, b, out);
    return cc_ctx->status();
  }
}

static Status VariantBinaryAddFunc(
    ::tensorflow::OpKernelContext* cc_ctx, const Variant& a, const Variant& b,
    Variant* out,