/**
   * 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) {

    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("windowSizeIncrement == 0 || windowSizeIncrement > 0x7fffffffL: 0")
    }
    assertFailsWith<IllegalArgumentException> {
      windowUpdate(0x80000000L)
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("windowSizeIncrement == 0 || windowSizeIncrement > 0x7fffffffL: 2147483648")
    }
  }

    inbound: Boolean,
    streamId: Int,
    length: Int,
    windowSizeIncrement: Long,
  ): String {
    val formattedType = formattedType(TYPE_WINDOW_UPDATE)
    val direction = if (inbound) "<<" else ">>"
    return format(
      "%s 0x%08x %5d %-13s %d",
      direction,
      streamId,
      length,
      formattedType,
      windowSizeIncrement,
    )
  }

      this.data = debugData.toByteArray()
    }

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

    override fun priority(
      streamId: Int,
      streamDependency: Int,
      weight: Int,

      errorCode: ErrorCode,
      debugData: ByteString,
    )

    /**
     * Notifies that an additional `windowSizeIncrement` bytes can be sent on `streamId`, or the
     * connection if `streamId` is zero.
     */
    fun windowUpdate(
      streamId: Int,
      windowSizeIncrement: Long,
    )

    /**
     * Called when reading a headers or priority frame. This may be used to change the stream's

  }

  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,
  ) {
    fail("")
  }

          removeStream(http2Stream.id)
        }
      }
    }

    override fun windowUpdate(
      streamId: Int,
      windowSizeIncrement: Long,
    ) {
      if (streamId == 0) {
        ******@****.***ck {
          writeBytesMaximum += windowSizeIncrement
          condition.signalAll()
        }
      } else {
        val stream = getStream(streamId)
        if (stream != null) {

        val windowUpdate = peer.takeFrame()
        assertThat(windowUpdate.type).isEqualTo(Http2.TYPE_WINDOW_UPDATE)
        windowUpdateStreamIds.add(windowUpdate.streamId)
        assertThat(windowUpdate.windowSizeIncrement).isEqualTo(windowUpdateThreshold.toLong())
      }
      // connection
      assertThat(windowUpdateStreamIds).contains(0)
      // stream
      assertThat(windowUpdateStreamIds).contains(3)
    }
  }