}

    def "forEach iterates the elements #elements"() {
        when:
        def newList = []
        listOf(elements).forEach { newList.add(it) }
        then:
        newList == elements
        listOf(elements) == PersistentList.of(*elements)

        where:
        elements << [
            [],
            ["a"],
            ["a", "b", "c"],

    }

    def "can set elements as convention of file collection"() {
        buildFile """
            def files = objects.fileCollection().convention('b')
            def elements = files.elements

            def name = 'a'
            files.from(name)

            assert elements.get().asFile == [file('b'), file('a')]
        """

        expect:
        succeeds()

        throw PermittedMetaException.ISE;
      }
    }

    private List<E> getElements() {
      List<E> elements = new ArrayList<>();
      Helpers.addAll(elements, previousElements);
      Helpers.addAll(elements, Helpers.reverse(nextElements));
      return elements;
    }
  }

  public enum KnownOrder {
    KNOWN_ORDER,
    UNKNOWN_ORDER
  }

        throw PermittedMetaException.ISE;
      }
    }

    private List<E> getElements() {
      List<E> elements = new ArrayList<>();
      Helpers.addAll(elements, previousElements);
      Helpers.addAll(elements, Helpers.reverse(nextElements));
      return elements;
    }
  }

  public enum KnownOrder {
    KNOWN_ORDER,
    UNKNOWN_ORDER
  }

  // Clone of Lists.newArrayList
  public static <E extends @Nullable Object> List<E> copyToList(Iterable<? extends E> elements) {
    List<E> list = new ArrayList<>();
    addAll(list, elements);
    return list;
  }

  public static <E extends @Nullable Object> List<E> copyToList(E[] elements) {
    return copyToList(Arrays.asList(elements));
  }

  // Clone of Sets.newLinkedHashSet

      TestCollectionGenerator<E> delegate) {
    return new ReserializingTestCollectionGenerator<>(delegate);
  }

  @Override
  public Collection<E> create(Object... elements) {
    return reserialize(delegate.create(elements));
  }

  @SuppressWarnings("unchecked")
  static <T> T reserialize(T object) {
    try {
      ByteArrayOutputStream bytes = new ByteArrayOutputStream();

      TestCollectionGenerator<E> delegate) {
    return new ReserializingTestCollectionGenerator<>(delegate);
  }

  @Override
  public Collection<E> create(Object... elements) {
    return reserialize(delegate.create(elements));
  }

  @SuppressWarnings("unchecked")
  static <T> T reserialize(T object) {
    try {
      ByteArrayOutputStream bytes = new ByteArrayOutputStream();

  // Clone of Lists.newArrayList
  public static <E extends @Nullable Object> List<E> copyToList(Iterable<? extends E> elements) {
    List<E> list = new ArrayList<>();
    addAll(list, elements);
    return list;
  }

  public static <E extends @Nullable Object> List<E> copyToList(E[] elements) {
    return copyToList(Arrays.asList(elements));
  }

  // Clone of Sets.newLinkedHashSet

  }

  /** constructor with array is of same size and has all elements */
  public void testConstructor2() {
    AtomicDoubleArray aa = new AtomicDoubleArray(VALUES);
    assertEquals(VALUES.length, aa.length());
    for (int i = 0; i < VALUES.length; i++) {
      assertBitEquals(VALUES[i], aa.get(i));
    }
  }

  /** constructor with empty array has size 0 and contains no elements */
  public void testConstructorEmptyArray() {

    } catch (UnsupportedOperationException expected) {
    }
    assertCollectionsAreEquivalent(multiset, copy);

    assertCollectionsAreEquivalent(multiset, copy);

    assertSetIsUnmodifiable(multiset.elementSet(), sampleElement);
    assertCollectionsAreEquivalent(multiset, copy);

    assertSetIsUnmodifiable(
        multiset.entrySet(),
        new Multiset.Entry<E>() {
          @Override