// 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);

   * {@code long} value in little-endian order.
   *
   * @throws IllegalStateException if {@code bits() < 64}
   */
  public abstract long asLong();

  /**
   * If this hashcode has enough bits, returns {@code asLong()}, otherwise returns a {@code long}
   * value with {@code asBytes()} as the least-significant bytes and {@code 0x00} as the remaining

    public String updatedBy;

    /**
     * The timestamp when this elevate word configuration was last updated.
     * Stored as a long value representing milliseconds since epoch.
     * Used for audit trail and concurrency control.
     */
    @ValidateTypeFailure
    public Long updatedTime;

    /**
     * The version number of the elevate word configuration for optimistic locking.

    }

    /**
     * Test close(long) successfully.
     *
     * @throws CIFSException
     */
    @Test
    void testCloseWithLastWriteTime_success() throws CIFSException {
        long lastWriteTime = System.currentTimeMillis();
        smbFileHandle.close(lastWriteTime);
        verify(smbFileHandle, times(1)).close(lastWriteTime);
    }

    /**
     * Test close(long) when a CIFSException is thrown.
     *

    ArrayList<Future<Long>> futures = new ArrayList<>();
    for (int i = 0; i < nTasks; i++) {
      futures.add(
          threadPool.submit(
              new Callable<Long>() {
                @Override
                public Long call() {
                  long threadSum = 0;
                  for (int j = 0; j < getsPerTask; j++) {
                    long delta = random.nextInt(deltaRange);

        virtualHostHelper = new VirtualHostHelper();
    }

    public void test_getVirtualHostPath() {
        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            private static final long serialVersionUID = 1L;

            @Override
            public Tuple3<String, String, String>[] getVirtualHosts() {

     */
    private final long timeout;

    /**
     * The timestamp when this handle was created
     */
    private final long createTime;

    /**
     * The timestamp of the last access to this handle
     */
    private volatile long lastAccessTime;

    /**
     * The associated lease key if this handle has an SMB2 lease
     */

    }

    public void test_edgeCases() {
        // Test with maximum values
        searchRenderData.setAllRecordCount(Long.MAX_VALUE);
        searchRenderData.setCurrentStartRecordNumber(Long.MAX_VALUE - 10);
        searchRenderData.setCurrentEndRecordNumber(Long.MAX_VALUE);
        searchRenderData.setPageSize(Integer.MAX_VALUE);
        searchRenderData.setAllPageCount(Integer.MAX_VALUE);

  public val onResponseBody: SocketEffect?
  public val onResponseEnd: SocketEffect?
  public val shutdownServer: Boolean

  public val headersDelayNanos: Long
  public val bodyDelayNanos: Long
  public val trailersDelayNanos: Long

  /** The streams the server will push with this response. */
  public val pushPromises: List<PushPromise>

  public val settings: Settings

  public constructor(
    code: Int = 200,

  @Throws(Exception::class)
  fun run() {
    val progressListener =
      object : ProgressListener {
        private var firstUpdate = true

        override fun update(
          bytesWritten: Long,
          contentLength: Long,
          done: Boolean,
        ) {
          if (done) {
            println("completed")
          } else {
            if (firstUpdate) {
              firstUpdate = false