val handshake = request.handshake
    assertThat(handshake!!.tlsVersion).isNotNull()
    assertThat(handshake.cipherSuite).isNotNull()
    assertThat(handshake.localPrincipal).isNotNull()
    assertThat(handshake.localCertificates.size).isEqualTo(1)
    assertThat(handshake.peerPrincipal).isNotNull()
    assertThat(handshake.peerCertificates.size).isEqualTo(1)
  }

  @Test
  fun shutdownTwice() {

    val handshake = request.handshake
    assertThat(handshake!!.tlsVersion).isNotNull()
    assertThat(handshake.cipherSuite).isNotNull()
    assertThat(handshake.localPrincipal).isNotNull()
    assertThat(handshake.localCertificates.size).isEqualTo(1)
    assertThat(handshake.peerPrincipal).isNotNull()
    assertThat(handshake.peerCertificates.size).isEqualTo(1)
  }

  @Test

    val client = clientTestRule.newClient()

    // Values should be non-null.
    val a = client.newBuilder().build()
    assertThat(a.dispatcher).isNotNull()
    assertThat(a.connectionPool).isNotNull()
    assertThat(a.sslSocketFactory).isNotNull()
    assertThat(a.x509TrustManager).isNotNull()

    // Multiple clients share the instances.
    val b = client.newBuilder().build()
    assertThat(b.dispatcher).isSameAs(a.dispatcher)

 * limitations under the License.
 */
package okhttp3

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isNotNull
import assertk.assertions.isTrue
import java.io.IOException
import java.io.InterruptedIOException
import java.net.HttpURLConnection
import java.time.Duration
import java.util.concurrent.CountDownLatch

        val networkRequest = chain.request()
        assertThat(networkRequest.header("User-Agent")).isNotNull()
        assertThat(networkRequest.header("Host")).isEqualTo(
          server.hostName + ":" + server.port,
        )
        assertThat(networkRequest.header("Accept-Encoding")).isNotNull()

        // The network response also has everything, including the raw gzipped content.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.logging

import assertk.assertThat
import assertk.assertions.isNotNull
import java.io.IOException
import java.net.UnknownHostException
import java.util.Arrays
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.SocketPolicy.FailHandshake

 * limitations under the License.
 */
package okhttp3

import assertk.assertThat
import assertk.assertions.hasMessage
import assertk.assertions.isEqualTo
import assertk.assertions.isNotNull
import assertk.assertions.isNull
import java.io.EOFException
import java.net.ProtocolException
import kotlin.test.assertFailsWith
import okhttp3.Headers.Companion.headersOf
import okhttp3.MediaType.Companion.toMediaType

    assertThat(parse(ascii, "a=b; domain=foo.bar.elb.amazonaws.com")).isNotNull()
    assertThat(parse(ascii, "a=b; domain=bar.elb.amazonaws.com")).isNull()
    assertThat(parse(ascii, "a=b; domain=com")).isNull()
    val unicode = "https://長.長.長崎.jp".toHttpUrl()
    assertThat(parse(unicode, "a=b; domain=長.長崎.jp")).isNotNull()
    assertThat(parse(unicode, "a=b; domain=長崎.jp")).isNull()

    }
  }

  public void testLexicographicalComparatorChoice() throws Exception {
    Comparator<byte[]> defaultComparator = UnsignedBytes.lexicographicalComparator();
    assertThat(defaultComparator).isNotNull();
    assertThat(UnsignedBytes.lexicographicalComparator()).isSameInstanceAs(defaultComparator);
    if (unsafeComparatorAvailable()) {
      assertThat(Class.forName(unsafeComparatorClassName()))

    // testing simple creation
    ImmutableSortedSet.Builder<SelfComparableExample> natural = ImmutableSortedSet.naturalOrder();
    assertThat(natural).isNotNull();
    ImmutableSortedSet.Builder<SelfComparableExample> reverse = ImmutableSortedSet.reverseOrder();
    assertThat(reverse).isNotNull();
  }

  private static class SuperComparableExample extends SelfComparableExample {}