}

    @Override
    public boolean add(@ParametricNullness E element) {
      checkArgument(predicate.apply(element));
      return unfiltered.add(element);
    }

    @Override
    public boolean addAll(Collection<? extends E> collection) {
      for (E element : collection) {
        checkArgument(predicate.apply(element));
      }
      return unfiltered.addAll(collection);
    }

   * have been removed.
   *
   * <p><b>Warning:</b> Typical uses of the resulting iterator may produce an infinite loop. You
   * should use an explicit {@code break} or be certain that you will eventually remove all the
   * elements.
   *
   * <p>To cycle over the elements {@code n} times, use the following: {@code
   * Iterables.concat(Collections.nCopies(n, Arrays.asList(elements)))}
   *

    E[] elements = createSamplesArray();
    E duplicate = elements[(elements.length / 2) - 1];
    elements[(elements.length / 2) + 1] = duplicate;
    return new ArrayWithDuplicate<>(elements, duplicate);
  }

  // Helper methods to improve readability of derived classes

  protected int getNumElements() {
    return getSubjectGenerator().getCollectionSize().getNumElements();
  }

      return unfiltered.add(element, occurrences);
    }

    @Override
    public int remove(@CheckForNull Object element, int occurrences) {
      checkNonnegative(occurrences, "occurrences");
      if (occurrences == 0) {
        return count(element);
      } else {
        return contains(element) ? unfiltered.remove(element, occurrences) : 0;
      }

     */
    @Input
    boolean isEnabled();

    /**
     * Sets element for the rule.
     *
     * @param element Element
     */
    void setElement(String element);

    /**
     * Gets the element for the rule as defined by

 * according to when the first occurrence of the element was added. When the multiset contains
 * multiple instances of an element, those instances are consecutive in the iteration order. If all
 * occurrences of an element are removed, after which that element is added to the multiset, the
 * element will appear at the end of the iteration.
 *

    }

    @Override
    public boolean add(@ParametricNullness E element) {
      checkArgument(predicate.apply(element));
      return unfiltered.add(element);
    }

    @Override
    public boolean addAll(Collection<? extends E> collection) {
      for (E element : collection) {
        checkArgument(predicate.apply(element));
      }
      return unfiltered.addAll(collection);
    }

    fun push(element: T) {
        lock.withLock {
            q.addFirst(element)
            if (q.size == 1) {
                notEmpty.signal()
            }
        }
    }

    /**
     * Returns the next group of elements after removing them from the queue.
     *
     * The group contains the most recently pushed element plus all

        when:
        container.get()

        then:
        def e = thrown(IllegalStateException)
        e.message == 'Cannot query the elements of this container as the elements have not been created yet.'
    }

    def "cannot get elements from when known action"() {
        given:
        container.add(Stub(SwiftBinary))
        container.whenElementKnown { container.get() }

        when:

    HierarchicalElement getParent();

    /**
     * Returns the child elements, or the empty set if there are no child elements.
     *
     * @return The child elements, or the empty set if there are no child elements.
     * @since 1.0-milestone-5
     */
    DomainObjectSet<? extends HierarchicalElement> getChildren();