for (LoadingCache<Object, Object> cache : caches()) {
      checkEmpty(cache);
    }
  }


  public void testInvalidate_empty() {
    for (LoadingCache<Object, Object> cache : caches()) {
      cache.getUnchecked("a");
      cache.getUnchecked("b");
      cache.invalidate("a");
      cache.invalidate("b");
      cache.invalidate(0);
      checkEmpty(cache);
    }
  }

 * the License.
 */

package com.google.common.cache;

import static com.google.common.cache.TestingCacheLoaders.bulkLoader;
import static com.google.common.cache.TestingCacheLoaders.constantLoader;
import static com.google.common.cache.TestingCacheLoaders.errorLoader;
import static com.google.common.cache.TestingCacheLoaders.exceptionLoader;
import static com.google.common.cache.TestingCacheLoaders.identityLoader;

    getAll(cache, asList(6, 8));
    CacheTesting.drainRecencyQueues(cache);
    ticker.advance(1, MILLISECONDS);
    assertThat(keySet).containsExactly(1, 3, 6, 8);

    // get fails to save 1, put saves 3
    cache.asMap().put(3, -3);
    getAll(cache, asList(1));
    CacheTesting.drainRecencyQueues(cache);
    ticker.advance(1, MILLISECONDS);
    assertThat(keySet).containsExactly(6, 8, 3);

 - ConnectionReleased
 - CallEnd
 
## Cache directory

The cache directory must be exclusively owned by a single instance.

Deleting the cache when it is no longer needed can be done.  However this may delete the purpose of the cache
which is designed to persist between app restarts.

```kotlin
cache.delete()
```
 
## Pruning the Cache

Pruning the entire Cache to clear space temporarily can be done using evictAll.

        assertTrue(cache.asMap().remove(key, value));
        assertFalse(cache.asMap().remove(key, -1));
        assertFalse(cache.asMap().containsKey(key));
      }
      checkEmpty(cache);
    }
  }


  public void testKeySet_populated() {
    for (LoadingCache<Object, Object> cache : caches()) {
      Set<Object> keys = cache.asMap().keySet();

  }

  public void testComputeIfPresent() {
    cache.put(key, "1");
    // simultaneous update for same key, expect count successful updates
    doParallelCacheOp(
        count,
        n -> {
          cache.asMap().computeIfPresent(key, (k, v) -> v + delimiter + n);
        });
    assertEquals(1, cache.size());
    assertThat(cache.getIfPresent(key).split(delimiter)).hasLength(count + 1);
  }

"""
    fileSystem.createDirectory(cache.directoryPath)
    writeFile(cache.directoryPath, "$urlKey.0", entryMetadata)
    writeFile(cache.directoryPath, "$urlKey.1", entryBody)
    writeFile(cache.directoryPath, "journal", journalBody)
    cache = Cache(fileSystem, cache.directory.path.toPath(), Int.MAX_VALUE.toLong())
    client =
      client.newBuilder()
        .cache(cache)
        .build()

    LocalLoadingCache<Object, Object> cache = makeCache(builder, identityLoader());
    assertEquals(0, cache.stats().hitCount());
    assertEquals(0, cache.stats().missCount());

    Object one = new Object();
    cache.getUnchecked(one);
    assertEquals(0, cache.stats().hitCount());
    assertEquals(1, cache.stats().missCount());

    cache.getUnchecked(one);
    assertEquals(1, cache.stats().hitCount());

    val headers =
      Headers.headersOf(
        "cache-control",
        "no-store",
        "Cache-Control",
        "no-cache",
      )
    val headerMap = headers.toMultimap()
    assertThat(headerMap["cache-control"]!!.size).isEqualTo(2)
    assertThat(headerMap["Cache-Control"]!!.size).isEqualTo(2)
  }

 * by the garbage collector. Entries with reclaimed keys or values may be removed from the cache on
 * each cache modification, on occasional cache accesses, or on calls to {@link Cache#cleanUp}; such
 * entries may be counted in {@link Cache#size}, but will never be visible to read or write
 * operations.
 *