assertThat(inputStream.read()).isEqualTo(-1)
    val elapsedNanos = System.nanoTime() - startNanos
    val elapsedMillis = TimeUnit.NANOSECONDS.toMillis(elapsedNanos)
    assertThat(elapsedMillis).isBetween(500L, 1000L)
  }

  /**
   * Throttle the response body by sleeping 500ms after every 3 bytes. With a 6-byte response, this
   * should yield one sleep for a total delay of 500ms.
   */
  @Test

  public void testSetFuture_stackOverflow() {
    SettableFuture<String> orig = SettableFuture.create();
    SettableFuture<String> prev = orig;
    for (int i = 0; i < 100000; i++) {
      SettableFuture<String> curr = SettableFuture.create();
      prev.setFuture(curr);
      prev = curr;
    }
    // prev represents the 'innermost' future
    prev.set("done");

        assertEquals(2, conservativePolicy.getMaxAttempts());
        assertEquals(2000, conservativePolicy.getInitialDelayMs());
        assertEquals(10000, conservativePolicy.getMaxDelayMs());
        assertEquals(3.0, conservativePolicy.getBackoffMultiplier());
        assertTrue(conservativePolicy.isExponentialBackoff());

        // NO_RETRY policy

    // Backoff and timing constants (in ms)
    private static final long BASE_POLL_INTERVAL = 1000;
    private static final long MAX_POLL_INTERVAL = 30000;
    private static final long BASE_RETRY_DELAY = 1000;
    private static final long MAX_RETRY_DELAY = 30000;
    private static final int MAX_BACKOFF_SHIFT = 3; // Maximum 8 seconds (2^3 * 1000ms)

    private final DirectoryLeaseManager leaseManager;

        assertEquals(WitnessNotification.WitnessIPAddress.IPV6, newIPv6.getFlags());
    }

    @Test
    void testWitnessIPAddressFlags() throws Exception {
        InetAddress ipv4 = InetAddress.getByName("10.0.0.1");
        InetAddress ipv6 = InetAddress.getByName("fe80::1");

        WitnessNotification.WitnessIPAddress addr4 = new WitnessNotification.WitnessIPAddress(ipv4);

     */
    protected int thumbnailTaskQueueSize = 10000;

    /**
     * Number of tasks to process in bulk operations.
     */
    protected int thumbnailTaskBulkSize = 100;

    /**
     * Timeout in milliseconds for thumbnail task queue operations.
     */
    protected long thumbnailTaskQueueTimeout = 10 * 1000L;

    /**

        return Stream.of(Arguments.of(0x1234, 0L, new byte[] { 0x34, 0x12, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }),
                // negative fid wraps around, lastWriteTime = 1000 -> 1 second -> int value 1
                Arguments.of(-1, 1000L, new byte[] { (byte) 0xFF, (byte) 0xFF, 0x01, 0x00, 0x00, 0x00 }));
    }

    /**
     * When lastWriteTime is zero the encoded unsigned time must be all 1s.
     */
    @Test

    }

    /**
     * @throws Exception
     */
    @Test
    public void testPerformance() throws Exception {
        for (int j = 0; j < 3; ++j) {
            final int num = 100000;
            final Map<String, String> hmap = new HashMap<String, String>();
            final Map<String, String> cimap = new CaseInsensitiveMap<String>();

            long start = System.currentTimeMillis();

            buffer = new DfsReferralRequestBuffer(path, 3);

            byte[] dst = new byte[buffer.size()];

            // Perform many rapid encodes
            for (int i = 0; i < 10000; i++) {
                int bytesEncoded = buffer.encode(dst, 0);
                assertEquals(buffer.size(), bytesEncoded);
            }
        }

        @Test

            Long expiration = System.currentTimeMillis() + 10000L;
            echoResponse.setExpiration(expiration);

            assertEquals(expiration, echoResponse.getExpiration());
        }

        @Test
        @DisplayName("Should handle null expiration")
        void testNullExpiration() {
            Long expiration = 1000L;
            echoResponse.setExpiration(expiration);