* non-null objects {@code x} and {@code y}, {@code equivalence.onResultOf(function).equivalent(a,
   * b)} is true if and only if {@code equivalence.equivalent(function.apply(a), function.apply(b))}
   * is true.
   *
   * <p>For example:
   *
   * <pre>{@code
   * Equivalence<Person> SAME_AGE = Equivalence.equals().onResultOf(GET_PERSON_AGE);
   * }</pre>
   *

  private static final Predicate<Entry<String, Integer>> PREDICATE =
      new Predicate<Entry<String, Integer>>() {
        @Override
        public boolean apply(Entry<String, Integer> entry) {
          return !"badkey".equals(entry.getKey()) && 55556 != entry.getValue();
        }
      };

  public MultimapsFilterEntriesAsMapTest() {
    super(true, true, false);
  }

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

  public void testEquals() {

    /**
     * Add a header line without any validation. Only appropriate for headers from the remote peer
     * or cache.
     */
    internal fun addLenient(line: String) =
      apply {
        val index = line.indexOf(':', 1)
        when {
          index != -1 -> {
            addLenient(line.substring(0, index), line.substring(index + 1))
          }
          line[0] == ':' -> {

    }

    @Override
    void forEachRemaining(Consumer<? super E> action) {
      spliteratorOfPrimitive.forEachRemaining(consumerizer.apply(action));
    }

    @Override
    boolean tryAdvance(Consumer<? super E> action) {
      return spliteratorOfPrimitive.tryAdvance(consumerizer.apply(action));
    }

    @Override
    @Nullable GeneralSpliterator<E> trySplit() {

    }

    @Override
    void forEachRemaining(Consumer<? super E> action) {
      spliteratorOfPrimitive.forEachRemaining(consumerizer.apply(action));
    }

    @Override
    boolean tryAdvance(Consumer<? super E> action) {
      return spliteratorOfPrimitive.tryAdvance(consumerizer.apply(action));
    }

    @Override
    @Nullable GeneralSpliterator<E> trySplit() {

   * This is useful if the function instance already exists, or so that you can supply a lambda
   * expressions. If those circumstances don't apply, you probably don't need to use this; subclass
   * {@code TreeTraverser} and implement its {@link #children} method directly.
   *
   * @since 20.0

    static Function<String, String> chain(Collection<? extends Function<String, String>> functions) {
        return s -> {
            for (Function<String, String> function : functions) {
                String v = function.apply(s);
                if (v != null) {
                    return v;
                }
            }
            return null;
        };
    }

    @SafeVarargs

                stream.accept(s);
            }
        }

        public <R> R get(final Function<Stream<T>, R> stream) {
            try (Stream<T> s = supplier.get()) {
                return stream.apply(s);
            }
        }
    }

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Use this to meta-annotate {@code XxxFeature.Require} annotations, so that those annotations can
 * be used to decide whether to apply a test to a given class-under-test.
 *
 * <p>This is needed because annotations can't implement interfaces, which is also why reflection is
 * used to extract values from the properties of the various annotations.
 *