}
        };

    assertThat(cache.getIfPresent(new Object())).isNull();

    Object newValue = new Object();
    valueRef.set(newValue);
    assertThat(cache.getIfPresent(new Object())).isSameInstanceAs(newValue);
  }

  public void testGetAllPresent_empty() {
    Cache<Object, Object> cache =
        new AbstractCache<Object, Object>() {
          @Override

    awaitBlockedOnInstanceOf(runner, InterruptibleTask.Blocker.class);

    Blocker blocker = (Blocker) LockSupport.getBlocker(runner);
    Thread owner = blocker.getOwner();
    assertThat(owner).isSameInstanceAs(interrupter);

    slowChannel.exitClose.countDown(); // release the interrupter

    // We need to wait for the runner to exit.  To make sure that the interrupting thread wakes it
    // back up.

    assertTrue(future.isDone());
    assertFalse(future.isCancelled());
    ExecutionException ee = assertThrows(ExecutionException.class, () -> future.get());
    assertThat(ee).hasCauseThat().isSameInstanceAs(e);
  }

  public void testSetFuture() throws Exception {
    SettableFuture<String> future = SettableFuture.create();
    SettableFuture<String> nested = SettableFuture.create();

  public void testLexicographicalComparatorSerializable() {
    Comparator<byte[]> comparator = SignedBytes.lexicographicalComparator();
    assertThat(SerializableTester.reserialize(comparator)).isSameInstanceAs(comparator);
  }

  public void testSortDescending() {
    testSortDescending(new byte[] {}, new byte[] {});
    testSortDescending(new byte[] {1}, new byte[] {1});

    assertTrue(future.isDone());
    assertFalse(future.isCancelled());
    ExecutionException ee = assertThrows(ExecutionException.class, () -> future.get());
    assertThat(ee).hasCauseThat().isSameInstanceAs(e);
  }

  public void testSetFuture() throws Exception {
    SettableFuture<String> future = SettableFuture.create();
    SettableFuture<String> nested = SettableFuture.create();

    assertGoodFeatureEnum(ExampleFeature.class);
  }

  public void testAddImpliedFeatures_returnsSameSetInstance() {
    Set<Feature<?>> features = newHashSet(FOO);
    assertThat(addImpliedFeatures(features)).isSameInstanceAs(features);
  }

  public void testAddImpliedFeatures_addsImpliedFeatures() {
    assertThat(addImpliedFeatures(newHashSet(FOO))).containsExactly(FOO);

@NullUnmarked
public class CaseFormatTest extends TestCase {

  public void testIdentity() {
    for (CaseFormat from : CaseFormat.values()) {
      assertWithMessage("%s to %s", from, from).that(from.to(from, "foo")).isSameInstanceAs("foo");
      for (CaseFormat to : CaseFormat.values()) {
        assertWithMessage("%s to %s", from, to).that(from.to(to, "")).isEmpty();
        assertWithMessage("%s to %s", from, to).that(from.to(to, " ")).isEqualTo(" ");

    assertGoodFeatureEnum(ExampleFeature.class);
  }

  public void testAddImpliedFeatures_returnsSameSetInstance() {
    Set<Feature<?>> features = newHashSet(FOO);
    assertThat(addImpliedFeatures(features)).isSameInstanceAs(features);
  }

  public void testAddImpliedFeatures_addsImpliedFeatures() {
    assertThat(addImpliedFeatures(newHashSet(FOO))).containsExactly(FOO);

@NullUnmarked
public class CaseFormatTest extends TestCase {

  public void testIdentity() {
    for (CaseFormat from : CaseFormat.values()) {
      assertWithMessage("%s to %s", from, from).that(from.to(from, "foo")).isSameInstanceAs("foo");
      for (CaseFormat to : CaseFormat.values()) {
        assertWithMessage("%s to %s", from, to).that(from.to(to, "")).isEmpty();
        assertWithMessage("%s to %s", from, to).that(from.to(to, " ")).isEqualTo(" ");

    // Ensure we get a unique execution exception on each get
    assertNotSame(ee1, ee2);

    assertThat(ee1).hasCauseThat().isSameInstanceAs(failure);
    assertThat(ee2).hasCauseThat().isSameInstanceAs(failure);

    checkStackTrace(ee1);
    checkStackTrace(ee2);
  }

  public void testCancel_notDoneNoInterrupt() throws Exception {