} finally {
      if (t.getState() != Thread.State.TERMINATED) {
        t.interrupt();
        fail("Test timed out");
      }
    }
  }

  /**
   * Waits for LONG_DELAY_MS milliseconds for the thread to terminate (using {@link
   * Thread#join(long)}), else interrupts the thread (in the hope that it may terminate later) and
   * fails.
   */
  void awaitTermination(Thread t) {

   * ExecutorService#close}.
   *
   * @param service the {@code ExecutorService} to shut down
   * @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 28.0 (but only since 33.4.0 in the Android flavor)
   */
  @CanIgnoreReturnValue

        }
        return crawlerContext.sessionId;
    }

    /**
     * Waits for the crawling process to terminate indefinitely.
     */
    public void awaitTermination() {
        awaitTermination(0);
    }

    /**
     * Waits for the crawling process to terminate for a specified duration.
     * @param millis The maximum time to wait in milliseconds. A value of 0 means wait indefinitely.
     */

         * @return true if the thread is actively executing
         */
        public boolean isRunning() {
            return running;
        }

        /**
         * Waits for the crawling thread to terminate.
         * This method blocks until the thread completes its execution.
         * Interrupted exceptions are caught and logged at debug level.
         */
        public void awaitTermination() {
            try {

            this.finished = finished;
        }

        /**
         * Returns whether the process was terminated.
         * @return true if terminated, false otherwise.
         */
        public boolean isTeminated() {
            return teminated;
        }
    }

    /**
     * Thread to read and buffer output from an input stream.
     */

                logger.error("IndexUpdater is terminated.", e);
            } else if (logger.isInfoEnabled()) {
                logger.info("IndexUpdater is terminated.");
            }
            forceStop();
        } catch (final Throwable t) {
            if (ComponentUtil.available()) {
                logger.error("IndexUpdater is terminated.", t);
            } else if (logger.isDebugEnabled()) {

            this.p = p;
            this.ist = ist;
            this.timeout = timeout;
        }

        /**
         * Runs the process destroyer task to terminate the process.
         */
        @Override
        public void run() {
            if (!p.isAlive()) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Process {} is not alive.", p);

5. Termination
--------------

5.1. The rights granted under this License will terminate automatically
if You fail to comply with any of its terms. However, if You become
compliant, then the rights granted under this License from a particular
Contributor are reinstated (a) provisionally, unless and until such
Contributor explicitly and finally terminates Your grants, and (b) on an
ongoing basis, if such Contributor fails to notify You of the

cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following...

            this.finished = finished;
        }

        /**
         * Checks if the process has been terminated due to timeout.
         * @return True if the process was terminated, false otherwise.
         */
        public boolean isTeminated() {
            return teminated;
        }
    }

    /**
     * Thread that reads input stream data and buffers it for later retrieval.