Yuri Schimke <******@****.***> 1713104645 +0100

project(":mockwebserver-junit4").name = "mockwebserver3-junit4"
include(":mockwebserver-junit5")
project(":mockwebserver-junit5").name = "mockwebserver3-junit5"

val androidBuild: String by settings
val graalBuild: String by settings
val loomBuild: String by settings

if (androidBuild.toBoolean()) {
  include(":regression-test")
}

if (graalBuild.toBoolean()) {
  include(":native-image-tests")
}

include(":okcurl")

    @JvmField var data: ByteArray? = null

    @JvmField var settings: Settings? = null

    @JvmField var ack = false

    @JvmField var payload1 = 0

    @JvmField var payload2 = 0

    override fun settings(
      clearPrevious: Boolean,
      settings: Settings,
    ) {
      check(type == -1)
      this.type = Http2.TYPE_SETTINGS
      this.clearPrevious = clearPrevious

    stream.close(ErrorCode.REFUSED_STREAM, null)
  }

  /** When settings are received, adjust the allocation limit. */
  override fun onSettings(
    connection: Http2Connection,
    settings: Settings,
  ) {
    lock.withLock {
      val oldLimit = allocationLimit
      allocationLimit = settings.getMaxConcurrentStreams()

      if (allocationLimit < oldLimit) {

Please be considerate of your servers and their operators as you roll out this release. Compression
saves bandwidth but it costs CPU and memory! If you run into a problem you may need to adjust or
disable the `permessage-deflate` compression settings on your server.

Note that OkHttp won't use compression when sending messages smaller than 1 KiB.

 *  Fix: Don't crash when the URL hostname contains an underscore on Android.

    realConnection: RealConnection,
    maxConcurrentStreams: Int,
  ): Http2Connection {
    // Write the mocking script.
    val settings1 = Settings()
    settings1[Settings.MAX_CONCURRENT_STREAMS] = maxConcurrentStreams
    peer.sendFrame().settings(settings1)
    peer.acceptFrame() // ACK
    peer.sendFrame().ping(false, 2, 0)
    peer.acceptFrame() // PING
    peer.play()

    // Play it back.

    }
  }

  /** Write okhttp's settings to the peer. */
  @Throws(IOException::class)
  fun settings(settings: Settings) {
    this.withLock {
      if (closed) throw IOException("closed")
      frameHeader(
        streamId = 0,
        length = settings.size() * 6,
        type = TYPE_SETTINGS,
        flags = FLAG_NONE,
      )
      for (i in 0 until Settings.COUNT) {
        if (!settings.isSet(i)) continue

  }

  /** Merges [settings] into this peer's settings and sends them to the remote peer. */
  @Throws(IOException::class)
  fun setSettings(settings: Settings) {
    writer.withLock {
      this.withLock {
        if (isShutdown) {
          throw ConnectionShutdownException()
        }
        okHttpSettings.merge(settings)
      }
      writer.settings(settings)
    }
  }

    mockWebServer: MockWebServer,
  ) {
    setUp(protocol, mockWebServer)
    val settings = Settings()
    settings[Settings.MAX_CONCURRENT_STREAMS] = 2

    // Read & write a full request to confirm settings are accepted.
    server.enqueue(
      MockResponse.Builder()
        .settings(settings)
        .build(),
    )
    val call = client.newCall(Request(server.url("/")))

    var pushPromises: List<PushPromise> = mockResponse.pushPromises
    pushPromises = mockResponse.pushPromises
    mockResponse = mockResponse.withSettings(Settings())
    var settings: Settings = mockResponse.settings
    settings = mockResponse.settings
    mockResponse =
      mockResponse.withWebSocketUpgrade(
        object : WebSocketListener() {
        },
      )