.testEquals();
  }

  private static <K, V> SortedSetMultimap<K, V> wrap(final SortedSetMultimap<K, V> delegate) {
    return new ForwardingSortedSetMultimap<K, V>() {
      @Override
      protected SortedSetMultimap<K, V> delegate() {
        return delegate;
      }
    };
  }

@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class UnmodifiableListIterator<E extends @Nullable Object>
    extends UnmodifiableIterator<E> implements ListIterator<E> {
  /** Constructor for use by subclasses. */
  protected UnmodifiableListIterator() {}

  /**
   * Guaranteed to throw an exception and leave the underlying data unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.

    @Inject
    public Encrypt(MessageBuilderFactory messageBuilderFactory, SecDispatcher secDispatcher) {
        super(messageBuilderFactory, secDispatcher);
    }

    @Override
    protected int doExecute(DefaultEncryptInvoker.LocalContext context) throws Exception {
        String cleartext = context.reader.readLine("Enter the password to encrypt: ", '*');

 *
 */
public class TextExtractorTest extends PlainTestCase {
    private static final Logger logger = LoggerFactory.getLogger(TextExtractorTest.class);

    public TextExtractor textExtractor;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        StandardCrawlerContainer container = new StandardCrawlerContainer().singleton("textExtractor", TextExtractor.class);

        }
      }
    }
  }

  /** A guard that encapsulates a simple, mutable boolean flag. */
  static class FlagGuard extends Monitor.Guard {

    private boolean satisfied;

    protected FlagGuard(Monitor monitor) {
      super(monitor);
    }

    @Override
    public boolean isSatisfied() {
      return satisfied;
    }

    public void setSatisfied(boolean satisfied) {

    final TreeSet<Integer> result = Sets.newTreeSet(contents);
    // we have to make the result not Navigable
    return new ForwardingSortedSet<Integer>() {
      @Override
      protected SortedSet<Integer> delegate() {
        return result;
      }
    };
  }

  @Override
  SortedSet<Integer> filter(SortedSet<Integer> elements, Predicate<? super Integer> predicate) {

 *
 */
public class HtmlExtractorTest extends PlainTestCase {
    private static final Logger logger = LoggerFactory.getLogger(HtmlExtractorTest.class);

    public HtmlExtractor htmlExtractor;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        StandardCrawlerContainer container = new StandardCrawlerContainer().singleton("htmlExtractor", HtmlExtractor.class);

    AnEnum[] array = new AnEnum[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (AnEnum) e;
    }
    return create(array);
  }

  protected abstract Multiset<AnEnum> create(AnEnum[] elements);

  @Override
  public AnEnum[] createArray(int length) {
    return new AnEnum[length];
  }

  /** Sorts the enums according to their natural ordering. */

        super(tc);
    }


    /**
     * Returns the default HTTPS port.
     *
     * @return An <code>int</code> containing the default HTTPS port.
     */
    @Override
    protected int getDefaultPort () {
        return DEFAULT_HTTPS_PORT;
    }

    public void test_document() throws Exception {
        saveLastaDocMeta();
        assertTrue(true);
    }

    @Override
    protected DocumentGenerator createDocumentGenerator() {
        return super.createDocumentGenerator().suppressJobDoc();
    }