// Cache should be invalidated
        assertFalse(cacheEntry.isComplete());

        // Step 9: Test lease break
        // Re-populate cache
        directoryLeaseManager.updateDirectoryCache(directoryPath, files);
        assertTrue(cacheEntry.isComplete());

        // Simulate lease break with loss of read cache

    
    // READ_CACHING for directories means:
    // - Can cache directory enumeration results
    // - Can cache file existence queries
    // - Can cache basic file attributes
    
    // HANDLE_CACHING for directories means:
    // - Can keep directory handle open
    // - Can cache subdirectory handles
    
    // WRITE_CACHING for directories means:
    // - Can cache file creation/deletion notifications

import okio.Source
import okio.Timeout
import okio.buffer

/** Serves requests from the cache and writes responses to the cache. */
class CacheInterceptor(
  internal val cache: Cache?,
) : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val call = chain.call()
    val cacheCandidate = cache?.get(chain.request().requestForCache())

    val now = System.currentTimeMillis()

/**
 * Statistics about the performance of a {@link Cache}. Instances of this class are immutable.
 *
 * <p>Cache statistics are incremented according to the following rules:
 *
 * <ul>
 *   <li>When a cache lookup encounters an existing cache entry {@code hitCount} is incremented.
 *   <li>When a cache lookup first encounters a missing cache entry, a new entry is loaded.
 *       <ul>

import org.codelibs.fess.Constants;
import org.dbflute.helper.jprop.ObjectiveProperties;
import org.lastaflute.core.direction.PropertyFilter;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

public class FessConfigImpl extends FessConfig.SimpleImpl {

    private static final long serialVersionUID = 1L;

    @Override

 * the cache; the cache may delete or overwrite files from its directory. It is an error for
 * multiple processes to use the same cache directory at the same time.
 *
 * This cache limits the number of bytes that it will store on the filesystem. When the number of
 * stored bytes exceeds the limit, the cache will remove entries in the background until the limit
 * is satisfied. The limit is not strict: the cache may temporarily exceed it while waiting for

				return
			}
		case "Cache":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Cache")
				return
			}
			if z.Cache == nil {
				z.Cache = make(map[string]dataUsageEntry, zb0002)
			} else if len(z.Cache) > 0 {
				for key := range z.Cache {
					delete(z.Cache, key)
				}
			}
			for zb0002 > 0 {
				zb0002--

fi

# READ-ONLY DEPENDENCY CACHE
if [ -d "/opt/gradle-cache" ]; then
  echo "##teamcity[setParameter name='env.GRADLE_RO_DEP_CACHE' value='/opt/gradle-cache']"
  echo "Setting READ_ONLY Gradle cache via env.GRADLE_RO_DEP_CACHE to use /opt/gradle-cache"
fi

# Print details of volumes to help us understand https://github.com/gradle/gradle-private/issues/4642

    if (value != null) {
      return value;
    }

    // Store a local reference to the cache entry. If the backing map is immutable, this,
    // in combination with immutable cache entries, will ensure a thread-safe cache.
    CacheEntry<K, V> entry;

    // Check cache. We use == on purpose because it's cheaper and a cache miss is ok.
    entry = cacheEntry1;
    if (entry != null && entry.key == key) {
      return entry.value;

        byte[] data = "Hello, World!".getBytes();
        ContentCache cache = new ContentCache(data);

        // Memory-based cache close should not throw exception
        cache.close();

        // Should still be able to get input stream after close for memory cache
        try (InputStream stream = cache.getInputStream()) {
            assertNotNull(stream);
        }
    }

    @Test