E000-F8FF; [PRIVATE USE, PLANE 0]
   F0000-FFFFD; [PRIVATE USE, PLANE 15]

    assertThat(log).containsExactly("run@100000")

    taskFaker.advanceUntil(150.µs)
    assertThat(log).containsExactly("run@100000", "run@150000")

    taskFaker.advanceUntil(299.µs)
    assertThat(log).containsExactly("run@100000", "run@150000")

    taskFaker.advanceUntil(300.µs)
    assertThat(log).containsExactly("run@100000", "run@150000", "run@300000")

    taskFaker.assertNoMoreTasks()

    // 5 seconds starting on 1970-01-01.
    val heldCertificate =
      HeldCertificate.Builder()
        .validityInterval(5000L, 10000L)
        .build()
    val certificate = heldCertificate.certificate
    assertThat(certificate.notBefore.time).isEqualTo(5000L)
    assertThat(certificate.notAfter.time).isEqualTo(10000L)
  }

  @Test
  fun customDuration() {
    val now = System.currentTimeMillis()
    val heldCertificate =

      .isEqualTo(date("1950-01-01T00:00:00.000+0000").time)
    assertThat(Adapters.parseGeneralizedTime("20500101000000Z"))
      .isEqualTo(date("2050-01-01T00:00:00.000+0000").time)
    assertThat(Adapters.parseGeneralizedTime("20990101000000Z"))
      .isEqualTo(date("2099-01-01T00:00:00.000+0000").time)
    assertThat(Adapters.parseGeneralizedTime("19920521000000Z"))
      .isEqualTo(date("1992-05-21T00:00:00.000+0000").time)

   1D4C5-1D505
   1D507-1D50A
   1D50D-1D514
   1D516-1D51C
   1D51E-1D539
   1D53B-1D53E
   1D540-1D544
   1D546
   1D54A-1D550
   1D552-1D6A3
   1D6A8-1D7C9
   20000-2A6D6
   2F800-2FA1D
   F0000-FFFFD

  fun largeRead() {
    val data = randomByteString(1000000)
    write(data)
    val operator =
      FileOperator(
        randomAccessFile!!.getChannel(),
      )
    val buffer = Buffer()
    operator.read(0, buffer, data.size.toLong())
    assertThat(buffer.readByteString()).isEqualTo(data)
  }

  @Test
  fun largeWrite() {
    val data = randomByteString(1000000)
    val operator =
      FileOperator(

      webSocket.close(1000, reason)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("reason.size() > 123: $reason")
    }
    webSocket.close(1000, null)
    serverListener.assertClosing(1000, "")
    server.close(1000, null)
    clientListener.assertClosing(1000, "")
    clientListener.assertClosed(1000, "")
    serverListener.assertClosed(1000, "")
  }

  @Test

      )
    }
    val elapsedUntilFailure = System.nanoTime() - executeAtNanos
    assertThat(TimeUnit.NANOSECONDS.toMillis(elapsedUntilFailure).toDouble())
      .isCloseTo(1000.0, 250.0)

    // Confirm a single ping was sent but not acknowledged.
    val logs = testLogHandler.takeAll()
    assertThat(countFrames(logs, "FINE: >> 0x00000000     8 PING          "))
      .isEqualTo(1)

        .addHeader("Content-Range: bytes 1000-1001/2000")
        .build(),
    )
    server.enqueue(
      MockResponse.Builder()
        .body("BB")
        .build(),
    )
    val url = server.url("/")
    val request =
      Request.Builder()
        .url(url)
        .header("Range", "bytes=1000-1001")
        .build()

FFFE..FFFF    ; disallowed                             # 1.1  <noncharacter-FFFE>..<noncharacter-FFFF>
10000..1000B  ; valid                                  # 4.0  LINEAR B SYLLABLE B008 A..LINEAR B SYLLABLE B046 JE
1000C         ; disallowed                             # NA   <reserved-1000C>
1000D..10026  ; valid                                  # 4.0  LINEAR B SYLLABLE B036 JO..LINEAR B SYLLABLE B032 QO