// tag::locking-classpath[]
buildscript {
    configurations.classpath {
        resolutionStrategy.activateDependencyLocking()
    }
}

                <td>getUseGlobalDependencySubstitutionRules</td>
            </tr>
            <tr>
                <td>componentSelection</td>
            </tr>
            <tr>
                <td>activateDependencyLocking</td>
            </tr>
            <tr>
                <td>deactivateDependencyLocking</td>
            </tr>
            <tr>
                <td>sortArtifacts</td>
            </tr>
            <tr>

        then:
        1 * container.all(_ as Action) >> { Action action ->
            action.execute(configuration)
        }

        1 * configuration.getResolutionStrategy() >> strategy
        1 * strategy.activateDependencyLocking()
    }

    def 'deactivates dependency locking on configurations'() {
        given:
        ConfigurationContainer container = Mock()
        Configuration configuration = Mock()

public class DefaultDependencyLockingHandler implements DependencyLockingHandler {

    private static final Action<Configuration> ACTIVATE_LOCKING = configuration -> configuration.getResolutionStrategy().activateDependencyLocking();


    private static final Action<Configuration> DEACTIVATE_LOCKING = configuration -> configuration.getResolutionStrategy().deactivateDependencyLocking();

 *
 * @since 4.8
 */
public interface DependencyLockingHandler {

    /**
     * Convenience method for doing:
     *
     * configurations.all {
     *     resolutionStrategy.activateDependencyLocking()
     * }
     *
     */
    void lockAllConfigurations();

    /**
     * Convenience method for doing:
     *
     * configurations.all {

    }

    @Override
    public void preferProjectModules() {
        conflictResolution = ConflictResolution.preferProjectModules;
    }

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

    @Override

        buildFile << """
repositories {
    maven {
        url '${mavenRepo.uri}'
    }
}
configurations {
    conf
    lockEnabledConf {
        extendsFrom conf
        resolutionStrategy.activateDependencyLocking()
    }
}
dependencies {
    conf 'org:foo:[1.0,)'
    conf 'org:foo:1.1'

    conf 'org:foz:latest.integration'
    conf 'org:foz:1.1'

    conf 'org:bar:1.+'
    conf 'org:bar:1.1'

            }
        })
        then: 0 * validator.validateMutation(_)
    }

    def 'provides the expected DependencyLockingProvider'() {
        when:
        strategy.activateDependencyLocking()

        then:
        strategy.dependencyLockingProvider.is(dependencyLockingProvider)
    }

    def "copies dependency verification state"() {
        when:

    maven {
        name 'repo'
        url '${mavenRepo.uri}'
    }
}

configurations {
    unlockedConf
    lockedConf {
        extendsFrom unlockedConf
        resolutionStrategy.activateDependencyLocking()
    }
}

dependencies {
    unlockedConf 'org:foo:1.+'
}
"""
        lockfileFixture.createLockfile('unlockedConf', ['org:foo:1.0'])

        when:

     * This enables reproducible builds when using dynamic versions.
     *
     * @return this resolution strategy instance
     * @since 4.8
     */
    ResolutionStrategy activateDependencyLocking();

    /**
     * Deactivates dependency locking support in Gradle.
     *
     * @return this resolution strategy instance
     * @since 6.0
     */