super(delegate);
        this.delegate = delegate;
        this.source = source;
        this.artifacts = delegate.getArtifacts();
    }

    private DslOriginDependencyMetadataWrapper(LocalOriginDependencyMetadata delegate, Dependency source, List<IvyArtifactName> artifacts) {
        super(delegate);
        this.delegate = delegate;

                viewConfiguration.lenient(true);
                viewConfiguration.componentFilter(IS_A_MODULE_ID);
            }
        }).getArtifacts().getArtifacts();

        List<IdeExtendedRepoFileDependency> externalDependencies = new ArrayList<IdeExtendedRepoFileDependency>(artifacts.size());
        for (ResolvedArtifactResult artifact : artifacts) {

 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface ArtifactInstallerRequest {

    @Nonnull
    Session getSession();

    @Nonnull
    Collection<Artifact> getArtifacts();

    @Nonnull
    static ArtifactInstallerRequestBuilder builder() {
        return new ArtifactInstallerRequestBuilder();
    }

    @Nonnull

        cache.put(project1, new SetWithResolutionResult(null, artifacts));

        assertArrayEquals(
                artifacts.toArray(new Artifact[0]),
                cache.get(project1).getArtifacts().toArray(new Artifact[0]));

        ProjectArtifactsCache.Key project2 = new ProjectArtifactsCache.Key() {};

        Set<Artifact> reversedArtifacts = new LinkedHashSet<>(4);

        buildFile << """
        def expectedMetadataFileNames = ${expectedMetadataFiles.collect { "'" + it.name + "'" }} as Set

        for(component in result.resolvedComponents) {
            def artifacts = component.getArtifacts($requestedArtifact)
            artifacts.each { a ->
                assert a.id.componentIdentifier.displayName == "${id.displayName}" 
                assert a.id.componentIdentifier.group == "${id.group}" 

            Set<Artifact> allArtifacts = new LinkedHashSet<>();
            allArtifacts.add(rootArtifact);
            allArtifacts.addAll(result.getArtifacts());
            result.setArtifacts(allArtifacts);
        }

        return result;
    }

    public void resolve(

                }
            }
        """

        when:
        def smokeTestRunner = runner('assembleBootDist', 'check')

    }

    @Override
    public List<ExcludeMetadata> getExcludes() {
        return delegate.getExcludes();
    }

    @Override
    public List<IvyArtifactName> getArtifacts() {
        return delegate.getArtifacts();
    }

    @Override
    public DependencyMetadata withTarget(ComponentSelector target) {
        return delegate.withTarget(target);
    }

    @Override

                    assert artifacts.size() == 3
                    assert artifacts.collect { it.file.name } == ['hiphop-1.0.jar', 'child.jar', 'rock-1.0.jar']

                    artifacts = compile.getArtifacts { true }

                    assert artifacts.collect { it.file.name } == ['hiphop-1.0.jar', 'child.jar', 'rock-1.0.jar']

                    def unresolved = compile.unresolvedModuleDependencies

            "defaultArtifacts", DefaultArtifactPublicationSet.class, archivesConfiguration.getArtifacts()
        );

        configurations.all(configuration -> {
            if (!configuration.equals(archivesConfiguration)) {
                configuration.getArtifacts().configureEach(artifact -> {
                    if (configuration.isVisible()) {