fun allocate(count: Int): List<InetAddress> {
    val from = nextAddress
    nextAddress += count
    return (from until nextAddress)
      .map {
        return@map InetAddress.getByAddress(
          Buffer().writeInt(it.toInt()).readByteArray(),
        )
      }
  }

  /** Allocates and returns `count` fake IPv6 addresses like [::ff00:64, ::ff00:65].  */

      .build()

  private val api = retrofit.create(SslLabsService::class.java)

  suspend fun query(): List<Client> {
    return api.clients().map { userAgent ->
      Client(userAgent.name, userAgent.version, userAgent.platform, enabled = userAgent.suiteNames.map { SuiteId(null, it) })
    }
  }
}

suspend fun main() {
  val client = OkHttpClient()

  val scraper = SslLabsScraper(client)

  }

  fun takeResponseCookies(): List<Cookie> {
    return responseCookies.removeFirst()
  }

  fun assertResponseCookies(vararg cookies: String?) {
    assertThat(takeResponseCookies().map(Cookie::toString)).containsExactly(*cookies)
  }

  override fun saveFromResponse(
    url: HttpUrl,
    cookies: List<Cookie>,
  ) {
    responseCookies.add(cookies)
  }

}

internal fun idnToAscii(host: String): String? {
  val bufferA = Buffer().writeUtf8(host)
  val bufferB = Buffer()

  // 1. Map, from bufferA to bufferB.
  while (!bufferA.exhausted()) {
    val codePoint = bufferA.readUtf8CodePoint()
    if (!IDNA_MAPPING_TABLE.map(codePoint, bufferB)) return null
  }

  // 2. Normalize, from bufferB to bufferA.
  val normalized = normalizeNfc(bufferB.readUtf8())

        TimeUnit.NANOSECONDS.toMillis(actualElapsedNs)
          .toDouble(),
      )
        .isCloseTo(elapsedMs.toDouble(), 100.0)
    }

    return result
  }

  fun recordedEventTypes() = eventSequence.map { it.name }

  fun clearAllEvents() {
    while (eventSequence.isNotEmpty()) {
      takeEvent()
    }
  }

  private fun logEvent(e: ConnectionEvent) {
    if (e.connection != null) {

 */
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 {
        when {
          it.sourceCodePoint1 < codePoint -> -1
          it.sourceCodePoint0 > codePoint -> 1

    fun resetForTests(platform: Platform = findPlatform()) {
      this.platform = platform
    }

    fun alpnProtocolNames(protocols: List<Protocol>) = protocols.filter { it != Protocol.HTTP_1_0 }.map { it.toString() }

    // This explicit check avoids activating in Android Studio with Android specific classes
    // available when running plugins inside the IDE.
    val isAndroid: Boolean

  @Test
  fun hostnameTelephone() {
    // https://www.gosecure.net/blog/2020/10/27/weakness-in-java-tls-host-verification/

    // Map the single character telephone symbol (℡) to the string "tel".
    assertThat(parse("http://\u2121").host).isEqualTo("tel")

    // Map the Kelvin symbol (K) to the string "k".
    assertThat(parse("http://\u212A").host).isEqualTo("k")
  }

  @Test
  fun quirks() {

   00AD; ; Map to nothing
   034F; ; Map to nothing
   1806; ; Map to nothing
   180B; ; Map to nothing
   180C; ; Map to nothing
   180D; ; Map to nothing
   200B; ; Map to nothing
   200C; ; Map to nothing
   200D; ; Map to nothing
   2060; ; Map to nothing
   FE00; ; Map to nothing
   FE01; ; Map to nothing
   FE02; ; Map to nothing
   FE03; ; Map to nothing
   FE04; ; Map to nothing
   FE05; ; Map to nothing
   FE06; ; Map to nothing

    val serverUrl = urlWithIpAddress(server, "/")
    val androidCookieHandler: CookieHandler =
      object : CookieHandler() {
        override fun get(
          uri: URI,
          map: Map<String, List<String>>,
        ) = mapOf(
          "Cookie" to
            listOf(
              "\$Version=\"1\"; " +
                "a=\"android\";\$Path=\"/\";\$Domain=\"${serverUrl.host}\"; " +