throws LifecycleExecutionException {

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

                propertyInput.set(artifacts.resolvedArtifacts.map { it[0] })
                setPropertyInput.set(artifacts.resolvedArtifacts)
                listPropertyInput.set(artifacts.resolvedArtifacts)
                mapPropertyInput.put("some", artifacts.resolvedArtifacts.map { it[0] })
                nestedInput.nested.set(artifacts.resolvedArtifacts.map { it[0] })
                doLast {

                ArtifactCollection artifacts = getResolvedArtifacts(configuration, visitor);
                for (ResolvedArtifactResult resolvedArtifact : artifacts) {
                    resolvedArtifacts.put(resolvedArtifact.getId(), resolvedArtifact);
                    configurations.put(resolvedArtifact.getId(), configuration);
                }
                if (artifacts.getFailures().isEmpty()) {
                    continue;

        if (conflictResolvers == null) {
            conflictResolvers = Collections.singletonList(defaultConflictResolver);
        }

        Map<Object, List<ResolutionNode>> resolvedArtifacts = new LinkedHashMap<>();

        ResolutionNode root = new ResolutionNode(originatingArtifact, repositoryRequest.getRemoteRepositories());

        try {

            "incoming.artifactView { }.artifacts.resolvedArtifacts.get()",
            "incoming.artifactView { }.artifacts.failures",
            "incoming.artifactView { }.artifacts.artifactFiles.files",
            "resolve()",
            "files { true }",
            "fileCollection { true }.files",
            "resolvedConfiguration.files",
            "resolvedConfiguration.resolvedArtifacts"
        ]
    }

        "getFirstLevelModuleDependencies { true }" | _
        "getFiles { true }"                        | _
        "files"                                    | _
        "resolvedArtifacts"                        | _
    }

    @ToBeFixedForConfigurationCache(because = "task uses Configuration API")
    def "resolves strictly for artifact resolve failures when #expression is used"() {

            compare("incoming.artifacts", actualArtifacts, expectedArtifacts)

            actualArtifacts = findLines(configDetails, 'incoming-resolved-artifact')
            compare("incoming.resolvedArtifacts", actualArtifacts, expectedArtifacts)

            actualFiles = findLines(configDetails, 'incoming-artifact-file')
            compare("incoming.artifacts.artifactFiles", actualFiles, expectedFiles)

        doLast {
            assert configurations.compile.collect { it.name } == ['external1-1.0-classifier1.jar']
            assert configurations.compile.resolvedConfiguration.resolvedArtifacts.collect { "\${it.name}-\${it.classifier}" } == ['external1-classifier1']
        }
    }
}
project(':b') {
    dependencies {
        compile 'org.gradle.test:external1:1.0:classifier2'
    }

        DefaultResolvedArtifact               | ResolvedArtifact               | "project.configurations.create(java.util.UUID.randomUUID().toString()).tap { project.dependencies.add(name, 'junit:junit:4.13') }.resolvedConfiguration.resolvedArtifacts.first()"

        ResolvedArtifact artifact1 = artifact("a", null, "jar", "jar")
        ResolvedArtifact artifact2 = artifact("b", null, "jar", "jar")
        ResolvedArtifact artifact3 = artifact("b", "a-classifier", "jar", "jar")
        ResolvedArtifact artifact4 = artifact("b", "b-classifier", "b-type", "a-ext")
        ResolvedArtifact artifact5 = artifact("b", "b-classifier", "a-type", "b-ext")