protected ForwardingExecutorService() {}

  @Override
  protected abstract ExecutorService delegate();

  @CheckReturnValue
  @Override
  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    return delegate().awaitTermination(timeout, unit);
  }

  @Override
  public <T extends @Nullable Object> List<Future<T>> invokeAll(

   * Thread#join(long)}), else interrupts the thread (in the hope that it may terminate later) and
   * fails.
   */
  final void awaitTermination(Thread t) {
    awaitTermination(t, LONG_DELAY_MS);
  }

  // Some convenient Runnable classes

  // These classes don't merely allow checked exceptions but also store any exceptions that occur

                }
                Thread.sleep(50);
            }
            assertEquals(CrawlerStatus.RUNNING, crawler2.crawlerContext.getStatus());

            crawler1.awaitTermination();
            crawler2.awaitTermination();

            assertEquals(maxCount, dataService.getCount(sessionId1));
            assertEquals(maxCount, dataService.getCount(sessionId2));

            UrlQueue urlQueue;

   * Thread#join(long)}), else interrupts the thread (in the hope that it may terminate later) and
   * fails.
   */
  final void awaitTermination(Thread t) {
    awaitTermination(t, LONG_DELAY_MS);
  }

  // Some convenient Runnable classes

  // These classes don't merely allow checked exceptions but also store any exceptions that occur

  override fun isShutdown(): Boolean = shutdown

  override fun isTerminated(): Boolean = throw UnsupportedOperationException()

  override fun awaitTermination(
    timeout: Long,
    unit: TimeUnit,
  ): Boolean = throw UnsupportedOperationException()

    assertThat(Duration.ofNanos(recordedTimeout)).isEqualTo(Duration.ofDays(365));
  }

  public void testAwaitTermination() throws Exception {
    boolean result = executorService.awaitTermination(Duration.ofMinutes(144));

    assertThat(result).isTrue();
    assertThat(recordedTimeUnit).isEqualTo(NANOSECONDS);
    assertThat(Duration.ofNanos(recordedTimeout)).isEqualTo(Duration.ofMinutes(144));
  }

    return ImmutableList.of();
  }

  @Override
  public boolean isTerminated() {
    synchronized (lock) {
      return shutdown && runningTasks == 0;
    }
  }

  @Override
  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    synchronized (lock) {
      while (true) {
        if (shutdown && runningTasks == 0) {
          return true;

    @Override
    public boolean isShutdown() {
      return false;
    }

    @Override
    public boolean isTerminated() {
      return false;
    }

    @Override
    public boolean awaitTermination(long timeout, TimeUnit unit) {
      return false;
    }
  }

    @Override
    public boolean isShutdown() {
      return false;
    }

    @Override
    public boolean isTerminated() {
      return false;
    }

    @Override
    public boolean awaitTermination(long timeout, TimeUnit unit) {
      return false;
    }
  }

  }

  @Override
  public final boolean isTerminated() {
    return delegate.isTerminated();
  }

  @Override
  public final boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    return delegate.awaitTermination(timeout, unit);
  }