internal class SequentialExchangeFinder(
  override val routePlanner: RoutePlanner,
) : ExchangeFinder {
  override fun find(): RealConnection {
    var firstException: IOException? = null
    while (true) {
      if (routePlanner.isCanceled()) throw IOException("Canceled")

      try {
        val plan = routePlanner.plan()

        if (!plan.isReady) {
          val tcpConnectResult = plan.connectTcp()

class TaskRunnerTest {
  private val taskFaker = TaskFaker()

  @RegisterExtension @JvmField
  val testLogHandler = TestLogHandler(taskFaker.logger)

  private val taskRunner = taskFaker.taskRunner
  private val log = mutableListOf<String>()
  private val redQueue = taskRunner.newQueue()
  private val blueQueue = taskRunner.newQueue()
  private val greenQueue = taskRunner.newQueue()

  @AfterEach

import java.util.Date

/**
 * A received response or failure recorded by the response recorder.
 */
class RecordedResponse(
  @JvmField val request: Request,
  val response: Response?,
  val webSocket: WebSocket?,
  val body: String?,
  val failure: IOException?,
) {
  fun assertRequestUrl(url: HttpUrl) =
    apply {
      assertThat(request.url).isEqualTo(url)
    }

import org.junit.jupiter.api.extension.RegisterExtension

@Tag("Slowish")
class SocketFailureTest {
  @RegisterExtension
  val platform = PlatformRule()

  val listener = SocketClosingEventListener()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListener(listener)

import okio.Path.Companion.toPath
import okio.buffer
import okio.fakefilesystem.FakeFileSystem

class PostPath {
  private val client = OkHttpClient()
  private val fileSystem = FakeFileSystem()
  val path = "test.json".toPath()

  fun run() {
    fileSystem.write(path) {
      writeUtf8("{}")
    }

    val request =
      Request
        .Builder()
        .url("https://httpbin.org/anything")

  @Test
  fun hashCode_usesIdentityHashCode_legacyCase() {
    val cs = CipherSuite.TLS_RSA_EXPORT_WITH_RC4_40_MD5 // This one's javaName starts with "SSL_".
    assertThat(cs.hashCode(), cs.toString())
      .isEqualTo(System.identityHashCode(cs))
  }

  @Test
  fun hashCode_usesIdentityHashCode_regularCase() {
    // This one's javaName matches the identifier.
    val cs = CipherSuite.TLS_RSA_WITH_AES_128_CBC_SHA256

 */
open class DelegatingSocketFactory(
  private val delegate: SocketFactory,
) : SocketFactory() {
  @Throws(IOException::class)
  override fun createSocket(): Socket {
    val socket = delegate.createSocket()
    return configureSocket(socket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: String,
    port: Int,
  ): Socket {
    val socket = delegate.createSocket(host, port)

    // @JvmField val TLS_NULL_WITH_NULL_NULL = init("TLS_NULL_WITH_NULL_NULL", 0x0000)
    @JvmField val TLS_RSA_WITH_NULL_MD5 = init("SSL_RSA_WITH_NULL_MD5", 0x0001)

    @JvmField val TLS_RSA_WITH_NULL_SHA = init("SSL_RSA_WITH_NULL_SHA", 0x0002)

    @JvmField val TLS_RSA_EXPORT_WITH_RC4_40_MD5 = init("SSL_RSA_EXPORT_WITH_RC4_40_MD5", 0x0003)

  /**
   * Returns the result of dividing this by {@code val}.
   *
   * @since 14.0
   */
  public UnsignedLong dividedBy(UnsignedLong val) {
    return fromLongBits(UnsignedLongs.divide(value, checkNotNull(val).value));
  }

  /**
   * Returns this modulo {@code val}.
   *
   * @since 14.0
   */
  public UnsignedLong mod(UnsignedLong val) {

open class DelegatingServerSocketFactory(
  private val delegate: ServerSocketFactory,
) : ServerSocketFactory() {
  @Throws(IOException::class)
  override fun createServerSocket(): ServerSocket {
    val serverSocket = delegate.createServerSocket()
    return configureServerSocket(serverSocket)
  }

  @Throws(IOException::class)
  override fun createServerSocket(port: Int): ServerSocket {
    val serverSocket = delegate.createServerSocket(port)