if (protocol in protocols) {
            selected = protocol
            return selected
          }
        }
        selected = protocols[0] // On no intersection, try peer's first protocol.
        return selected
      } else if ((methodName == "protocolSelected" || methodName == "selected") && callArgs.size == 1) {
        this.selected = callArgs[0] as String // Server selected this protocol.
        return null

        def selected = results.select(selector, Mock(ArtifactSelectionSpec), false)

        expect:
        selected.getArtifacts() instanceof CompositeResolvedArtifactSet
        selected.getArtifacts().sets == [variant1Artifacts, variant2Artifacts]

        selected.getArtifactsWithId(0) == variant1Artifacts
        selected.getArtifactsWithId(1) == variant2Artifacts
    }

    private static ComponentState findComponent(Object selected) {
        if (selected instanceof ComponentState) {
            return (ComponentState) selected;
        }
        if (selected instanceof NodeState) {
            return ((NodeState) selected).getComponent();
        }
        throw new IllegalArgumentException("Cannot extract a ComponentState from " + selected.getClass());
    }

    /**
     * This component was selected because it's the root component.
     */
    ROOT("root"),

    /**
     * This component was selected because it was requested directly.
     */
    REQUESTED("requested"),

    /**
     * This component was selected by a rule.
     */
    SELECTED_BY_RULE("selected by rule"),

    /**
     * This component was selected because selection was forced on this version.

	reqs, ok = g.required[m]
	return reqs, ok
}

// Selected returns the selected version of the given module path.
//
// If no version is selected, Selected returns version "none".
func (g *Graph) Selected(path string) (version string) {
	v, ok := g.selected[path]
	if !ok {
		return "none"
	}
	return v
}

// BuildList returns the selected versions of all modules present in the Graph,

            selected = getPathType(path);
            if (JavaPathType.CLASSES.equals(selected)) {
                selected = JavaPathType.PROCESSOR_CLASSES;
            } else if (JavaPathType.MODULES.equals(selected)) {
                selected = JavaPathType.PROCESSOR_MODULES;
            }
        }
        return Optional.ofNullable(selected);
    }

    /**

            } else {
                it
            }
        }
        val expression = when (selected) {
            is KtExpression -> selected
            is KtValueArgument -> selected.getArgumentExpression()
            else -> null
        } ?: error("expect an expression but got ${selected.text}, ${selected::class}")
        val type = executeOnPooledThreadInReadAction {
            analyseForTest(expression) {

                scenario("Selected project").activeRequiredProjects(MODULE_B).expectResult(MODULE_B),
                scenario("Selected aggregator project (including child modules)")
                        .activeRequiredProjects(MODULE_C)
                        .expectResult(MODULE_C, MODULE_C_1, MODULE_C_2),
                scenario("Selected aggregator project with non-recursive")

    @Nullable
    private ModuleVersionIdentifier getModuleVersionId(ResolvedComponentResult selected) {
        // Match found - need to make sure that if the selection is a project, we use its publication identity
        if (selected.getId() instanceof ProjectComponentIdentifier) {
            Path identityPath = ((ProjectComponentIdentifierInternal) selected.getId()).getIdentityPath();

        when:
        def deps = builder.getRoot(id("a")).dependencies

        then:
        def b = deps.find { it.selected.id.module == 'b' }
        def c = deps.find { it.selected.id.module == 'c' }

        b.selected.selectionReason.forced
        c.selected.selectionReason.conflictResolution
    }

    def "links dependents correctly"() {
        given:
        node("a")
        node("b")