then: 1 * validator.validateMutation(STRATEGY)

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

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

        when: strategy.failOnNonReproducibleResolution()
        then: 2 * validator.validateMutation(STRATEGY)

    public DependencyConstraint attributes(Action<? super AttributeContainer> configureAction) {
        if (attributesFactory == null) {
            warnAboutInternalApiUse();
            return this;
        }
        validateMutation();
        if (attributes == null) {
            attributes = attributesFactory.mutable();
        }
        configureAction.execute(attributes);
        return this;
    }

    @Override
    public void because(String reason) {
        validateMutation();
    }

    @Override
    protected void validateMutation() {
        throw new UnsupportedOperationException("Minimal dependencies are immutable.");
    }

    @Override
    protected void validateMutation(Object currentValue, Object newValue) {
        validateMutation();
    }

    @Override

        then:
        (1.._) * validator.validateMutation(STRATEGY)

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

        when:
        cachePolicy.eachArtifact(Actions.doNothing())
        then:
        1 * validator.validateMutation(STRATEGY)

        when:

    @Override
    public ResolutionStrategy failOnVersionConflict() {
        mutationValidator.validateMutation(STRATEGY);
        this.conflictResolution = ConflictResolution.strict;
        return this;
    }

    @Override
    public ResolutionStrategy failOnDynamicVersions() {
        mutationValidator.validateMutation(STRATEGY);
        this.failOnDynamicVersions = true;
        return this;
    }

        this.mutationValidator = validator;
    }

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

    @Override
    public void setRefreshDependencies() {
        mutationValidator.validateMutation(STRATEGY);
        refresh = true;
    }

    public void cacheDynamicVersionsFor(final int value, final TimeUnit unit) {

        this.onMutate = onMutate.add(action);
    }

    protected void validateMutation() {
        onMutate.execute(this);
    }

    protected void validateMutation(Object currentValue, Object newValue) {
        if (!Objects.equal(currentValue, newValue)) {
            validateMutation();
        }
    }

    private void validateNotVariantAware() {

    @Override
    public void because(String reason) {
        validateMutation();
    }

    @Override
    protected void validateMutation() {
        throw new UnsupportedOperationException("Minimal dependencies are immutable.");
    }

    @Override
    protected void validateMutation(Object currentValue, Object newValue) {
        validateMutation();
    }

    @Override

    public void because(@Nullable String reason) {
        validateMutation();
        this.reason = reason;
    }

    @Override
    public AttributeContainer getAttributes() {
        return projectDependency.getAttributes();
    }

    @Override
    public DependencyConstraint attributes(Action<? super AttributeContainer> configureAction) {
        validateMutation();
        projectDependency.attributes(configureAction);

        then: 1 * checker.validateMutation(STRATEGY)

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

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

        when: rules.withModule("something:else", Actions.doNothing())
        then: 1 * checker.validateMutation(STRATEGY)