if (outFramesIterator.hasNext()) {
          nextOutFrame = outFramesIterator.next()
          end = nextOutFrame.start
          truncated = false
        } else {
          end = outBytes.size.toLong()
          truncated = nextOutFrame.truncated
        }

        // Write a frame.
        val length = (end - start).toInt()
        outputStream.write(outBytes, start.toInt(), length)

  // 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())
    val cachedClient = bootstrapClient.newBuilder().cache(cache).build()
    val cachedDns = buildLocalhost(cachedClient, false)

    repeat(2) {
      server.enqueue(
        dnsResponse(

        } else if (type == Double.class) {
            return DoubleConversionUtil.toDouble(o);
        } else if (type == Long.class) {
            return LongConversionUtil.toLong(o);
        } else if (type == Float.class) {
            return FloatConversionUtil.toFloat(o);
        } else if (type == Short.class) {
            return ShortConversionUtil.toShort(o);

     */
    fun maxAge(
      maxAge: Int,
      timeUnit: TimeUnit,
    ) = apply {
      require(maxAge >= 0) { "maxAge < 0: $maxAge" }
      val maxAgeSecondsLong = timeUnit.toSeconds(maxAge.toLong())
      this.maxAgeSeconds = maxAgeSecondsLong.commonClampToInt()
    }

    /**
     * Accept cached responses that have exceeded their freshness lifetime by up to `maxStale`. If

    server.webSocket!!.send(message)
    taskFaker.runTasks()
    assertThat(client.clientSourceBufferSize())
      .isGreaterThan(message.length.toLong()) // Not compressed.
    assertThat(client.processNextFrame()).isTrue()
    client.listener.assertTextMessage(message)
  }

  @Test
  fun messagesCompressedWhenConfigured() {

        if (o == null) {
            return null;
        } else if (o instanceof BigInteger) {
            return (BigInteger) o;
        } else {
            final Long l = LongConversionUtil.toLong(o, pattern);
            if (l == null) {
                return null;
            }
            return BigInteger.valueOf(l);
        }
    }

      Http2ExchangeCodec(client, this, chain, http2Connection)
    } else {
      socket.soTimeout = chain.readTimeoutMillis()
      source.timeout().timeout(chain.readTimeoutMillis.toLong(), MILLISECONDS)
      sink.timeout().timeout(chain.writeTimeoutMillis.toLong(), MILLISECONDS)
      Http1ExchangeCodec(client, this, source, sink)
    }
  }

  @Throws(SocketException::class)

  var writeBytesTotal = 0L
    internal set

  /** The total number of bytes permitted to be produced by incoming `WINDOW_UPDATE` frame. */
  var writeBytesMaximum: Long = connection.peerSettings.initialWindowSize.toLong()
    internal set

  /** Received headers yet to be [taken][takeHeaders]. */
  private val headersQueue = ArrayDeque<Headers>()

  /** True if response headers have been sent or received. */

          client = null,
          carrier = this,
          source = source,
          sink = sink,
        )
      source.timeout().timeout(readTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
      sink.timeout().timeout(writeTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
      tunnelCodec.writeRequest(nextRequest.headers, requestLine)
      tunnelCodec.finishRequest()
      val response =

  private fun createNewCache() {
    createNewCacheWithSize(Int.MAX_VALUE)
  }

  private fun createNewCacheWithSize(maxSize: Int) {
    cache =
      DiskLruCache(filesystem, cacheDir, appVersion, 2, maxSize.toLong(), taskRunner).also {
        toClose.add(it)
      }
    synchronized(cache) { cache.initialize() }
  }

  fun setUp(
    baseFilesystem: FileSystem,
    windows: Boolean,
  ) {
    this.cacheDir =