* This is useful if the function instance already exists, or so that you can supply a lambda
   * expressions. If those circumstances don't apply, you probably don't need to use this; subclass
   * {@code TreeTraverser} and implement its {@link #children} method directly.
   *
   * @since 20.0

   * is defined as the function h such that {@code h(a) == g(f(a))} for each {@code a}.
   *
   * <p><b>JRE users and Android users who opt in to library desugaring:</b> use {@code
   * g.compose(f)} or (probably clearer) {@code f.andThen(g)} instead. Note that it is not
   * serializable.
   *
   * @param g the second function to apply
   * @param f the first function to apply

    // Clear any previous interrupt before running the test.
    if (Thread.currentThread().isInterrupted()) {
      throw new AssertionError(
          "Thread interrupted on test entry. "
              + "Some test probably didn't clear the interrupt state");
    }

    tearDownStack.addTearDown(
        new TearDown() {
          @Override
          public void tearDown() {
            Thread.interrupted();
          }

  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {

    public ImmutableMap<K, V> buildOrThrow() {
      return build(/* throwIfDuplicateKeys= */ true);
    }

    public ImmutableMap<K, V> buildKeepingLast() {
      if (valueComparator != null) {
        // Probably not worth supporting this in GWT
        throw new UnsupportedOperationException(
            "orderEntriesByValue + buildKeepingLast not supported under GWT");
      }
      return build(/* throwIfDuplicateKeys= */ false);

        .addEqualityGroup(ImmutableDoubleArray.of(1, 3))
        .addEqualityGroup(ImmutableDoubleArray.of(1, 2, 3))
        .testEquals();
  }

  /**
   * This is probably a weird and hacky way to test what we're really trying to test, but hey, it
   * caught a bug.
   */
  public void testTrimmed() {
    ImmutableDoubleArray iia = ImmutableDoubleArray.of(0, 1, 3);

      Class<?> cls;
      try {
        cls = classInfo.load();
      } catch (NoClassDefFoundError e) {
        // In case there were linking problems, this is probably not a class we care to test anyway.
        logger.log(Level.SEVERE, "Cannot load class " + classInfo + ", skipping...", e);
        continue;
      }
      if (!cls.isInterface()) {
        classes.add(cls);

        .addEqualityGroup(ImmutableLongArray.of(1, 3))
        .addEqualityGroup(ImmutableLongArray.of(1, 2, 3))
        .testEquals();
  }

  /**
   * This is probably a weird and hacky way to test what we're really trying to test, but hey, it
   * caught a bug.
   */
  public void testTrimmed() {
    ImmutableLongArray iia = ImmutableLongArray.of(0, 1, 3);

   * pass null inputs to LegacyConverter, and it can violate the contract of Converter.
   *
   * TODO(cpovirk): Could this be simplified if we modified implementations of LegacyConverter to
   * override methods (probably called "unsafeDoForward" and "unsafeDoBackward") with the same
   * signatures as the methods below, rather than overriding the same doForward and doBackward
   * methods as implementations of normal converters do?
   *

  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {