assertThat(Longs.tryParse("")).isNull();
    assertThat(Longs.tryParse("-")).isNull();
    assertThat(Longs.tryParse("+1")).isNull();
    assertThat(Longs.tryParse("999999999999999999999999")).isNull();
    assertThat(Longs.tryParse(" ")).isNull();
    assertThat(Longs.tryParse("1 ")).isNull();
    assertThat(Longs.tryParse(" 1")).isNull();
    assertWithMessage("Max long + 1")

 */
package okhttp3.zstd

import assertk.assertThat
import assertk.assertions.hasMessage
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import com.squareup.zstd.okio.zstdCompress
import java.io.IOException
import kotlin.test.assertFailsWith
import okhttp3.CompressionInterceptor
import okhttp3.Gzip
import okhttp3.MediaType.Companion.toMediaType

    assertThat("Thu, 01 Jan 1970 00:00:00".toHttpDateOrNull()).isNull()
    // Missing seconds treated as bad.
    assertThat("Thu, 01 Jan 1970 00:00 GMT".toHttpDateOrNull()).isNull()
    // Extra spaces treated as bad.
    assertThat("Thu,  01 Jan 1970 00:00 GMT".toHttpDateOrNull()).isNull()
    // Missing leading zero treated as bad.
    assertThat("Thu, 1 Jan 1970 00:00 GMT".toHttpDateOrNull()).isNull()

    // RFC 850, obsoleted by RFC 1036 with any TZ.

    assertThat(ArbitraryInstances.get(WithGenericConstant.class)).isNull();
  }

  public void testGet_nullConstant() {
    assertThat(ArbitraryInstances.get(WithNullConstant.class)).isNull();
  }

  public void testGet_constantTypeDoesNotMatch() {
    assertThat(ArbitraryInstances.get(ParentClassHasConstant.class)).isNull();
  }

  public void testGet_nonPublicConstantNotUsed() {

    return suite;
  }

  public void testAllocArraysDefault() {
    CompactHashSet<Integer> set = CompactHashSet.create();
    assertThat(set.needsAllocArrays()).isTrue();
    assertThat(set.elements).isNull();

    set.add(1);
    assertThat(set.needsAllocArrays()).isFalse();
    assertThat(set.elements).hasLength(CompactHashing.DEFAULT_SIZE);
  }

  public void testAllocArraysExpectedSize() {

  fun assertNoNetworkResponse() =
    apply {
      assertThat(response!!.networkResponse).isNull()
    }

  /** Asserts that the current response didn't use the cache.  */
  fun assertNoCacheResponse() =
    apply {
      assertThat(response!!.cacheResponse).isNull()
    }

  /**
   * Asserts that the current response used the cache and returns the cache response.
   */

        // Arrange
        when(tree.send(isNull())).thenThrow(new CIFSException("null request"));

        // Act
        CIFSException ex = assertThrows(CIFSException.class, () -> tree.send(null));

        // Assert
        assertEquals("null request", ex.getMessage());
        verify(tree).send((Request<CommonServerMessageBlockResponse>) isNull());
    }

    @Test

 */
package okhttp3.internal.connection

import assertk.assertThat
import assertk.assertions.containsExactlyInAnyOrder
import assertk.assertions.isFalse
import assertk.assertions.isNotNull
import assertk.assertions.isNull
import assertk.assertions.isTrue
import java.io.IOException
import java.security.cert.CertificateException
import javax.net.ssl.SSLHandshakeException
import javax.net.ssl.SSLSocket
import okhttp3.ConnectionSpec

    assertFalse(equalTo1.apply(null));
    Predicate<@Nullable Object> isNull = Equivalence.equals().equivalentTo(null);
    assertFalse(isNull.apply("1"));
    assertFalse(isNull.apply("2"));
    assertTrue(isNull.apply(null));

    new EqualsTester()
        .addEqualityGroup(equalTo1, Equivalence.equals().equivalentTo("1"))
        .addEqualityGroup(isNull)
        .addEqualityGroup(Equivalence.identity().equivalentTo("1"))

    assertEquals((Character) 'c', table.get("foo", 3));
    assertThat(table.get("foo", 2)).isNull();
    assertThat(table.get("bar", 3)).isNull();
    assertThat(table.get("cat", 1)).isNull();
    assertThat(table.get("foo", null)).isNull();
    assertThat(table.get(null, 1)).isNull();
    assertThat(table.get(null, null)).isNull();
  }

  public void testIsEmpty() {
    assertTrue(table.isEmpty());