}
                configurations {
                    compile {
                        attributes.attribute color, 'blue'
                    }
                }
                task resolveRed(type: Resolve) {
                    artifacts = configurations.compile.incoming.artifactView {
                        attributes { it.attribute(color, 'red') }
                    }.artifacts
                }

        def results4 = new DefaultVisitedGraphResults(resolutionResult, Collections.singleton(unresolved), resolveEx)

        expect:
        visitFailures(results1) == []
        visitFailures(results2) == [throwable]
        visitFailures(results3) == [resolveEx]
        visitFailures(results4) == [throwable, resolveEx]
    }

    is ObjectOrigin.External -> resolveRef(objectOrigin.key.objectType)
    is ObjectOrigin.NewObjectFromMemberFunction -> resolveRef(objectOrigin.function.returnValueType)
    is ObjectOrigin.NewObjectFromTopLevelFunction -> resolveRef(objectOrigin.function.returnValueType)
    is ObjectOrigin.PropertyReference -> resolveRef(objectOrigin.property.valueType)
    is ObjectOrigin.PropertyDefaultValue -> resolveRef(objectOrigin.property.valueType)

        then:
        1 * localAccess.resolveComponentMetaData(moduleComponentId, componentRequestMetaData, _) >> { id, meta, result ->
            result.resolved(componentState)
        }
        1 * result.resolved(_, _) >> { ComponentGraphResolveState state, ComponentGraphSpecificResolveState graphState ->
            assert state == componentState
            assert graphState.repositoryName == repo.name

        and: "Has error output"
        failure.assertHasDescription("Could not determine the dependencies of task ':forceResolution'.")
        failure.assertHasCause("Could not resolve all dependencies for configuration ':resolveMe'.")
        failure.assertHasCause("Could not resolve project :.")

    /**
     * A {@link FileCollection} containing all resolved files. The returned collection
     * carries all task dependencies required to build the resolved files, and when used
     * as a task input the files will be built before the task executes.
     */
    FileCollection getFiles();

    /**
     * A set of resolved artifacts corresponding to the resolved files.
     */
    ArtifactCollection getArtifacts();

    def "Older Gradle versions mark all dependencies as resolved"() {
        when:
        def project = loadToolingModel(EclipseProject)
        def allDependencies = project.classpath

        then:
        allDependencies.size() == 2
        allDependencies[0].resolved
        allDependencies[0].attemptedSelector == null
        allDependencies[1].resolved
        allDependencies[1].attemptedSelector == null
    }

        carets.flatMap { findReferencesAtCaret(mainFile, it.offset) }.forEach { reference ->
            val resolved = reference.resolve() ?: testServices.assertions.fail { "Could not resolve reference at caret" }
            testServices.assertions.assertTrue(reference.isReferenceTo(resolved))
            testServices.assertions.assertEqualsToTestDataFileSibling(resolved.renderResolvedPsi(testServices))
        }
    }

        get() = mutableNestedObjectAccess

    private
    val typeRefContext = SchemaTypeRefContext(schema)

    override fun resolveRef(dataTypeRef: DataTypeRef): DataType = typeRefContext.resolveRef(dataTypeRef)

    fun enterScope(newScope: AnalysisScope) {
        mutableScopes.add(newScope)
    }

    @Subject
    CachedMetadataProvider provider

    def 'verifies that metadata was provided when state is Resolved'() {
        given:
        cachedResult.state >> BuildableModuleComponentMetaDataResolveResult.State.Resolved
        cachedResult.metaData >> componentState
        provider = new CachedMetadataProvider(cachedResult)

        expect:
        provider.usable