@RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  private val listener = RecordingConnectionListener()
  private val handshakeCertificates = localhost()

  open val fastFallback: Boolean get() = true

  private var client: OkHttpClient =
    clientTestRule
      .newClientBuilder()

  /** Logger to log exceptions caught when running runnables. */
  private static final LazyLogger log = new LazyLogger(ExecutionList.class);

  private final Object lock = new Object();

  /**
   * The runnable, executor pairs to execute. This acts as a stack threaded through the {@link
   * RunnableExecutorPair#next} field.
   */
  @GuardedBy("lock")
  private @Nullable RunnableExecutorPair runnables;

  @GuardedBy("lock")

        Thread.yield();
      }
    }

    private boolean isBlocked() {
      return getState() == Thread.State.WAITING && LockSupport.getBlocker(this) == future;
    }
  }

  static final class TimedWaiterThread extends Thread {
    private final AbstractFuture<?> future;
    private final long timeout;
    private final TimeUnit unit;
    private Exception exception;
    private volatile long startTime;

  // but types are typically only Comparable to themselves).
  @SuppressWarnings({"rawtypes", "unchecked"})
  private static MultimapBuilderWithKeys<Comparable<?>> rawtypeToWildcard(
      MultimapBuilderWithKeys<Comparable> treeKeys) {
    return (MultimapBuilderWithKeys) treeKeys;
  }

  @SuppressWarnings({"rawtypes", "unchecked"})
  private static <K extends @Nullable Object>
      SortedSetMultimapBuilder<K, Comparable<?>> rawtypeToWildcard(

import org.codelibs.fess.util.ComponentUtil;

/**
 * @author FreeGen
 */
public class User extends BsUser implements FessUser {

    private static final long serialVersionUID = 1L;

    private String originalPassword;

    private Map<String, String> attributes;

    public Long getVersionNo() {
        return asDocMeta().version();
    }

    public void setVersionNo(final Long version) {

public class DocList extends ArrayList<Map<String, Object>> {

    /** Serial version UID for serialization */
    private static final long serialVersionUID = 1L;

    /** Total content size of all documents in this list */
    private long contentSize = 0;

    /** Total processing time for all documents in this list */
    private long processingTime = 0;

    /**
     * Default constructor for DocList.

 * propagated out from the {@link Flushables#flush} method if {@code swallowException} is true.
 *
 * @author Michael Lancaster
 */
@NullUnmarked
public class FlushablesTest extends TestCase {
  private Flushable mockFlushable;

  public void testFlush_clean() throws IOException {
    // make sure that no exception is thrown regardless of value of
    // 'swallowException' when the mock does not throw an exception.

 *
 * @see java.io.Serializable
 */
public class RequestHeader implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * The name of the request header.
     */
    private String name;

    /**
     * The value of the request header.
     */
    private String value;

    /**
     * Constructs a new RequestHeader with the specified name and value.
     *

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Thread)
@Fork(value = 1)
public class BytesArrayReadLongBenchmark {

    @Param(value = { "1" })
    private int dataMb;

    private BytesReference bytesArray;

    private StreamInput streamInput;

    @Setup
    public void initResults() throws IOException {
        final BytesStreamOutput tmp = new BytesStreamOutput();

@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Thread)
@Fork(value = 1)
public class PagedBytesReferenceReadLongBenchmark {

    @Param(value = { "1" })
    private int dataMb;

    private BytesReference pagedBytes;

    private StreamInput streamInput;

    @Setup
    public void initResults() throws IOException {
        final BytesStreamOutput tmp = new BytesStreamOutput();