@GwtIncompatible // TreeRangeSet
public abstract class AbstractRangeSetTest extends TestCase {
  public static void testInvariants(RangeSet<?> rangeSet) {
    testInvariantsInternal(rangeSet);
    testInvariantsInternal(rangeSet.complement());
  }

  private static <C extends Comparable<?>> void testInvariantsInternal(RangeSet<C> rangeSet) {
    assertEquals(rangeSet.asRanges().isEmpty(), rangeSet.isEmpty());

    @CanIgnoreReturnValue
    boolean set(T t);

    @CanIgnoreReturnValue
    boolean setException(Throwable t);
  }

  private static class NewAbstractFutureFacade<T> extends AbstractFuture<T> implements Facade<T> {
    @CanIgnoreReturnValue
    @Override
    public boolean set(T t) {
      return super.set(t);
    }

    @CanIgnoreReturnValue
    @Override
    public boolean setException(Throwable t) {

/** An ordering for a pre-existing comparator. */
@GwtCompatible(serializable = true)
@ElementTypesAreNonnullByDefault
final class ComparatorOrdering<T extends @Nullable Object> extends Ordering<T>
    implements Serializable {
  final Comparator<T> comparator;

  ComparatorOrdering(Comparator<T> comparator) {
    this.comparator = checkNotNull(comparator);
  }

  @Override

 *
 * @deprecated since maven 4.0, this class is now a no-op class and is only here for compatibility
 */
@Named
@Singleton
@Deprecated
public class DefaultReportingConverter implements ReportingConverter {

    @Override
    public void convertReporting(Model model, ModelBuildingRequest request, ModelProblemCollector problems) {}

 * declaration that has the most transitive steps away from the project being built.
 *
 * @since 3.0
 */
@Named("farthest")
@Singleton
@Deprecated
public class FarthestConflictResolver implements ConflictResolver {
    // ConflictResolver methods -----------------------------------------------

    /*

import org.codehaus.plexus.interpolation.InterpolationPostProcessor;
import org.codehaus.plexus.interpolation.util.ValueSourceUtils;

/**
 *
 */
@Deprecated
public class PathTranslatingPostProcessor implements InterpolationPostProcessor {

    private final List<String> unprefixedPathKeys;
    private final File projectDir;
    private final PathTranslator pathTranslator;
    private final List<String> expressionPrefixes;

import org.eclipse.aether.artifact.ArtifactType;
import org.eclipse.aether.artifact.ArtifactTypeRegistry;

import static java.util.Objects.requireNonNull;

class TypeRegistryAdapter implements ArtifactTypeRegistry {
    private final TypeRegistry typeRegistry;

    TypeRegistryAdapter(TypeRegistry typeRegistry) {
        this.typeRegistry = requireNonNull(typeRegistry, "typeRegistry");
    }

 * Optional features of classes derived from {@code Multimap}.
 *
 * @author Louis Wasserman
 */
@SuppressWarnings("rawtypes") // maybe avoidable if we rework the whole package?
@GwtCompatible
public enum MultimapFeature implements Feature<Multimap> {
  VALUE_COLLECTIONS_SUPPORT_ITERATOR_REMOVE;

  private final Set<Feature<? super Multimap>> implied;

  MultimapFeature(Feature<? super Multimap>... implied) {
    this.implied = copyToSet(implied);

package org.codelibs.fess.suggest.converter;

import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class ReadingConverterChain implements ReadingConverter {
    private final List<ReadingConverter> converters = new ArrayList<>();

    @Override
    public void init() throws IOException {
        for (final ReadingConverter converter : converters) {

    assertThat(repeated).containsExactly(1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3).inOrder();
  }

  interface X {}

  interface Y {}

  static class A implements X, Y {}

  static class B implements X, Y {}

  /**
   * This test passes if the {@code concat(…).filter(…).filter(…)} statement at the end compiles.