}

  fun assertRequests(vararg expectedHosts: String?) {
    assertThat(requestedHosts).containsExactly(*expectedHosts)
    requestedHosts.clear()
  }

  /** Allocates and returns `count` fake IPv4 addresses like [255.0.0.100, 255.0.0.101].  */
  fun allocate(count: Int): List<InetAddress> {
    val from = nextAddress
    nextAddress += count
    return (from until nextAddress)
      .map {

        ) {
          socket = connection.socket() as SSLSocket
        }

        override fun requestHeadersStart(call: Call) {
          if (closed) {
            throw IOException("fake socket failure")
          }
        }
      }
    val localClient = client.newBuilder().eventListener(eventListener).build()

    val call1 = localClient.newCall(Request(server.url("/")))

    assertThat(recordedRequest.handshakeServerNames).containsExactly("cash.app")
  }

  /**
   * Connect to [hostnameOrIpAddress] and return what was received. To fake an arbitrary hostname we
   * tell MockWebServer to act as a proxy.
   */
  private fun requestToHostnameViaProxy(hostnameOrIpAddress: String): RecordedRequest {
    val heldCertificate =
      HeldCertificate.Builder()

 * server's hostname is sent to the proxy.
 *
 * Prior to sending any CONNECT request OkHttp always calls the proxy authenticator so that it may
 * prepare preemptive authentication. OkHttp will call [authenticate] with a fake `HTTP/1.1 407
 * Proxy Authentication Required` response that has a `Proxy-Authenticate: OkHttp-Preemptive`
 * challenge. The proxy authenticator may return either an authenticated request, or null to

@font-face {
    font-family: cash-market;
    src: url("https://cash-f.squarecdn.com/static/fonts/cash-market/v2/CashMarket-Regular.woff2") format("woff2");
    font-weight: 400;
    font-style: normal
}

@font-face {
    font-family: cash-market;
    src: url("https://cash-f.squarecdn.com/static/fonts/cash-market/v2/CashMarket-Medium.woff2") format("woff2");
    font-weight: 500;
    font-style: normal
}

@font-face {

              "00010000003b00102a032880f0290011faceb00c00000002"
          ).decodeHex(),
      )
    assertThat(decoded)
      .containsExactly(InetAddress.getByName("2a03:2880:f029:11:face:b00c:0:2"))
  }

  @Test
  fun testGoogleDotComDecodingNxdomainFailure() {
    assertFailsWith<UnknownHostException> {
      decodeAnswers(
        hostname = "sdflkhfsdlkjdf.ee",
        byteString =

   31B8-31EF
   321D-321F
   3244-3250
   327C-327E
   32CC-32CF
   32FF
   3377-337A
   33DE-33DF
   33FF
   4DB6-4DFF
   9FA6-9FFF
   A48D-A48F
   A4C7-ABFF
   D7A4-D7FF
   FA2E-FA2F
   FA6B-FAFF
   FB07-FB12
   FB18-FB1C
   FB37
   FB3D
   FB3F
   FB42
   FB45
   FBB2-FBD2
   FD40-FD4F
   FD90-FD91
   FDC8-FDCF
   FDFD-FDFF
   FE10-FE1F

 * it easy to get sample values to use in such tests.
 *
 * This class is pretty fast and loose with default values: it attempts to provide values that are
 * well-formed, but doesn't guarantee values are internally consistent. Callers must take care to
 * configure the factory when sample values impact the correctness of the test.
 */
class TestValueFactory : Closeable {
  var taskFaker: TaskFaker = TaskFaker()

    assertThat(forJavaName("SSL_DH_RSA_EXPORT_WITH_DES40_CBC_SHA"))
      .isEqualTo(forJavaName("TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA"))
    assertThat(forJavaName("SSL_FAKE_NEW_CIPHER"))
      .isEqualTo(forJavaName("TLS_FAKE_NEW_CIPHER"))
  }

  @Test
  fun applyIntersectionRetainsTlsPrefixes() {
    val socket = FakeSslSocket()
    socket.enabledProtocols = arrayOf("TLSv1")