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);

    }

    /**
     * Adds {@code element} to the {@code ImmutableSortedMultiset}.
     *
     * @param element the element to add
     * @return this {@code Builder} object
     * @throws NullPointerException if {@code element} is null
     */
    @CanIgnoreReturnValue
    @Override
    public Builder<E> add(E element) {
      super.add(element);
      return this;
    }

    /**

    assertEquals("Should be able to peek() at first element", "A", peekingIterator.peek());
    assertEquals(
        "Should be able to peek() first element multiple times", "A", peekingIterator.peek());
    assertEquals(
        "next() should still return first element after peeking", "A", peekingIterator.next());

    assertEquals("Should be able to peek() at middle element", "B", peekingIterator.peek());
    assertEquals(

package gradlebuild.docs

import groovy.xml.dom.DOMCategory
import org.w3c.dom.Element
import org.w3c.dom.Node

class BuildableDOMCategory extends DOMCategory {
    public static void setText(Element element, String value) {
        while (element.hasChildNodes()) {
            element.removeChild(element.getFirstChild())
        }
        element.appendChild(element.ownerDocument.createTextNode(value))
    }

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");

   */
  @CanIgnoreReturnValue // pushed down from class to method
  @Override
  public boolean add(E e) {
    return offer(e);
  }

  /**
   * Inserts the specified element into this priority queue.
   *
   * @param e the element to add
   * @return {@code true} (as specified by {@link Queue#offer})

    /**
     * Return the index of the next lower element in the list, or {@code -1} if there is no such
     * element.
     */
    NEXT_LOWER {
      @Override
      int resultIndex(int higherIndex) {
        return higherIndex - 1;
      }
    },
    /**
     * Return the index of the next higher element in the list, or {@code list.size()} if there is
     * no such element.
     */
    NEXT_HIGHER {

        Element root = pomDocument.root();

        // Check if this POM has a parent
        Element parentElement = root.child(PARENT).orElse(null);
        if (parentElement == null) {
            return false;
        }

        // Apply full inference (parent element trimming based on relativePath)

   * stream.filter(element::equals).count()}. If {@code element} might be null, use {@code
   * stream.filter(Predicate.isEqual(element)).count()} instead.
   *
   * @see java.util.Collections#frequency(Collection, Object) Collections.frequency(Collection,
   *     Object)
   */
  public static int frequency(Iterable<?> iterable, @Nullable Object element) {
    if ((iterable instanceof Multiset)) {

    ToOptionalState<T> combine(ToOptionalState<T> other) {
      if (element == null) {
        return other;
      } else if (other.element == null) {
        return this;
      } else {
        if (extras.isEmpty()) {
          // Replace immutable empty list with mutable list.
          extras = new ArrayList<>();
        }
        extras.add(other.element);
        extras.addAll(other.extras);