if (!this.filter.accept(nr)) {
                    continue;
                }
                return nr;
            } catch (final CIFSException e) {
                log.error("Failed to apply filter", e);
                continue;
            } catch (final MalformedURLException e) {
                log.error("Failed to create child URL", e);
                continue;
            }
        }

            reload(updater);
        }
    }

    /**
     * Reloads the stopwords dictionary from its source file.
     *
     * @param updater An optional updater to apply changes during reload.
     * @throws DictionaryException if the dictionary file cannot be read.
     */
    protected void reload(final StopwordsUpdater updater) {

    new ForwardingWrapperTester()
        .testForwarding(
            Multimap.class,
            new Function<Multimap, Multimap<?, ?>>() {
              @Override
              public Multimap<?, ?> apply(Multimap delegate) {
                return wrap((Multimap<?, ?>) delegate);
              }
            });
  }

  public void testEquals() {
    Multimap<Integer, String> map1 = ImmutableMultimap.of(1, "one");

            .createTestSuite());

    Function<String, String> removeFirstCharacter =
        new Function<String, String>() {
          @Override
          public String apply(String input) {
            return input.substring(1);
          }
        };

    suite.addTest(
        CollectionTestSuiteBuilder.using(
                new TestStringCollectionGenerator() {

        Maps.asMap(
            ImmutableSet.of(AnEnum.A),
            new Function<AnEnum, AnEnum>() {
              boolean used = false;

              @Override
              public AnEnum apply(AnEnum ae) {
                checkState(!used, "should not be applied more than once");
                used = true;
                return ae;
              }
            });

    new ForwardingWrapperTester()
        .testForwarding(
            interfaceType,
            new Function<Object, T>() {
              @Override
              public T apply(Object delegate) {
                T mock = mock(forwarderClass, CALLS_REAL_METHODS);
                try {
                  T stubber = doReturn(delegate).when(mock);
                  DELEGATE_METHOD.invoke(stubber);

    assertThat(request.header("If-Modified-Since")).isEqualTo(
      "Mon, 18 Aug 2014 15:16:06 GMT",
    )
  }

  companion object {
    fun fromArgs(vararg args: String): Main =
      Main().apply {
        parse(args.toList())
      }

    private fun bodyAsString(body: RequestBody?): String =
      try {
        val buffer = Buffer()
        body!!.writeTo(buffer)

    new ForwardingWrapperTester()
        .testForwarding(
            Collection.class,
            new Function<Collection, Collection>() {
              @Override
              public Collection apply(Collection delegate) {
                return wrap(delegate);
              }
            });
  }

  private static <T> Collection<T> wrap(Collection<T> delegate) {
    return new ForwardingCollection<T>() {

  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            Queue.class,
            new Function<Queue, Queue>() {
              @Override
              public Queue apply(Queue delegate) {
                return wrap(delegate);
              }
            });
  }

  private static <T> Queue<T> wrap(Queue<T> delegate) {
    return new ForwardingQueue<T>() {
      @Override

      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include