import org.junit.rules.ExternalResource

class MockWebServer :
  ExternalResource(),
  Closeable {
  val delegate = mockwebserver3.MockWebServer()

  val requestCount: Int by delegate::requestCount

  var bodyLimit: Long by delegate::bodyLimit

  var serverSocketFactory: ServerSocketFactory? by delegate::serverSocketFactory

  var dispatcher: Dispatcher = QueueDispatcher()
    set(value) {
      field = value

  private static BigInteger oldSlowFactorial(int n1, int n2) {
    assert n1 <= n2;
    if (IntMath.log2(n2, CEILING) * (n2 - n1) < Long.SIZE - 1) {
      // the result will definitely fit into a long
      long result = 1;
      for (int i = n1 + 1; i <= n2; i++) {
        result *= i;
      }
      return BigInteger.valueOf(result);
    }

    /*

            return SmbFile.ATTR_READONLY | SmbFile.ATTR_DIRECTORY;
        }

        @Override
        public long createTime() {
            return 0L;
        }

        @Override
        public long lastModified() {
            return 0L;
        }

        @Override
        public long length() {
            return 0L;
        }

        @Override
        public String toString() {

    /**
     * The archive stream factory.
     */
    @Resource
    protected ArchiveStreamFactory archiveStreamFactory;

    /**
     * The maximum content size.
     */
    protected long maxContentSize = -1;

    /**
     * Creates a new ZipExtractor instance.
     */
    public ZipExtractor() {
        super();
    }

    @Override

     * Retry policy for handling transient failures
     */
    public static class RetryPolicy implements Serializable {
        private static final long serialVersionUID = 1L;

        private final int maxAttempts;
        private final long initialDelayMs;
        private final long maxDelayMs;
        private final double backoffMultiplier;
        private final boolean exponentialBackoff;

        // Test with MAX_VALUE
        long maxMid = Long.MAX_VALUE;
        doNothing().when(messageBlock).setMid(maxMid);
        when(messageBlock.getMid()).thenReturn(maxMid);

        messageBlock.setMid(maxMid);
        assertEquals(maxMid, messageBlock.getMid());

        // Test with MIN_VALUE
        long minMid = Long.MIN_VALUE;
        doNothing().when(messageBlock).setMid(minMid);

 */
@GwtCompatible
final class LongAdder extends Striped64 implements Serializable, LongAddable {
  @GwtIncompatible @J2ktIncompatible   private static final long serialVersionUID = 7249069246863182397L;

  /** Version of plus for use in retryUpdate */
  @Override
  final long fn(long v, long x) {
    return v + x;
  }

  /** Creates a new adder with initial sum of zero. */
  public LongAdder() {}

  /**
   * Adds the given value.

    }
  }

  /** A view of a subsection of the containing byte source. */
  private final class SlicedByteSource extends ByteSource {

    final long offset;
    final long length;

    SlicedByteSource(long offset, long length) {
      checkArgument(offset >= 0, "offset (%s) may not be negative", offset);
      checkArgument(length >= 0, "length (%s) may not be negative", length);

  /**
   * @since 15.0 (previously returned ScheduledFuture)
   */
  @Override
  ListenableScheduledFuture<?> scheduleAtFixedRate(
      Runnable command, long initialDelay, long period, TimeUnit unit);

  /**
   * Duration-based overload of {@link #scheduleAtFixedRate(Runnable, long, long, TimeUnit)}.
   *
   * @since 29.0
   */
  @J2ktIncompatible
  default ListenableScheduledFuture<?> scheduleAtFixedRate(

        return this;
    }

    public void setCreatedTime_Equal(Long createdTime) {
        setCreatedTime_Term(createdTime, null);
    }

    public void setCreatedTime_Equal(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setCreatedTime_Term(createdTime, opLambda);
    }

    public void setCreatedTime_Term(Long createdTime) {
        setCreatedTime_Term(createdTime, null);
    }