TrustedListenableFutureTask<Integer> task =
        TrustedListenableFutureTask.create(
            () -> {
              enterLatch.countDown();
              try {
                new CountDownLatch(1).await(); // wait forever
                throw new AssertionError();
              } catch (InterruptedException e) {
                interruptedExceptionThrown.set(true);
                throw e;
              } finally {
              }

    TrustedListenableFutureTask<Integer> task =
        TrustedListenableFutureTask.create(
            () -> {
              enterLatch.countDown();
              try {
                new CountDownLatch(1).await(); // wait forever
                throw new AssertionError();
              } catch (InterruptedException e) {
                interruptedExceptionThrown.set(true);
                throw e;
              } finally {
              }

    public boolean isDone() {
      /*
       * If isDone is true during the call to listenInPoolThread,
       * listenInPoolThread doesn't start a thread. Make sure it's false the
       * first time through (and forever after, since no one else cares about
       * it).
       */
      return false;
    }
  }

  private static final class RecordingRunnable implements Runnable {

    public boolean isDone() {
      /*
       * If isDone is true during the call to listenInPoolThread,
       * listenInPoolThread doesn't start a thread. Make sure it's false the
       * first time through (and forever after, since no one else cares about
       * it).
       */
      return false;
    }
  }

  private static final class RecordingRunnable implements Runnable {

    * Normally, a token is set to expire after some time.
        * So, the user will have to log in again at some point later.
        * And if the token is stolen, the risk is less. It is not like a permanent key that will work forever (in most of the cases).
* The frontend stores that token temporarily somewhere.
* The user clicks in the frontend to go to another section of the frontend web app.
* The frontend needs to fetch some more data from the API.

    try {
      Thread.class.getMethod("stop").invoke(this);
      join();
    } catch (ReflectiveOperationException e) {
      // stop() threw or did not exist. Don't join() the thread, which might hang forever.
    }

    if (uncaughtThrowable != null) {
      throw new AssertionError("Uncaught throwable in " + getName(), uncaughtThrowable);
    }
  }

  /**

            ContiguousSet.closedOpen(Integer.MIN_VALUE, Integer.MIN_VALUE),
            ImmutableSortedSet.of(),
            ImmutableSet.of())
        .testEquals();
    // not testing hashCode for these because it takes forever to compute
    assertEquals(
        ContiguousSet.closed(Integer.MIN_VALUE, Integer.MAX_VALUE),
        ContiguousSet.create(Range.<Integer>all(), integers()));
    assertEquals(

The idea is to automate the acquisition and renewal of these certificates so that you can have **secure HTTPS, for free, forever**.

## HTTPS for Developers { #https-for-developers }

Here's an example of how an HTTPS API could look like, step by step, paying attention mainly to the ideas important for developers.

### Domain Name { #domain-name }

  private var expectMoreExchanges = true

  // These properties are accessed by canceling threads. Any thread can cancel a call, and once it's
  // canceled it's canceled forever.

  @Volatile private var canceled = false

  @Volatile private var exchange: Exchange? = null
  internal val plansToCancel = CopyOnWriteArrayList<RoutePlanner.Plan>()

/// tip

...Although if the whole application is just **crashing immediately** it probably doesn't make sense to keep restarting it forever. But in those cases, you will probably notice it during development, or at least right after deployment.