assertThat(UnsignedBytes.lexicographicalComparator()).isSameInstanceAs(defaultComparator);
    if (unsafeComparatorAvailable()) {
      assertThat(Class.forName(unsafeComparatorClassName()))
          .isSameInstanceAs(defaultComparator.getClass());
    } else {
      assertThat(UnsignedBytes.lexicographicalComparatorJavaImpl())
          .isSameInstanceAs(defaultComparator);
    }
  }

    }
  }

  public void testEnsureCapacity() {
    assertThat(Shorts.ensureCapacity(EMPTY, 0, 1)).isSameInstanceAs(EMPTY);
    assertThat(Shorts.ensureCapacity(ARRAY1, 0, 1)).isSameInstanceAs(ARRAY1);
    assertThat(Shorts.ensureCapacity(ARRAY1, 1, 1)).isSameInstanceAs(ARRAY1);
    assertThat(Shorts.ensureCapacity(ARRAY1, 2, 1))
        .isEqualTo(new short[] {(short) 1, (short) 0, (short) 0});
  }

    assertThat(base32().upperCase()).isSameInstanceAs(base32());
  }

  public void testBase32LowerCase() {
    testEncodingWithCasing(base32().lowerCase(), "foobar", "mzxw6ytboi======");
  }

  public void testBase32IgnoreCase() {
    BaseEncoding ignoreCase = base32().ignoreCase();
    assertThat(ignoreCase).isNotSameInstanceAs(base32());
    assertThat(ignoreCase).isSameInstanceAs(base32().ignoreCase());

    }
  }

  public void testEnsureCapacity() {
    assertThat(Longs.ensureCapacity(EMPTY, 0, 1)).isSameInstanceAs(EMPTY);
    assertThat(Longs.ensureCapacity(ARRAY1, 0, 1)).isSameInstanceAs(ARRAY1);
    assertThat(Longs.ensureCapacity(ARRAY1, 1, 1)).isSameInstanceAs(ARRAY1);
    assertThat(Longs.ensureCapacity(ARRAY1, 2, 1))
        .isEqualTo(new long[] {(long) 1, (long) 0, (long) 0});
  }

    ImmutableDoubleArray iia3 = ImmutableDoubleArray.of(5, 25, 125);

    assertThat(iia0.subArray(0, 0)).isSameInstanceAs(ImmutableDoubleArray.of());
    assertThat(iia1.subArray(0, 0)).isSameInstanceAs(ImmutableDoubleArray.of());
    assertThat(iia1.subArray(1, 1)).isSameInstanceAs(ImmutableDoubleArray.of());
    assertThat(iia1.subArray(0, 1).asList()).containsExactly(5.0);

    ImmutableIntArray iia3 = ImmutableIntArray.of(5, 25, 125);

    assertThat(iia0.subArray(0, 0)).isSameInstanceAs(ImmutableIntArray.of());
    assertThat(iia1.subArray(0, 0)).isSameInstanceAs(ImmutableIntArray.of());
    assertThat(iia1.subArray(1, 1)).isSameInstanceAs(ImmutableIntArray.of());
    assertThat(iia1.subArray(0, 1).asList()).containsExactly(5);

    ImmutableLongArray iia3 = ImmutableLongArray.of(5, 25, 125);

    assertThat(iia0.subArray(0, 0)).isSameInstanceAs(ImmutableLongArray.of());
    assertThat(iia1.subArray(0, 0)).isSameInstanceAs(ImmutableLongArray.of());
    assertThat(iia1.subArray(1, 1)).isSameInstanceAs(ImmutableLongArray.of());
    assertThat(iia1.subArray(0, 1).asList()).containsExactly(5L);

  }

  public void testMinMaxNatural_equalInstances() {
    Foo a = new Foo(1);
    Foo b = new Foo(1);
    assertThat(Comparators.min(a, b)).isSameInstanceAs(a);
    assertThat(Comparators.max(a, b)).isSameInstanceAs(a);
  }

  public void testMinMaxComparator() {
    Comparator<Integer> natural = Ordering.natural();
    Comparator<Integer> reverse = Collections.reverseOrder(natural);

          }
        };
    assertEquals(0, service.startUpCalled);
    RuntimeException e =
        assertThrows(RuntimeException.class, () -> service.startAsync().awaitRunning());
    assertThat(e).hasCauseThat().isSameInstanceAs(exception);
    assertEquals(1, service.startUpCalled);
    assertEquals(Service.State.FAILED, service.state());
    assertThat(service.transitionStates).containsExactly(Service.State.STARTING);
  }

      getDone(future);
      fail();
    } catch (ExecutionException e) {
      assertThat(e.getCause()).isSameInstanceAs(expectedException);
    }

    try {
      getDoneFromTimeoutOverload(future);
      fail();
    } catch (ExecutionException e) {
      assertThat(e).hasCauseThat().isSameInstanceAs(expectedException);
    }
  }