}

    @Override
    public @Nullable Long previous(Long value) {
      long l = value;
      return (l == Long.MIN_VALUE) ? null : l - 1;
    }

    @Override
    Long offset(Long origin, long distance) {
      checkNonnegative(distance, "distance");
      long result = origin + distance;
      if (result < 0) {
        checkArgument(origin < 0, "overflow");
      }
      return result;
    }

  /** Invokes {@code unit.}{@link TimeUnit#sleep(long) sleep(sleepFor)} uninterruptibly. */
  @J2ktIncompatible
  @GwtIncompatible // concurrency
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public static void sleepUninterruptibly(long sleepFor, TimeUnit unit) {
    boolean interrupted = false;
    try {
      long remainingNanos = unit.toNanos(sleepFor);
      long end = System.nanoTime() + remainingNanos;

   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  // We use this method only for cases in which we need to decompose to primitives.

   * 0} and {@code 2^64 - 1} inclusive.
   *
   * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated; use the
   * equivalent {@link Long#compareUnsigned(long, long)} method instead.
   *
   * @param a the first unsigned {@code long} to compare
   * @param b the second unsigned {@code long} to compare

  //             TreeSubSetTest.suite());
  //     }

  public static long SHORT_DELAY_MS;
  public static long SMALL_DELAY_MS;
  public static long MEDIUM_DELAY_MS;
  public static long LONG_DELAY_MS;

  /**
   * Returns the shortest timed delay. This could be reimplemented to use for example a Property.
   */
  protected long getShortDelay() {
    return 50;
  }

   *     wrap(String.class) == String.class
   * </pre>
   */
  public static <T> Class<T> wrap(Class<T> type) {
    checkNotNull(type);

    // cast is safe: long.class and Long.class are both of type Class<Long>
    @SuppressWarnings("unchecked")
    Class<T> wrapped = (Class<T>) PRIMITIVE_TO_WRAPPER_TYPE.get(type);
    return (wrapped == null) ? type : wrapped;
  }

  /**

    }

  fun throttleBody(
    bytesPerPeriod: Long,
    period: Long,
    unit: TimeUnit,
  ) = apply {
    throttleBytesPerPeriod = bytesPerPeriod
    throttlePeriodAmount = period
    throttlePeriodUnit = unit
  }

  fun getThrottlePeriod(unit: TimeUnit): Long = unit.convert(throttlePeriodAmount, throttlePeriodUnit)

  fun setBodyDelay(
    delay: Long,
    unit: TimeUnit,
  ) = apply {

 * maximumSize}, {@link #maximumWeight(long) maximumWeight}, {@link #expireAfterWrite
 * expireAfterWrite}, {@link #expireAfterAccess expireAfterAccess}, {@link #weakKeys weakKeys},
 * {@link #weakValues weakValues}, or {@link #softValues softValues} are requested.
 *
 * <p>If {@link #maximumSize(long) maximumSize} or {@link #maximumWeight(long) maximumWeight} is

  }

  data class ConnectionClosed(
    override val timestampNs: Long,
    override val connection: Connection,
  ) : ConnectionEvent()

  data class ConnectionAcquired(
    override val timestampNs: Long,
    override val connection: Connection,
    val call: Call,
  ) : ConnectionEvent()

  data class ConnectionReleased(
    override val timestampNs: Long,
    override val connection: Connection,
    val call: Call,

      }
      return bufferedSource;
    }

    private Source source(Source source) {
      return new ForwardingSource(source) {
        long totalBytesRead = 0L;

        @Override public long read(Buffer sink, long byteCount) throws IOException {
          long bytesRead = super.read(sink, byteCount);
          // read() returns the number of bytes read, or -1 if this source is exhausted.