}
  }

  /** Confirm all tasks have completed. Used by the test thread only. */
  fun assertNoMoreTasks() {
    taskRunner.assertLockNotHeld()

    taskRunner.withLock {
      assertThat(activeThreads).isEqualTo(0)
    }
  }

  /** Unblock a waiting task thread. Used by the test thread only. */
  fun interruptCoordinatorThread() {
    taskRunner.assertLockNotHeld()

    String oldName = Thread.currentThread().getName();
    Supplier<String> newName = Suppliers.ofInstance("MyCrazyThreadName");
    Callable<@Nullable Void> callable =
        () -> {
          assertThat(Thread.currentThread().getName()).isEqualTo(newName.get());
          return null;
        };
    Callables.threadRenaming(callable, newName).call();
    assertThat(Thread.currentThread().getName()).isEqualTo(oldName);
  }

    String oldName = Thread.currentThread().getName();
    Supplier<String> newName = Suppliers.ofInstance("MyCrazyThreadName");
    Callable<@Nullable Void> callable =
        () -> {
          assertThat(Thread.currentThread().getName()).isEqualTo(newName.get());
          return null;
        };
    Callables.threadRenaming(callable, newName).call();
    assertThat(Thread.currentThread().getName()).isEqualTo(oldName);
  }

     *
     * 1. The client thread begins to block on a get() call to a future.
     * 2. The client thread is interrupted sometime before the result would be
     *   available.
     * 3. We expect the client's get() to throw an InterruptedException.
     * 4. We expect the client thread's interrupt state to be false.
     * 5. The client thread again makes a blocking call to get().

            monitor.leave();
          }
        });
    awaitUninterruptibly(enteredLatch);
  }

  @CanIgnoreReturnValue
  static Thread startThread(Runnable runnable) {
    Thread thread = new Thread(runnable);
    thread.setDaemon(true);
    thread.start();
    return thread;
  }

  /**
   * Generates a test case verifying that calling any enterXxx, tryEnterXxx, or waitForXxx method

      }
    }
  }

  private static class Interrupter implements Runnable {
    final Thread threadToInterrupt;

    Interrupter(Thread threadToInterrupt) {
      this.threadToInterrupt = threadToInterrupt;
    }

    @Override
    public void run() {
      try {
        Thread.sleep(100);
      } catch (InterruptedException e) {
        throw new AssertionError();
      } finally {

        // Trip circuit
        circuitBreaker.trip();
        Thread.sleep(100);

        long afterTripTime = circuitBreaker.getTimeSinceLastStateChange();
        assertTrue(afterTripTime >= 100, "Time should have advanced");
        assertTrue(afterTripTime < 200, "Time should be reasonable");

        // Reset circuit
        circuitBreaker.reset();
        Thread.sleep(50);

  }

  /**
   * Wraps the given callable such that for the duration of {@link Callable#call} the thread that is
   * running will have the given name.
   *
   * @param callable The callable to wrap
   * @param nameSupplier The supplier of thread names, {@link Supplier#get get} will be called once
   *     for each invocation of the wrapped callable.
   */
  @J2ktIncompatible

    // Run a task on the composed Executor that interrupts its thread (i.e. this thread).
    fakePool.execute(() -> Thread.currentThread().interrupt());
    // Run a task that expects that it is not interrupted while it is running.
    e.execute(() -> assertThat(Thread.currentThread().isInterrupted()).isFalse());

    // Run these together.
    fakePool.runAll();

                }
            });
        }

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