val serverHandshake = serverHandshakeFuture.get()
    assertThat(listOf(clientCertificate.certificate, clientIntermediate.certificate))
      .isEqualTo(serverHandshake.peerCertificates)
    assertThat(listOf(serverCertificate.certificate, serverIntermediate.certificate))
      .isEqualTo(serverHandshake.localCertificates)
    val clientHandshake = clientHandshakeFuture.get()

    makeRequest(client)

    val expectedConnectionCipherSuites = expectedConnectionCipherSuites(client)
    // Will choose a poor cipher suite but not plaintext.
//    assertThat(handshake.cipherSuite).isEqualTo("TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256")
    assertThat(handshakeEnabledCipherSuites).containsExactly(
      *expectedConnectionCipherSuites.toTypedArray(),
    )
  }

  @Test
  fun clientOrderApplied() {

    val call = client.newCall(networkRequest)

    call.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.cacheResponse).isNull()
    }

    val cachedCall = client.newCall(request)

    cachedCall.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.cacheResponse).isNotNull()
    }
  }

  private fun assumeNetwork() {

  @Test
  fun defaultPrefix() {
    assertThat(Platform().getPrefix()).isEqualTo("OkHttp")
  }

  @Test
  fun testToStringIsClassname() {
    assertThat(Platform().toString()).isEqualTo("Platform")
  }

  @Test
  fun testNotAndroid() {
    platform.assumeNotAndroid()

    // This is tautological so just confirms that it runs.
    assertThat(isAndroid).isEqualTo(false)
  }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")

package mockwebserver3

import assertk.assertThat
import assertk.assertions.isEqualTo
import java.net.InetAddress
import java.net.Socket
import okhttp3.Headers
import okhttp3.Headers.Companion.headersOf
import okhttp3.internal.EMPTY_HEADERS
import okio.Buffer

    assertThat(formEncode(59)).isEqualTo("%3B")
    assertThat(formEncode(60)).isEqualTo("%3C")
    assertThat(formEncode(61)).isEqualTo("%3D")
    assertThat(formEncode(62)).isEqualTo("%3E")
    assertThat(formEncode(63)).isEqualTo("%3F")
    assertThat(formEncode(64)).isEqualTo("%40")
    assertThat(formEncode(65)).isEqualTo("A")
    assertThat(formEncode(90)).isEqualTo("Z")
    assertThat(formEncode(91)).isEqualTo("%5B")

        .url("https://square.com")
        .build()
    assertThat(request.tag()).isNull()
    assertThat(request.tag(Any::class.java)).isNull()
    assertThat(request.tag(UUID::class.java)).isNull()
    assertThat(request.tag(String::class.java)).isNull()

    // Alternate access APIs also work.
    assertThat(request.tag<String>()).isNull()
    assertThat(request.tag(String::class)).isNull()
  }

  @Test

    assertThat(pool.closeConnections(50L)).isEqualTo(100L)
    assertThat(pool.connectionCount()).isEqualTo(1)
    assertThat(c1.socket().isClosed).isFalse()

    // Running at time 60, the pool returns that nothing can be evicted until time 150.
    assertThat(pool.closeConnections(60L)).isEqualTo(90L)
    assertThat(pool.connectionCount()).isEqualTo(1)
    assertThat(c1.socket().isClosed).isFalse()

    assertThat("0:0:0:0:0:FFFF:129.144.52.38".canParseAsIpAddress()).isTrue()
    assertThat("::13.1.68.3".canParseAsIpAddress()).isTrue()
    assertThat("::FFFF:129.144.52.38".canParseAsIpAddress()).isTrue()

    // Hostnames
    assertThat("go".canParseAsIpAddress()).isFalse()
    assertThat("localhost".canParseAsIpAddress()).isFalse()
    assertThat("squareup.com".canParseAsIpAddress()).isFalse()

    assertThat(call2Get.method).isEqualTo("GET")
    assertThat(call2Get.path).isEqualTo("/call2")
    assertThat(call2Get.sequenceNumber).isEqualTo(0)
    val call1Get = server.takeRequest()
    assertThat(call1Get.method).isEqualTo("GET")
    assertThat(call1Get.path).isEqualTo("/call1")
    assertThat(call1Get.sequenceNumber).isEqualTo(1)
    assertThat(client.connectionPool.connectionCount()).isEqualTo(1)
  }