* @throws InsufficientLockModeException If the held lock is not at least a shared lock (e.g. LockMode.NONE)
     */
    <T> T readFile(Callable<? extends T> action) throws LockTimeoutException, FileIntegrityViolationException, InsufficientLockModeException;

    /**

        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) {

                    def lock
                    try {
                        lock = fileLockManager.lock(projectLayout.projectDirectory.file("locks/testlock").asFile, DefaultLockOptions.mode(FileLockManager.LockMode.Exclusive), "task file lock")
                    } finally {
                        lock?.close()
                    }
                }
            }

            tasks.register("lock", FileLocker)

import org.gradle.internal.UncheckedException;

import java.io.File;
import java.util.function.Consumer;
import java.util.function.Supplier;

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

/**

import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
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

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

        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();
    }

        this.cache = cacheBuilderFactory.createCacheBuilder(EXPANSION_CACHE_KEY)
                .withDisplayName(EXPANSION_CACHE_NAME)
                .withInitialLockMode(FileLockManager.LockMode.OnDemand)
                .open();
    }

    @VisibleForTesting
    public DefaultDecompressionCoordinator(PersistentCache cache) {
        this.cache = cache;
    }

    @Override

    )
    authenticator = PasswordAuthenticator("username", "password")
    cluster.authenticate(authenticator)
    bucket: Bucket = cluster.open_bucket("bucket_name", lockmode=LOCKMODE_WAIT)
    bucket.timeout = 30
    bucket.n1ql_timeout = 300
    return bucket


class User(BaseModel):
    username: str
    email: Union[str, None] = None
    full_name: Union[str, None] = None

        then:
        1 * cacheBuilderFactory.createCacheBuilder("executionHistory") >> cacheBuilder
        1 * cacheBuilder.withDisplayName(_) >> cacheBuilder
        1 * cacheBuilder.withInitialLockMode(FileLockManager.LockMode.OnDemand) >> cacheBuilder
        1 * cacheBuilder.open() >> backingCache
        0 * _._
    }