)

    taskFaker.advanceUntil(540.ms)
    assertEvents(
      "plan 2 TCP connect canceled",
    )

    taskFaker.assertNoMoreTasks()
  }

  /**
   * This test puts several connections in flight that all fail at approximately the same time. It
   * confirms the fast fallback implements these invariants:
   *
   *  * if there's no TCP connect in flight, start one.

    val endpointUrl = server.url("/endpoint")

    var request =
      Request.Builder()
        .url(endpointUrl)
        .header("Content-Type", "application/xml")
        .put(ValidRequestBody())
        .build()
    client.newCall(request).execute().use {
      assertEquals(201, it.code)
    }

    request =
      Request.Builder()
        .url(endpointUrl)
        .head()

fun Request.Builder.commonDelete(body: RequestBody?): Request.Builder = method("DELETE", body)

fun Request.Builder.commonPut(body: RequestBody): Request.Builder = method("PUT", body)

fun Request.Builder.commonPatch(body: RequestBody): Request.Builder = method("PATCH", body)

fun Request.Builder.commonMethod(
  method: String,
  body: RequestBody?,
): Request.Builder =
  apply {

    }
  }

  private fun RepositoryPlugin.deployFile(file: Path) {
    if (fileSystem.metadataOrNull(file)?.isRegularFile != true) return
    try {
      fileSystem.read(file) {
        put(inputStream(), RepositoryPlugin.PutOptions())
        println("Deployed ${file.name}")
      }
    } catch (e: IllegalArgumentException) {
      if ("Jar does not have a symbolic name" in e.message!!) {

    builder = builder.get()
    builder = builder.head()
    builder = builder.post(requestBody)
    builder = builder.delete(requestBody)
    builder = builder.delete(null)
    builder = builder.put(requestBody)
    builder = builder.patch(requestBody)
    builder = builder.method("", requestBody)
    builder = builder.method("", null)
    builder = builder.tag("")
    builder = builder.tag(null)

  private const val SETTINGS_HEADER_TABLE_SIZE = 4_096

  /**
   * The decoder has ultimate control of the maximum size of the dynamic table but we can choose
   * to use less. We'll put a cap at 16K. This is arbitrary but should be enough for most purposes.
   */
  private const val SETTINGS_HEADER_TABLE_SIZE_LIMIT = 16_384

  val STATIC_HEADER_TABLE =
    arrayOf(
      Header(TARGET_AUTHORITY, ""),

    assertThat(recordedRequest.method).isEqualTo("DELETE")
    assertThat(recordedRequest.body.readUtf8()).isEqualTo("def")
  }

  @Test
  fun put() {
    server.enqueue(MockResponse(body = "abc"))
    val request =
      Request.Builder()
        .url(server.url("/"))
        .put("def".toRequestBody("text/plain".toMediaType()))
        .build()
    executeSynchronously(request)
      .assertCode(200)

   * simultaneously adopted and removed.
   */
  private val connections = ConcurrentLinkedQueue<RealConnection>()

  init {
    // Put a floor on the keep alive duration, otherwise cleanup will spin loop.
    require(keepAliveDuration > 0L) { "keepAliveDuration <= 0: $keepAliveDuration" }
  }

  fun idleConnectionCount(): Int {
    return connections.count {

    testRequestMethod("POST", true, withOverride = true)
  }

  @Test
  fun requestMethodPutIsNotCached() {
    testRequestMethod("PUT", false)
  }

  @Test
  fun requestMethodPutIsNotCachedEvenWithOverride() {
    testRequestMethod("PUT", false, withOverride = true)
  }

  @Test
  fun requestMethodDeleteIsNotCached() {
    testRequestMethod("DELETE", false)
  }

          val editCountBefore = editCount
          yieldUntil { nanoTime >= waitUntil || editCount > editCountBefore }
        }
      }
    }

    override fun put(element: T) {
      taskRunner.lock.withLock {
        delegate.put(element)
        editCount++
      }
    }

    override fun iterator() = error("unsupported")

    override fun offer(e: T) = error("unsupported")