0 * handler._
    }

    def "receive queues incoming messages"() {
        when:
        connection.queueIncoming("incoming1")
        connection.queueIncoming("incoming2")
        connection.queueIncoming("incoming3")
        def result = []
        result << daemonConnection.receive(20, TimeUnit.SECONDS)

        }
    }

    private class TestConnector {
        private final BlockingQueue<InterHubMessage> incomingA = new LinkedBlockingQueue<>()
        private final BlockingQueue<InterHubMessage> outgoingA = new LinkedBlockingQueue<>()
        private final BlockingQueue<InterHubMessage> incomingB = new LinkedBlockingQueue<>()
        private final BlockingQueue<InterHubMessage> outgoingB = new LinkedBlockingQueue<>()

        expression << [
            "files",
            "incoming.resolutionResult.root",
            "incoming.resolutionResult.rootComponent.get()",
            "incoming.artifacts.artifactFiles.files",
            "incoming.artifacts.artifacts",
            "incoming.artifactView { }.files.files",
            "incoming.artifactView { }.artifacts.artifacts",
            "incoming.artifactView { }.artifacts.resolvedArtifacts.get()",

    InterHubMessage receive() {
        def message = incoming.take()
        return message == END ? null : (InterHubMessage) message
    }

    /**
     * Queues the given message to return from {@link #receive()}.
     */
    void queueIncoming(InterHubMessage message) {
        incoming.put(message)
    }

    /**
     * Marks the end of the incoming messages.
     */
    @Override
    void stop() {

    def "can access resolved files from afterResolve hook"() {
        given:
        file("thing.txt") << "stuff"
        buildFile << """
            configurations {
                things.incoming.afterResolve { incoming ->
                    incoming.files.files
                    println "accessed files"
                }
            }
            dependencies {
                things files("thing.txt")
            }

        where:
        expression                                                    | _
        "incoming.artifacts"                                          | _
        "incoming.artifactView({}).artifacts"                         | _
        "incoming.artifactView({componentFilter { true }}).artifacts" | _
        "incoming.artifactView({lenient(true)}).artifacts"            | _
    }

	m.blockQueue(func() {
		close(m.stopped)
		close(m.incoming)
	})
	m.distributing.Wait()
}

// loop receives from m.incoming and distributes to all watchers.
func (m *Broadcaster) loop() {
	// Deliberately not catching crashes here. Yes, bring down the process if there's a
	// bug in watch.Broadcaster.
	for event := range m.incoming {
		if event.Type == internalRunFunctionMarker {

        println "files 2: " + configurations.compile.incoming.files.collect { it.name }
        println "files 3: " + configurations.compile.files.collect { it.name }
        println "files 4: " + configurations.compile.resolve().collect { it.name }
        println "files 5: " + configurations.compile.incoming.artifactView({}).files.collect { it.name }

def conf = configurations.conf
conf.incoming.beforeResolve { incoming ->
    calls << "sharedBeforeResolve"
}
conf.withDependencies { incoming ->
    calls << "sharedWithDependencies"
}

def confCopy = conf.copyRecursive()
configurations.add(confCopy)

conf.incoming.beforeResolve { incoming ->
    calls << "confBeforeResolve"
}
conf.withDependencies { incoming ->
    calls << "confWithDependencies"
}

        """
    }

    def "resolve the main classes through incoming.files"() {
        buildFile << """
            task verifyFiles(type: FilesVerificationTask) {
                incomingFiles.from(configurations.compileClasspath.incoming.files)
            }
        """
        expect:
        succeeds ':verifyFiles'
    }
    def "resolve the main classes through incoming.artifacts"() {
        buildFile << """