*/
    boolean hasSeenCapability(Capability capability);

    interface Candidate {
        NodeState getNode();
        Capability getCapability();
        Collection<NodeState> getImplicitCapabilityProviders();
    }

    interface ResolutionDetails extends ConflictResolutionResult {
        Collection<? extends Capability> getCapabilityVersions();

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


    private final Collection<? extends ModuleIdentifier> participatingModules;
    private final ComponentState selected;

    }

    static PotentialEdge of(ResolveState resolveState, NodeState from, ModuleComponentIdentifier toComponent, ModuleComponentSelector toSelector, ComponentIdentifier owner) {
        return of(resolveState, from, toComponent, toSelector, owner, false, true);
    }

                // of the platform was discovered. In this case, we need to restart the selection,
                // or some members will not be upgraded
                for (NodeState nodeState : selected.getNodes()) {
                    nodeState.markForVirtualPlatformRefresh();
                }
            }
            hasForcedParticipatingModule |= isParticipatingModuleForced(state);
        }
    }

    @Nullable

        }
    }

    NodeState node(ComponentState cs) {
        def metadata = Mock(VariantGraphResolveMetadata) {
            getDependencies() >> []
            getCapabilities() >> ImmutableCapabilities.of([])
        }
        def state = Mock(VariantGraphResolveState) {
            getMetadata() >> metadata
        }

        def node = new NodeState(id++, cs, resolveState, state, true) {

    private final ResolveState resolveState;
    private final NodeState from;
    private final ModuleComponentSelector cs;
    private final ModuleComponentIdentifier componentId;
    private final ComponentIdentifier platformId; // just for reporting
    private final boolean force;
    private final boolean transitive;

            this.pending = pending;
        }

        boolean isPending() {
            return this.pending;
        }
    }

    PendingState maybeAddAsPendingDependency(NodeState node, DependencyState dependencyState);

    boolean markNotPending(ModuleIdentifier id);

    void complete();

            .sorted(Comparator.comparing(AssessedCandidate::getDisplayName))
            .collect(Collectors.toList());
    }

    public List<AssessedCandidate> assessNodeStates(Set<NodeState> nodes) {
        return nodes.stream()
            .map(NodeState::getMetadata)
            .map(variant -> assessCandidate(variant.getName(), variant.getCapabilities(), variant.getAttributes().asImmutable()))

import org.gradle.internal.component.model.DependencyMetadata;
import org.gradle.internal.component.model.VariantGraphResolveState;

import java.util.List;
import java.util.Set;

class RootNode extends NodeState implements RootGraphNode {
    private final ResolveOptimizations resolveOptimizations;
    private final List<? extends DependencyMetadata> syntheticDependencies;

    private final VirtualPlatformState platformState;
    private final NodeState platformNode;
    private final ResolveState resolveState;

    LenientPlatformResolveMetadata(ModuleComponentIdentifier moduleComponentIdentifier, ModuleVersionIdentifier moduleVersionIdentifier, VirtualPlatformState platformState, NodeState platformNode, ResolveState resolveState) {
        this.moduleComponentIdentifier = moduleComponentIdentifier;