private FileLockManager.LockMode mode;
    private boolean crossVersion;

    private DefaultLockOptions(FileLockManager.LockMode mode, boolean crossVersion) {
        this.mode = mode;
        this.crossVersion = crossVersion;
    }

    public static DefaultLockOptions mode(FileLockManager.LockMode lockMode) {
        return new DefaultLockOptions(lockMode, false);
    }

    def initAction = Mock(CacheInitializationAction)
    def onOpenAction = Mock(Consumer)
    def onCloseAction = Mock(Consumer)
    def lockOptions = DefaultLockOptions.mode(FileLockManager.LockMode.Shared)
    def cacheAccess = new FixedSharedModeCrossProcessCacheAccess("<cache>", file, lockOptions, lockManager, initAction, onOpenAction, onCloseAction)

        expect:
        emptyDir.assertDoesNotExist()

        when:
        def cache = new DefaultPersistentDirectoryCache(emptyDir, "<display-name>", properties, mode(FileLockManager.LockMode.Shared), initializationAction, cacheCleanup, lockManager, Mock(ExecutorFactory), buildOperationRunner)
        try {
            cache.open()
        } finally {
            cache.close()
        }

        then:

     * </p>
     * <ul>
     *     <li>Using {@link org.gradle.cache.FileLockManager.LockMode#Exclusive} will lock the cache on open() in the exclusive mode and keep it locked until {@link PersistentCache#close()} is called.</li>

    private Consumer<? super PersistentCache> initializer;
    private CacheCleanupStrategy cacheCleanupStrategy = CacheCleanupStrategy.NO_CLEANUP;
    private LockOptions lockOptions = mode(FileLockManager.LockMode.Shared);
    private String displayName;

    public DefaultCacheBuilder(CacheFactory factory, File baseDir) {
        this.factory = factory;
        this.baseDir = baseDir;
    }

    @Override

 */
package org.gradle.cache.internal

import org.gradle.cache.FileAccess
import org.gradle.cache.FileLock
import org.gradle.cache.FileLockManager
import org.gradle.cache.FileLockManager.LockMode
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule
import spock.lang.Specification

import java.util.function.Supplier

     *
     * @return the lock state corresponding to the lock with the given ID.
     *
     * @throws org.gradle.internal.locking.MissingLockStateException If the {@code LockMode} is {@link LockMode#STRICT} but no lock state can be found.
     */
    DependencyLockingState loadLockState(String lockId, DisplayName lockOwner);

    /**
     * Records the resolution result to the lock with the given ID.

        then:
        1 * cacheBuilderFactory.createCacheBuilder(CACHE_KEY) >> cacheBuilder
        1 * cacheBuilder.withDisplayName(CACHE_DISPLAY_NAME) >> cacheBuilder
        1 * cacheBuilder.withInitialLockMode(FileLockManager.LockMode.OnDemand) >> cacheBuilder
        1 * cacheBuilder.open() >> { cache }
        1 * cache.close()
    }

    def "creates JAR file on demand for identifier '#identifier'"(String identifier) {

    /**
     * These modes can be used either with {@link FileLockManager} or when creating {@link PersistentCache} via {@link CacheBuilder#withInitialLockMode(LockMode)}
     */
    enum LockMode {

        /**
         * On demand, single writer, no readers (on demand exclusive mode).
         * <br><br>
         *

package org.gradle.cache;

public interface LockOptions {

    FileLockManager.LockMode getMode();

    boolean isUseCrossVersionImplementation();

    /**
     * Creates a copy of this options instance using the given mode.
     *
     * @param mode the mode to overwrite the current mode with
     */
    LockOptions copyWithMode(FileLockManager.LockMode mode);