internal val connectionListener: ConnectionListener
    get() = delegate.connectionListener

  /** Close and remove all idle connections in the pool. */
  fun evictAll() {
    delegate.evictAll()
  }

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.

```kotlin
cache.evictAll()
```

Removing individual items can be done using the urls iterator.
This would be typical after a user initiates a force refresh by a pull to refresh type action.

```java

      connections.remove(connection)
      if (connections.isEmpty()) cleanupQueue.cancelAll()
      true
    } else {
      scheduleCloser()
      false
    }
  }

  fun evictAll() {
    val i = connections.iterator()
    while (i.hasNext()) {
      val connection = i.next()
      val socketToClose =
        connection.withLock {
          if (connection.calls.isEmpty()) {

  }

  @Test
  fun evictAll() {
    set("a", "a", "a")
    set("b", "b", "b")
    cache.evictAll()
    assertThat(cache.size()).isEqualTo(0)
    assertAbsent("a")
    assertAbsent("b")
  }

  @Test
  fun evictAllWithPartialCreate() {
    val a = cache.edit("a")!!
    a.setString(0, "a1")
    a.setString(1, "a2")
    cache.evictAll()
    assertThat(cache.size()).isEqualTo(0)

  /**
   * Deletes all values stored in the cache. In-flight writes to the cache will complete normally,
   * but the corresponding responses will not be stored.
   */
  @Throws(IOException::class)
  fun evictAll() {
    cache.evictAll()
  }

  /**
   * Returns an iterator over the URLs in this cache. This iterator doesn't throw
   * `ConcurrentModificationException`, but if new responses are added while iterating, their URLs

 *
 * ```java
 * client.dispatcher().executorService().shutdown();
 * ```
 *
 * Clear the connection pool with [evictAll()][ConnectionPool.evictAll]. Note that the connection
 * pool's daemon thread may not exit immediately.
 *
 * ```java
 * client.connectionPool().evictAll();
 * ```
 *
 * If your client has a cache, call [close()][Cache.close]. Note that it is an error to create calls

	public fun <init> (Lokio/FileSystem;Lokio/Path;J)V
	public fun close ()V
	public final fun delete ()V
	public final fun directory ()Ljava/io/File;
	public final fun directoryPath ()Lokio/Path;
	public final fun evictAll ()V
	public fun flush ()V
	public final fun hitCount ()I
	public final fun initialize ()V
	public final fun isClosed ()Z
	public static final fun key (Lokhttp3/HttpUrl;)Ljava/lang/String;
	public final fun maxSize ()J

  }

  /**
   * Deletes all stored values from the cache. In-flight edits will complete normally but their
   * values will not be stored.
   */
  @Synchronized
  @Throws(IOException::class)
  fun evictAll() {
    initialize()
    // Copying for concurrent iteration.
    for (entry in lruEntries.values.toTypedArray()) {
      removeEntry(entry)
    }
    mostRecentTrimFailed = false
  }

          .source()
          .readUtf8Line()
          .also { line = it } != null
      ) {
        println(line)
      }
    } finally {
      response.body.close()
    }
    client.connectionPool.evictAll()
  }

    // Should not get to this response, so fail if so.
    // Avoids timeout on error
    server.enqueue(MockResponse(code = 420, body = "Enhance Your Calm"))
  }

  @Test
  fun evictAll() {
    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("Cache-Control: max-age=60")
        .body("A")
        .build(),
    )
    server.enqueue(