}

  /**
   * Returns a new, empty builder for {@link ImmutableIntArray} instances, sized to hold up to
   * {@code initialCapacity} values without resizing. The returned builder is not thread-safe.
   *
   * <p><b>Performance note:</b> When feasible, {@code initialCapacity} should be the exact number
   * of values that will be added, if that knowledge is readily available. It is better to guess a

    assertFalse(future.isDone());
    assertFalse(future.isCancelled());

    CountDownLatch successLatch = new CountDownLatch(1);

    // Run cancellation in a separate thread as an extra thread-safety test.
    new Thread(
            () -> {
              assertThrows(CancellationException.class, future::get);
              successLatch.countDown();
            })
        .start();

        ThreadFactory threadFactory = r -> {
            Thread t = new Thread(r, "ResourceManager-Cleanup");
            t.setDaemon(true);
            return t;
        };
        cleanupExecutor = Executors.newSingleThreadScheduledExecutor(threadFactory);

        // Add shutdown hook for cleanup
        Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown, "ResourceManager-Shutdown"));

        indexUpdater.start();

        // Give the thread time to process exceptions
        Thread.sleep(2000);

        // Clean up the thread
        indexUpdater.setFinishCrawling(true);
        indexUpdater.interrupt();
        indexUpdater.join(2000);

        // Test passes if no exception is thrown and thread terminates properly
        assertFalse("Thread should have terminated", indexUpdater.isAlive());
    }

    }

    public void test_setIndexUpdaterPriority() {
        int priority = Thread.MAX_PRIORITY;
        webFsIndexHelper.setIndexUpdaterPriority(priority);
        assertEquals(priority, webFsIndexHelper.indexUpdaterPriority);
    }

    public void test_setIndexUpdaterPriority_withMinValue() {
        int priority = Thread.MIN_PRIORITY;
        webFsIndexHelper.setIndexUpdaterPriority(priority);

    void testConcurrentAccess() throws InterruptedException {
        // Test thread safety of getInstance
        LogStream.setInstance(testStream);

        final LogStream[] instances = new LogStream[10];
        Thread[] threads = new Thread[10];

        for (int i = 0; i < threads.length; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                instances[index] = LogStream.getInstance();

                null);

        assertFalse(durableInfo.isExpired());

        // Wait for expiration
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        assertTrue(durableInfo.isExpired());

        // Test persistent handle (never expires)

          @Override
          public void run() {
            list.execute();
          }
        };
    Thread thread1 = new Thread(execute);
    Thread thread2 = new Thread(execute);
    thread1.start();
    thread2.start();
    assertEquals(0, runCalled.get());
    okayToRun.countDown();
    thread1.join();
    thread2.join();
    assertEquals(1, runCalled.get());
  }

   * which is still better than alternatives.
   *
   * Per-thread hash codes are initialized to random values.
   * Contention and/or table collisions are indicated by failed
   * CASes when performing an update operation (see method
   * retryUpdate). Upon a collision, if the table size is less than
   * the capacity, it is doubled in size unless some other thread
   * holds the lock. If a hashed slot is empty, and lock is

        for (Thread thread : threads) {
            thread.join();
        }

        // Check all providers were created successfully
        for (int i = 0; i < threadCount; i++) {
            assertNull("Thread " + i + " threw exception", exceptions[i]);
            assertNotNull("Thread " + i + " failed to create provider", providers[i]);
        }
    }

    // Test with very large time adjustment values