settings[Settings.MAX_CONCURRENT_STREAMS] = 75
    assertThat(settings.getMaxConcurrentStreams()).isEqualTo(75)
    settings.clear()
    assertThat(settings.getMaxFrameSize(16384)).isEqualTo(16384)
    settings[Settings.MAX_FRAME_SIZE] = 16777215
    assertThat(settings.getMaxFrameSize(16384)).isEqualTo(16777215)
    assertThat(settings.getMaxHeaderListSize(-1)).isEqualTo(-1)
    settings[Settings.MAX_HEADER_LIST_SIZE] = 16777215

  }

  fun getMaxConcurrentStreams(): Int {
    val bit = 1 shl MAX_CONCURRENT_STREAMS
    return if (bit and set != 0) values[MAX_CONCURRENT_STREAMS] else Int.MAX_VALUE
  }

  fun getMaxFrameSize(defaultValue: Int): Int {
    val bit = 1 shl MAX_FRAME_SIZE
    return if (bit and set != 0) values[MAX_FRAME_SIZE] else defaultValue
  }

  fun getMaxHeaderListSize(defaultValue: Int): Int {

  @Throws(IOException::class)
  fun applyAndAckSettings(peerSettings: Settings) {
    this.withLock {
      if (closed) throw IOException("closed")
      this.maxFrameSize = peerSettings.getMaxFrameSize(maxFrameSize)
      if (peerSettings.headerTableSize != -1) {
        hpackWriter.resizeHeaderTable(peerSettings.headerTableSize)
      }
      frameHeader(
        streamId = 0,
        length = 0,

import okio.BufferedSource
import okio.ByteString
import okio.Source
import okio.Timeout

/**
 * Reads HTTP/2 transport frames.
 *
 * This implementation assumes we do not send an increased [frame][Settings.getMaxFrameSize] to the
 * peer. Hence, we expect all frames to have a max length of [Http2.INITIAL_MAX_FRAME_SIZE].
 */
class Http2Reader(
  /** Creates a frame reader with max header table size of 4096. */

    settings[Settings.MAX_FRAME_SIZE] = newMaxFrameSize
    val connection = connectWithSettings(true, settings)

    // verify the peer's settings were read and applied.
    assertThat(connection.peerSettings.getMaxFrameSize(-1)).isEqualTo(newMaxFrameSize)
    assertThat(connection.writer.maxDataLength()).isEqualTo(newMaxFrameSize)
  }

  /**