*/
  public abstract L get(Object key);

  /**
   * Returns the stripe at the specified index. Valid indexes are 0, inclusively, to {@code size()},
   * exclusively.
   *
   * @param index the index of the stripe to return; must be in {@code [0...size())}
   * @return the stripe at the specified index
   */
  public abstract L getAt(int index);

  /**

 * iterator to an {@code UnmodifiableIterator} using {@link Iterators#unmodifiableIterator}.
 *
 * @author Jared Levy
 * @since 2.0
 */
@GwtCompatible
public abstract class UnmodifiableIterator<E extends @Nullable Object> implements Iterator<E> {
  /** Constructor for use by subclasses. */
  protected UnmodifiableIterator() {}

  /**

/**
 * Abstract base class for document ingesters that process and transform documents
 * before they are indexed. Ingesters can be used to modify document content,
 * extract additional metadata, or perform other transformations during the
 * indexing process.
 *
 * Ingesters are processed in priority order, with lower numbers having higher priority.
 */
public abstract class Ingester {

 *
 * @author Kurt Alfred Kluever
 * @since 10.0
 */
@J2ktIncompatible
@GwtIncompatible
public abstract class ForwardingExecutorService extends ForwardingObject
    implements ExecutorService {
  /** Constructor for use by subclasses. */
  protected ForwardingExecutorService() {}

  @Override
  protected abstract ExecutorService delegate();

  @CheckReturnValue
  @Override

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.client.http;

import org.codelibs.fess.crawler.client.AbstractCrawlerClient;

/**
 * HcHttpClient is the abstract base class for HTTP client implementations
 * using Apache HttpComponents. This class provides common constants and
 * configurations shared between HC4 and HC5 implementations.
 *
 * <p>Key properties and configurations:</p>

 * AbstractMapBasedMultimap} that converts the returned collections into {@code Lists}. The {@link
 * #createCollection} method must return a {@code List}.
 *
 * @author Jared Levy
 * @since 2.0
 */
@GwtCompatible
abstract class AbstractListMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMapBasedMultimap<K, V> implements ListMultimap<K, V> {
  /**
   * Creates a new multimap that uses the provided map.
   *

    protected String bulkTimeout = "3m";
    protected String deleteTimeout = "3m";
    protected String refreshTimeout = "1m";

    protected abstract String asEsIndex();

    protected abstract String asEsIndexType();

    protected abstract String asEsSearchType();

    protected abstract <RESULT extends ENTITY> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType);

 *
 * @author Kevin Bourrillion
 * @author Dimitris Andreou
 */
// TODO(kevinb): this class still needs some design-and-document-for-inheritance love
abstract class AbstractStreamingHasher extends AbstractHasher {
  /** Buffer via which we pass data to the hash algorithm (the implementor) */
  private final ByteBuffer buffer;

 *
 * @author Louis Wasserman
 */
public abstract class ForwardingSortedMultiset<E extends @Nullable Object>
    extends ForwardingMultiset<E> implements SortedMultiset<E> {
  /** Constructor for use by subclasses. */
  protected ForwardingSortedMultiset() {}

  @Override
  protected abstract SortedMultiset<E> delegate();

  @Override
  public SortedSet<E> elementSet() {

/**
 * Base test class providing common test infrastructure and utilities.
 * All test classes should extend this to ensure consistent test setup.
 */
@ExtendWith(MockitoExtension.class)
public abstract class BaseTest {

    protected final Logger logger = LoggerFactory.getLogger(getClass());

    @BeforeEach
    void baseSetUp() {
        // Common setup for all tests