when:
        details.useTarget(null)

        then:
        thrown(UnsupportedNotationException)

        when:
        details.useTarget(null, SELECTED_BY_RULE)

        then:
        thrown(UnsupportedNotationException)
    }

    def "can specify target module"() {
        when:
        details.useTarget("org:bar:2.0")

        then:

            delegate.useTarget(useSelector, selectionReason);
        } else if (useVersion != null) {
            if (delegate.getTarget() instanceof ModuleComponentSelector) {
                ModuleComponentSelector target = (ModuleComponentSelector) delegate.getTarget();
                if (!useVersion.equals(target.getVersionConstraint())) {

    public ComponentSelector getRequested() {
        return requested;
    }

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

    @Override
    public void useTarget(Object notation, String reason) {
        useTarget(notation, componentSelectionDescriptorFactory.newDescriptor(SELECTED_BY_RULE, reason));
    }

    @Override

        given:
        substitutions.all({ it.useTarget("1.0") } as Action)
        substitutions.all({ it.useTarget("2.0") } as Action)
        substitutions.all({ it.useTarget("3.0") } as Action)
        def details = Mock(DependencySubstitutionInternal)

        when:
        substitutions.ruleAction.execute(details)

        then:
        1 * details.useTarget("1.0")
        then:

    @Override
    public ComponentSelector getRequested() {
        throw methodShouldNotHaveBeenCalled();
    }

    @Override
    public void useTarget(Object notation) {
        throw methodShouldNotHaveBeenCalled();
    }

    @Override
    public void useTarget(Object notation, String reason) {
        throw methodShouldNotHaveBeenCalled();
    }

    @Override

configurations.all {
    resolutionStrategy.eachDependency {
        if (requested.name == "groovy-all") {
            useTarget(mapOf("group" to requested.group, "name" to "groovy", "version" to requested.version))
            because("""prefer "groovy" over "groovy-all"""")
        }
        if (requested.name == "log4j") {
            useTarget("org.slf4j:log4j-over-slf4j:1.7.10")

        when:
        details.useTarget("com:bar:3.0")

        then:
        details.target.toString() == 'com:bar:3.0'

        when:
        details.useVersion('5.0')

        then:
        details.target.toString() == 'com:bar:5.0'
    }

    def "can provide a custom selection reason with useTarget"() {
        def details = newDependencyResolveDetails("org", "foo", "1.0")

        if (details.requested.name == 'groovy-all') {
            details.useTarget group: details.requested.group, name: 'groovy', version: details.requested.version
            details.because "prefer 'groovy' over 'groovy-all'"
        }
        if (details.requested.name == 'log4j') {
            details.useTarget "org.slf4j:log4j-over-slf4j:1.7.10"

     * return a target module with updated target version.
     * <p>
     * If you need to change not only the version but also group or name please use the {@link #useTarget(Object)} method.
     *
     * @param version to use when resolving this dependency, cannot be null.
     * It is valid to configure the same version as requested.
     */
    void useVersion(String version);

                @Override
                public void useTarget(Object notation, ComponentSelectionDescriptor ruleDescriptor) {
                    ds.useTarget(addImplicitRequestAttributesAndCapabilities(notation), ruleDescriptor);
                }

                @Override
                public void useTarget(Object notation) {
                    ds.useTarget(addImplicitRequestAttributesAndCapabilities(notation));