Thread.sleep(5); // Small delay to ensure different timestamps
            Smb2LeaseKey key2 = limitedManager.requestLease("/share/file2.txt", Smb2LeaseState.SMB2_LEASE_READ_CACHING);
            Thread.sleep(5); // Small delay to ensure different timestamps

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
    }

    while (client.connectionPool.connectionCount() > 0) {
      Thread.sleep(1000)
    }
  }

  @Test
  fun testHttpRequest() {
    server.enqueue(MockResponse())
    server.start()

    val request = Request.Builder().url(server.url("/")).build()

      it is ResponseFailed

  private fun sleep(delayMillis: Int) {
    try {
      Thread.sleep(delayMillis.toLong())
    } catch (e: InterruptedException) {
      Thread.currentThread().interrupt()
    }
  }

  private fun cancelLater(
    call: Call,
    delayMillis: Int,
  ): CountDownLatch {
    val latch = CountDownLatch(1)
    Thread {
      sleep(delayMillis)
      if (cancelMode == CANCEL) {

    val request = Request(server.url("/"))
    val response1 = client.newCall(request).execute()
    assertThat(response1.body.string()).isEqualTo("a")

    // Give the thread pool a chance to evict.
    Thread.sleep(500)
    val response2 = client.newCall(request).execute()
    assertThat(response2.body.string()).isEqualTo("b")
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)

        assertFalse(registration.isExpired(60000));

        // Wait a bit to ensure some time has passed
        Thread.sleep(50);
        // Should be expired with very short timeout (shorter than sleep time)
        assertTrue(registration.isExpired(10));
    }

    @Test
    void testStateTransitions() {

   *       of a task are ignored.
   * </ol>
   *
   * <p>{@code RuntimeException}s thrown by tasks are simply logged and the executor keeps trucking.
   * If an {@code Error} is thrown, the error will propagate and execution will stop until the next
   * time a task is submitted.
   *

        // Create next index - this is the main method we're testing
        Thread.sleep(1000); // Wait before creating next index (following existing test pattern)
        suggester.createNextIndex();
        Thread.sleep(100);

        // Verify that createNextIndex completed without exceptions
        // The update alias should now point to the new index

        public String call() throws InterruptedException {
          MILLISECONDS.sleep(DELAY_MS);
          return GOOD_CALLABLE_RESULT;
        }
      };
  private static final Callable<String> BAD_CALLABLE =
      new Callable<String>() {
        @Override
        public String call() throws InterruptedException, SampleException {
          MILLISECONDS.sleep(DELAY_MS);
          throw new SampleException();
        }
      };

        // Wait for expiration
        Thread.sleep(150);

        // Should be expired now
        assertTrue(auth.isExpired());

        // Reset timestamp
        auth.resetAuthenticationTimestamp();
        assertFalse(auth.isExpired());

        // Test with no expiration (TTL = 0)
        auth.setAuthenticationTTL(0);
        Thread.sleep(100);
        assertFalse(auth.isExpired());

      this.everyMillis = everyMillis;
      this.interruptee = interruptee;
    }

    @Override
    public void run() {
      while (true) {
        try {
          Thread.sleep(everyMillis);
        } catch (InterruptedException e) {
          // ok. just stop sleeping.
        }
        if (shouldStop) {
          break;
        }
        interruptee.interrupt();
      }
    }