MutationValidator.MutationType.DEPENDENCY_ATTRIBUTES,
            MutationValidator.MutationType.DEPENDENCY_CONSTRAINT_ATTRIBUTES,
            MutationValidator.MutationType.ARTIFACTS,
            MutationValidator.MutationType.USAGE,
            MutationValidator.MutationType.HIERARCHY
        ]
    }

    def "does not reevaluate component metadata when #mutationType change"() {

         * prevented on resolved configurations.
         */
        DEPENDENCY_ATTRIBUTES("dependency attributes"),

        /**
         * The mutation of the attributes (other than coordinates) of a dependency constraint.
         * Theoretically these should be bundled under {@link MutationType#DEPENDENCIES}, but these mutations are not (yet)

            return true;
        }
        return false;
    }

    private void preventIllegalParentMutation(MutationType type) {
        // TODO: We can remove this check once we turn `maybePreventMutation` into an error
        if (type == MutationType.DEPENDENCY_ATTRIBUTES || type == MutationType.DEPENDENCY_CONSTRAINT_ATTRIBUTES) {
            return;
        }

        if (isFullyResoled(currentResolveState.get())) {

            ((DependencyConstraintInternal) dependencyConstraint).addMutationValidator(constraint ->
                ((MutationValidator) clientConfiguration).validateMutation(MutationValidator.MutationType.DEPENDENCY_CONSTRAINT_ATTRIBUTES)
            );
        }
        return addInternalDependencyConstraint(dependencyConstraint);
    }

        @Nullable
        private LocalComponentGraphResolveState cachedValue;

        @Override
        public void validateMutation(MutationType type) {
            if (type != MutationType.STRATEGY) {
                LocalComponentGraphResolveState value = currentValue();
                if (value != null) {
                    value.reevaluate();
                }
            }

        this.getEventRegister().registerLazyAddAction(x -> rootComponentMetadataBuilder.getValidator().validateMutation(MutationValidator.MutationType.HIERARCHY));
        this.whenObjectRemoved(x -> rootComponentMetadataBuilder.getValidator().validateMutation(MutationValidator.MutationType.HIERARCHY));
    }

    @Override
    @SuppressWarnings("deprecation")
    protected Configuration doCreate(String name) {

import java.util.concurrent.TimeUnit

import static org.gradle.api.internal.artifacts.DefaultModuleVersionSelector.newSelector
import static org.gradle.api.internal.artifacts.configurations.MutationValidator.MutationType.STRATEGY

class DefaultResolutionStrategySpec extends Specification {

    def cachePolicy = Mock(DefaultCachePolicy)
    def dependencySubstitutions = Mock(DependencySubstitutionsInternal)

import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import static org.gradle.api.internal.artifacts.configurations.MutationValidator.MutationType.STRATEGY;

public class DefaultResolutionStrategy implements ResolutionStrategyInternal {

    private static final String ASSUME_FLUID_DEPENDENCIES = "org.gradle.resolution.assumeFluidDependencies";

                        // things like dependency constraints here
                        bar.validateMutation(${MutationValidator.MutationType.class.name}.DEPENDENCIES)
                    }
                }
            }
            dependencies {
                foo project(path: ':lib', configuration: 'foo')