* LoadingCache#getAll}.
   *
   * <p>If the returned map doesn't contain all requested {@code keys} then the entries it does
   * contain will be cached, but {@code getAll} will throw an exception. If the returned map
   * contains extra keys not present in {@code keys} then all returned entries will be cached, but
   * only the entries for {@code keys} will be returned from {@code getAll}.
   *

        assertFalse(cacheEntry.isComplete());

        // Step 3: Verify can cache directory listing
        assertTrue(directoryLeaseManager.canCacheDirectoryListing(directoryPath));

        // Step 4: Initially no cached listing
        assertNull(directoryLeaseManager.getCachedDirectoryListing(directoryPath));

        // Step 5: Simulate directory enumeration and update cache

 * @author mike nonemacher
 */

@NullUnmarked
public class PopulatedCachesTest extends TestCase {
  // we use integers as keys; make sure the range covers some values that ARE cached by
  // Integer.valueOf(int), and some that are not cached. (127 is the highest cached value.)
  static final int WARMUP_MIN = 120;
  static final int WARMUP_MAX = 135;
  static final int WARMUP_SIZE = WARMUP_MAX - WARMUP_MIN;

  public void testSize_populated() {

        urlIterator.remove()
      }
    }
```

### Troubleshooting

1. Valid cacheable responses are not being cached

Make sure you are reading responses fully as unless they are read fully, cancelled or stalled Responses will not be cached.

### Overriding normal cache behaviour

        .onlyIfCached()
        .noTransform()
        .immutable()
        .build()
    assertThat(cacheControl.toString()).isEqualTo(
      "no-cache, no-store, max-age=1, max-stale=2, min-fresh=3, only-if-cached, no-transform, immutable",
    )
    assertThat(cacheControl.noCache).isTrue()
    assertThat(cacheControl.noStore).isTrue()
    assertThat(cacheControl.maxAgeSeconds).isEqualTo(1)

     * an I/O error, or if the target entry is evicted while this editor is active. In either case
     * we delete the editor's created files and prevent new files from being created. Note that once
     * an editor has been detached it is possible for another editor to edit the entry.
     */
    internal fun detach() {
      if (entry.currentEditor == this) {
        if (civilizedFileSystem) {
          completeEdit(this, false) // Delete it now.

        directoryLeaseManager.requestDirectoryLease(directoryPath, DirectoryLeaseState.DIRECTORY_READ_HANDLE,
                DirectoryCacheScope.IMMEDIATE_CHILDREN);

        // No cached listing initially
        assertNull(directoryLeaseManager.getCachedDirectoryListing(directoryPath));

        // Setup mock files
        when(mockFile1.getName()).thenReturn("file1.txt");

package com.google.common.cache;

import com.google.common.annotations.GwtCompatible;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;

/**
 * The reason why a cached entry was removed.
 *
 * @author Charles Fry
 * @since 10.0
 */
@GwtCompatible
public enum RemovalCause {
  /**
   * The entry was manually removed by the user. This can result from the user invoking {@link

        // Default constructor
    }

    /** The HTTP header name for User-Agent */
    protected static final String USER_AGENT = "user-agent";

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

    }
  }

  // TODO GET preferred order - with tests to confirm this
  // 1. successful fresh cached GET response
  // 2. unsuccessful (404, 500) fresh cached GET response
  // 3. successful network response
  // 4. successful stale cached GET response
  // 5. unsuccessful response
  @Test
  fun usesCache() {
    val cache = Cache(cacheFs, "cache".toPath(), (100 * 1024).toLong())