}
    }

    @Override
    public void setMutationValidator(MutationValidator validator) {
        mutationValidator = validator;
        cachePolicy.setMutationValidator(validator);
        componentSelectionRules.setMutationValidator(validator);
        dependencySubstitutions.setMutationValidator(validator);
    }

    @Override

    DependencySubstitutions allWithDependencyResolveDetails(Action<? super DependencyResolveDetails> rule, ComponentSelectorConverter componentSelectorConverter);

    void setMutationValidator(MutationValidator validator);

    DependencySubstitutionsInternal copy();

    /**
     * Discard all state held by this container.
     */
    void discard();

        1 * details.useTarget("3.0")
        0 * details._
    }

    def "mutations trigger lenient validation"() {
        given:
        def validator = Mock(MutationValidator)
        substitutions.setMutationValidator(validator)

        when:
        substitutions.all(Mock(Action))
        then:
        1 * validator.validateMutation(STRATEGY)

        when:
        with(substitutions) {

        1 * cachePolicy.cacheDynamicVersionsFor(1 * 60 * 60 * 1000, TimeUnit.MILLISECONDS)
    }

    def "mutation is checked for public API"() {
        def validator = Mock(MutationValidator)
        strategy.setMutationValidator(validator)

        when: strategy.failOnVersionConflict()
        then: 1 * validator.validateMutation(STRATEGY)

        when: strategy.failOnDynamicVersions()

     */
    ResolutionStrategyInternal copy();

    /**
     * Sets the validator to invoke before mutation. Any exception thrown by the action will veto the mutation.
     */
    void setMutationValidator(MutationValidator action);

    /**
     * Returns the dependency locking provider linked to this resolution strategy.
     *
     * @return dependency locking provider
     */

            .toComposite();
    }

    /**
     * Sets the validator to invoke prior to each mutation.
     */
    public void setMutationValidator(MutationValidator mutationValidator) {
        this.mutationValidator = mutationValidator;
    }

    private static RuleActionAdapter createAdapter() {

        copy.artifactCacheRules == cachePolicy.artifactCacheRules
    }

    def "mutation is checked"() {
        def validator = Mock(MutationValidator)
        given:
        cachePolicy.setMutationValidator(validator)

        when:
        cachePolicy.cacheChangingModulesFor(0, TimeUnit.HOURS)
        then:
        (1.._) * validator.validateMutation(STRATEGY)

        when:

        "org.gradle" | "lib" | false
        "com.gradle" | "api" | false
    }

    def "mutation is checked for public API"() {
        def checker = Mock(MutationValidator)
        rules.setMutationValidator(checker)

        when: rules.all(Actions.doNothing())
        then: 1 * checker.validateMutation(STRATEGY)

        when: rules.all(Closure.IDENTITY)
        then: 1 * checker.validateMutation(STRATEGY)

        this.offline = policy.offline;
        this.refresh = policy.refresh;
    }

    /**
     * Sets the validator to invoke prior to each mutation.
     */
    public void setMutationValidator(MutationValidator validator) {
        this.mutationValidator = validator;
    }

    @Override
    public void setOffline() {
        mutationValidator.validateMutation(STRATEGY);
        offline = true;

                }
                return this;
            }
        };
    }

    @Override
    public void setMutationValidator(MutationValidator validator) {
        mutationValidator = validator;
    }

    @Override
    public DependencySubstitutionsInternal copy() {
        return new DefaultDependencySubstitutions(