def variant = Stub(VariantGraphResolveState)
        variant.toString() >> name
        variant.name >> name
        def configuration = Stub(ConfigurationGraphResolveState)
        component.getConfiguration(name) >> configuration
        configuration.name >> name
        configuration.toString() >> name
        configuration.asVariant() >> variant
        configuration.metadata >> metadata

[[sec:swift_application_task_variants]]
=== Variant-dependent Tasks

The Swift Application Plugin creates tasks based on the variants of the application component.
Read the <<building_swift_projects.adoc#sec:introducing_build_variants-swift,introduction to build variants>> for more information.
The following diagram shows the relationship between variant-dependent tasks.

.Swift Application Plugin variant-dependent task graph

		if i.Name == n {
			return &i
		}
	}
	return nil
}

// Define variants, which control the base image of an image.
// Tags will have the variant append (like 1.0-distroless).
// The DefaultVariant is a special variant that has no explicit tag (like 1.0); it
// is not a unique variant though. Currently, it represents DebugVariant.

        module.parsedModuleMetadata.variants.size() == 1
        def variant = module.parsedModuleMetadata.variants[0]
        variant.dependencies.size() == 3

        variant.dependencies[0].group == 'org'
        variant.dependencies[0].module == 'foo'
        variant.dependencies[0].version == '1.0'
        variant.dependencies[0].prefers == null
        variant.dependencies[0].strictly == '1.0'

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

        def variant = variants.find { it.name == name }
        if (variant == null) {
            variant = new VariantMetadataSpec(name)
            variants << variant
        }
        spec.delegate = variant
        spec.resolveStrategy = Closure.DELEGATE_FIRST
        spec()
    }

    @ToBeFixedForConfigurationCache
    def variants() {
        given:
        sample variants

        when:
        run "assemble"

        then:
        final debugX86 = executable(variants.dir.file("build/exe/main/x86/debug/main"))
        final releaseX86 = executable(variants.dir.file("build/exe/main/x86/release/main"))
        final debugX64 = executable(variants.dir.file("build/exe/main/x64/debug/main"))

It may also fail if the variant selection result is ambiguous, meaning that Gradle does not have enough information to select one of multiple mutual exclusive variants.
In that case, more information can be provided through <<#sub:terminology_attribute,variant attributes>>.
Examples of variants each Java components typically offers are _api_ and _runtime_ variants.
Others examples are JDK8 and JDK11 variants.

                def root = result.root
                assert root.id.projectName == 'root'
                assert root.variants.size() == 2
                def conf = root.variants.find { it.displayName == 'conf' }
                def other = root.variants.find { it.displayName == 'other' }
                assert conf != null
                assert other != null
            }
        """

            .stream()
            .flatMap(variant -> variant.prepareForArtifactResolution().getArtifactVariants().stream())
            .map(variant -> new DefaultResolvedVariantResult(
                component.getId(),
                Describables.of(variant.getName()),
                component.getAttributeDesugaring().desugar(variant.getAttributes().asImmutable()),