/** The request attribute key for storing cached user agent type */
    protected static final String USER_AGENT_TYPE = "ViewHelper.UserAgent";

    /**
     * Determines the user agent type from the current HTTP request.
     * The method analyzes the User-Agent header to categorize the browser type
     * and caches the result in the request attribute for subsequent calls.
     *

            entry.breaking = true;
            entry.updateState(newState);
            // Flush any cached data if losing write cache
            if (!entry.hasWriteCache()) {
                flushCachedWrites(entry.path);
            }
            // Invalidate cached data if losing read cache
            if (!entry.hasReadCache()) {
                invalidateReadCache(entry.path);
            }

        // Should not throw any exception.
        assertDoesNotThrow(() -> dfsImpl.cache(mockContext, "invalidpath", mockReferral));
    }

    @Test
    void testCache_ValidPath() {
        // Scenario: A valid referral is cached.
        DfsReferralDataInternal mockReferral = mock(DfsReferralDataInternal.class);

    when {
      name.equals("Cache-Control", ignoreCase = true) -> {
        if (headerValue != null) {
          // Multiple cache-control headers means we can't use the raw value.
          canUseHeaderValue = false
        } else {
          headerValue = value
        }
      }

      name.equals("Pragma", ignoreCase = true) -> {
        // Might specify additional cache-control params. We invalidate just in case.

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

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

### Download

```kotlin
testImplementation("com.squareup.okhttp3:okhttp-dnsoverhttps:5.3.0")
```

### Usage

```
  val appCache = Cache(File("cacheDir", "okhttpcache"), 10 * 1024 * 1024)
  val bootstrapClient = OkHttpClient.Builder().cache(appCache).build()

  val dns = DnsOverHttps.Builder().client(bootstrapClient)
    .url("https://dns.google/dns-query".toHttpUrl())

    /**
     * Gets a buffer from the cache or creates a new one if the cache is empty.
     *
     * Performance: O(1) operation using concurrent queue
     *
     * @return a byte buffer for SMB operations
     * @throws IllegalStateException if buffer size exceeds maximum allowed
     */
    static public byte[] getBuffer() {
        // Try to get from cache first - O(1) operation
        byte[] buf = bufferQueue.poll();

 * </p>
 *
 * <pre>
 * BeanDesc beanDesc = BeanDescFactory.getBeanDesc(Foo.class);
 * </pre>
 * <p>
 * {@link BeanDesc} is cached. To clear the cache, call {@link DisposableUtil#dispose()}.
 * </p>
 *
 * @author higa
 * @see BeanDesc
 * @see DisposableUtil
 */
public abstract class BeanDescFactory {

    /**
     * Do not instantiate.

    }

    /**
     * Gets the maximum age for cached directory data before requiring refresh
     * @return the maximum cache age in milliseconds
     */
    public long getMaxCacheAge() {
        return maxCacheAge;
    }

    /**
     * Sets the maximum age for cached directory data
     * @param maxCacheAge the maximum cache age in milliseconds
     */