buildLogicBuilder.prepareClassPath(classpathConfiguration, resolutionContext);
        }
    }

    @Override
    public void dependencyLocking(Closure configureClosure) {
        ConfigureUtil.configure(configureClosure, getDependencyLocking());
    }

    @Override
    public DependencyLockingHandler getDependencyLocking() {

        DefaultExternalModuleDependency       | Dependency                     | "project.dependencies.create('junit:junit:4.13')"
        DefaultDependencyLockingHandler       | DependencyLockingHandler       | "project.dependencyLocking"

        mavenRepo.module('org', 'foo', '1.0').publish()
        mavenRepo.module('org', 'foo', '1.1').publish()

        buildFile << """
dependencyLocking {
    lockAllConfigurations()
}

repositories {
    maven {
        name 'repo'
        url '${mavenRepo.uri}'
    }
}
configurations {
    lockedConf
}

dependencies {

        configuration.execute(getNormalization());
    }

    @Inject
    @Override
    public abstract DependencyLockingHandler getDependencyLocking();

    @Override
    public void dependencyLocking(Action<? super DependencyLockingHandler> configuration) {
        configuration.execute(getDependencyLocking());
    }

    @Override

==== Changes in dependency locking

With Gradle 6.4, the incubating API for <<dependency_locking#fine_tuning_dependency_locking_behaviour_with_lock_mode, dependency locking `LockMode`>> has changed.
The value is now set via a `Property<LockMode>` instead of a direct setter.
This means that the notation to set the value has to be updated for the Kotlin DSL:

```
dependencyLocking {
    lockMode.set(LockMode.STRICT)
}
```

Method <org.gradle.api.initialization.dsl.ScriptHandler.dependencyLocking(groovy.lang.Closure)> has arguments/return type groovy.lang.Closure that is not Gradle public API or primitive or built-in JDK classes or Kotlin classes in (ScriptHandler.java:0)

     */
    void normalization(Action<? super InputNormalizationHandler> configuration);

    /**
     * Configures dependency locking
     *
     * @since 4.8
     */
    void dependencyLocking(Action<? super DependencyLockingHandler> configuration);

    /**
     * Provides access to configuring dependency locking
     *
     * @since 4.8
     */

            new DocumentationRegistry().getDocumentationRecommendationFor("information on generating lock state", "dependency_locking", "generating_and_updating_dependency_locks"));
    }
    public MissingLockStateException(DisplayName displayName) {

include::dependency_verification.adoc[leveloffset=+1]

= Declaring Versions
include::single_versions.adoc[leveloffset=+1]
include::rich_versions.adoc[leveloffset=+1]
include::dynamic_versions.adoc[leveloffset=+1]
include::dependency_locking.adoc[leveloffset=+1]

= Controlling Transitive Dependencies
include::dependency_constraints.adoc[leveloffset=+1]
include::dependency_downgrade_and_exclude.adoc[leveloffset=+1]
include::platforms.adoc[leveloffset=+1]

import java.util.List;
import java.util.Map;
import java.util.Set;

public class ResolutionResultGraphBuilder implements ResolvedComponentVisitor {
    private static final DefaultComponentSelectionDescriptor DEPENDENCY_LOCKING = new DefaultComponentSelectionDescriptor(ComponentSelectionCause.CONSTRAINT, Describables.of("Dependency locking"));
    private final Long2ObjectMap<DefaultResolvedComponentResult> components = new Long2ObjectOpenHashMap<>();