// we try hard to make them robust in practice.  We could additionally try to add in a system
    // load timeout multiplier.  Or we could try to use a CPU time bound instead of wall clock time
    // bound.  But these ideas are harder to implement.  We do not try to detect or handle a
    // user-specified -XX:+DisableExplicitGC.
    //
    // TODO(user): Consider using

                        }
                    });
                }

                startLatch.countDown(); // Start all threads simultaneously
                assertTrue("Concurrent registration timed out", endLatch.await(10, TimeUnit.SECONDS));

                // Verify all searchers were registered (1 initial + numThreads * searchersPerThread)
                assertEquals(numThreads * searchersPerThread, registeredCount.get());

  private static void runUntimedInterruptsTest(int times)
      throws InterruptedException, ExecutionException, TimeoutException {
    SettableFuture<String> future = SettableFuture.create();
    FutureTask<Boolean> interruptReporter = untimedInterruptReporter(future, false);

    runNInterruptsTest(times, future, interruptReporter);
  }

  private static void runTimedInterruptsTest(int times)

  private static void runUntimedInterruptsTest(int times)
      throws InterruptedException, ExecutionException, TimeoutException {
    SettableFuture<String> future = SettableFuture.create();
    FutureTask<Boolean> interruptReporter = untimedInterruptReporter(future, false);

    runNInterruptsTest(times, future, interruptReporter);
  }

  private static void runTimedInterruptsTest(int times)

        // Scenario 2: Command timeout
        CommandExecutionException timeout =
                new CommandExecutionException("Command execution timed out after 30 seconds", new RuntimeException("Timeout"));
        assertTrue(timeout.getMessage().contains("timed out"));
        assertNotNull(timeout.getCause());

        // Scenario 3: Permission denied

   * @param timeout the maximum time to wait for the {@code ExecutorService} to terminate
   * @return {@code true} if the {@code ExecutorService} was terminated successfully, {@code false}
   *     if the call timed out or was interrupted
   * @since 33.4.0 (but since 28.0 in the JRE flavor)
   */
  @CanIgnoreReturnValue
  @J2ktIncompatible
  @GwtIncompatible // java.time.Duration

   */
  private static TestCase generateGuardWithWrongMonitorTestCase(
      Method method, boolean fair1, boolean fair2) {
    boolean timed = isTimed(method); // Not going to bother with all timeouts, just 0ms.
    return new TestCase(method.getName() + (timed ? "(0ms)" : "()") + "/WrongMonitor->IMSE") {
      @Override
      protected void runTest() throws Throwable {
        Monitor monitor1 = new Monitor(fair1);

                throw new RuntimeException("Operation timed out after 30 seconds");
            }
        };
        ComponentUtil.register(searchEngineClient, "searchEngineClient");

        // Execute the job
        String result = purgeDocJob.execute();

        // Assert error message is in the result
        assertTrue(result.contains("Operation timed out after 30 seconds"));
    }

    @Test

            }

            if (p.waitFor(commandTimeout + commandDestroyTimeout, TimeUnit.MILLISECONDS)) {
                if (task.isExecuted()) {
                    // Process was killed by the timer.
                    logger.warn("{} was timed out and destroyed.", getName());
                } else {
                    // Process finished normally.
                    final int exitValue = p.exitValue();

        };
    TimeoutException e =
        assertThrows(
            TimeoutException.class, () -> service.startAsync().awaitRunning(1, MILLISECONDS));
    assertThat(e)
        .hasMessageThat()
        .isEqualTo("Timed out waiting for Foo [STARTING] to reach the RUNNING state.");
  }

  private static class TestService extends AbstractIdleService {
    int startUpCalled = 0;
    int shutDownCalled = 0;