* The lock is not released between calling {@link #requiresInitialization(FileLock)} and this method.
     */
    void initialize(FileLock fileLock);

    CacheInitializationAction NO_INIT_REQUIRED = new CacheInitializationAction() {
        @Override
        public boolean requiresInitialization(FileLock fileLock) {
            return false;
        }

        @Override

    def lockManager = Mock(FileLockManager)
    def cacheAccess = new LockOnDemandCrossProcessCacheAccess("<cache>", file, DefaultLockOptions.mode(FileLockManager.LockMode.Exclusive), lockManager, new ReentrantLock(), Stub(CacheInitializationAction), Stub(Consumer), Stub(Consumer))

    def "close when lock has never been acquired"() {
        when:
        cacheAccess.close()

        then:
        0 * _
    }

     * simultaneously. Then the second one, attempting to initialize the cache, will fail to obtain an exclusive lock on the cache. Instead
     * of failing, it should recheck if initialization was performed by calling {@link CacheInitializationAction#requiresInitialization(org.gradle.cache.FileLock)}
     * again. This is simulated here by an requiresInitialization() implementation that returns false after a number of calls to itself.
     */

import javax.annotation.Nullable;
import java.io.File;
import java.util.Arrays;
import java.util.Collection;
import java.util.function.Supplier;

import static org.gradle.cache.internal.CacheInitializationAction.NO_INIT_REQUIRED;

public class DefaultPersistentDirectoryStore implements ReferencablePersistentCache {

    public static final int CLEANUP_INTERVAL_IN_HOURS = 24;

    private final File dir;

    private final CacheInitializationAction initializationAction;
    private final Consumer<FileLock> onOpenAction;
    private final Consumer<FileLock> onCloseAction;
    private FileLock fileLock;

    private final CacheInitializationAction initializationAction;
    private final Consumer<FileLock> onOpenAction;
    private final Consumer<FileLock> onCloseAction;
    private FileLock fileLock;

        this.properties.putAll(properties);
    }

    @Override
    protected CacheInitializationAction getInitAction() {
        return new Initializer();
    }

    public Properties getProperties() {
        return properties;
    }

    private class Initializer implements CacheInitializationAction {
        @Override
        public boolean requiresInitialization(FileLock lock) {

    private final Runnable unlocker;
    private final Consumer<FileLockReleasedSignal> whenContended;
    private int lockCount;
    private FileLock fileLock;
    private final CacheInitializationAction initAction;
    private FileLockReleasedSignal lockReleaseSignal;

    /**

class FixedExclusiveModeCrossProcessCacheAccessTest extends Specification {
    def file = new TestFile("some-file.lock")
    def lockManager = Mock(FileLockManager)
    def initAction = Mock(CacheInitializationAction)
    def onOpenAction = Mock(Consumer)
    def onCloseAction = Mock(Consumer)

class FixedSharedModeCrossProcessCacheAccessTest extends Specification {
    def file = new TestFile("some-file.lock")
    def lockManager = Mock(FileLockManager)
    def initAction = Mock(CacheInitializationAction)
    def onOpenAction = Mock(Consumer)
    def onCloseAction = Mock(Consumer)
    def lockOptions = DefaultLockOptions.mode(FileLockManager.LockMode.Shared)