| Maximum number of versions per object                                           | 10000 (can be configured to higher values but we do not recommend beyond 10000) |

 * This class wraps search results with pagination information, facet responses, and query statistics.
 * It implements the List interface to provide standard list operations while adding search-specific
 * functionality such as page navigation, record counts, and query execution times.
 */
public class QueryResponseList implements List<Map<String, Object>> {

    /** The underlying list that contains the actual search result documents. */

        <constraint name="__context__"...

  }

  /**
   * This is an enum singleton rather than an anonymous class so ProGuard can figure out it's only
   * referenced by emptyModifiableIterator().
   */
  private enum EmptyModifiableIterator implements Iterator<Object> {
    INSTANCE;

    @Override
    public boolean hasNext() {
      return false;
    }

    @Override
    public Object next() {
      throw new NoSuchElementException();

 */
public class RuleManagerTest extends PlainTestCase {

    /**
     * Test implementation of RuleManager for testing purposes
     */
    public static class TestRuleManager implements RuleManager {
        private final List<Rule> rules = new ArrayList<>();
        private int getRuleCallCount = 0;

        @Override
        public Rule getRule(ResponseData responseData) {

 *
 * @author Louis Wasserman
 */
@GwtCompatible
abstract class AbstractMultimap<K extends @Nullable Object, V extends @Nullable Object>
    implements Multimap<K, V> {
  @Override
  public boolean isEmpty() {
    return size() == 0;
  }

  @Override
  public boolean containsValue(@Nullable Object value) {
    for (Collection<V> collection : asMap().values()) {

import jakarta.annotation.PostConstruct;
import jakarta.annotation.Resource;

/**
 * A factory class for managing and creating crawler clients based on URL patterns.
 * This class implements AutoCloseable to properly handle resource cleanup.
 *
 * <p>The factory maintains a map of regular expression patterns to crawler clients,
 * allowing for URL-based client selection. Clients can be added with specific patterns

import org.jspecify.annotations.NullMarked;

/**
 * Create multisets of strings for tests.
 *
 * @author Jared Levy
 */
@GwtCompatible
@NullMarked
public abstract class TestStringMultisetGenerator implements TestMultisetGenerator<String> {
  @Override
  public SampleElements<String> samples() {
    return new Strings();
  }

  @Override
  public Multiset<String> create(Object... elements) {

import org.jspecify.annotations.NullUnmarked;

/**
 * A byte source for testing that has configurable behavior.
 *
 * @author Colin Decker
 */
@NullUnmarked
public final class TestByteSource extends ByteSource implements TestStreamSupplier {

  private final byte[] bytes;
  private final ImmutableSet<TestOption> options;

  private boolean inputStreamOpened;
  private boolean inputStreamClosed;

import java.util.Comparator;
import org.jspecify.annotations.Nullable;

/** An ordering for a pre-existing comparator. */
@GwtCompatible
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