}

    def "generates event for resolving intrinsic artifacts via incoming file collection"() {
        given:
        settingsFile << settingsFileContent()
        buildFile << buildFileContent('.incoming.files')
        expectDownload()

        when:
        def events = ProgressEvents.create()
        withConnection {

            dependencies {
                conf 'org:foo:0.5', 'org:bar:1.0', 'org:baz:1.0'
            }
            task resolutionResult {
                doLast {
                    def result = configurations.conf.incoming.resolutionResult
                    result.allComponents {
                        if(it.id instanceof ModuleComponentIdentifier) {
                            println it.id.module + ":" + it.id.version + " " + it.selectionReason

                implementation(project(":producer"))
            }

            task resolve {
                def conf = configurations.classpath
                def root = conf.incoming.resolutionResult.root
                def artifactVariants = conf.incoming.artifacts.artifacts.collect { it.variant }
                doLast {
                    def graphVariant = root.dependencies.find { it.selected.id.projectPath == ":producer" }.resolvedVariant

                    }
                }

                task resolve {
                    // Get a view specifying the default type
                    def defaultView = configurations.compile.incoming.artifactView {
                        attributes {
                            it.attribute(artifactType, 'jar')
                        }
                    }
                    def defaultFiles = defaultView.files

            }
"""
    }

    def "artifact collection has resolved artifact files and metadata"() {
        when:
        buildFile << """
            def artifacts = configurations.compile.incoming.artifacts

            task checkArtifacts {
                doLast {
                    def artifactFiles = artifacts.artifactFiles
                    def artifactResults = artifacts.artifacts

                compile 'test:test:1.2:util@aar'
                compile('test:test-api:1.2') { targetConfiguration = 'compile' }
            }
            task show {
                def artifacts = configurations.compile.incoming.artifacts
                inputs.files artifacts.artifactFiles
                doLast {
                    artifacts.each {
                        println it.file.name + ' ' + it.variant.attributes
                    }

// filter when they previously didn't.
func Filter(w Interface, f FilterFunc) Interface {
	fw := &filteredWatch{
		incoming: w,
		result:   make(chan Event),
		f:        f,
	}
	go fw.loop()
	return fw
}

type filteredWatch struct {
	incoming Interface
	result   chan Event
	f        FilterFunc
}

// ResultChan returns a channel which will receive filtered events.

        }

        @Override
        void flush() {
            dispatch.flush()
        }

        InterHubMessage receive() {
            return incoming.take()
        }

        void stop() {
            incoming.put(new EndOfStream())
        }
    }

            detached.dependencies.add(project.dependencies.create(project(':other')))

            task checkDependencies(type: CheckDependencies) {
                result = detached.incoming.resolutionResult.rootComponent
                artifacts = detached.incoming.artifacts
            }

        """

        file("other/build.gradle") << """
            plugins {
                id 'java-library'
            }

            actualFiles = findLines(configDetails, 'incoming-file')
            compare("incoming.files", actualFiles, expectedFiles)

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

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