l.MoveBefore(e2, e4)
	checkListPointers(l, []*(_Element[int]){e1, e3, e2, e4})
	e2, e3 = e3, e2

	l.MoveBefore(e4, e1)
	checkListPointers(l, []*(_Element[int]){e4, e1, e2, e3})
	e1, e2, e3, e4 = e4, e1, e2, e3

	l.MoveAfter(e4, e1)
	checkListPointers(l, []*(_Element[int]){e1, e4, e2, e3})
	e2, e3, e4 = e4, e2, e3

	l.MoveAfter(e2, e3)
	checkListPointers(l, []*(_Element[int]){e1, e3, e2, e4})
	e2, e3 = e3, e2
}

  }

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

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

        e.cause == failure

        when:
        resource.withContent(action)

        then:
        def e2 = thrown(ResourceException)
        e2.message == "Could not get resource '${file.toURI()}'."
        e2.cause == failure
    }

    def "can ignore missing file when using ContentAndMetadataAction"() {
        def file = tmpDir.file("missing")

        expect:

                                  const char* e2,
                                  Pred pred,
                                  const T1& v1,
                                  const T2& v2) {
  if (pred(v1, v2)) return AssertionSuccess();

  return AssertionFailure() << pred_text << "("
                            << e1 << ", "
                            << e2 << ") evaluates to false, where"

        def e = thrown(AssertionError)
        e.message.trim().startsWith('Expected: a collection containing "none"')

        when:
        failure.assertHasLineNumber(23)

        then:
        def e2 = thrown(AssertionError)
        e2.message.trim().startsWith('Expected: a collection containing "23"')
    }

    def "cannot assert that failure location is present when missing"() {
        given:
        def output = """

000002f0  c1 2d 2f 4e d2 25 14 96  24 c6 18 97 82 93 1c 1b  |.-/N.%..$.......|
00000300  b4 ca 77 8b 17 7c cf 08  ca 06 e2 ef f3 97 6a 31  |..w..|........j1|
00000310  88 aa 46 a2 d3 7b 65 56  e2 77 72 df              |..F..{eV.wr.|
>>> Flow 4 (server to client)
00000000  14 03 03 00 01 01 16 03  03 00 40 b8 19 a7 e2 35  |..........@....5|
00000010  8a be 5f 4c 91 d2 db 3f  f3 42 90 8e b5 7f ea f7  |.._L...?.B......|

  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e1, E e2) {
    return ofInternal(Ordering.natural(), e1, e2);
  }

  @SuppressWarnings("unchecked")
  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e1, E e2, E e3) {
    return ofInternal(Ordering.natural(), e1, e2, e3);
  }

  @SuppressWarnings("unchecked")

                                  const char* e2,
                                  Pred pred,
                                  const T1& v1,
                                  const T2& v2) {
  if (pred(v1, v2)) return AssertionSuccess();

  return AssertionFailure() << pred_text << "("
                            << e1 << ", "
                            << e2 << ") evaluates to false, where"

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

  /**
   * 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) {
    return construct(e1, e2, e3);
  }

  /**

    return copyFromElements(e1, e2, e3, e4, e5);
  }

  /**
   * Returns an immutable multiset containing the given elements, in the "grouped iteration order"
   * described in the class documentation.
   *
   * @throws NullPointerException if any element is null
   * @since 6.0 (source-compatible since 2.0)
   */
  public static <E> ImmutableMultiset<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E... others) {