val call = i.next()
      if (call.request.url.toString() == url) {
        i.remove()
        dispatcherTest.dispatcher.finishedAccessor(call)
        return
      }
    }
    throw AssertionError("No such job: $url")
  }

  override fun shutdown() {
    shutdown = true
  }

  override fun shutdownNow(): List<Runnable> {
    throw UnsupportedOperationException()
  }

    if (cancel) {
      cancel = false
      eventSource.cancel()
    }
  }

  private fun nextEvent(): Any {
    return events.poll(10, TimeUnit.SECONDS)
      ?: throw AssertionError("Timed out waiting for event.")
  }

  fun assertExhausted() {
    assertThat(events).isEmpty()
  }

  fun assertEvent(
    id: String?,
    type: String?,
    data: String,
  ) {

    if (assertionsEnabled && !taskRunner.lock.isHeldByCurrentThread) {
      throw AssertionError("Thread ${Thread.currentThread().name} MUST hold lock on $this")
    }
  }

  @Suppress("NOTHING_TO_INLINE")
  internal inline fun Any.assertThreadDoesntHoldLock() {
    if (assertionsEnabled && taskRunner.lock.isHeldByCurrentThread) {
      throw AssertionError("Thread ${Thread.currentThread().name} MUST NOT hold lock on $this")
    }
  }

    try {
      ensureAllConnectionsReleased()
      releaseClient()
    } catch (ae: AssertionError) {
      result += ae
    }

    try {
      if (taskQueuesWereIdle) {
        ensureAllTaskQueuesIdle()
      }
    } catch (ae: AssertionError) {
      result += ae
    }

    if (result != null) throw result
  }

  private fun releaseClient() {

    } else {
      events.add(Failure(t, response))
    }
  }

  private fun nextEvent(): Any {
    return events.poll(10, TimeUnit.SECONDS)
      ?: throw AssertionError("Timed out waiting for event.")
  }

  fun assertTextMessage(payload: String?) {
    assertThat(nextEvent()).isEqualTo(Message(string = payload))
  }

  fun assertBinaryMessage(payload: ByteString?) {

          Interceptor { chain: Interceptor.Chain? ->
            try {
              ready.countDown()
              waiting.await()
            } catch (e: InterruptedException) {
              throw AssertionError()
            }
            throw IOException()
          },
        )
        .build()
    val a1 = client.newCall(newRequest("http://a/1"))
    val a2 = client.newCall(newRequest("http://a/2"))

    val thread =
      object : Thread() {
        override fun run() {
          throw RuntimeException("boom!")
        }
      }
    thread.start()
    thread.join()

    assertFailsWith<AssertionError> {
      testRule.afterEach(extensionContext)
    }.also { expected ->
      assertThat(expected).hasMessage("uncaught exception thrown during test")
      assertThat(expected.cause!!).hasMessage("boom!")
    }
  }

    requestBodySinks.add(sink)
  }

  override fun isDuplex(): Boolean = true

  @Throws(InterruptedException::class)
  fun takeSink(): BufferedSink {
    return requestBodySinks.poll(5, SECONDS) ?: throw AssertionError("no sink to take")
  }

  fun assertNoMoreSinks() {
    assertTrue(requestBodySinks.isEmpty())
  }

        arrayOf<KeyManager>(keyManager),
        arrayOf<TrustManager>(trustManager),
        SecureRandom(),
      )
      sslContext.socketFactory
    } catch (e: GeneralSecurityException) {
      throw AssertionError(e)
    }
  }

          e: IOException,
        ) {
          throw AssertionError()
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          try {
            responseRef.put(response)
          } catch (e: InterruptedException) {
            throw AssertionError()
          }
        }
      },
    )