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;

                def idsA = configurations.a.incoming.artifacts.resolvedArtifacts.map { it.id }
                def filesB = configurations.b
                def idsB = configurations.b.incoming.artifacts.resolvedArtifacts.map { it.id }
                def filesC = configurations.c
                def idsC = configurations.c.incoming.artifacts.resolvedArtifacts.map { it.id }
                doLast {

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

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

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

        try {

                Provider<Set<ResolvedArtifactResult>> resolvedArtifacts = resolvableDependencies.getArtifacts().getResolvedArtifacts();

                task.getArtifactFiles().from(resolvableDependencies.getArtifacts().getArtifactFiles());
                task.getArtifactIdentifiers().set(resolvedArtifacts.map(result -> result.stream().map(ResolvedArtifactResult::getId).collect(toList())));

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

    }

    void assertInReadOnlyCache(String... fileNames) {
        def artifacts = resolvedArtifacts
        fileNames.each { fileName ->
            assertInReadOnlyCache(artifacts[fileName])
        }
    }

    void assertNotInReadOnlyCache(String... fileNames) {
        def artifacts = resolvedArtifacts
        fileNames.each { fileName ->
            assertNotInReadOnlyCache(artifacts[fileName])

                }
                incomingArtifacts.each {
                    writeArtifact("incoming-artifact", writer, it)
                }
                incomingArtifacts.resolvedArtifacts.get().each {
                    writeArtifact("incoming-resolved-artifact", writer, it)
                }
                incomingArtifacts.artifactFiles.each {

            'logback-classic-1.0.13.jar',
            'logback-core-1.0.13.jar',
            'slf4j-api-1.7.5.jar'
        ]

        assert compile.resolvedConfiguration.resolvedArtifacts.collect { it.file.name } == [
            'logback-classic-1.0.13.jar',
            'logback-core-1.0.13.jar',
            'slf4j-api-1.7.5.jar'
        ]
    }
}

task repoNames {
    doLast {

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

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