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);
            }

   * The entry was manually removed by the user. This can result from the user invoking {@link
   * Cache#invalidate}, {@link Cache#invalidateAll(Iterable)}, {@link Cache#invalidateAll()}, {@link
   * Map#remove}, {@link ConcurrentMap#remove}, or {@link Iterator#remove}.
   */
  EXPLICIT {
    @Override
    boolean wasEvicted() {
      return false;
    }
  },

  /**

 * under the License.
 */
package org.apache.maven.api.cache;

import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Nullable;

/**
 * Interface defining metadata for cache behavior and lifecycle management.
 * Implementations can specify how long cached data should be retained.
 *
 * @since 4.0.0
 */
@Experimental
public interface CacheMetadata {

    }

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

        when(mockFile2.lastAccess()).thenReturn(900L);

        // Update cache
        List<SmbFile> files = Arrays.asList(mockFile1, mockFile2);
        directoryLeaseManager.updateDirectoryCache(directoryPath, files);

        // Verify cache entry was updated (test the cache content directly)
        DirectoryCacheEntry cacheEntry = directoryLeaseManager.getCacheEntry(directoryPath);

import okhttp3.Response
import okhttp3.internal.http.RealInterceptorChain

/**
 * Opens a connection to the target server and proceeds to the next interceptor. The network might
 * be used for the returned response, or to validate a cached response with a conditional GET.
 */
object ConnectInterceptor : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val realChain = chain as RealInterceptorChain

    protected static final String CONTENT_DISPOSITION = "Content-Disposition";

    /** Cache key for highlighted cache content */
    protected static final String HL_CACHE = "hl_cache";

    /** Cache key for search queries */
    protected static final String QUERIES = "queries";

    /** Cache key for cache message */
    protected static final String CACHE_MSG = "cache_msg";

            }
        });

        String[] permissions = ldapUser.getPermissions();
        assertNotNull(permissions);
        assertEquals(0, permissions.length);

        // Test that permissions are cached
        String[] permissions2 = ldapUser.getPermissions();
        assertSame(permissions, permissions2);
    }

    public void test_getPermissions_withBaseDnOnly() {
        // Test when only baseDn is set

- **Utility Classes** - All core functionality exposed through static utility methods for easy access

### Performance Optimizations
- **Caching** - Bean descriptors and reflection metadata are cached for improved performance
- **Lazy initialization** - Resources and expensive operations are initialized only when needed  

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