}

  public void testOfInstanceSuppliesNull() {
    Supplier<@Nullable Integer> nullSupplier = Suppliers.ofInstance(null);
    assertThat(nullSupplier.get()).isNull();
  }

  @J2ktIncompatible
  @GwtIncompatible // Thread
  @SuppressWarnings("DoNotCall")
  public void testExpiringMemoizedSupplierThreadSafe() throws Throwable {

      assertEquals(Integer.valueOf(0), defaultConverter.convert("anything"));
      assertEquals("", defaultConverter.reverse().convert(123));
      assertThat(defaultConverter.convert(null)).isNull();
      assertThat(defaultConverter.reverse().convert(null)).isNull();
    }
  }

  public void testConverterDefaultValue() {
    new ConverterDefaultValueChecker().check();
  }

  private static class VisibilityMethods {

      }
    } catch (Throwable expected) {
      assertThat(expected).isInstanceOf(IOException.class);
    }

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());
    assertThat(c3).isNull();

    assertTrue(suppressor.suppressions.isEmpty());
  }

  public void testExceptionThrown_whileClosingLastCloseable() throws IOException {
    Closer closer = new Closer(suppressor);

  }

  public void testGetOnlyElement_withDefault_empty_null() {
    Iterable<String> iterable = emptyList();
    assertThat(Iterables.<@Nullable String>getOnlyElement(iterable, null)).isNull();
  }

  public void testGetOnlyElement_withDefault_multiple() {
    Iterable<String> iterable = asList("foo", "bar");
    assertThrows(IllegalArgumentException.class, () -> getOnlyElement(iterable, "x"));
  }

        ImmutableSortedSet.copyOf(new String[] {"e", "e", "f", "b", "i", "d", "c", "k"});
    assertThat(set.floor("a")).isNull();
  }

  public void testCeiling_emptySet() {
    ImmutableSortedSet<String> set = ImmutableSortedSet.copyOf(new String[] {});
    assertThat(set.ceiling("f")).isNull();
  }

  public void testCeiling_elementPresent() {
    ImmutableSortedSet<String> set =

 * limitations under the License.
 */
package okhttp3.tls.internal.der

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isNull
import assertk.assertions.isTrue
import java.math.BigInteger
import java.security.KeyFactory
import java.security.spec.PKCS8EncodedKeySpec
import java.security.spec.X509EncodedKeySpec
import java.text.SimpleDateFormat

    String string = source.read();
    assertExpectedString(string);
  }

  public void testReadFirstLine() throws IOException {
    if (expectedLines.isEmpty()) {
      assertThat(source.readFirstLine()).isNull();
    } else {
      assertEquals(expectedLines.get(0), source.readFirstLine());
    }
  }

  public void testReadLines_toList() throws IOException {
    assertExpectedLines(source.readLines());
  }

    underlying.put("a", 1);
    Map<String, String> map = transformValues(underlying, Functions.toStringFunction());
    assertEquals("1", map.remove("a"));
    assertThat(map.remove("b")).isNull();
  }

  public void testTransformEqualityOfMapsWithNullValues() {
    Map<String, @Nullable String> underlying = new HashMap<>();
    underlying.put("a", null);
    underlying.put("b", "");

    rangeSet.add(Range.closed(3, 10));
    assertEquals(Range.closed(3, 10), rangeSet.rangeContaining(5));
    assertTrue(rangeSet.contains(5));
    assertThat(rangeSet.rangeContaining(1)).isNull();
    assertFalse(rangeSet.contains(1));
  }

  public void testRangeContaining2() {
    RangeSet<Integer> rangeSet = TreeRangeSet.create();
    rangeSet.add(Range.closed(3, 10));

import assertk.assertions.contains
import assertk.assertions.hasMessage
import assertk.assertions.isCloseTo
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isNull
import assertk.assertions.isTrue
import assertk.fail
import java.io.IOException
import java.net.HttpURLConnection
import java.net.SocketTimeoutException
import java.time.Duration
import java.util.Arrays