fail();
    }
  }

  private static class RunFailingService extends AbstractService {
    @Override
    protected void doStart() {
      notifyStarted();
      notifyFailed(EXCEPTION);
    }

    @Override
    protected void doStop() {
      fail();
    }
  }

  private static class StopFailingService extends AbstractService {
    @Override

    public static void doThrow(Object arg) {
      if (arg == null) {
        throw new FooException();
      }
    }

    public void noArg() {}

    public void oneArg(String s) {
      checkNotNull(s);
    }

    void packagePrivateOneArg(String s) {
      checkNotNull(s);
    }

    protected void protectedOneArg(String s) {
      checkNotNull(s);
    }

  @Override
  protected void setUp() {
    future = TestedFuture.create();
    delegate = newDelegate();
  }

  public void testPending() {
    assertPending(future);
  }

  public void testSuccessful() throws Exception {
    assertThat(future.set(1)).isTrue();
    assertSuccessful(future, 1);
  }

  public void testFailed() throws Exception {
    Exception cause = new Exception();

            .createTestSuite());

    return suite;
  }

  // Creation tests

  public void testEmptyBuilder() {
    ImmutableSortedMap<String, Integer> map =
        ImmutableSortedMap.<String, Integer>naturalOrder().build();
    assertEquals(Collections.<String, Integer>emptyMap(), map);
  }

  public void testSingletonBuilder() {
    ImmutableSortedMap<String, Integer> map =

  private static final boolean[] VALUES = {false, true};

  public void testHashCode() {
    assertThat(Booleans.hashCode(true)).isEqualTo(Boolean.TRUE.hashCode());
    assertThat(Booleans.hashCode(false)).isEqualTo(Boolean.FALSE.hashCode());
  }

  public void testTrueFirst() {
    assertThat(Booleans.trueFirst().compare(true, true)).isEqualTo(0);

  private static final boolean[] VALUES = {false, true};

  public void testHashCode() {
    assertThat(Booleans.hashCode(true)).isEqualTo(Boolean.TRUE.hashCode());
    assertThat(Booleans.hashCode(false)).isEqualTo(Boolean.FALSE.hashCode());
  }

  public void testTrueFirst() {
    assertThat(Booleans.trueFirst().compare(true, true)).isEqualTo(0);

  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testStringConverterSerialization() {
    SerializableTester.reserializeAndAssert(Shorts.stringConverter());
  }

  public void testToArray() {
    // need explicit type parameter to avoid javac warning!?
    List<Short> none = Arrays.<Short>asList();
    assertThat(Shorts.toArray(none)).isEqualTo(EMPTY);

  }

  public void testOf() {
    assertEquals("training", Optional.of("training").get());
  }

  public void testOf_null() {
    try {
      Optional.of(null);
      fail();
    } catch (NullPointerException expected) {
    }
  }

  public void testFromNullable() {
    Optional<String> optionalName = Optional.fromNullable("bob");
    assertEquals("bob", optionalName.get());
  }

  public void testHashCode() {
    for (float value : VALUES) {
      assertThat(Floats.hashCode(value)).isEqualTo(((Float) value).hashCode());
    }
  }

  public void testIsFinite() {
    for (float value : NUMBERS) {
      assertThat(Floats.isFinite(value))
          .isEqualTo(!(Float.isInfinite(value) || Float.isNaN(value)));
    }
  }

  public void testCompare() {
    for (float x : VALUES) {

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testAlwaysTrue_serialization() {
    checkSerialization(Predicates.alwaysTrue());
  }

  /*
   * Tests for Predicates.alwaysFalse().
   */

  public void testAlwaysFalse_apply() throws Exception {
    assertEvalsToFalse(Predicates.alwaysFalse());
  }

  public void testAlwaysFalse_equality() throws Exception {
    new EqualsTester()