return dataStoreMap.get(name.toLowerCase(Locale.ROOT));
    }

    /**
     * Returns an array of available data store names discovered from plugin JAR files.
     * This method implements a time-based caching mechanism that refreshes the list
     * every 60 seconds to balance performance with up-to-date plugin discovery.
     *
     * @return array of data store names sorted alphabetically, never null
     */

   * instead.
   *
   * @since 14.0
   */
  public static UnsignedLong fromLongBits(long bits) {
    // TODO(lowasser): consider caching small values, like Long.valueOf
    return new UnsignedLong(bits);
  }

  /**
   * Returns an {@code UnsignedLong} representing the same value as the specified {@code long}.
   *

import java.nio.file.Files;

import org.codelibs.curl.Curl;
import org.junit.After;
import org.junit.Test;

/**
 * Test class for ContentCache.
 * Tests memory-based and file-based content caching.
 */
public class ContentCacheTest {

    private File tempFile;

    @After
    public void tearDown() {
        if (tempFile != null && tempFile.exists()) {
            tempFile.delete();
        }

    /*
     * This test will catch problems where the underlying iterator
     * throws a RuntimeException when retrieving the nth element.
     *
     * If the PeekingIterator is caching elements too aggressively,
     * it may throw the exception on the (n-1)th element (oops!).
     */

    /* Checks the case where the first element throws an exception. */

    List<Integer> list = emptyList();

    fun isCacheable(
      response: Response,
      request: Request,
    ): Boolean {
      // Always go to network for uncacheable response codes (RFC 7231 section 6.1), This
      // implementation doesn't support caching partial content.
      when (response.code) {
        HTTP_OK,
        HTTP_NOT_AUTHORITATIVE,
        HTTP_NO_CONTENT,
        HTTP_MULT_CHOICE,
        HTTP_MOVED_PERM,
        HTTP_NOT_FOUND,

```java
/** Dangerous interceptor that rewrites the server's cache-control header. */
private static final Interceptor REWRITE_CACHE_CONTROL_INTERCEPTOR = new Interceptor() {

        "Content-Type".equals(fieldName, ignoreCase = true)
  }
}

private fun Request.requestForCache(): Request {
  val cacheUrlOverride = cacheUrlOverride

  // Allow POST and QUERY caching only when there is a cacheUrlOverride
  return if (cacheUrlOverride != null && (HttpMethod.isCacheable(method) || method == "POST")) {
    newBuilder()
      .get()
      .url(cacheUrlOverride)

    protected String preferredCiphers = "AES_128_GCM,AES_128_CCM,AES_256_GCM,AES_256_CCM";
    /** Whether AES-256 encryption is enabled */
    protected boolean aes256Enabled = true;
    /** Whether to use SMB2/SMB3 leases for caching */
    protected boolean useLease = true;
    /** Lease timeout in milliseconds */
    protected int leaseTimeout = 30000;
    /** Maximum number of concurrent leases */
    protected int maxLeases = 1000;

  }

  /**
   * Provides a check of whether an exception type is valid for use with {@link
   * FuturesGetChecked#getChecked(Future, Class)}, possibly using caching.
   *
   * <p>Uses reflection to gracefully fall back to when certain implementations aren't available.
   */
  private static final class GetCheckedTypeValidatorHolder {

import java.util.HashMap;
import java.util.Iterator;

import jcifs.smb1.Config;
import jcifs.smb1.UniAddress;
import jcifs.smb1.util.LogStream;

/**
 * Implements DFS (Distributed File System) referral caching and resolution.
 * This class manages DFS referral cache and provides DFS path resolution functionality.
 */
public class Dfs {

    /**
     * Default constructor for Dfs.
     * Initializes the DFS referral system.