public void testForEachUnknownOrder() {
    List<E> elements = new ArrayList<>();
    collection.forEach(elements::add);
    assertEqualIgnoringOrder(asList(createSamplesArray()), elements);
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testForEachKnownOrder() {
    List<E> elements = new ArrayList<>();
    collection.forEach(elements::add);
    List<E> expected = copyToList(getOrderedElements());

  /** Returns an iterable whose iterator returns the given elements in order. */
  public static <E extends @Nullable Object> MinimalIterable<E> of(E... elements) {
    // Make sure to get an unmodifiable iterator
    return new MinimalIterable<>(asList(elements).iterator());
  }

  /**
   * Returns an iterable whose iterator returns the given elements in order. The elements are copied

        return new String(buf);
    }

    /**
     * Converts an {@link Element} to a string.
     *
     * @param element
     *            The element. Must not be {@literal null}.
     * @return The converted string.
     */
    public static String toString(final Element element) {
        assertArgumentNotNull("element", element);

        final StringBuilder buf = new StringBuilder(1000);

class STSElement(object):
    """STS aware XML parsing class. Wraps a root element name and
    cElementTree.Element instance. Provides STS namespace aware parsing
    functions.

    """

    def __init__(self, root_name, element):
        self.root_name = root_name
        self.element = element

    @classmethod
    def fromstring(cls, root_name, data):

            <p><b>Note:</b> This will not automagically make a Mojo run when the plugin declaration is added
            to the POM. It merely enables the user to omit the {@code <phase>} element from the
            surrounding {@code <execution>} element.</p>
          </description>
        </field>
        <field>
          <name>executePhase</name>
          <version>1.0.0+</version>
          <type>String</type>

   * add the edge connecting them. We are not using the proxy methods here as we want to test {@code
   * putEdge} when the end-points are not elements of the graph.
   */
  @Test
  public void putEdge_nodesNotInGraph() {
    assume().that(graphIsMutable()).isTrue();

    graphAsMutableGraph.addNode(N1);

import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class ElementWarningsRenderer {
    public void renderTo(DslElementDoc elementDoc, String type, Element parent) {
        if (elementDoc.isDeprecated()) {
            Document document = parent.getOwnerDocument();
            Element caution = document.createElement("caution");
            parent.appendChild(caution);
            Element para = document.createElement("para");

      // at least one element.
      this.expectedValuesPerKey = max(expectedValuesPerKey, 1);

      return this;
    }

    /**
     * By default, if we are handed a value collection bigger than expectedValuesPerKey, presize to
     * accept that many elements.
     *

    StackTraceElement[] elements = e.getStackTrace();
    for (int i = 0; i < elements.length; i++) {
      StackTraceElement element = elements[i];
      if (element.getClassName().equals(clazz) && element.getMethodName().equals(method)) {
        return i;
      }
    }
    throw new AssertionError(
        "Expected element " + clazz + "." + method + " not found in stack trace", e);
  }

  }

  @Override
  public boolean contains(@Nullable Object element) {
    return count(element) > 0;
  }

  // Modification Operations
  @CanIgnoreReturnValue
  @Override
  public final boolean add(@ParametricNullness E element) {
    add(element, 1);
    return true;
  }

  @CanIgnoreReturnValue
  @Override
  public int add(@ParametricNullness E element, int occurrences) {
    throw new UnsupportedOperationException();