cache = cacheBuilderFactory
            .createCacheBuilder("javaCompile")
            .withDisplayName("Java compile cache")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
        IndexedCacheParameters<HashCode, ClassSetAnalysisData> jarCacheParameters = IndexedCacheParameters.of(
            "jarAnalysis",
            new HashCodeSerializer(),

     * }
     *
     * @since 6.0
     */
    void unlockAllConfigurations();

    /**
     * Allows to query the lock mode currently configured
     *
     * @since 6.1
     */
    Property<LockMode> getLockMode();

    /**
     * Allows to configure the file used for saving lock state
     * <p>
     * Make sure the lock file is unique per project and separate between the buildscript and project itself.
     * <p>

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

        this.cache = cacheBuilderFactory
            .createCacheBuilder("fileContent")
            .withDisplayName("file content cache")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
    }

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

    @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

            // and move them atomically into the cache
            // TODO Should use a read-write lock on the cache's base directory for cleanup, though
            .withInitialLockMode(FileLockManager.LockMode.None)
            .open();
        this.cache = cache;
        this.baseDirectory = cache.getBaseDir();

                return count < 4
            }

            void initialize(FileLock fileLock) {}
        }
        def lockOptions = DefaultLockOptions.mode(FileLockManager.LockMode.Shared)
        def lockManager1 = DefaultFileLockManagerTestHelper.createDefaultFileLockManager(100)
        new FixedSharedModeCrossProcessCacheAccess("<cache>", cacheDir, lockOptions, lockManager1, countingInitAction, {}, {})

		t.Errorf("Expected secret type %v, got %v", v1.SecretTypeOpaque, s2.Type)
	}
}

func TestSetDefaultPersistentVolume(t *testing.T) {
	fsMode := v1.PersistentVolumeFilesystem
	blockMode := v1.PersistentVolumeBlock

	tests := []struct {
		name               string
		volumeMode         *v1.PersistentVolumeMode
		expectedVolumeMode v1.PersistentVolumeMode
	}{
		{

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