*/
class CipherSuiteSurvey(
  val clients: List<Client>,
  val ianaSuites: IanaSuites,
  val orderBy: List<SuiteId>,
) {
  fun printGoogleSheet() {
    print("name")
    for (client in clients) {
      print("\t")
      print(client.nameAndVersion)
    }
    println()
    val sortedSuites =
      ianaSuites.suites.sortedBy { ianaSuite ->
        val index = orderBy.indexOfFirst { it.matches(ianaSuite) }

        executor.schedule({
          System.out.printf("%.2f Canceling call.%n", (System.nanoTime() - startNanos) / 1e9f)
          call.cancel()
          System.out.printf("%.2f Canceled call.%n", (System.nanoTime() - startNanos) / 1e9f)
        }, 1, TimeUnit.SECONDS)

        System.out.printf("%.2f Executing call.%n", (System.nanoTime() - startNanos) / 1e9f)
        try {

private fun runBatch(
  dnsProviders: List<DnsOverHttps>,
  names: List<String>,
) {
  var time = System.currentTimeMillis()
  for (dns in dnsProviders) {
    println("Testing ${dns.url}")
    for (host in names) {
      print("$host: ")
      System.out.flush()
      try {
        val results = dns.lookup(host)
        println(results)
      } catch (uhe: UnknownHostException) {
        var e: Throwable? = uhe
        while (e != null) {

    reason: String,
  ) {
    printStatus("-")
  }

  private fun printStatus(s: String) {
    if (++testCount % 80 == 0) {
      printStatus("\n")
    }
    originalSystemErr?.print(s)
  }

  override fun executionFinished(
    testIdentifier: TestIdentifier,
    testExecutionResult: TestExecutionResult,
  ) {
    if (!testIdentifier.isContainer) {
      when (testExecutionResult.status!!) {

![Events Diagram](../assets/images/******@****.***)

Here’s a [sample event listener](https://github.com/square/okhttp/blob/master/samples/guide/src/main/java/okhttp3/recipes/PrintEventsNonConcurrent.java) that prints each event with a timestamp.

```java
class PrintingEventListener extends EventListener {
  private long callStartNanos;

  private void printEvent(String name) {
    long nowNanos = System.nanoTime();

  }

  @Test fun `point with only x set`() {
    val bytes = "3003800109".decodeHex()
    val point = Point(9L, null)
    assertThat(Point.ADAPTER.fromDer(bytes)).isEqualTo(point)
    assertThat(Point.ADAPTER.toDer(point)).isEqualTo(bytes)
  }

  @Test fun `point with only y set`() {
    val bytes = "3003810109".decodeHex()
    val point = Point(null, 9L)

 * All comments are ignored.
 *
 * Regular lines contain fields separated by semicolons.
 *
 * The first element on each line is a single hex code point (like 0041) or a hex code point range
 * (like 0030..0039).
 *
 * The second element on each line is a mapping type, like `valid` or `mapped`.
 *

    // appendCodePoint(). The Punycode algorithm processes code points in increasing code-point
    // order, not in increasing index order.
    val codePoints = mutableListOf<Int>()

    // consume all code points before the last delimiter (if there is one)
    //  and copy them to output, fail on any non-basic code point
    val lastDelimiter = string.lastIndexOf('-', limit)
    if (lastDelimiter >= pos) {

 *    thread's [uncaught exception handler][Thread.UncaughtExceptionHandler]. By default this
 *    crashes the application on Android and prints a stacktrace on the JVM. (Crash reporting
 *    libraries may customize this behavior.)
 *
 * A good way to signal a failure is with a synthetic HTTP response:
 *
 * ```kotlin
 *   @Throws(IOException::class)

 *
 * If your authentication may be flaky and requires retries you should apply some policy
 * to limit the retries by the class of errors and number of attempts.  To get the number of
 * attempts to the current point use this function.
 *
 * ```java
 * private int responseCount(Response response) {
 *   int result = 1;
 *   while ((response = response.priorResponse()) != null) {
 *     result++;
 *   }