}
        }

        ProjectResolutionResult resolutionResult = resolveProject(selection, selection.getOriginalPath(), defaultBuild);
        return getSelectorForBuild(resolutionResult.build).getSelection(selection, resolutionResult.project, resolutionResult.taskName, resolutionResult.includeSubprojects);
    }

    @Override

        val allReceiverReferences = resolutionResult.conventionAdditions.map { it.container } +
            resolutionResult.conventionAssignments.map { it.lhs.receiverObject } +
            resolutionResult.conventionNestedObjectAccess.map { it.dataObject.accessor.access(it.container, it.dataObject) } +
            resolutionResult.additions.map { it.container } +
            resolutionResult.assignments.map { it.lhs.receiverObject } +

            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) {

        """

        buildA.buildFile << """
            def runtimeClasspath = configurations.runtimeClasspath
            def rootProvider = runtimeClasspath.incoming.resolutionResult.rootComponent
            classes.doLast {
                def rootComponent = rootProvider.get()
                assert rootComponent.id.build.buildPath == ':'
                assert rootComponent.id.build.name == ':'

        }

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

                    result = IncludeFileResolutionResult.HasMacroIncludes;
                }
                SourceIncludesResolver.IncludeResolutionResult resolutionResult = sourceIncludesResolver.resolveInclude(file, include, visibleMacros);
                if (!resolutionResult.isComplete()) {
                    LOGGER.info("Cannot locate header file for '{}' in source file '{}'. Assuming changed.", include.getAsSourceText(), file.getName());

            }

            loggingCapabilities {
                enforceLogback()
            }

            tasks.register("resolve") {
                def root = configurations.runtimeClasspath.incoming.resolutionResult.rootComponent
                doLast {
                    println root.get()
                }
            }
        """

        expect:
        succeeds("resolve", "--stacktrace")
    }

                    configurations.compileClasspath.incoming.resolutionResult.allDependencies.collect {
                        it.toString()
                    } as Set
                }
                def incomingRuntimeClasspath = provider {
                    configurations.runtimeClasspath.incoming.resolutionResult.allDependencies.collect {
                        it.toString()
                    } as Set

            dependencies {
                conf("org:moduleA:1.0")
            }

            tasks.named("checkDeps") {
                doLast {
                    def result = configurations.conf.incoming.resolutionResult
                    boolean found = false
                    result.allComponents {
                        if (id instanceof ModuleComponentIdentifier && id.module == 'moduleA') {

                dependencies {
                    conf project(":")
                }
            }

            task resolve {
                def result = buildscript.configurations.conf.incoming.resolutionResult
                def root = result.root
                assert root.id.projectName == 'root'
                assert root.variants.size() == 2
                def conf = root.variants.find { it.displayName == 'conf' }