private final boolean allowNoMatchingVariants;
    private final ResolutionStrategy.SortOrder sortOrder;

    public ArtifactSelectionSpec(
        ImmutableAttributes requestAttributes,
        Spec<? super ComponentIdentifier> componentFilter,
        boolean selectFromAllVariants,
        boolean allowNoMatchingVariants,
        ResolutionStrategy.SortOrder sortOrder
    ) {
        this.requestAttributes = requestAttributes;

            metadataHandler.getModuleMetadataProcessor().getModuleReplacements(),
            resolutionStrategy.getDependencySubstitutionRule(),
            resolutionStrategy.getConflictResolution(),
            resolutionStrategy.getCapabilitiesResolutionRules(),
            resolutionStrategy.isFailingOnDynamicVersions(),
            resolutionStrategy.isFailingOnChangingVersions(),
            new CompositeDependencyGraphVisitor(visitors)

        buildFile << """
            $common

            dependencies {
                conf 'org.stuff:foo:2.0', 'org.utils:impl:1.3', 'org.utils:optional-lib:5.0'
            }

            configurations.conf.resolutionStrategy {
                dependencySubstitution {
                    all {
                        if (it.requested instanceof ModuleComponentSelector) {

import org.gradle.api.artifacts.ResolutionStrategy
import spock.lang.Specification
import spock.lang.Subject

class DefaultDependencyLockingHandlerTest extends Specification {

    def 'activates dependency locking on configurations'() {
        given:
        ConfigurationContainer container = Mock()
        Configuration configuration = Mock()
        ResolutionStrategy strategy = Mock()
        @Subject

// tag::locking-explicit[]
// tag::locking-single[]
configurations {
    compileClasspath {
        resolutionStrategy.activateDependencyLocking()
    }
// end::locking-single[]
    runtimeClasspath {
        resolutionStrategy.activateDependencyLocking()
    }
    annotationProcessor {
        resolutionStrategy.activateDependencyLocking()
    }
// tag::locking-single[]
}
// end::locking-single[]

dependencies {

// Need to have at least one configuration declared, otherwise the rules are never evaluated
val conf by configurations.creating

// tag::module_to_project_substitution[]
configurations.all {
    resolutionStrategy.dependencySubstitution {
        substitute(module("org.utils:api"))
            .using(project(":api")).because("we work with the unreleased development version")
        substitute(module("org.utils:util:2.5")).using(project(":util"))
    }
}

configurations.all {
    resolutionStrategy {
        failOnVersionConflict()
    }
}
// end::fail-on-version-conflict[]

// tag::fail-on-dynamic[]
configurations.all {
    resolutionStrategy {
        failOnDynamicVersions()
    }
}
// end::fail-on-dynamic[]

// tag::fail-on-changing[]
configurations.all {
    resolutionStrategy {
        failOnChangingVersions()
    }
}

        pluginBuilder.publishAs("org.example.plugin:plugin:${version}", mavenRepo, executer)
    }

    private void useCustomRepository(String resolutionStrategy = "") {
        settingsFile << """
          pluginManagement {
            $resolutionStrategy
            repositories {
                maven {
                    url "${mavenRepo.uri}"
                }
            }
          }
        """

        return Collections.unmodifiableSet(parsedForcedModules);
    }

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

    @Override
    public ResolutionStrategy failOnDynamicVersions() {
        mutationValidator.validateMutation(STRATEGY);

        }
    }
    configurations.classpath {
        resolutionStrategy.activateDependencyLocking()
    }
    dependencies {
        classpath 'org.foo:foo-plugin:[1.0,2.0)'
    }
}
repositories {
    maven {
        url = '$mavenRepo.uri'
    }
}
configurations {
    classpath {
        resolutionStrategy.activateDependencyLocking()
    }
}
dependencies {