<uses-permission android:name="android.permission.INTERNET" />

  <application
    android:allowBackup="true"
    android:label="@string/app_name"
    android:supportsRtl="true"
    android:name=".TestApplication"
  >
    <activity
      android:name=".MainActivity"
      android:exported="true">
      <intent-filter>
        <action android:name="android.intent.action.MAIN" />

   *
   * @return true if the range of [string] from [pos] to [limit] was valid and decoded successfully.
   *     Otherwise, the decode failed.
   */
  private fun decodeLabel(
    string: String,
    pos: Int,
    limit: Int,
    result: Buffer,
  ): Boolean {
    if (!string.regionMatches(pos, PREFIX_STRING, 0, 4, ignoreCase = true)) {
      result.writeUtf8(string, pos, limit)

        return emptyList()
      }

    var cookies: MutableList<Cookie>? = null
    for ((key, value) in cookieHeaders) {
      if (("Cookie".equals(key, ignoreCase = true) || "Cookie2".equals(key, ignoreCase = true)) &&
        value.isNotEmpty()
      ) {
        for (header in value) {
          if (cookies == null) cookies = mutableListOf()
          cookies.addAll(decodeHeaderAsJavaNetCookies(url, header))

open class RecordingConnectionListener(
  /**
   * An override to ignore the normal order that is enforced.
   * EventListeners added by Interceptors will not see all events.
   */
  private val enforceOrder: Boolean = true,
) : ConnectionListener() {
  val eventSequence: Deque<ConnectionEvent> = ConcurrentLinkedDeque()

  private val forbiddenLocks = mutableSetOf<Any>()

 * [mapping step]: https://www.unicode.org/reports/tr46/#ProcessingStepMap
 */
class SimpleIdnaMappingTable internal constructor(
  internal val mappings: List<Mapping>,
) {
  /**
   * Returns true if the [codePoint] was applied successfully. Returns false if it was disallowed.
   */
  fun map(
    codePoint: Int,
    sink: BufferedSink,
  ): Boolean {
    val index =
      mappings.binarySearch {

      sink = data,
      random = random,
      perMessageDeflate = false,
      noContextTakeover = false,
      minimumDeflateSize = 0L,
    )
  private val clientWriter =
    WebSocketWriter(
      isClient = true,
      sink = data,
      random = random,
      perMessageDeflate = false,
      noContextTakeover = false,
      minimumDeflateSize = 0L,
    )

  @Test fun serverTextMessage() {

  @Throws(IOException::class)
  fun processNextEvent(): Boolean {
    var id = lastId
    var type: String? = null
    val data = Buffer()

    while (true) {
      when (source.select(options)) {
        in 0..2 -> {
          completeEvent(id, type, data)
          return true
        }

        in 3..4 -> {
          source.readData(data)
        }

        in 5..7 -> {

    serverTruncatesRequestOnLongPost(https = false)
  }

  @Test
  fun serverTruncatesRequestOnLongPostHttp2() {
    enableProtocol(Protocol.HTTP_2)
    serverTruncatesRequestOnLongPost(https = true)
  }

  private fun serverTruncatesRequestOnLongPost(https: Boolean) {
    server.enqueue(
      MockResponse(
        body = "abc",
        socketPolicy = DoNotReadRequestBody(ErrorCode.NO_ERROR.httpCode),

    writeTimeoutMillis: Int = 10_000,
    socketConnectTimeoutMillis: Int = 10_000,
    socketReadTimeoutMillis: Int = 10_000,
    pingIntervalMillis: Int = 10_000,
    retryOnConnectionFailure: Boolean = true,
    fastFallback: Boolean = true,
    routeDatabase: RouteDatabase = RouteDatabase(),
  ) : this(
    RealConnectionPool(
      taskRunner = taskRunner,
      maxIdleConnections = maxIdleConnections,

      }
    }

  val basicConstraints: Extension
    get() {
      return tbsCertificate.extensions.first {
        it.id == ObjectIdentifiers.BASIC_CONSTRAINTS
      }
    }

  /** Returns true if the certificate was signed by [issuer]. */
  @Throws(SignatureException::class)
  fun checkSignature(issuer: PublicKey): Boolean {
    val signedData = CertificateAdapters.tbsCertificate.toDer(tbsCertificate)