assertNotNull(jobProcess);

            // Poll for process to complete
            for (int i = 0; i < 50; i++) {
                if (!jobProcess.getProcess().isAlive()) {
                    break;
                }
                Thread.sleep(100);
            }

            // Clean up
            processHelper.destroyProcess(sessionId);

        indexUpdater.indexingHelper = indexingHelper;
    }

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

          interruptingTask.stopInterrupting();
          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");
            /*

          interruptingTask.stopInterrupting();
          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");
            /*

    assertEquals(State.RUNNING, service.state());
    service.stopAsync();
    waiter.join(LONG_TIMEOUT_MILLIS); // ensure that the await in the other thread is triggered
    assertFalse(waiter.isAlive());
  }

  public void testAwaitTerminated_failedService() throws Exception {
    ManualSwitchedService service = new ManualSwitchedService();
    FutureTask<IllegalStateException> waiter =

    assertEquals(State.RUNNING, service.state());
    service.stopAsync();
    waiter.join(LONG_TIMEOUT_MILLIS); // ensure that the await in the other thread is triggered
    assertFalse(waiter.isAlive());
  }

  public void testAwaitTerminated_failedService() throws Exception {
    ManualSwitchedService service = new ManualSwitchedService();
    FutureTask<IllegalStateException> waiter =

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

      this.shutdown = shutdown;
      start();
    }

    @SuppressWarnings("ThreadPriorityCheck") // TODO: b/175898629 - Consider onSpinWait.
    void shutdown() {
      shutdown.set(true);
      while (this.isAlive()) {
        Thread.yield();
      }
    }
  }

  void assertWrapsInterruptedException(RuntimeException e) {
    assertThat(e).hasMessageThat().contains("Unexpected interrupt");

        InputStreamThread thread = jobProcess.getInputStreamThread();

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

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

      this.shutdown = shutdown;
      start();
    }

    @SuppressWarnings("ThreadPriorityCheck") // TODO: b/175898629 - Consider onSpinWait.
    void shutdown() {
      shutdown.set(true);
      while (this.isAlive()) {
        Thread.yield();
      }
    }
  }

  void assertWrapsInterruptedException(RuntimeException e) {
    assertThat(e).hasMessageThat().contains("Unexpected interrupt");