* input futures, if all succeed.
   *
   * <p>The list of results is in the same order as the input list.
   *
   * <p>This differs from {@link #successfulAsList(ListenableFuture[])} in that it will return a
   * failed future if any of the items fails.
   *
   * <p>Canceling this future will attempt to cancel all the component futures, and if any of the

        if (expected == null || actual == null) {
            fail("Arrays are not equal: one is null");
        }
        assertEquals("Array lengths differ", expected.length, actual.length);
        for (int i = 0; i < expected.length; i++) {
            assertEquals("Array element at index " + i + " differs", expected[i], actual[i]);
        }
    }

    @Override
    public void setUp() throws Exception {
        super.setUp();

 * implementations exist for particular cases, like {@link ImmutableTable} views and hash flooding.
 * (This doc discusses {@link ImmutableMap} subclasses only for the JRE flavor; the Android flavor
 * differs.)
 *
 * @author Jesse Wilson
 * @author Kevin Bourrillion
 * @author Gregory Kick
 */
@GwtCompatible
final class RegularImmutableMap<K, V> extends ImmutableMap<K, V> {
  @SuppressWarnings("unchecked")

   *
   * <p>If the mapped keys or values contain duplicates (according to {@link
   * Object#equals(Object)}), an {@code IllegalArgumentException} is thrown when the collection
   * operation is performed. (This differs from the {@code Collector} returned by {@link
   * Collectors#toMap(Function, Function)}, which throws an {@code IllegalStateException}.)
   *
   * @since 33.2.0 (available since 21.0 in guava-jre)
   */

    // be released.
    return 1L << ((Long.SIZE - 1) - Long.numberOfLeadingZeros(x));
  }

  /**
   * Returns {@code true} if {@code x} represents a power of two.
   *
   * <p>This differs from {@code Long.bitCount(x) == 1}, because {@code
   * Long.bitCount(Long.MIN_VALUE) == 1}, but {@link Long#MIN_VALUE} is not a power of two.
   */

   * check its availability with {@link #lazyStackTraceIsLazy()}.
   *
   * <p>The expected (but not guaranteed) performance of the special implementation differs from
   * {@code getStackTrace} in one main way: The {@code lazyStackTrace} call itself returns quickly
   * by delaying the per-stack-frame work until each element is accessed. Roughly speaking:
   *
   * <ul>

    Iterable<?> a;
    Iterable<?> b;

    // A few elements.
    a = asList(4, 8, 15, 16, 23, 42);
    b = asList(4, 8, 15, 16, 23, 42);
    assertTrue(elementsEqual(a, b));

    // An element differs.
    a = asList(4, 8, 15, 12, 23, 42);
    b = asList(4, 8, 15, 16, 23, 42);
    assertFalse(elementsEqual(a, b));

    // null versus non-null.
    a = Arrays.<@Nullable Integer>asList(4, 8, 15, null, 23, 42);

    NullPointerTester tester = new NullPointerTester();
    tester.testAllPublicStaticMethods(Lists.class);
  }

  /**
   * This is just here to illustrate how {@code Arrays#asList} differs from {@code
   * Lists#newArrayList}.
   */
  public void testArraysAsList() {
    List<String> ourWay = Lists.newArrayList("foo", "bar", "baz");
    List<String> otherWay = asList("foo", "bar", "baz");

  }

  /**
   * Not supported. Use {@link #naturalOrder}, which offers better type-safety, instead. This method
   * exists only to hide {@link ImmutableSet#builder} from consumers of {@code ImmutableSortedSet}.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Use {@link ImmutableSortedSet#naturalOrder}, which offers better type-safety.
   */
  @DoNotCall("Use naturalOrder")
  @Deprecated

    Iterable<?> a;
    Iterable<?> b;

    // A few elements.
    a = asList(4, 8, 15, 16, 23, 42);
    b = asList(4, 8, 15, 16, 23, 42);
    assertTrue(elementsEqual(a, b));

    // An element differs.
    a = asList(4, 8, 15, 12, 23, 42);
    b = asList(4, 8, 15, 16, 23, 42);
    assertFalse(elementsEqual(a, b));

    // null versus non-null.
    a = Arrays.<@Nullable Integer>asList(4, 8, 15, null, 23, 42);