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

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

    )
    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 * _._
    }

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