// Verify the stack trace contains this test method
        boolean foundTestMethod = false;
        for (StackTraceElement element : exception.getStackTrace()) {
            if (element.getMethodName().equals("test_stackTrace") && element.getClassName().equals(this.getClass().getName())) {
                foundTestMethod = true;
                break;
            }
        }

    }

    /**
     * Returns the element type of the parameterized collection declared as the method's argument type.
     *
     * @param method
     *            The method. Cannot be {@literal null}
     * @param position
     *            The position of the parameterized collection in the method's argument list
     * @return The element type of the parameterized collection
     */

            return parent.get(index);
        }

        public E set(final int index, final E element) {
            return parent.set(index, element);
        }

        public void add(final int index, final E element) {
            parent.add(index, element);
        }

        public E remove(final int index) {
            return parent.remove(index);
        }

  }

  @Override
  public @Nullable Entry<E> lastEntry() {
    return isEmpty() ? null : getEntry(length - 1);
  }

  @Override
  public int count(@Nullable Object element) {
    int index = elementSet.indexOf(element);
    return (index >= 0) ? getCount(index) : 0;
  }

  @Override
  public int size() {
    long size = cumulativeCounts[offset + length] - cumulativeCounts[offset];

    val message =
      buildString {
        append("Certificate pinning failure!")
        append("\n  Peer certificate chain:")
        for (element in peerCertificates) {
          append("\n    ")
          append(pin(element))
          append(": ")
          append(element.subjectDN.name)
        }
        append("\n  Pinned certificates for ")
        append(hostname)
        append(":")
        for (pin in pins) {

     */
    protected void createFilterChain() {
        FilterChain chain = createDefaultFilterChain();
        for (final Filter element : filterList) {
            chain = appendFilterChain(element, chain);
        }
        filterChain = chain;
    }

    /**
     * Appends a filter to an existing filter chain.
     *
     * @param filter the filter to append

     */
    runConcurrentlyMutatedTest(elements(), ops(add(1), add(2)), wrap);

    runConcurrentlyMutatedTest(elements(), ops(add(1), nop()), wrap);

    runConcurrentlyMutatedTest(elements(), ops(add(1), remove()), wrap);

    runConcurrentlyMutatedTest(elements(), ops(nop(), add(1)), wrap);

    runConcurrentlyMutatedTest(elements(1), ops(remove(), nop()), wrap);

            return parent.get(index);
        }

        @Override
        public E set(final int index, final E element) {
            return parent.set(index, element);
        }

        @Override
        public void add(final int index, final E element) {
            parent.add(index, element);
        }

        @Override
        public E remove(final int index) {
            return parent.remove(index);

  public void testPeek_size1() {
    assertEquals("size1Queue.peek() should return first element", e0(), getQueue().peek());
    expectUnchanged();
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  @CollectionSize.Require(SEVERAL)
  public void testPeek_sizeMany() {
    assertEquals("sizeManyQueue.peek() should return first element", e0(), getQueue().peek());
    expectUnchanged();
  }

 *
 * @author shot
 * @param <T> the element type
 */
public class EnumerationIterator<T> implements Iterator<T> {

    private Enumeration<T> enumeration = null;

    /**
     * Returns an {@link Iterable} that wraps an {@link Enumeration} for use in a for-each statement.
     *
     * @param <T> the element type
     * @param enumeration the enumeration (must not be {@literal null})