for (NodeState node : nodes) {
            if (node.isSelected()) {
                consumer.accept(node);
            }
        }
    }

    @Override
    public List<ComponentState> getDependents() {
        List<ComponentState> incoming = Lists.newArrayListWithCapacity(nodes.size());
        for (NodeState node : nodes) {
            for (EdgeState dependencyEdge : node.getIncomingEdges()) {

            if (componentState.isCandidateForConflictResolution()) {
                versions.add(componentState);
            }
        }
        return versions;
    }

    public Collection<ComponentState> getAllVersions() {
        return this.versions.values();
    }

    private static boolean areAllCandidatesForSelection(Collection<ComponentState> values) {

    def componentState = Stub(ModuleComponentGraphResolveState)
    @Subject
    CachedMetadataProvider provider

    def 'verifies that metadata was provided when state is Resolved'() {
        given:
        cachedResult.state >> BuildableModuleComponentMetaDataResolveResult.State.Resolved
        cachedResult.metaData >> componentState
        provider = new CachedMetadataProvider(cachedResult)

        resolver.resolve(dependencyMetaData, null, null, result)

        then:
        1 * registry.getComponent(id) >> componentState
        1 * result.resolved(componentState, _)
        0 * result._
    }

    def "resolves project component"() {
        setup:
        def componentState = Mock(LocalComponentGraphResolveState)
        def result = Mock(BuildableComponentResolveResult)

            result.resolved(componentState)
        }
        1 * result.resolved(_, _) >> { ComponentGraphResolveState state, ComponentGraphSpecificResolveState graphState ->
            assert state == componentState
            assert graphState.repositoryName == repo.name
        }

        and:
        0 * localAccess._

    @Issue("gradle/gradle#5920")
    def "order of components should be preserved"() {
        PotentialConflict conflict
        CapabilityInternal capability = capability()
        ComponentState cs1 = component("g", "m1")
        ComponentState cs2 = component("g", "m2")

        def expectedIds = [cs1, cs2].collect { it.id.module }

        when:
        conflict = handler.registerCandidate(
            candidate(capability, cs1)

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.builder.NodeState;

import java.util.Collection;
import java.util.stream.Collectors;

class DefaultConflictResolutionResult implements ConflictResolutionResult {

    private static ComponentState findComponent(Object selected) {
        if (selected instanceof ComponentState) {

    private final ModuleConflictResolver<ComponentState> resolver;
    private final ConflictContainer<ModuleIdentifier, ComponentState> conflicts = new ConflictContainer<>();
    private final ModuleReplacementsData moduleReplacements;

    public DefaultConflictHandler(ModuleConflictResolver<ComponentState> resolver, ModuleReplacementsData moduleReplacements) {
        this.resolver = resolver;

        return processed;
    }

    /**
     * Attempts to resolve a target `ComponentState` for the given dependency.
     * On successful resolve, a `ComponentState` is constructed for the identifier, recorded as {@link ModuleResolveState#getSelected()},
     * and added to the graph.
     * On resolve failure, the failure is recorded and no `ComponentState` is selected.
     */

        def componentState = Stub(ComponentGraphResolveState)
        _ * componentState.instanceId >> componentId
        _ * componentState.id >> DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId(org, name), ver)
        _ * componentState.metadata >> componentMetadata

        def variant = Stub(ResolvedGraphVariant)