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

    def onOpenAction = Mock(Consumer)
    def onCloseAction = Mock(Consumer)
    def cacheAccess = new FixedExclusiveModeCrossProcessCacheAccess("<cache>", file, DefaultLockOptions.mode(FileLockManager.LockMode.Exclusive), lockManager, initAction, onOpenAction, onCloseAction)

    def "acquires lock then validates cache and runs handler action on open"() {
        def lock = Mock(FileLock)

        when:

    public NativeDependencyCache(GlobalScopedCacheBuilderFactory cacheBuilderFactory) {
        cache = cacheBuilderFactory.createCacheBuilder("native-dep")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
    }

    public File getModuleMapFile(final ModuleMap moduleMap) {
        final String hash = moduleMap.getHashCode().toCompactString();
        return cache.useCache(() -> {

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

import java.util.function.Consumer

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

class DefaultCacheFactoryTest extends Specification {
    @Rule

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;

/**
 * A {@link CrossProcessCacheAccess} implementation used when a cache is opened with an exclusive lock that is held until the cache is closed. This implementation is simply a no-op for these methods.
 */

        cache = cacheBuilderFactory
            .createCacheBuilder("vcsMetadata")
            .withDisplayName("VCS metadata")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand) // Don't need to lock anything until we use the caches
            .open();
        workingDirCache = cache.createIndexedCache("workingDirs", String.class, VALUE_SERIALIZER);
    }

    @Override

 * while it is in use. You can change this use {@link CacheBuilder#withInitialLockMode(org.gradle.cache.FileLockManager.LockMode)}.
 *
 * <p>You can use {@link CacheBuilder#withInitializer(java.util.function.Consumer)} to provide an action to initialize the contents

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";

        this.vcsWorkingDirCache = cacheBuilderFactory
            .createCrossVersionCacheBuilder("vcs-1")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .withDisplayName("VCS Checkout Cache")
            .withCleanupStrategy(createCacheCleanupStrategy())
            .open();
    }

    private CacheCleanupStrategy createCacheCleanupStrategy() {