}

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

        // Test thread safety with concurrent operations
        final int threadCount = 10;
        Thread[] threads = new Thread[threadCount];
        final boolean[] results = new boolean[threadCount];

        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                String thumbnailId = "concurrent-" + index;

      takeEvent()
    }
  }

  private fun logEvent(e: ConnectionEvent) {
    if (e.connection != null) {
      assertThat(Thread.holdsLock(e.connection), "Called with lock $${e.connection}")
        .isFalse()
    }
    for (lock in forbiddenLocks) {
      assertThat(Thread.holdsLock(lock), "Called with lock $lock")
        .isFalse()
    }

    if (enforceOrder) {
      checkForStartEvent(e)
    }

  /**
   * Returns an exception handler that exits the system. This is particularly useful for the main
   * thread, which may start up other, non-daemon threads, but fail to fully initialize the
   * application successfully.
   *
   * <p>Example usage:
   *
   * <pre>
   * public static void main(String[] args) {
   *   Thread.currentThread().setUncaughtExceptionHandler(UncaughtExceptionHandlers.systemExit());
   *   ...
   * </pre>
   *

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

        // Test thread safety
        final int threadCount = 10;
        final int docsPerThread = 10;
        final List<Thread> threads = new ArrayList<>();
        final AtomicInteger successCount = new AtomicInteger(0);

        for (int i = 0; i < threadCount; i++) {
            final int threadId = i;
            Thread thread = new Thread(() -> {

            }

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

            // Then
            for (int i = 0; i < threadCount; i++) {
                assertTrue(success[i], "Thread " + i + " failed");
            }
        }

        @Test

          @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());
  }

                threads[i].start();
            }

            // Wait for all threads to complete
            for (Thread thread : threads) {
                thread.join();
            }
        }

        // Then
        for (int i = 0; i < threadCount; i++) {
            assertTrue(results[i], "Thread " + i + " should have completed successfully");
        }
    }

    @Test

@J2ktIncompatible
@GwtIncompatible
public final class JdkFutureAdapters {
  /**
   * Assigns a thread to the given {@link Future} to provide {@link ListenableFuture} functionality.
   *
   * <p><b>Warning:</b> If the input future does not already implement {@code ListenableFuture}, the
   * returned future will emulate {@link ListenableFuture#addListener} by taking a thread from an