interruptingThread.interrupt();
            joinUninterruptibly(interruptingThread, 2500, MILLISECONDS);
            Thread.interrupted();
            if (interruptingThread.isAlive()) {
              // This will be hidden by test-output redirection:
              logger.severe("InterruptenatorTask did not exit; future tests may be affected");
              /*

        indexUpdater.indexingHelper = indexingHelper;
    }

    @Override
    public void tearDown() throws Exception {
        if (indexUpdater != null && indexUpdater.isAlive()) {
            indexUpdater.setFinishCrawling(true);
            indexUpdater.interrupt();
            indexUpdater.join(1000);
        }
        super.tearDown();
    }

    // Test initialization

        } finally {
            if (task != null) {
                task.cancel();
            }
            if (p != null && p.isAlive()) {
                logger.warn("Process {} is still alive in finally block. Forcing destruction.", p);
                if (task == null) {
                    task = new ProcessDestroyer(p, ist, commandDestroyTimeout);

            interruptingThread.interrupt();
            joinUninterruptibly(interruptingThread, 2500, MILLISECONDS);
            Thread.interrupted();
            if (interruptingThread.isAlive()) {
              // This will be hidden by test-output redirection:
              logger.severe("InterruptenatorTask did not exit; future tests may be affected");
              /*

        InputStreamThread thread = jobProcess.getInputStreamThread();

        assertEquals("InputStreamThread", thread.getName());
        assertFalse("Thread should not be started yet", thread.isAlive());
    }

    public void test_processAssignment() throws IOException {
        Process mockProcess = createMockProcess("assignment test");
        JobProcess jobProcess = new JobProcess(mockProcess);

     */
    public boolean isProcessRunning(final String sessionId) {
        final JobProcess jobProcess = runningProcessMap.get(sessionId);
        return jobProcess != null && jobProcess.getProcess().isAlive();
    }

    /**
     * Internal method to destroy a specific JobProcess.
     * Handles cleanup of streams, threads, and process termination.
     *

        } catch (final Throwable t) {
            logger.error("Crawler does not work correctly.", t);
            exitCode = Constants.EXIT_FAIL;
        } finally {
            if (commandThread != null && commandThread.isAlive()) {
                commandThread.interrupt();
            }
            if (systemMonitorTask != null) {
                systemMonitorTask.cancel();
            }
            if (hotThreadMonitorTask != null) {

        };
    stoppingThread.start();
    // this should be super fast since the only non-stopped service is a NoOpService
    stoppingThread.join(1000);
    assertFalse("stopAsync has deadlocked!.", stoppingThread.isAlive());
    failLeave.countDown(); // release the background thread
  }

  /**
   * Catches a bug where when constructing a service manager failed, later interactions with the

    Stopwatch stopwatch = Stopwatch.createStarted();
    Thread thread = new Thread(new JoinTarget(15));
    thread.start();
    thread.join();
    assertFalse(thread.isAlive());

    joinUninterruptibly(thread);
    joinUninterruptibly(thread, 0, MILLISECONDS);
    joinUninterruptibly(thread, -42, MILLISECONDS);
    joinUninterruptibly(thread, LONG_DELAY_MS, MILLISECONDS);

                  () -> {
                    reloadStarted.countDown();

                    Thread blockingForRefresh = threadAboutToBlockForRefresh.get();
                    while (blockingForRefresh.isAlive()
                        && blockingForRefresh.getState() != WAITING) {
                      Thread.yield();
                    }

                    return key + "Reload";
                  });