rstStream?.receiveRstStream(errorCode)
    }

    override fun settings(
      clearPrevious: Boolean,
      settings: Settings,
    ) {
      writerQueue.execute("$connectionName applyAndAckSettings") {
        applyAndAckSettings(clearPrevious, settings)
      }
    }

    /**
     * Apply inbound settings and send an acknowledgement to the peer that provided them.
     *

      }
      sink.write(CONNECTION_PREFACE)
      sink.flush()
    }
  }

  /** Applies `peerSettings` and then sends a settings ACK. */
  @Throws(IOException::class)
  fun applyAndAckSettings(peerSettings: Settings) {
    this.withLock {
      if (closed) throw IOException("closed")
      this.maxFrameSize = peerSettings.getMaxFrameSize(maxFrameSize)
      if (peerSettings.headerTableSize != -1) {

    connection: Http2Connection,
    amount: Int,
  ) {
    val settings = Settings()
    settings[Settings.MAX_CONCURRENT_STREAMS] = amount
    connection.readerRunnable.applyAndAckSettings(true, settings)
    assertThat(connection.peerSettings[Settings.MAX_CONCURRENT_STREAMS]).isEqualTo(amount)
    taskFaker.runTasks()
  }

    }
  }

  @Test fun ackSettingsAppliesMaxFrameSize() {
    val newMaxFrameSize = 16777215
    val writer = Http2Writer(Buffer(), true)
    writer.applyAndAckSettings(Settings().set(Settings.MAX_FRAME_SIZE, newMaxFrameSize))
    assertThat(writer.maxDataLength()).isEqualTo(newMaxFrameSize)
    writer.frameHeader(0, newMaxFrameSize, Http2.TYPE_DATA, FLAG_NONE)
  }

    val connection = connect(peer)

    // fake a settings frame with clear flag set.
    val settings2 = Settings()
    settings2[Settings.MAX_CONCURRENT_STREAMS] = 60000
    connection.readerRunnable.applyAndAckSettings(true, settings2)
    connection.withLock {
      assertThat(connection.peerSettings.headerTableSize).isEqualTo(-1)
      assertThat(connection.peerSettings.initialWindowSize)