configurations {
                testArtifacts
            }

            configurations.testArtifacts.outgoing.artifact(testJar)
        """

        file('consumer/build.gradle').text = """
            dependencies {
                testImplementation(project(":producer"))
                testImplementation(project(['path' : ":producer", 'configuration' : "testArtifacts"]))
            }
        """

        when:

        return """
            configurations {
                testartifacts
            }

            dependencies {
                testartifacts 'org.gradle.test:${lib}:${resolveVersion}'
            }

            task ${resolveTask}(type: Copy) {
                dependsOn ":publish"
                from {
                    configurations.testartifacts
                }
                into "\${buildDir}/copies"

            it.plugins.apply(JavaPlugin)
        }

        child1.configurations.create("testArtifacts")
        def task = child1.tasks.create("testJar", Jar) {
            archiveClassifier.set("tests")
            from(project.sourceSets.test.output)
        }
        child1.artifacts.add("testArtifacts", task)
        child2.dependencies {
            implementation child2.dependencies.project(path: ":child1")

            }
        }

        child1.configurations.create("testArtifacts")
        def task = child1.tasks.create("testJar", Jar) {
            archiveClassifier.set("tests")
            from(project.sourceSets.test.output)
        }
        child1.dependencies {
            implementation "fakegroup:test:1.0"
        }
        child1.artifacts.add("testArtifacts", task)
        child2.dependencies {

        def runtimeArtifacts = resolveMetaData.getConfiguration("runtime").artifacts
        def testArtifacts = resolveMetaData.getConfiguration("testUtil").artifacts

        runtimeArtifacts*.id.displayName as Set == ["foo-1.0.jar (org:foo:1.0)"] as Set
        testArtifacts*.id.displayName as Set == ["foo-all-1.0.zip (org:foo:1.0)"] as Set
    }

import java.io.File;
import java.util.Collection;

public class TestArtifactSet implements ResolvedArtifactSet, ResolvedArtifactSet.Artifacts {
    public static final String DEFAULT_TEST_VARIANT = "test variant";
    private final DisplayName variantName;
    private final AttributeContainer variant;
    private final ImmutableSet<ResolvedArtifact> artifacts;

            request.setArtifacts(replacePom(request.getArtifacts()));
        }
        return request;
    }

    public DeployRequest remapDeployArtifacts(RepositorySystemSession session, DeployRequest request) {
        if (Features.buildConsumer(session.getUserProperties()) && consumerPomPresent(request.getArtifacts())) {

        InternalSession session = InternalSession.from(request.getSession());
        try {
            InstallRequest installRequest =
                    new InstallRequest().setArtifacts(session.toArtifacts(request.getArtifacts()));

            InstallResult result = repositorySystem.install(session.getSession(), installRequest);
        } catch (InstallationException e) {

        Collection<Artifact> artifacts = nonNull(request.getArtifacts(), "request.artifacts");
        RemoteRepository repository = nonNull(request.getRepository(), "request.repository");
        try {
            DeployRequest deployRequest = new DeployRequest()
                    .setRepository(session.toRepository(repository))
                    .setArtifacts(session.toArtifacts(artifacts));

    int SELECT_VERSION_FROM_RANGE = 10;

    int RESTRICT_RANGE = 11;

    int MANAGE_ARTIFACT_VERSION = 12;

    int MANAGE_ARTIFACT_SCOPE = 13;

    int MANAGE_ARTIFACT_SYSTEM_PATH = 14;

    void testArtifact(Artifact node);

    void startProcessChildren(Artifact artifact);

    void endProcessChildren(Artifact artifact);

    void includeArtifact(Artifact artifact);