}

        @Override
        public int compare(ResolvableSelectorState left, ResolvableSelectorState right) {
            if (right.isProject() == left.isProject()) {
                if (right.isFromLock() == left.isFromLock()) {
                    if (hasLatestSelector(right) == hasLatestSelector(left)) {
                        if (isDynamicSelector(right) == isDynamicSelector(left)) {

        return source;
    }

    @Override
    public boolean isForce() {
        return delegate.isForce();
    }

    @Override
    public boolean isFromLock() {
        return delegate.isFromLock();
    }

    @Override
    public List<IvyArtifactName> getArtifacts() {
        return artifacts;
    }

    @Override

        return dependency instanceof ForcingDependencyMetadata && ((ForcingDependencyMetadata) dependency).isForce();
    }

    public boolean isFromLock() {
        return dependency instanceof LocalOriginDependencyMetadata && ((LocalOriginDependencyMetadata) dependency).isFromLock();
    }

    void addSelectionReasons(List<ComponentSelectionDescriptorInternal> reasons) {
        if (reasonsAlreadyAdded) {
            return;

            Registration registration = results.get(i);
            ComponentIdResolveResult discovered = registration.result;
            if (selectorAcceptsCandidate(selector, discovered, registration.selector.isFromLock())) {
                found = discovered;
                selector.markResolved();
                break;
            }
        }
        if (found!=null) {
            register(selector, found);

    @Override
    LocalOriginDependencyMetadata forced();

    /**
     * Is this a dependency constraint created for a dependency lock?
     */
    boolean isFromLock();

    }

    @Override
    boolean isForce() {
        return false
    }

    @Override
    boolean isSoftForce() {
        return false
    }

    @Override
    boolean isFromLock() {
        return false
    }

    @Override
    boolean hasStrongOpinion() {
        return false
    }

    @Override
    IvyArtifactName getFirstDependencyArtifact() {
        return null

     * In that case, a call to {@link #resolve(VersionSelector)} is not required.
     */
    void markResolved();

    boolean isForce();

    boolean isSoftForce();

    boolean isFromLock();

    boolean hasStrongOpinion();

    IvyArtifactName getFirstDependencyArtifact();

    @Deprecated
    org.gradle.api.artifacts.ClientModule getClientModule();

    boolean isChanging();

    @Override
    public boolean isForce() {
        return false;
    }

    @Override
    public boolean isSoftForce() {
        return false;
    }

    @Override
    public boolean isFromLock() {
        return false;
    }

    @Override
    public boolean hasStrongOpinion() {
        return false;
    }

    @Override
    public IvyArtifactName getFirstDependencyArtifact() {

    @Override
    public LocalOriginDependencyMetadata forced() {
        if (force) {
            return this;
        }
        return copyWithForce();
    }

    @Override
    public boolean isFromLock() {
        return fromLock;
    }

    @Override
    public DependencyMetadata withReason(String reason) {
        if (Objects.equal(reason, this.reason)) {
            return this;
        }

        Mock(ResolvableSelectorState) {
            getVersionConstraint() >> Mock(ResolvedVersionConstraint) {
                getPreferredSelector() >> new ExactVersionSelector(version)
            }
            isFromLock() >> true
            toString() >> "lock $version"
        }
    }