from.attribute(artifactType, "jar")
                        to.attribute(artifactType, "red")
                    }
                }
                tasks.register("resolveRed") {
                    def artifacts = configurations.compile.incoming.artifactView {
                        attributes { it.attribute(artifactType, 'red') }
                    }.artifacts

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

     *
     * @return resolved dependencies files
     * @since 3.3
     */
    Set<File> getFiles();

    /**
     * Returns successfully resolved files. Ignores dependencies or files that cannot be resolved.
     *
     * @param dependencySpec dependency spec
     * @return resolved dependencies files
     *

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

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

}
// end::defining-sources-jar-task[]

// tag::pom-customization[]
// tag::versions-resolved[]
publishing {
    publications {
        create<MavenPublication>("mavenJava") {
// end::versions-resolved[]
// end::pom-customization[]
            artifactId = "my-library"
            from(components["java"])
// tag::versions-resolved[]
            versionMapping {
                usage("java-api") {

    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

        then: // Succeeds: configuration is not 'resolved' as part of the task inputs
        outputContains('[direct-dep-1.0.jar]')

        when:

        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 :.")

        descriptor.authoritative
        descriptor.hasResult()
    }

    def "can mark as resolved using meta-data"() {
        def metaData = Stub(ModuleComponentResolveMetadata)

        when:
        descriptor.resolved(metaData)

        then:
        descriptor.state == BuildableModuleComponentMetaDataResolveResult.State.Resolved
        descriptor.failure == null
        descriptor.metaData == metaData