given:
        ResolutionStrategyInternal resolutionStrategy = Mock()

        resolveContext.name >> 'lockedConf'
        resolveContext.resolutionStrategy >> resolutionStrategy
        resolveContext.hasDependencies() >> false

        when:
        dependencyResolver.resolveBuildDependencies(resolveContext)

        then:

        0 * resolutionStrategy._
    }

    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) {

        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);

        }
    }
}
dependencies {
    components {
        all(StatusRule)
    }
}

// tag::reject-version-1-1[]
configurations {
    rejectConfig {
        resolutionStrategy {
            componentSelection {
                // Accept the highest version matching the requested version that isn't '1.5'
                all { ComponentSelection selection ->

        }
    }
}
dependencies {
    components {
        all(StatusRule::class.java)
    }
}

// tag::reject-version-1-1[]
configurations {
    create("rejectConfig") {
        resolutionStrategy {
            componentSelection {
                // Accept the highest version matching the requested version that isn't '1.5'
                all {

 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact

import org.gradle.api.artifacts.ResolutionStrategy
import org.gradle.api.artifacts.component.ComponentSelector
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ExcludeSpec

import org.gradle.api.internal.artifacts.ivyservice.dependencysubstitution.DependencySubstitutionsInternal;
import org.gradle.api.internal.artifacts.ivyservice.resolutionstrategy.CapabilitiesResolutionInternal;
import org.gradle.internal.ImmutableActionSet;

public interface ResolutionStrategyInternal extends ResolutionStrategy {
    /**
     * Discard any configuration state that is not required after graph resolution has been attempted.
     */