* equivalent elements are added to it, it is undefined which will come first in the output.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
final class TopKSelector<
    T extends @Nullable Object> {

  /**
   * Returns a {@code TopKSelector} that collects the lowest {@code k} elements added to it,
   * relative to the natural ordering of the elements, and returns them via {@link #topK} in

    public interface FilteredCall<CQ extends EsAbstractConditionQuery, CF extends EsAbstractConditionQuery> {

        void callback(CQ query, CF filter);
    }

    @FunctionalInterface
    public interface OperatorCall<CQ extends EsAbstractConditionQuery> {

        void callback(CQ query);
    }

    @FunctionalInterface
    public interface ScoreFunctionCall<CC extends ScoreFunctionCreator<?>> {

    public interface FilteredCall<CQ extends EsAbstractConditionQuery, CF extends EsAbstractConditionQuery> {

        void callback(CQ query, CF filter);
    }

    @FunctionalInterface
    public interface OperatorCall<CQ extends EsAbstractConditionQuery> {

        void callback(CQ query);
    }

    @FunctionalInterface
    public interface ScoreFunctionCall<CC extends ScoreFunctionCreator<?>> {

   *
   * @since 10.0
   */
  @GwtCompatible(serializable = true)
  public final <S extends @Nullable T> Equivalence<Iterable<S>> pairwise() {
    // Ideally, the returned equivalence would support Iterable<? extends T>. However,
    // the need for this is so rare that it's not worth making callers deal with the ugly wildcard.
    return new PairwiseEquivalence<>(this);
  }

package jcifs.smb1.util.transport;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;

public class TransportException extends IOException {

    private Throwable rootCause;

    public TransportException() {
    }
    public TransportException( String msg ) {
        super( msg );
    }
    public TransportException( Throwable rootCause ) {
        this.rootCause = rootCause;
    }

 * iterates. This class is not thread safe.
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
final class ConsumingQueueIterator<T extends @Nullable Object> extends AbstractIterator<T> {
  private final Queue<T> queue;

  ConsumingQueueIterator(Queue<T> queue) {
    this.queue = checkNotNull(queue);
  }

  @Override
  @CheckForNull

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.ingest;

import org.codelibs.fess.unit.UnitFessTestCase;

public class IngestFactoryTest extends UnitFessTestCase {

    public void test_add_1() {
        IngestFactory factory = new IngestFactory();
        factory.add(new TestIngester(1));
        factory.add(new TestIngester(2));

/**
 * Creates sorted sets, containing sample elements, to be tested.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface TestSortedSetGenerator<E extends @Nullable Object> extends TestSetGenerator<E> {
  @Override
  SortedSet<E> create(Object... elements);

  /**
   * Returns an element less than the {@link #samples()} and less than {@link
   * #belowSamplesGreater()}.
   */

import java.util.List;

public class AnnotatedAndAbstractInSuperclassTest extends AbstractEventBusTest<SubClass> {
  abstract static class SuperClass {
    @Subscribe
    public abstract void overriddenAndAnnotatedInSubclass(Object o);

    @Subscribe
    public abstract void overriddenInSubclass(Object o);
  }

  static class SubClass extends SuperClass {

/**
 * Creates sorted sets, containing sample elements, to be tested.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface TestSortedSetGenerator<E extends @Nullable Object> extends TestSetGenerator<E> {
  @Override
  SortedSet<E> create(Object... elements);

  /**
   * Returns an element less than the {@link #samples()} and less than {@link
   * #belowSamplesGreater()}.
   */