private Boolean explain;

        private Float minScore;

        private String preference;

        private String routing;

        private String searchType;

        private long timeoutInMillis = -1;

        private Boolean version;

        private Boolean seqNoAndPrimaryTerm = Boolean.TRUE;

        private int terminateAfter = 0;

    }
  }

  private static class ExpectedHashCode {
    final byte[] bytes;
    final int asInt;
    final Long asLong; // null means that asLong should throw an exception
    final String toString;

    ExpectedHashCode(byte[] bytes, int asInt, @Nullable Long asLong, String toString) {
      this.bytes = bytes;
      this.asInt = asInt;
      this.asLong = asLong;
      this.toString = toString;

      return super.hashCode();
    }

    @Override
    public V setValue(V value) {
      assertTrue(Thread.holdsLock(mutex));
      return super.setValue(value);
    }

    private static final long serialVersionUID = 0;
  }

  static class TestMap<K, V> extends SynchronizedMapTest.TestMap<K, V>
      implements NavigableMap<K, V> {

    public TestMap(NavigableMap<K, V> delegate, Object mutex) {

 *
 * @param <L> the type of the lock-like object to be used
 * @author Justin T. Sampson
 */
public final class TestThread<L> extends Thread implements TearDown {

  private static final long DUE_DILIGENCE_MILLIS = 100;
  private static final long TIMEOUT_MILLIS = 5000;

  private final L lockLikeObject;

  private final SynchronousQueue<Request> requestQueue = new SynchronousQueue<>();

  public int hashCode() {
    return elementEquivalence.hashCode() ^ 0x46a3eb07;
  }

  @Override
  public String toString() {
    return elementEquivalence + ".pairwise()";
  }

  private static final long serialVersionUID = 1;

    }

    @Override
    public int end() {
      return matcher.end();
    }

    @Override
    public int start() {
      return matcher.start();
    }
  }

  private static final long serialVersionUID = 0;

    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer depth;

    @Min(value = 0)
    @Max(value = 9223372036854775807L)
    @ValidateTypeFailure
    public Long maxAccessCount;

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

public class WebApiException extends FessSystemException {

    private static final long serialVersionUID = 1L;

    private final int statusCode;

    public int getStatusCode() {
        return statusCode;
    }

  fun delegate(): RequestBody {
    return delegate
  }

  override fun contentType(): MediaType? {
    return delegate.contentType()
  }

  @Throws(IOException::class)
  override fun contentLength(): Long {
    return delegate.contentLength()
  }

  @Throws(IOException::class)
  override fun writeTo(sink: BufferedSink) {
    delegate.writeTo(sink)
  }

  override fun isDuplex(): Boolean {

    super(cause);
  }

  public UncheckedTimeoutException(@CheckForNull String message, @CheckForNull Throwable cause) {
    super(message, cause);
  }

  private static final long serialVersionUID = 0;