frame.writeInt(expectedWindowSizeIncrement.toInt())

    // Check writer sends the same bytes.
    assertThat(windowUpdate(expectedWindowSizeIncrement)).isEqualTo(frame)
    reader.nextFrame(
      requireSettings = false,
      object : BaseTestHandler() {
        override fun windowUpdate(
          streamId: Int,
          windowSizeIncrement: Long,
        ) {

    payload2: Int,
  ) {
    fail("")
  }

  override fun goAway(
    lastGoodStreamId: Int,
    errorCode: ErrorCode,
    debugData: ByteString,
  ) {
    fail("")
  }

  override fun windowUpdate(
    streamId: Int,
    windowSizeIncrement: Long,
  ) {
    fail("")
  }

  override fun priority(
    streamId: Int,
    streamDependency: Int,
    weight: Int,
    exclusive: Boolean,
  ) {

    for (i in 0..2) {
      val windowUpdateStreamIds: MutableList<Int?> = ArrayList(2)
      for (j in 0..1) {
        val windowUpdate = peer.takeFrame()
        assertThat(windowUpdate.type).isEqualTo(Http2.TYPE_WINDOW_UPDATE)
        windowUpdateStreamIds.add(windowUpdate.streamId)
        assertThat(windowUpdate.windowSizeIncrement).isEqualTo(windowUpdateThreshold.toLong())
      }
      // connection

  }

  internal fun writeWindowUpdateLater(
    streamId: Int,
    unacknowledgedBytesRead: Long,
  ) {
    writerQueue.execute("$connectionName[$streamId] windowUpdate") {
      try {
        writer.windowUpdate(streamId, unacknowledgedBytesRead)
      } catch (e: IOException) {
        failConnection(e)
      }
    }
  }

  fun writePing(
    reply: Boolean,
    payload1: Int,

      check(type == -1)
      this.type = Http2.TYPE_GOAWAY
      this.streamId = lastGoodStreamId
      this.errorCode = errorCode
      this.data = debugData.toByteArray()
    }

    override fun windowUpdate(
      streamId: Int,
      windowSizeIncrement: Long,
    ) {
      check(type == -1)
      this.type = Http2.TYPE_WINDOW_UPDATE
      this.streamId = streamId

        frameLogWindowUpdate(
          inbound = true,
          streamId = streamId,
          length = length,
          windowSizeIncrement = increment,
        ),
      )
    }
    handler.windowUpdate(streamId, increment)
  }

  @Throws(IOException::class)
  override fun close() {
    source.close()
  }

  /**

    }
  }

  /**
   * Inform peer that an additional `windowSizeIncrement` bytes can be sent on `streamId`, or the
   * connection if `streamId` is zero.
   */
  @Throws(IOException::class)
  fun windowUpdate(
    streamId: Int,
    windowSizeIncrement: Long,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      require(windowSizeIncrement != 0L && windowSizeIncrement <= 0x7fffffffL) {

HSPLokhttp3/internal/http2/Http2Connection$ReaderRunnable;->settings(ZLokhttp3/internal/http2/Settings;)V
HSPLokhttp3/internal/http2/Http2Connection$ReaderRunnable;->windowUpdate(IJ)V
HSPLokhttp3/internal/http2/Http2Connection;-><clinit>()V
HSPLokhttp3/internal/http2/Http2Connection;-><init>(Lokhttp3/internal/http2/Http2Connection$Builder;)V

    choco install ccleaner; \
    choco install chocolatey; \
    choco install chocolatey-core.extension; \
    choco install chocolatey-visualstudio.extension; \
    choco install chocolatey-windowsupdate.extension; \
    choco install cmake.install; \
    choco install dotnetcore-sdk; \
    choco install git; \
    choco install git.install; \
    choco install GoogleChrome; \