*/
  public static <E> ImmutableList<E> of(E e1, E e2, E e3) {
    return construct(e1, e2, e3);
  }

  /**
   * Returns an immutable list containing the given elements, in order.
   *
   * @throws NullPointerException if any element is null
   */
  public static <E> ImmutableList<E> of(E e1, E e2, E e3, E e4) {
    return construct(e1, e2, e3, e4);
  }

  /**

  }

  public static <E> ImmutableList<E> of(E e1, E e2, E e3) {
    return new RegularImmutableList<E>(ImmutableList.<E>nullCheckedList(e1, e2, e3));
  }

  public static <E> ImmutableList<E> of(E e1, E e2, E e3, E e4) {
    return new RegularImmutableList<E>(ImmutableList.<E>nullCheckedList(e1, e2, e3, e4));
  }

  public static <E> ImmutableList<E> of(E e1, E e2, E e3, E e4, E e5) {

  public void testSetCount_zeroToOne_supported() {
    assertSetCount(e3(), 1);
  }

  @CollectionFeature.Require({SUPPORTS_ADD, FAILS_FAST_ON_CONCURRENT_MODIFICATION})
  public void testSetCountZeroToOneConcurrentWithIteration() {
    Iterator<E> iterator = collection.iterator();
    assertSetCount(e3(), 1);
    assertThrows(ConcurrentModificationException.class, iterator::next);
  }

  @ListFeature.Require(SUPPORTS_SET)
  public void testReplaceAll() {
    getList().replaceAll(e -> samples.e3());
    expectContents(nCopies(getNumElements(), samples.e3()));
  }

  @ListFeature.Require(SUPPORTS_SET)
  public void testReplaceAll_changesSome() {
    getList().replaceAll(e -> e.equals(samples.e0()) ? samples.e3() : e);
    E[] expected = createSamplesArray();
    for (int i = 0; i < expected.length; i++) {

  // TODO: rename e3, e4 => missing1, missing2
  private final E e0;
  private final E e1;
  private final E e2;
  private final E e3;
  private final E e4;

  public SampleElements(E e0, E e1, E e2, E e3, E e4) {
    this.e0 = e0;
    this.e1 = e1;
    this.e2 = e2;
    this.e3 = e3;
    this.e4 = e4;
  }

  @Override
  public Iterator<E> iterator() {

          put(e3());
          iterator.next();
        });
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  public void testPut_unsupportedNotPresent() {
    assertThrows(UnsupportedOperationException.class, () -> put(e3()));
    expectUnchanged();
    expectMissing(e3());
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)

  @ListFeature.Require(SUPPORTS_SET)
  public void testReplaceAll() {
    getList().replaceAll(e -> samples.e3());
    expectContents(Collections.nCopies(getNumElements(), samples.e3()));
  }

  @ListFeature.Require(SUPPORTS_SET)
  public void testReplaceAll_changesSome() {
    getList().replaceAll(e -> e.equals(samples.e0()) ? samples.e3() : e);
    E[] expected = createSamplesArray();
    for (int i = 0; i < expected.length; i++) {

  public void testSet_indexTooLow() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().set(-1, e3()));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_SET)
  public void testSet_indexTooHigh() {
    int index = getNumElements();
    assertThrows(IndexOutOfBoundsException.class, () -> getList().set(index, e3()));
    expectUnchanged();
  }

  @CollectionSize.Require(absent = ZERO)

  public void testAddAll_supportedSomePresent() {
    assertTrue(
        "addAll(somePresent) should return true",
        collection.addAll(MinimalCollection.of(e3(), e0())));
    assertTrue("should contain " + e3(), collection.contains(e3()));
    assertTrue("should contain " + e0(), collection.contains(e0()));
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  @CollectionSize.Require(absent = ZERO)

    assertTrue("add(notPresent) should return true", collection.add(e3()));
    expectAdded(e3());
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  public void testAdd_unsupportedNotPresent() {
    assertThrows(UnsupportedOperationException.class, () -> collection.add(e3()));
    expectUnchanged();
    expectMissing(e3());
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)