*
 * This implementation's STD3 rules are configured to `UseSTD3ASCIIRules=false`. This is
 * permissive and permits the `_` character.
 *
 * [mapping table]: https://www.unicode.org/reports/tr46/#IDNA_Mapping_Table
 * [mapping step]: https://www.unicode.org/reports/tr46/#ProcessingStepMap
 */
class SimpleIdnaMappingTable internal constructor(
  internal val mappings: List<Mapping>,
) {
  /**

      .isCloseTo(now.toDouble(), deltaMillis)
    assertThat(certificate.notAfter.time.toDouble())
      .isCloseTo(now.toDouble() + durationMillis, deltaMillis)
  }

  @Test
  fun customInterval() {
    // 5 seconds starting on 1970-01-01.
    val heldCertificate =
      HeldCertificate.Builder()
        .validityInterval(5000L, 10000L)
        .build()
    val certificate = heldCertificate.certificate

    .setBody("{}");
```

MockResponse can be used to simulate a slow network. This is useful for
testing timeouts and interactive testing.

```java
response.throttleBody(1024, 1, TimeUnit.SECONDS);
```


#### RecordedRequest

Verify requests by their method, path, HTTP version, body, and headers.

```java
RecordedRequest request = server.takeRequest();

 *
 * [RFC 3492]: https://datatracker.ietf.org/doc/html/rfc3492
 * [RFC 5890]: https://datatracker.ietf.org/doc/html/rfc5890
 * [UTS #46]: https://www.unicode.org/reports/tr46/
 */
object Punycode {
  val PREFIX_STRING = "xn--"
  val PREFIX = PREFIX_STRING.encodeUtf8()

  private const val BASE = 36
  private const val TMIN = 1
  private const val TMAX = 26

      randomAccessFile.setLength(0L)
      result.writeHeader(PREFIX_DIRTY, -1L, -1L)

      return result
    }

    /**
     * Creates a relay that reads a recorded stream from [file].
     *
     * **Warning:** callers to this method must immediately call [newSource] to create a source and
     * close that when they're done. Otherwise a handle to [file] will be leaked.
     */

    assertThat(Adapters.parseGeneralizedTime("19920622123421Z"))
      .isEqualTo(date("1992-06-22T12:34:21.000+0000").time)
  }

  @Disabled("fractional seconds are not implemented")
  @Test
  fun `parse generalized time with fractional seconds`() {
    assertThat(Adapters.parseGeneralizedTime("19920722132100.3Z"))
      .isEqualTo(date("1992-07-22T13:21:00.300+0000").time)
  }

      " cipherSuite=${handshake?.cipherSuite ?: "none"}" +
      " protocol=$protocol}"
  }

  companion object {
    const val IDLE_CONNECTION_HEALTHY_NS = 10_000_000_000 // 10 seconds.

    fun newTestConnection(
      taskRunner: TaskRunner,
      connectionPool: RealConnectionPool,
      route: Route,
      socket: Socket,
      idleAtNs: Long,
    ): RealConnection {

    // We know that a fresh connection was created if the server recorded a request with sequence
    // number 0. Since the client may have attempted to reuse the broken connection just before
    // creating a fresh connection, the server may have recorded 2 requests at this point. The order
    // of recording is non-deterministic.
    val requestAfter = server.takeRequest()

    assertInvalid("http://aa$dotA126/", "Invalid URL host: \"aa$dotA126\"")
  }

  /**
   * UTS 46 Validity Criteria: Decoded punycode must be NFC.
   *
   * https://www.unicode.org/reports/tr46/#Validity_Criteria
   */
  @Test
  fun hostnameInPunycodeNfcAndNfd() {
    // café can be NFC (é is one code point) or NFD (e plus ´ as two code points).
    val hostNfc = "café.com"

import org.junit.jupiter.api.extension.ExtensionContext
import org.junit.rules.TestRule
import org.junit.runner.Description
import org.junit.runners.model.Statement

/**
 * A log handler that records which log messages were published so that a calling test can make
 * assertions about them.
 */
class TestLogHandler(
  private val logger: Logger,
) : TestRule, BeforeEachCallback, AfterEachCallback {