}
    }
    val outputStream = socket.getOutputStream()
    val inputStream = socket.getInputStream()
    val reader = Http2Reader(inputStream.source().buffer(), client)
    val outFramesIterator: Iterator<OutFrame> = outFrames.iterator()
    val outBytes = bytesOut.readByteArray()
    var nextOutFrame: OutFrame? = null
    for (i in 0 until frameCount) {
      if (nextOutFrame == null && outFramesIterator.hasNext()) {

    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
   * will not be returned. If existing responses are evicted during iteration, they will be absent
   * (unless they were already returned).
   *

  @ParameterizedTest
  @ArgumentsSource(FileSystemParamProvider::class)
  fun iterator(parameters: Pair<FileSystem, Boolean>) {
    setUp(parameters.first, parameters.second)
    set("a", "a1", "a2")
    set("b", "b1", "b2")
    set("c", "c1", "c2")
    val iterator = cache.snapshots()
    assertThat(iterator.hasNext()).isTrue()
    iterator.next().use {
      assertThat(it.key()).isEqualTo("a")

 *  Fix: Defer the `SecurityException` when looking up the default proxy selector.
 *  Fix: Don't use brackets formatting IPv6 host names in MockWebServer.
 *  Fix: Don't permit cache iterators to remove entries that are being written.


## Version 4.0.1

_2019-07-10_

 *  Fix: Tolerate null-hostile lists in public API. Lists created with `List.of(...)` don't like it

        }
      }
    }

    override fun put(element: T) {
      taskRunner.lock.withLock {
        delegate.put(element)
        editCount++
      }
    }

    override fun iterator() = error("unsupported")

    override fun offer(e: T) = error("unsupported")

    override fun peek(): T = error("unsupported")

    override fun offer(
      element: T,
      timeout: Long,

   */
  private fun promoteAndExecute(): Boolean {
    lock.assertNotHeld()

    val executableCalls = mutableListOf<AsyncCall>()
    val isRunning: Boolean
    this.withLock {
      val i = readyAsyncCalls.iterator()
      while (i.hasNext()) {
        val asyncCall = i.next()

        if (runningAsyncCalls.size >= this.maxRequests) break // Max capacity.

      serverSocket?.closeQuietly()

      val openClientSocket = openClientSockets.iterator()
      while (openClientSocket.hasNext()) {
        openClientSocket.next().closeQuietly()
        openClientSocket.remove()
      }

      val httpConnection = openConnections.iterator()
      while (httpConnection.hasNext()) {
        httpConnection.next().closeQuietly()
        httpConnection.remove()

      scheduleOpener(connection.route.address)
      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()) {
            i.remove()

	public final fun getDate (Ljava/lang/String;)Ljava/util/Date;
	public final fun getInstant (Ljava/lang/String;)Ljava/time/Instant;
	public fun hashCode ()I
	public fun iterator ()Ljava/util/Iterator;
	public final fun name (I)Ljava/lang/String;
	public final fun names ()Ljava/util/Set;
	public final fun newBuilder ()Lokhttp3/Headers$Builder;
	public static final fun of (Ljava/util/Map;)Lokhttp3/Headers;

        .body("c")
        .build(),
    )
    val urlC = server.url("/c")
    assertThat(get(urlC).body.string()).isEqualTo("c")

    // Confirm the iterator returns those responses...
    val i: Iterator<String> = cache.urls()
    assertThat(i.hasNext()).isTrue()
    assertThat(i.next()).isEqualTo(urlA.toString())
    assertThat(i.hasNext()).isTrue()