}.artifacts
                inputs.files artifacts.artifactFiles
                doLast {
                    artifacts.each {
                        println "Transformed artifact: \${it.file.name} (\${it.id.componentId}), location: \${it.file.absolutePath}"
                    }
                }
            }
        """
        expect:
        execute(buildA, "resolve")

     * This simulates the case where a library is published with Gradle metadata, and
     * that this library published additional variants, that use an artifact with a classifier.
     * If a Maven consumer wants to use that artifact, it has no choice but using <classifier>,
     * so if a Gradle consumer depends on that Maven published library, we want to make sure we
     * can match this classified dependency to a proper variant.
     */

                .findAll { it instanceof ArtifactNotFoundException }
                .collect { ((ArtifactNotFoundException) it).repository.id } as Set
            assert missingRepos.size() < allRepoIds.size(): "Artifact ${it.getArtifact()} not found in any repository."

            it.getExceptions().findAll { !(it instanceof ArtifactNotFoundException) }.each { throw it }
        }

            } catch (MultipleArtifactsNotFoundException e) {

                Collection<Artifact> missing = new HashSet<>(e.getMissingArtifacts());

                for (Iterator<Artifact> it = missing.iterator(); it.hasNext(); ) {
                    String key = ArtifactUtils.key(it.next());
                    if (projectIds.contains(key)) {
                        it.remove();
                    }

        }
        isCanBeResolved = false
        isCanBeConsumed = true
        isVisible = false
        extends.forEach { extendsFrom(it) }
        artifacts.forEach { outgoing.artifact(it) }
    }

fun consumableSourcesVariant(name: String, extends: List<Configuration>, vararg artifacts: Any) =
    configurations.create("${name}Elements") {
        attributes {

import static org.gradle.internal.classpath.transforms.MrJarUtils.isInUnsupportedMrJarVersionedDirectory;

/**
 * A transform that analyzes an artifact: it discovers all super types for classes in an artifact and all class dependencies.<br><br>
 *
 * Outputs 5 files:<br>
 * 1. Instrumentation classpath marker file.<br>

                return inputArtifact -> resolvedOutputs;
            }
        }

        /**
         * Results of a transform that includes parts or the whole of its input artifact.
         * It might also include outputs produced by the transform.
         */
        private static class MixedInputAndProducedOutputResult extends TransformExecutionResult {

        if (dsl == BuildInitDsl.GROOVY) {
            assert text.contains("id 'maven-publish'")
            def configLines = ["from(components.java)"]
            configLines += additionalArchiveTasks.collect { "artifact($it)" }
            def publishingBlock = TextUtil.toPlatformLineSeparators(TextUtil.indent("""
            publishing {
                publications {
                    maven(MavenPublication) {

                def variantArtifact = moduleDir.file(it.publishUrl)
                publish(variantArtifact) { Writer writer ->
                    writer << "${it.name} : Variant artifact $it.publishUrl"
                }
            }
        }

        return this
    }

    File publishArtifact(Map<String, ?> artifact) {
        def artifactFile = artifactFile(artifact)

        then:
        publication.asNormalisedPublication().mainArtifact.extension == "ext"
        publication.pom.packaging == "ext"
    }

    def 'if there is only one artifact it is the main artifact even if packaging is different'() {
        when:
        def mavenArtifact = Mock(MavenTestArtifact) {
            shouldBePublished() >> true
        }