package com.example;

/**
* Foo class.
*/
public class Foo {

}
"""
        using m2
        succeeds("publishToMavenLocal")
    }

    def "sources jar attributes match derived variants attributes"() {
        file("consumer/build.gradle") << """
dependencies {
    implementation 'com.example:test:1.0'
}

task resolve {
    def artifacts = configurations.runtimeClasspath.incoming.artifactView {

 * <ul>
 *     <li>Select a variant of the component instance. The variant selected for artifact resolution may be different to that used for graph resolution,
 *     for example when using an {@link org.gradle.api.artifacts.ArtifactView} to select different variants.</li>
 *     <li>Determine how to produce the artifacts of the variant, for example by running a chain of transformers.</li>

                variant.getFiles(), variant.getCapabilities(), variantToDependencies.get(variant.getName()), variant.isExternalVariant()));
        }
        ImmutableList<AbstractRealisedModuleComponentResolveMetadata.ImmutableRealisedVariantImpl> realisedVariants = builder.build();

        def variant1 = new DefaultSoftwareComponentVariant('variant1', ImmutableAttributes.EMPTY, [artifact1] as Set)
        artifact1.getFile() >> projectDir.file("artifact1")
        variant1.artifacts >> [artifact1]
        def publishableVariant1 = Stub(PublishableVariant)
        publishableVariant1.name >> "debug"
        publishableVariant1.usages >> [variant1]

                variant.getFiles(), variant.getCapabilities(), variantToDependencies.get(variant.getName()), variant.isExternalVariant()));
        }
        ImmutableList<AbstractRealisedModuleComponentResolveMetadata.ImmutableRealisedVariantImpl> realisedVariants = builder.build();
        return new RealisedIvyModuleResolveMetadata(resolveMetadata, realisedVariants, readIvyConfigurations(decoder, resolveMetadata));

    }

    def "can resolve derived variants"() {
        transitive.adhocVariants().variant("jar", [
                "org.gradle.category": "library",
                "org.gradle.dependency.bundling": "external",
                "org.gradle.usage": "java-runtime"
        ]) {
            artifact("transitive-1.0.jar")
        }
                .variant("sources", [

            formatter.node("Cannot choose between the available variants of ");
        } else {
            String node = "The consumer was configured to find " + describer.describeAttributeSet(failure.getRequestedAttributes().asMap());
            if (listAvailableVariants) {
                node = node + ". However we cannot choose between the following variants of ";
            } else {

import org.gradle.internal.taskgraph.NodeIdentity;
import org.gradle.operations.dependencies.configurations.ConfigurationIdentity;
import org.gradle.operations.dependencies.variants.Capability;
import org.gradle.operations.dependencies.variants.ComponentIdentifier;

import javax.annotation.Nullable;
import java.util.List;
import java.util.Map;

/**
 * Identity of a transform step node in an execution plan.
 *

            return ImmutableList.of(
                // When deriving variants for the Java ecosystem, we actually have 2 components "mixed together": the library and the platform
                // and there's no way to figure out what was the intent when it was published. So we derive variants for both.
                libraryCompileScope(compileConfiguration, attributes, attributesFactory),

        main.parsedPom.scopes.isEmpty()
        def mainMetadata = main.parsedModuleMetadata
        mainMetadata.variants.size() == 2
        mainMetadata.variant("debugRuntime").availableAt.coords == "some.group:test_debug:1.2"
        mainMetadata.variant("releaseRuntime").availableAt.coords == "some.group:test_release:1.2"

        def debug = mavenRepo.module('some.group', 'test_debug', '1.2')