protected abstract void realRun() throws Throwable;

    public final void run() {
      try {
        realRun();
      } catch (Throwable t) {
        threadUnexpectedException(t);
      }
    }
  }

  public abstract class RunnableShouldThrow implements Runnable {
    protected abstract void realRun() throws Throwable;

    final Class<?> exceptionClass;

    protected abstract void realRun() throws Throwable;

    @Override
    public final void run() {
      try {
        realRun();
      } catch (Throwable t) {
        threadUnexpectedException(t);
      }
    }
  }

  public abstract class RunnableShouldThrow implements Runnable {
    protected abstract void realRun() throws Throwable;

    final Class<?> exceptionClass;

        try {
            final CrawlerContext crawlerContext = (CrawlerContext) objs[0];
            final UrlQueue<?> urlQueue = (UrlQueue<?>) objs[1];
            Throwable e = (Throwable) objs[2];
            if (e instanceof MultipleCrawlingAccessException) {
                final Throwable[] causes = ((MultipleCrawlingAccessException) e).getCauses();
                if (causes.length > 0) {
                    e = causes[causes.length - 1];

      get() = connectState == ConnectState.TLS_CONNECTED

    var tcpConnectDelayNanos = 0L
    var tcpConnectThrowable: Throwable? = null
    var yieldBeforeTcpConnectReturns = false
    var connectTcpNextPlan: FakePlan? = null
    var tlsConnectDelayNanos = 0L
    var tlsConnectThrowable: Throwable? = null
    var connectTlsNextPlan: FakePlan? = null

    fun createRetry(): FakePlan {
      check(retry == null)

    public void fatal(final String message, final Throwable t) {
        logger.fatal(message, t);
    }

    @Override
    public boolean isErrorEnabled() {
        return logger.isErrorEnabled();
    }

    @Override
    public void error(final String message) {
        logger.error(message);
    }

    @Override
    public void error(final String message, final Throwable t) {
        logger.error(message, t);
    }

    }

    @Override
    public void fatal(final String message) {
        logger.logp(Level.SEVERE, sourceClass, null, message);
    }

    @Override
    public void fatal(final String message, final Throwable t) {
        logger.logp(Level.SEVERE, sourceClass, null, message, t);
    }

    @Override
    public boolean isErrorEnabled() {
        return logger.isLoggable(Level.SEVERE);
    }

    @Override

    boolean isFatalEnabled();

    void fatal(String message);

    void fatal(String message, Throwable t);

    boolean isErrorEnabled();

    void error(String message);

    void error(String message, Throwable t);

    boolean isWarnEnabled();

    void warn(String message);

    void warn(String message, Throwable t);

    boolean isInfoEnabled();

    void info(String message);

static void addCauseMethodName(String); public static Throwable getCause(Throwable); public static Throwable getCause(Throwable, String[]); public static Throwable getRootCause(Throwable); private static Throwable getCauseUsingWellKno(Throwable); private static Throwable getCauseUsingMethodN(Throwable, String); private static Throwable getCauseUsingFieldNa(Throwable, String); public static int getThrowableCount(Throwable); public static Throwable[] getThrowables(Throwable); public static int index...

   * returns {@code true}. Calling {@code get()} will immediately throw the provided {@code
   * Throwable} wrapped in an {@code ExecutionException}.
   */
  public static <V extends @Nullable Object> ListenableFuture<V> immediateFailedFuture(
      Throwable throwable) {
    checkNotNull(throwable);
    return new ImmediateFailedFuture<>(throwable);
  }

  /**

            }
            return (T) v;
        }

        static class AltRes {
            final Throwable t;

            AltRes(Throwable t) {
                this.t = t;
            }
        }
    }

    @SuppressWarnings("unchecked")
    static <T extends Throwable> void uncheckedThrow(Throwable t) throws T {
        throw (T) t; // rely on vacuous cast
    }