.map(variant -> resolveStateFor(variant).asVariant())
                .collect(Collectors.toList())
        );
        this.idGenerator = idGenerator;
        this.selectableVariantResults = graphMetadata.getVariantsForGraphTraversal().stream()
            .flatMap(variant -> variant.getVariants().stream())
            .map(variant -> new DefaultResolvedVariantResult(
                getId(),

     * @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

        outputContains("$silenceMethod(variant)")
        outputContains('Declares capability org:foo:1.0')
        outputContains("Variant runtimeElements")
        outputDoesNotContain("Variant apiElements")
        javaLibrary.assertPublished()
    }

    def "can ignore all publication warnings by variant name"() {
        given:

        return conf;
    }

    /**
     * Ensures the target variant matches the request attributes and is consumable. This needs to be called
     * for variants that are selected by means other than attribute matching.
     *
     * Note: This does not need to be called for variants selected via attribute matching, since
     * attribute matching ensures selected variants are compatible with the requested attributes.
     */

        List<TestVariant> variants = new ArrayList<TestVariant>();
        variants.add(TestVariant.tapiCurrent(rootId, discoveryRequest));
        variants.add(TestVariant.selected(rootId, discoveryRequest));
        variants.add(TestVariant.tapiTargetLoaded(rootId, discoveryRequest));

        return variants;
    }

        if (attributes.isEmpty()) {
            failWith("Variant '" + name + "' must declare at least one attribute.");
        }
        if (variants.containsKey(name)) {
            failWith("It is invalid to have multiple variants with the same name ('" + name + "')");
        } else {
            VariantIdentity identity = new VariantIdentity(attributes, capabilities);
            if (variants.containsValue(identity)) {

    /**
     * Define a variant with attributes. Variants are only published when using {@link #withModuleMetadata()}.
     */
    MavenModule variant(String variant, Map<String, String> attributes)

    /**
     * Define a variant with attributes. Variants are only published when using {@link #withModuleMetadata()}.
     */

        );
    }

    private void writeVariants() throws IOException {
        List<ModuleMetadataSpec.Variant> variants = metadata.variants;
        if (variants.isEmpty()) {
            return;
        }
        writeArray("variants", () -> {
            for (ModuleMetadataSpec.Variant variant : variants) {
                if (variant instanceof ModuleMetadataSpec.LocalVariant) {