// Multiple threads read the lastLoadedTime
        for (int i = 0; i < 10; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                observedTimes[index] = testFactory.lastLoadedTime;
            });
        }

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

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

   * intentionally, so there is no other way to clean up these threads. (The better solution,
   * though, would be to run the tests that use TestThread in separate VMs so that their threads
   * don't hang around during other tests.)
   */
  @Override
  public void tearDown() throws Exception {
    try {
      Thread.class.getMethod("stop").invoke(this);
      join();

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

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

  }

  @J2ktIncompatible
  @GwtIncompatible // threads
  public void testRenaming() throws Exception {
    String oldName = Thread.currentThread().getName();
    Supplier<String> newName = Suppliers.ofInstance("MyCrazyThreadName");
    Callable<@Nullable Void> callable =
        () -> {
          assertThat(Thread.currentThread().getName()).isEqualTo(newName.get());
          return null;
        };

  }

  @J2ktIncompatible
  @GwtIncompatible // threads
  public void testRenaming() throws Exception {
    String oldName = Thread.currentThread().getName();
    Supplier<String> newName = Suppliers.ofInstance("MyCrazyThreadName");
    Callable<@Nullable Void> callable =
        () -> {
          assertThat(Thread.currentThread().getName()).isEqualTo(newName.get());
          return null;
        };

                }
            });
        }

        // Start all threads
        for (Thread thread : threads) {
            thread.start();
        }

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

        // Verify no errors occurred during concurrent execution
        assertFalse(hasError.get());

  /** Returns a new started daemon Thread running the given runnable. */
  final Thread newStartedThread(Runnable runnable) {
    Thread t = new Thread(runnable);
    t.setDaemon(true);
    t.start();
    return t;
  }

  /**
   * Waits for the specified time (in milliseconds) for the thread to terminate (using {@link
   * Thread#join(long)}), else interrupts the thread (in the hope that it may terminate later) and

            });
        }

        // Start all threads
        for (Thread thread : threads) {
            thread.start();
        }

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

        // All results should be the same
        String expectedValue = "Test Fess";
        for (String result : results) {

        // Verify that thread dump was processed
        assertFalse("Should capture some thread dump output", capturedOutput.isEmpty());

        // Verify format - should contain "Thread:" entries
        boolean hasThreadEntry = capturedOutput.stream().anyMatch(line -> line.startsWith("Thread:"));
        assertTrue("Should contain Thread: entries", hasThreadEntry);

  /** Returns a new started daemon Thread running the given runnable. */
  final Thread newStartedThread(Runnable runnable) {
    Thread t = new Thread(runnable);
    t.setDaemon(true);
    t.start();
    return t;
  }

  /**
   * Waits for the specified time (in milliseconds) for the thread to terminate (using {@link
   * Thread#join(long)}), else interrupts the thread (in the hope that it may terminate later) and