}
  }

  static final Predicate<String> FILTER_KEYS =
      new Predicate<String>() {
        @Override
        public boolean apply(@Nullable String string) {
          return !"banana".equals(string) && !"eggplant".equals(string);
        }
      };

  static final Predicate<String> FILTER_VALUES =
      new Predicate<String>() {
        @Override

  public void testRemoveIf_unsupportedEmptyCollection() {
    try {
      assertFalse(
          "removeIf(Predicate) should return false or throw " + "UnsupportedOperationException",
          collection.removeIf(
              x -> {
                throw new AssertionError("predicate should never be called");
              }));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();

      Predicate<T> predicate) {
    return new PredicateFunction<>(predicate);
  }

  /** @see Functions#forPredicate */
  private static class PredicateFunction<T extends @Nullable Object>
      implements Function<T, Boolean>, Serializable {
    private final Predicate<T> predicate;

    private PredicateFunction(Predicate<T> predicate) {
      this.predicate = checkNotNull(predicate);
    }

    @Override

         * The result will contain only the paths of types for which the predicate returned {@code true}.
         * It is recommended to apply a filter for retaining only the types of paths of interest,
         * because it can resolve ambiguities when a path could be of many types.
         *
         * @param pathTypeFilter predicate evaluating whether a path type should be included in the result

      Predicate<T> predicate) {
    return new PredicateFunction<>(predicate);
  }

  /** @see Functions#forPredicate */
  private static class PredicateFunction<T extends @Nullable Object>
      implements Function<T, Boolean>, Serializable {
    private final Predicate<T> predicate;

    private PredicateFunction(Predicate<T> predicate) {
      this.predicate = checkNotNull(predicate);
    }

    @Override

    }

    private static class Relocation {
        private final Predicate<Artifact> predicate;
        private final boolean global;
        private final Artifact source;
        private final Artifact target;

        private Relocation(boolean global, Artifact source, Artifact target) {
            this.predicate = artifactPredicate(source);
            this.global = global;
            this.source = source;

  }

  /**
   * Waits until the given predicate returns true, invoking the garbage collector as necessary to
   * try to ensure that this will happen.
   *
   * @throws RuntimeException if timed out or interrupted while waiting
   */
  @SuppressWarnings("removal") // b/260137033
  public static void awaitDone(FinalizationPredicate predicate) {
    if (predicate.isDone()) {
      return;
    }

    throw new UnsupportedOperationException();
  }

  public final boolean removeAll(Collection<?> oldElements) {
    throw new UnsupportedOperationException();
  }

  public final boolean removeIf(Predicate<? super E> predicate) {
    throw new UnsupportedOperationException();
  }

  public final boolean retainAll(Collection<?> elementsToKeep) {
    throw new UnsupportedOperationException();
  }

  public final void clear() {

  }

  /**
   * Waits until the given predicate returns true, invoking the garbage collector as necessary to
   * try to ensure that this will happen.
   *
   * @throws RuntimeException if timed out or interrupted while waiting
   */
  @SuppressWarnings("removal") // b/260137033
  public static void awaitDone(FinalizationPredicate predicate) {
    if (predicate.isDone()) {
      return;
    }

    }
  }

  static final Predicate<String> FILTER_KEYS =
      new Predicate<String>() {
        @Override
        public boolean apply(@Nullable String string) {
          return !"banana".equals(string) && !"eggplant".equals(string);
        }
      };

  static final Predicate<String> FILTER_VALUES =
      new Predicate<String>() {
        @Override