return cacheBuilderFactory
            .createCrossVersionCacheBuilder(CACHE_KEY)
            .withDisplayName(CACHE_NAME)
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .withCleanupStrategy(createCacheCleanupStrategy(fileAccessTimeJournal))
            .open();
    }

    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:

        }
    }

    private FileLock lockBuildLogicQueueFile() {
        return fileLockManager.lock(
            new File(projectCacheDir.getDir(), "noVersion/buildLogic"),
            mode(FileLockManager.LockMode.Exclusive),
            "build logic queue"
        );
    }

        cache = cacheBuilderFactory
            .createCrossVersionCacheBuilder(CACHE_KEY)
            .withDisplayName("journal cache")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
        store = cache.createIndexedCache(IndexedCacheParameters.of(FILE_ACCESS_CACHE_NAME, FILE_SERIALIZER, LONG_SERIALIZER)

import org.gradle.StartParameter
import org.gradle.api.Action
import org.gradle.api.artifacts.DependencySubstitution
import org.gradle.api.artifacts.component.ModuleComponentIdentifier
import org.gradle.api.artifacts.dsl.LockMode
import org.gradle.api.internal.DomainObjectContext
import org.gradle.api.internal.artifacts.DefaultModuleIdentifier
import org.gradle.api.internal.artifacts.ivyservice.dependencysubstitution.DependencySubstitutionRules

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

        return fileHasher;
    }

    private FileLock exclusiveLockFor(File file) {
        return fileLockManager.lock(
            file,
            mode(FileLockManager.LockMode.Exclusive).useCrossVersionImplementation(),
            "instrumented jar cache"
        );
    }

    private String hashOf(FileSystemLocationSnapshot sourceSnapshot) {

     * Returns some memento of the current state of this target file.
     */
    State getState();

    /**
     * The actual mode of the lock. May be different to what was requested.
     */
    FileLockManager.LockMode getMode();

    /**
     * An immutable snapshot of the state of a lock.
     */
    interface State {
        boolean canDetectChanges();
        boolean isInInitialState();

        this.cache = cacheBuilderFactory.createCacheBuilder(CACHE_KEY)
            .withDisplayName(CACHE_DISPLAY_NAME)
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
        this.gradleVersion = gradleVersion;
    }

    @Override
    public File get(final String identifier, final Action<File> creator) {

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