_ * lock.state
        1 * cleanupExecutor.cleanup()
        0 * _._

        where:
        accessType << [Exclusive, Shared, OnDemand, None]
    }

    def "cleans up on close when clean up has not already occurred"() {
        def access = newAccess(OnDemand)

        when:
        access.open()
        access.close()

        then:
        1 * cleanupExecutor.cleanup()
        0 * _

        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) {
        def cacheDir = tmpDir.testDirectory

    }

    void canSpecifyLockModeForDirectoryCache() {
        when:
        builder.withInitialLockMode(OnDemand).open()

        then:
        1 * cacheFactory.open(sharedCacheDir, null, [:], mode(OnDemand), _, NO_CLEANUP) >> cache
    }

    void canSpecifyDisplayNameForDirectoryCache() {
        when:
        builder.withDisplayName("<cache>").open()

        then:

import org.junit.Rule
import spock.lang.AutoCleanup
import spock.lang.Specification
import spock.lang.Subject

import java.util.concurrent.TimeUnit

import static org.gradle.cache.FileLockManager.LockMode.OnDemand
import static org.gradle.cache.FileLockManager.LockMode.Shared
import static org.gradle.cache.internal.filelock.DefaultLockOptions.mode

class DefaultPersistentDirectoryStoreTest extends Specification {

    @Rule

import org.gradle.testfixtures.internal.NativeServicesTestFixture
import org.junit.Rule
import spock.lang.Issue

import static org.gradle.cache.FileLockManager.LockMode.OnDemand
import static org.gradle.cache.internal.filelock.DefaultLockOptions.mode

class DefaultPersistentDirectoryStoreConcurrencyTest extends ConcurrentSpec {

    @Rule

        cache = cacheBuilderFactory
                .createCacheBuilder("nativeCompile")
                .withDisplayName("native compile cache")
                .withInitialLockMode(FileLockManager.LockMode.OnDemand)
                .open();
        IndexedCacheParameters<String, CompilationState> parameters = IndexedCacheParameters.of("nativeCompile", String.class, new CompilationStateSerializer())

import org.gradle.internal.time.TimestampSuppliers;

import javax.inject.Inject;
import java.io.File;
import java.util.function.Supplier;

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

public class DirectoryBuildCacheServiceFactory implements BuildCacheServiceFactory<DirectoryBuildCache> {
    public static final String FAILED_READ_SUFFIX = ".failed";

        cache = cacheBuilderFactory.createCacheBuilder(cacheKind.cacheId)
            .withDisplayName(cacheKind.description)
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
    }

    public <K, V> IndexedCache<K, V> createIndexedCache(IndexedCacheParameters<K, V> parameters, int maxEntriesToKeepInMemory, boolean cacheInMemoryForShortLivedProcesses) {

            this.port = port;
            this.lockId = generator.getAsLong();
            if (options.getMode() == LockMode.OnDemand) {
                throw new UnsupportedOperationException("Locking mode OnDemand is not supported.");
            }

            this.target = target;

            this.displayName = displayName;

        this.cache = cacheBuilderFactory
            .createCacheBuilder("executionHistory")
            .withDisplayName("execution history cache")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
    }

    @Override
    public PersistentCache get() {
        return cache;
    }

    @Override
    public void close() {
        cache.close();
    }