};
        assertEquals(Long.valueOf(31556926000L), yearEnv.getTimeAdjustTimeMillisAsLong());

        // Test maximum long value
        FessEnv.SimpleImpl maxEnv = new FessEnv.SimpleImpl() {
            protected Properties prepareProperties() {
                Properties props = new Properties();
                props.setProperty(FessEnv.TIME_ADJUST_TIME_MILLIS, String.valueOf(Long.MAX_VALUE));
                return props;

     * @param length length of buffer
     */
    public Smb2RdmaTransform(long offset, int token, int length) {
        this.offset = offset;
        this.token = token;
        this.length = length;
    }

    /**
     * Get buffer offset
     *
     * @return offset within registered buffer
     */
    public long getOffset() {
        return offset;
    }

    /**
     * Get RDMA token
     *

    abstract long gcdLong(long a, long b);

    abstract boolean noAddOverflow(int a, int b);

    abstract boolean noAddOverflow(long a, long b);

    abstract boolean noMulOverflow(int a, int b);

    abstract boolean noMulOverflow(long a, long b);
  }

  private final int[] factorials = new int[ARRAY_SIZE];
  private final int[][] binomials = new int[ARRAY_SIZE][2];

        private final int attributes;
        private final long createTime;
        private final long lastWriteTime;
        private final long lastAccessTime;
        private final long size;

        TestInfo(int attributes, long createTime, long lastWriteTime, long lastAccessTime, long size) {
            this.attributes = attributes;
            this.createTime = createTime;

   */
  public long sum() {
    return map.values().stream().mapToLong(Long::longValue).sum();
  }

  @LazyInit private transient @Nullable Map<K, Long> asMap;

  /** Returns a live, read-only view of the map backing this {@code AtomicLongMap}. */
  public Map<K, Long> asMap() {
    Map<K, Long> result = asMap;
    return (result == null) ? asMap = createAsMap() : result;

    protected List<String> commandList;

    /** Timeout for command execution in milliseconds. */
    protected long commandTimeout = 30 * 1000L;// 30sec

    /** Timeout for destroying processes in milliseconds. */
    protected long commandDestroyTimeout = 5 * 1000L;// 5sec

    /** Base directory for command execution. */
    protected File baseDir;

        // When - Calculate delays for increasing attempts
        long delay1 = policy.getDelayMs(1);
        long delay2 = policy.getDelayMs(2);
        long delay3 = policy.getDelayMs(3);
        long delay4 = policy.getDelayMs(4);
        long delay10 = policy.getDelayMs(10);

        // Then
        assertEquals(1000, delay1);
        assertEquals(2000, delay2);

internal class ThrottledSink(
  private val socket: MockWebServerSocket,
  private val delegate: Sink,
  private val bytesPerPeriod: Long,
  private val periodDelayNanos: Long,
) : Sink by delegate {
  private var bytesWrittenSinceLastDelay = 0L

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    var bytesLeft = byteCount

    while (bytesLeft > 0) {
      if (bytesWrittenSinceLastDelay == bytesPerPeriod) {

  /* Helper function to make a Long value from an Integer. */
  private static final Function<Integer, Long> TO_LONG =
      new Function<Integer, Long>() {
        @Override
        public Long apply(Integer n) {
          return Long.valueOf(n);
        }
      };

  /* Helper function to make a BigInteger value from a Long. */
  private static final Function<Long, BigInteger> TO_BIGINTEGER =

    Helpers.testComparator(comparator, ordered);
  }

  public void testSort() {
    testSort(new long[] {}, new long[] {});
    testSort(new long[] {2}, new long[] {2});
    testSort(new long[] {2, 1, 0}, new long[] {0, 1, 2});
    testSort(new long[] {2, GREATEST, 1, LEAST}, new long[] {LEAST, 1, 2, GREATEST});
  }