} else {
            return matchesRequested(candidate);
        }
    }

    private boolean matchesRequested(DependencyResult candidate) {
        ComponentSelector requested = candidate.getRequested();

        if (requested instanceof ModuleComponentSelector) {
            ModuleComponentSelector requestedModule = (ModuleComponentSelector)requested;

                throw new GradleException("Conflicting external source dependency rules were found in nested builds for " + mapping.getRequested().getDisplayName() + ":\n  " + CollectionUtils.join("\n  ", resolutionDisplayNames));
            }
        }
    }

    @Override
    public boolean hasRules() {

        this.requested = requested;
        this.target = requested;
        this.artifactSelectionDetails = new DefaultArtifactSelectionDetails(this, artifacts);
    }

    @Override
    public ComponentSelector getRequested() {
        return requested;
    }

    @Override
    public void useTarget(Object notation) {
        useTarget(notation, ComponentSelectionReasons.SELECTED_BY_RULE);
    }

    @Override

    public List<ResolvedVariantResult> getAllVariants() {
        return allVariants;
    }

    @Override
    public AttributeContainer getAttributes() {
        ComponentSelector requested = dependency.getRequested();
        return requested instanceof ModuleComponentSelector
            ? requested.getAttributes()
            : ImmutableAttributes.EMPTY;
    }

    @Override
    public List<Section> getExtraDetails() {

     * The requested dependency does not change even if there are multiple dependency substitution rules
     * that manipulate the dependency metadata.
     */
    ComponentSelector getRequested();

    /**
     * This method can be used to replace a dependency before it is resolved,
     * e.g. change group, name or version (or all three of them), or replace it
     * with a project dependency.
     *

    }

    private AbstractRenderableDependencyResult dep(ComponentSelector requested, ComponentIdentifier selected) {
        return new AbstractRenderableDependencyResult() {
            ComponentSelector getRequested() {
                return requested
            }

            ComponentIdentifier getActual() {
                return selected
            }
        }
    }

                sb.append("\n");
            }
        }
    }

    private static void renderSelector(StringBuilder sb, SelectorState selectorState) {
        sb.append('\'').append(selectorState.getRequested()).append('\'');
    }

    private static void renderReason(StringBuilder sb, SelectorState selector) {
        ComponentSelectionReasonInternal selectionReason = selector.getSelectionReason();

            ModuleVersionResolveException failure = dependency.getFailure();
            if (failure != null) {
                addUnresolvedDependency(dependency, dependency.getRequested(), failure);
            }
        }
    }

    public Set<UnresolvedDependency> complete(Set<UnresolvedDependency> extraFailures) {
        if (extraFailures.isEmpty() && failuresByRevisionId.isEmpty()) {

    }

    private DependencyResult asDependencyResult(final ModuleVersionIdentifier versionIdentifier) {
        return new DependencyResult() {
            @Override
            public ComponentSelector getRequested() {
                return DefaultModuleComponentSelector.newSelector(versionIdentifier.getModule(), versionIdentifier.getVersion());
            }

            @Override

            }
            getExclusions() >> Mock(ExcludeSpec)
            getAttributes() >> ImmutableAttributes.EMPTY
            getSelector() >> Mock(DependencyGraphSelector) {
                getRequested() >> Mock(ComponentSelector) {
                    getRequestedCapabilities() >> []
                }
            }
        }
        graphSelector = Mock(GraphVariantSelector) {