* resources) are stored and retrieved. There are two primary types of repositories:<ul>
 *     <li><dfn>{@linkplain org.apache.maven.api.LocalRepository local repository}</dfn>: A directory on the developer's machine where Maven caches
 *     downloaded artifacts.</li>
 *     <li><dfn>{@linkplain org.apache.maven.api.RemoteRepository remote repository}</dfn>: A central or distributed location from which Maven can download artifacts

 * limitations under the License.
 */

package com.google.common.cache;

import static com.google.common.base.MoreObjects.firstNonNull;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;

import com.google.common.base.Equivalence;
import com.google.common.base.Ticker;
import com.google.common.cache.AbstractCache.StatsCounter;

        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

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

    }

    @Test
    public void testContentCache() {
        CurlResponse response = new CurlResponse();
        byte[] data = "test content".getBytes();
        ContentCache cache = new ContentCache(data);

        response.setContentCache(cache);

        // ContentCache is not directly accessible, but we can test through content methods
        assertNotNull(response);
    }

    @Test

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

  @BeforeExperiment
  void setUp() {
    LocalCache<Object, Object> cache =
        new LocalCache<>(
            CacheBuilder.newBuilder().concurrencyLevel(1).initialCapacity(capacity), null);
    checkState(cache.segments.length == 1);
    segment = cache.segments[0];
    checkState(segment.table.length() == capacity);
    for (int i = 0; i < segment.threshold; i++) {
      cache.put(new Object(), new Object());
    }

import org.lastaflute.web.util.LaServletContextUtil;
import org.lastaflute.web.validation.ActionValidator;
import org.opensearch.monitor.os.OsProbe;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.ibm.icu.util.ULocale;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;

/**

    }

    /**
     * Test that buffer cache handles allocation when cache is full.
     */
    @Test
    public void testBufferAllocationWhenCacheFull() {
        // Given - Allocate many buffers to potentially fill the cache
        List<byte[]> buffers = new ArrayList<>();

        // Allocate more buffers than cache can hold
        for (int i = 0; i < 20; i++) {

    LocalCache<Object, Object> cache =
        new LocalCache<>(CacheBuilder.newBuilder().concurrencyLevel(1), null);
    segment = cache.segments[0];
    chain = null;
    for (int i = 0; i < length; i++) {
      Object key = new Object();
      // TODO(b/145386688): This access should be guarded by 'this.segment', which is not currently
      // held
      chain = segment.newEntry(key, cache.hash(key), chain);
      if (i == 0) {