import assertk.assertions.isNull
import assertk.assertions.isTrue
import java.io.IOException
import java.text.SimpleDateFormat
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?,
) {

    assertThat(response.body.string()).isEqualTo("hello, OkHttp")

    val recorded = server.takeRequest()
    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")
    assertThat(recorded.headers["Accept-Encoding"]).isEqualTo("gzip")
    assertThat(recorded.headers["Connection"]).isEqualTo("Keep-Alive")
    assertThat(recorded.headers["User-Agent"]!!).matches(Regex("okhttp/.*"))
  }

    its own IDN mapping table in the library.

 *  New: Prefer the client's configured precedence order for TLS cipher suites. (OkHttp used to
    prefer the JDK’s precedence order.) This change may cause your HTTP calls to negotiate a
    different cipher suite than before! OkHttp's defaults cipher suites are selected for good
    security and performance.

     *
     * Since we can't ACK settings on the current reader thread (the reader thread can't write) we
     * execute all peer settings logic on the writer thread. This relies on the fact that the
     * writer task queue won't reorder tasks; otherwise settings could be applied in the opposite
     * order than received.
     */
    fun applyAndAckSettings(
      clearPrevious: Boolean,

     *
     * ## Upstream
     *
     * In this case the current thread is assigned as the upstream reader. We read bytes from
     * upstream and copy them to both the file and to the buffer. Finally we release the upstream
     * reader lock and return the new bytes.
     *
     * ## The file
     *
     * In this case we copy bytes from the file to the [sink].
     *

    val recorded = server.takeRequest()
    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")
    assertThat(recorded.headers["Accept-Encoding"]).isNull() // No built-in gzip.
    assertThat(recorded.headers["Connection"]).isEqualTo("Upgrade, HTTP2-Settings")
    if (PlatformVersion.majorVersion < 19) {
      assertThat(recorded.headers["Content-Length"]).isEqualTo("0")
    }

    }

    val recorded = server.takeRequest()
    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")
    assertThat(recorded.headers["Accept-Encoding"]).isEqualTo("gzip, x-gzip, deflate")
    assertThat(recorded.headers["Connection"]).isEqualTo("keep-alive")
    assertThat(recorded.headers["User-Agent"]!!).startsWith("Apache-HttpClient/")
  }

   *
   * If there's nothing to read and no default value, this will throw an exception.
   */
  fun fromDer(reader: DerReader): T

  fun fromDer(byteString: ByteString): T {
    val buffer = Buffer().write(byteString)
    val reader = DerReader(buffer)
    return fromDer(reader)
  }

  /**
   * Writes [value] to this adapter, unless it is the default value and can be safely omitted.
   *

            override fun close() {
              closed.set(true)
              super.close()
            }
          }.buffer()
        }
      }
    val reader = body.charStream()
    assertThat(reader.read()).isEqualTo('h'.code)
    reader.close()
    assertThat(closed.get()).isTrue()
  }

  @Test
  fun sourceSeesBom() {
    val body = "efbbbf68656c6c6f".decodeHex().toResponseBody()

        if (truncated) {
          socket.close()
        }
      } else {
        // read a frame
        val inFrame = InFrame(i, reader)
        reader.nextFrame(false, inFrame)
        inFrames.add(inFrame)
      }
    }
  }

  fun openSocket(): Socket = Socket("localhost", port)

  @Synchronized override fun close() {