}
    }

    void stopInterrupting() {
      shouldStop = true;
    }
  }

  /** Interrupts the current thread after sleeping for the specified delay. */
  static void requestInterruptIn(long time, TimeUnit unit) {
    checkNotNull(unit);
    Thread interruptee = Thread.currentThread();
    new Thread(
            new Runnable() {
              @Override
              public void run() {
                try {

            }
        }, 1, true);

        assertNotNull(TimeoutManager.getInstance().thread);
        Thread.sleep(2000);
        assertTrue(expiredCount > 0);
        assertEquals(1, TimeoutManager.getInstance().getTimeoutTaskCount());
        TimeoutManager.getInstance().stop();
        assertNull(TimeoutManager.getInstance().thread);
        Thread.sleep(10);
        int count = expiredCount;
        task.stop();

     *
     * @return the {@link UrlQueue} instance associated with the current thread, or {@code null} if none is set.
     */
    public static UrlQueue<?> getUrlQueue() {
        return URL_QUEUE_THREAD_LOCAL.get();
    }

    /**
     * Sets the URL queue for the current thread. If the provided URL queue is null,
     * the URL queue for the current thread is removed.
     *

            }

            // 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

  class Interruptenator extends Thread {
    final AtomicBoolean shutdown;

    Interruptenator(Thread interruptee) {
      this(interruptee, new AtomicBoolean(false));
    }

    @SuppressWarnings("ThreadPriorityCheck") // TODO: b/175898629 - Consider onSpinWait.
    Interruptenator(Thread interruptee, AtomicBoolean shutdown) {
      super(
          new Runnable() {

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

  public void testAddAfterRun() throws Exception {

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

    }

    @Test
    public void testThreadSafety() throws InterruptedException {
        // Test concurrent updates from multiple threads
        Thread[] threads = new Thread[10];

        for (int i = 0; i < threads.length; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 100; j++) {
                    String name = "file" + index + "_" + j + ".txt";

    assertThat(Thread.interrupted()).isTrue();
  }

  public void testInterrupt_doesNotInterruptSubsequentTask() throws Exception {
    // Run a task that interrupts its thread (i.e. this thread).
    e.execute(
        new Runnable() {
          @Override
          public void run() {
            Thread.currentThread().interrupt();
          }
        });

                }
            });
        }

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