doLast {
                    def resolvedArtifacts = configurations.deps.incoming.files.files
                    assert resolvedArtifacts.find { (it.name =~ 'gradle-api-(.*)\\\\.jar').matches() }
                    assert resolvedArtifacts.find { (it.name =~ 'gradle-installation-beacon-(.*)\\\\.jar').matches() }
                    assert resolvedArtifacts.find { (it.name =~ 'groovy-(.*)\\\\.jar').matches() }

        Collection<? extends ResolvableArtifact> resolvedArtifacts;
        try {
            resolvedArtifacts = componentArtifactResolver.resolveArtifacts(artifacts);
        } catch (Exception e) {
            return new UnavailableResolvedArtifactSet(e);
        }
        if (resolvedArtifacts.isEmpty()) {
            return EMPTY;
        }
        if (resolvedArtifacts.size() == 1) {

        this.graphResults = graphResults;
        this.resolvedArtifacts = resolvedArtifacts;
        this.resolutionHost = resolutionHost;
    }

    @Override
    public void visitDependencies(TaskDependencyResolveContext context) {
        graphResults.visitFailures(context::visitFailure);
        context.add(resolvedArtifacts);
    }

    @Override

                } catch (Exception e) {
                    // Optional artifact is not available
                    continue;
                }
            }
            resolvedArtifacts.add(result.getResult());
        }
        return resolvedArtifacts.build();
    }

        for (ArtifactSet artifactSet : artifactsById) {
            ResolvedArtifactSet resolvedArtifacts = artifactSet.select(variantSelector, spec);
            if (!lenient || !(resolvedArtifacts instanceof UnavailableResolvedArtifactSet)) {
                resolvedArtifactSets.add(resolvedArtifacts);
            } else {
                resolvedArtifactSets.add(ResolvedArtifactSet.EMPTY);
            }
        }

            throws LifecycleExecutionException {

        Set<Artifact> resolvedArtifacts = resolveProjectArtifacts(
                project, scopesToCollect, scopesToResolve, session, aggregating, projectArtifacts);
        if (resolvedArtifacts instanceof ProjectArtifactsCache.ArtifactsSetWithResult) {
            return ((ProjectArtifactsCache.ArtifactsSetWithResult) resolvedArtifacts).getResult();
        } else {

        println "display-names: " + configurations.compile.resolvedConfiguration.resolvedArtifacts.collect { it.toString() }
        println "ids: " + configurations.compile.resolvedConfiguration.resolvedArtifacts.collect { it.id.toString() }
        println "names: " + configurations.compile.resolvedConfiguration.resolvedArtifacts.collect { "\$it.name:\$it.extension:\$it.type" }

        this.resolvedArtifacts = resolvedArtifacts;
        this.missingArtifacts = missingArtifacts;
    }

    /**
     * artifacts that could be resolved
     *
     * @return {@link List} of {@link Artifact}
     */
    public List<Artifact> getResolvedArtifacts() {
        return resolvedArtifacts;
    }

    /**
     * artifacts that could NOT be resolved

                artifactFiles.from(configurations.compile.incoming.artifacts.artifactFiles)
                resolvedArtifacts.set(configurations.compile.incoming.artifacts.resolvedArtifacts)
                outputFile.set(layout.buildDirectory.file('output.txt'))
                doLast {
                    def artifactResults = resolvedArtifacts.get()

                    assert artifactResults.size() == 3

            }
            def resolvedArtifacts = artifacts.findAll { it instanceof ResolvedArtifactResult }
            assert expectedMetadataFileNames.size() == resolvedArtifacts.size()

            ${createUnresolvedArtifactResultVerificationCode()}

            if(expectedMetadataFileNames.size() > 0) {
                def resolvedArtifactFileNames = resolvedArtifacts*.file.name as Set