*
   * {@snippet :
   * Lists.cartesianProduct(ImmutableList.of(
   *     ImmutableList.of(1, 2),
   *     ImmutableList.of("A", "B", "C")))
   * }
   *
   * <p>returns a list containing six lists in the following order:
   *
   * <ul>
   *   <li>{@code ImmutableList.of(1, "A")}
   *   <li>{@code ImmutableList.of(1, "B")}
   *   <li>{@code ImmutableList.of(1, "C")}
   *   <li>{@code ImmutableList.of(2, "A")}

      ImmutableSet.copyOf(RoundingMode.values());

  static final ImmutableList<RoundingMode> ALL_SAFE_ROUNDING_MODES =
      ImmutableList.of(DOWN, UP, FLOOR, CEILING, HALF_EVEN, HALF_UP, HALF_DOWN);

  // Exponents to test for the pow() function.
  static final ImmutableList<Integer> EXPONENTS =
      ImmutableList.of(0, 1, 2, 3, 4, 7, 10, 15, 20, 25, 40, 70);

    }

    private static ImmutableList<ManyValues> createAll() {
      ImmutableList.Builder<ManyValues> builder = ImmutableList.builder();
      double[] values = new double[5];
      for (double first : ImmutableList.of(1.1, POSITIVE_INFINITY, NEGATIVE_INFINITY, NaN)) {
        values[0] = first;
        values[1] = -44.44;
        for (double third : ImmutableList.of(33.33, POSITIVE_INFINITY, NEGATIVE_INFINITY, NaN)) {

  - type: textarea
    attributes:
      label: API(s)
      description: Which existing classes or methods do you want to improve?
      placeholder: e.g., `com.google.common.collect.ImmutableList::of`
      render: java
    validations:
      required: true

  - type: textarea
    attributes:
      label: How do you want it to be improved?
    validations:
      required: true

    Comparator<Iterable<String>> lexy = Comparators.lexicographical(comparator);

    ImmutableList<String> empty = ImmutableList.of();
    ImmutableList<String> a = ImmutableList.of("a");
    ImmutableList<String> aa = ImmutableList.of("a", "a");
    ImmutableList<String> ab = ImmutableList.of("a", "b");
    ImmutableList<String> b = ImmutableList.of("b");

    testComparator(lexy, empty, a, aa, ab, b);

    new EqualsTester()

  }

  ImmutableRangeSet(ImmutableList<Range<C>> ranges) {
    this(ranges, /* complement= */ null);
  }

  private ImmutableRangeSet(
      ImmutableList<Range<C>> ranges, @Nullable ImmutableRangeSet<C> complement) {
    this.ranges = ranges;
    this.complement = complement;
  }

  private final transient ImmutableList<Range<C>> ranges;

    multimap().replaceValues(k3(), values);
    assertGet(k3(), values);
    assertEquals(size + values.size(), multimap().size());
  }

  @SuppressWarnings("EmptyList") // ImmutableList doesn't support nullable element types
  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})
  public void testReplaceValuesWithEmpty() {
    int size = multimap().size();

  }

  public void testWriteLines_withSpecificSeparator() throws IOException {
    sink.writeLines(ImmutableList.of("foo", "bar", "baz"), "\n");
    assertEquals("foo\nbar\nbaz\n", sink.getString());
  }

  public void testWriteLines_withDefaultSeparator() throws IOException {
    sink.writeLines(ImmutableList.of("foo", "bar", "baz"));
    String separator = System.getProperty("line.separator");

 * backed by an {@code ImmutableList} or array.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@SuppressWarnings("serial") // uses writeReplace, not default serialization
class RegularImmutableAsList<E> extends ImmutableAsList<E> {
  private final ImmutableCollection<E> delegate;
  private final ImmutableList<? extends E> delegateList;

    }
  }

  abstract V getValue(int iterationIndex);

  @Override
  final ImmutableCollection<V> createValues() {
    return isEmpty() ? ImmutableList.of() : new Values();
  }

  @WeakOuter
  private final class Values extends ImmutableList<V> {
    @Override
    public int size() {
      return RegularImmutableTable.this.size();
    }

    @Override
    public V get(int index) {