PersistentCache workerClassPathCache = cacheBuilderFactory
                        .createCacheBuilder("workerMain")
                        .withInitialLockMode(FileLockManager.LockMode.Exclusive)
                        .withInitializer(new CacheInitializer())
                        .open();
                    try {

        BuildCommencedTimeProvider timeProvider,
        boolean refreshKeys) {
        cache = cacheBuilderFactory
            .createCrossVersionCacheBuilder("keyrings")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
        this.buildOperationRunner = buildOperationRunner;
        this.delegate = delegate;
        this.timeProvider = timeProvider;
        this.refreshKeys = refreshKeys;

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)
}
```

Users of the Groovy DSL should not be impacted as the notation `lockMode = LockMode.STRICT` remains valid.

        final PersistentCache zincCache = globalScopedCacheBuilderFactory.createCacheBuilder(zincCacheKey)
            .withDisplayName(zincCacheName)
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();


        File compilerBridgeJar;
        if (isScala3(scalaVersion)) {
            compilerBridgeJar = findFile("scala3-sbt-bridge", hashedScalaClasspath.getClasspath());

import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.nio.file.Files;
import java.util.Collections;
import java.util.function.Supplier;

import static org.gradle.cache.FileLockManager.LockMode.OnDemand;
import static org.gradle.internal.snapshot.CaseSensitivity.CASE_SENSITIVE;

@SuppressWarnings("MethodMayBeStatic")
class BuildCacheClientModule extends AbstractModule {

        this.keyToSnapshottable = keyToSnapshottable;
        this.timeProvider = timeProvider;
        this.cache = cacheBuilderFactory
            .createCacheBuilder(name)
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
        IndexedCacheParameters<HashCode, CachedEntry<RESULT>> cacheParams = createCacheConfiguration(name, resultSerializer, cacheDecoratorFactory);

    }

    public FileLock acquireWriteLock(File destinationFile, String operationName) {
        return lockManager.lock(destinationFile, DefaultLockOptions.mode(FileLockManager.LockMode.Exclusive), destinationFile.getName(), operationName);
    }

    public File getDownloadLocation() {
        return jdkDirectory;
    }

    private static String getNameWithoutExtension(File file) {

        store = cacheBuilderFactory.createCacheBuilder("signature-verification")
            .withDisplayName("Signature verification cache")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
        InterningStringSerializer stringSerializer = new InterningStringSerializer(new StringInterner());
        cache = store.createIndexedCache(
            IndexedCacheParameters.of(

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;
import java.util.function.Supplier;

import static org.gradle.cache.FileLockManager.LockMode.Exclusive;

@ThreadSafe
public class DefaultCacheCoordinator implements CacheCreationCoordinator, ExclusiveCacheAccessCoordinator {
    private final static Logger LOG = LoggerFactory.getLogger(DefaultCacheCoordinator.class);

			newObj:     podWithOwnerRefs(blockRC1, blockRC2, blockNode),
			checkError: expectNoError,
		},
		{
			name:               "super-user, create, some ownerReferences have blockOwnerDeletion=true, hangingRESTMapper",
			username:           "super",
			resource:           api.SchemeGroupVersion.WithResource("pods"),
			newObj:             podWithOwnerRefs(blockRC1, blockRC2, blockNode),
			restMapperOverride: &neverReturningRESTMapper{},