this.projectDependencies.from(runtimeClasspath.incoming.artifactView {
            componentFilter {
                it is ProjectComponentIdentifier
            }
        }.files)
        this.externalDependencies.from(runtimeClasspath.incoming.artifactView {
            componentFilter {
                externalComponents.contains(it)
            }
        }.files)

     *
     * @param type The type
     * @return A sink. Method calls made on this object are sent as outgoing messages.
     */
    <T> T addOutgoing(Class<T> type);

    /**
     * Registers a handler for incoming messages on the given type. The provided handler is not required to be
     * thread-safe. Messages are delivered to the handler by a single thread.
     *

"""
    }

    def "downloads only the metadata when dependency graph is queried"() {
        given:
        buildFile << """
            task graph {
                def root = configurations.compile.incoming.resolutionResult.rootComponent
                doLast {
                    root.get()
                }
            }
"""

        when:
        module.pom.expectGet()
        module2.pom.expectGet()

public interface ConnectionAcceptor extends AsyncStoppable {
    Address getAddress();

    /**
     * Stops accepting incoming connections.
     */
    @Override
    void requestStop();

    /**
     * Stops accepting incoming connections and blocks until the accept action has completed executing for any queued connections.
     */
    @Override
    void stop();

import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.Global.class)
public interface IncomingConnector {
    /**
     * Starts listening for incoming connections. Assigns an arbitrary address for the endpoint.
     *
     * @param action the action to execute on incoming connection. The supplied action is not required to be thread-safe.

val codeCoverageReport by tasks.registering(JacocoReport::class) {
    additionalClassDirs(classesPath.filter { it.isDirectory() })
    additionalSourceDirs(sourcesPath.incoming.artifactView { lenient(true) }.files)
    executionData(coverageDataPath.incoming.artifactView { lenient(true) }.files.filter { it.exists() })

    reports {
        html.required = true
        xml.required = true
    }
}

        given:
        buildFile << """
            configurations {
                parent { }
                things.extendsFrom parent
                all {
                    incoming.beforeResolve { throw new RuntimeException() }
                    incoming.afterResolve { throw new RuntimeException() }
                }
            }
            dependencies {
                parent files("parent.txt")

package org.gradle.execution.plan.edges;

import org.gradle.execution.plan.Node;
import org.gradle.execution.plan.NodeSets;

import java.util.SortedSet;
import java.util.function.Consumer;

/**
 * Only incoming dependencies, no incoming must-run-after or finalizes relationships.
 */
class DependencyPredecessorsOnlyNodeSet implements DependentNodesSet {
    private final SortedSet<Node> dependencyPredecessors = NodeSets.newSortedNodeSet();

// A function that returns extra dependencies for each op. These might
// e.g. be known side-effects (or control dependencies) between ops.
// If "incoming" is true, then the list of (extra) predecessors of the
// op should be returned. If "incoming" is false, the list of successors.
// The algorithm assumes that these are consistent which each other. So
// if (and only if) op1 is in extra_dependencies(op2, true), then op2

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