@Override
  protected abstract ListIterator<E> delegate();

  @Override
  public void add(@ParametricNullness E element) {
    delegate().add(element);
  }

  @Override
  public boolean hasPrevious() {
    return delegate().hasPrevious();
  }

  @Override
  public int nextIndex() {
    return delegate().nextIndex();
  }

  @CanIgnoreReturnValue
  @Override

    private final Callable<T> delegate;

    WrappedCallable(Callable<T> delegate) {
      this.delegate = delegate;
    }

    @Override
    public T call() throws Exception {
      return delegate.call();
    }
  }

  private static final class WrappedRunnable implements Runnable {
    private final Runnable delegate;

    WrappedRunnable(Runnable delegate) {
      this.delegate = delegate;
    }

                    + " the delegate) instead of forwarding to delegate.close()");
          }
        };
    ExecutorService wrapper =
        new ForwardingExecutorService() {
          @Override
          protected ExecutorService delegate() {
            return delegate;
          }
        };
    Method closeMethod;
    try {

  public static final class NavigableSetSubsetTestSetGenerator<E>
      extends SortedSetSubsetTestSetGenerator<E> {
    public NavigableSetSubsetTestSetGenerator(
        TestSortedSetGenerator<E> delegate, Bound to, Bound from) {
      super(delegate, to, from);
    }

    @Override
    NavigableSet<E> createSubSet(SortedSet<E> sortedSet, E firstExclusive, E lastExclusive) {
      NavigableSet<E> set = (NavigableSet<E>) sortedSet;

              @Override
              public Deque<?> apply(Deque delegate) {
                return wrap((Deque<?>) delegate);
              }
            });
  }

  private static <T> Deque<T> wrap(Deque<T> delegate) {
    return new ForwardingDeque<T>() {
      @Override
      protected Deque<T> delegate() {
        return delegate;
      }
    };
  }

              public ListIterator<?> apply(ListIterator delegate) {
                return wrap((ListIterator<?>) delegate);
              }
            });
  }

  private static <T> ListIterator<T> wrap(ListIterator<T> delegate) {
    return new ForwardingListIterator<T>() {
      @Override
      protected ListIterator<T> delegate() {
        return delegate;
      }
    };
  }

        this.filter = filter;
        this.next = advance();
    }

    /**
     * @return next element
     */
    private SmbResource advance() {
        while (this.delegate.hasNext()) {
            final FileEntry n = this.delegate.next();
            if (this.filter == null) {
                try {
                    return adapt(n);
                } catch (final MalformedURLException e) {

    // --------------------------/

    private final MavenStaxWriter delegate = new MavenStaxWriter();

    // -----------/
    // - Methods -/
    // -----------/

    public MavenXpp3Writer() {
        this(false);
    }

    protected MavenXpp3Writer(boolean addLocationInformation) {
        delegate.setAddLocationInformation(addLocationInformation);
    }

    /**

    private final TestMultisetGenerator<E> delegate;

    ForwardingTestMultisetGenerator(TestMultisetGenerator<E> delegate) {
      this.delegate = delegate;
    }

    @Override
    public SampleElements<E> samples() {
      return delegate.samples();
    }

    @Override
    public E[] createArray(int length) {
      return delegate.createArray(length);
    }

    @Override

    RerunTestResultProcessor(TestResultProcessor delegate) {
        this.delegate = delegate;
    }

    @Override
    public void started(TestDescriptorInternal descriptor, TestStartEvent testStartEvent) {
        activeDescriptorsById.put(descriptor.getId(), descriptor);
        if (rootTestDescriptor == null) {
            rootTestDescriptor = descriptor;
            try {
                delegate.started(descriptor, testStartEvent);