}.also { expected ->
      assertThat(expected).hasMessage("Failed to parse UTCTime 191216#30210Z")
    }
  }

  @Test fun `cannot decode generalized time with offset`() {
    assertFailsWith<ProtocolException> {
      Adapters.GENERALIZED_TIME.fromDer("181332303139313231353139303231302d30383030".decodeHex())
    }.also { expected ->
      assertThat(expected).hasMessage("Failed to parse GeneralizedTime 20191215190210-0800")
    }
  }

        |lu/GJQZoU9lDrCPeUcQ28tzOWw==
        |-----END PRIVATE KEY-----
        |
        """.trimMargin(),
      )
      fail<Any>()
    } catch (expected: IllegalArgumentException) {
      if (!platform.isConscrypt()) {
        assertThat(expected.message).isEqualTo("failed to decode certificate")
      }
    }
    try {
      decode(
        """
        |-----BEGIN CERTIFICATE-----

    )

    taskFaker.advanceUntil(510.ms)
    assertEvents(
      "plan 0 TCP connect failed",
    )

    taskFaker.advanceUntil(520.ms)
    assertEvents(
      "plan 1 TCP connect failed",
    )

    taskFaker.advanceUntil(530.ms)
    assertEvents(
      "plan 2 TCP connect failed",
      "take plan 3",
      "plan 3 TCP connecting...",
    )

    taskFaker.advanceUntil(780.ms)

        }
      }

      val startNs = System.nanoTime()
      val response: Response
      try {
        response = chain.proceed(request)
      } catch (e: Exception) {
        logger.log("<-- HTTP FAILED: $e")
        throw e
      }

      val tookMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs)

      val responseBody = response.body!!
      val contentLength = responseBody.contentLength()

    connection.calls.add(CallReference(this, callStackTrace))
  }

  /**
   * Releases resources held with the request or response of [exchange]. This should be called when
   * the request completes normally or when it fails due to an exception, in which case [e] should
   * be non-null.
   *
   * If the exchange was canceled or timed out, this will wrap [e] in an exception that provides

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *

        }
      }
    ```

### Posting a File ([.kt][PostFileKotlin], [.java][PostFileJava])

It's easy to use a file as a request body.

=== ":material-language-kotlin: Kotlin"
    ```kotlin
      private val client = OkHttpClient()

      fun run() {
        val file = File("README.md")

        val request = Request.Builder()

    internal `DiskLruCache` assumes an inode-like file system, where it's fine to delete files that
    are currently being read or written. On Windows the file system forbids this so we must be more
    careful when deleting and renaming files.

 *  Fix: Don't crash on Java 8u252 which introduces an API previously found only on Java 9 and

    assertThat(regularRoutes.size).isEqualTo(numberOfAddresses)
    // Add first regular route as failed.
    routeDatabase.failed(regularRoutes[0])
    // Reset selector
    routeSelector = newRouteSelector(address)

    // The first selection prioritizes the non-failed routes.
    val selection2 = routeSelector.next()
    assertThat(selection2.next()).isEqualTo(regularRoutes[1])

   * thread.
   */
  fun finishReader() {
    val failed: Boolean
    val code: Int
    val reason: String?
    var streamsToClose: Streams?
    var readerToClose: WebSocketReader?
    synchronized(this) {
      failed = this.failed
      code = receivedCloseCode
      reason = receivedCloseReason

      readerToClose = reader
      reader = null