Throwable a, Throwable b, Throwable c, Throwable d, Throwable e) {}

    public ExceptionWithManyConstructors(
        Throwable a, Throwable b, Throwable c, Throwable d, Throwable e, String s, Integer i) {}
  }

  public static final class ExceptionWithoutThrowableConstructor extends Exception {
    public ExceptionWithoutThrowableConstructor(String s) {
      super(s);
    }
  }

        Throwable a, Throwable b, Throwable c, Throwable d, Throwable e) {}

    public ExceptionWithManyConstructors(
        Throwable a, Throwable b, Throwable c, Throwable d, Throwable e, String s, Integer i) {}
  }

  public static final class ExceptionWithoutThrowableConstructor extends Exception {
    public ExceptionWithoutThrowableConstructor(String s) {
      super(s);
    }
  }

@ElementTypesAreNonnullByDefault
final class Platform {
  static boolean isInstanceOfThrowableClass(Throwable t, Class<? extends Throwable> expectedClass) {
    /*
     * This method is used only by CatchingFuture, and CatchingFuture accepts only Throwable.class
     * under GWT.
     */
    return true;
  }

  static void restoreInterruptIfIsInterruptedException(Throwable t) {}

  private Platform() {}

     */
    void debug(CharSequence content, Throwable error);

    /**
     * Sends an exception to the user in the <b>debug</b> error level.
     * The stack trace for this exception will be output when this error level is enabled.
     *
     * @param error the error that caused this log
     */
    void debug(Throwable error);

    void debug(Supplier<String> content);

      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)

    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;

          }
        }

        val throwable = connectResult.throwable
        if (throwable != null) {
          if (throwable !is IOException) throw throwable
          if (firstException == null) {
            firstException = throwable
          } else {
            firstException.addSuppressed(throwable)
          }
        }

        val nextPlan = connectResult.nextPlan

     * @param cause a cause
     * @deprecated use {@link #ArtifactMetadataRetrievalException(String, Throwable, Artifact)}
     */
    @Deprecated
    public ArtifactMetadataRetrievalException(String message, Throwable cause) {
        this(message, cause, null);
    }

    public ArtifactMetadataRetrievalException(String message, Throwable cause, Artifact artifact) {
        super(message, cause);
        this.artifact = artifact;
    }

  static void assertNodeNotInGraphErrorMessage(Throwable throwable) {
    assertThat(throwable).hasMessageThat().startsWith(NODE_STRING);
    assertThat(throwable).hasMessageThat().contains(ERROR_ELEMENT_NOT_IN_GRAPH);
  }
  
  static void assertEdgeNotInGraphErrorMessage(Throwable throwable) {
    assertThat(throwable).hasMessageThat().startsWith(EDGE_STRING);
    assertThat(throwable).hasMessageThat().contains(ERROR_ELEMENT_NOT_IN_GRAPH);
  }

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