super(message);
    }

    public AbstractMojoExecutionException(String message, Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new {@code AbstractMojoExecutionException} exception wrapping an underlying {@code Throwable}.
     *
     * @param cause the cause which is saved for later retrieval by the {@link #getCause()} method.

    @Nullable private String value = null;
    @Nullable private Throwable failure = null;
    private boolean wasCalled = false;
    private final Object monitor = new Object();

    MockCallback(String expectedValue) {
      this.value = expectedValue;
    }

    MockCallback(Throwable expectedFailure) {
      this.failure = expectedFailure;
    }

    @Override

    private final Mojo mojo;

    private final Throwable cause;

    public MojoExecutionEvent(MavenSession session, MavenProject project, MojoExecution mojoExecution, Mojo mojo) {
        this(session, project, mojoExecution, mojo, null);
    }

    public MojoExecutionEvent(
            MavenSession session, MavenProject project, MojoExecution mojoExecution, Mojo mojo, Throwable cause) {
        this.session = session;

        // Mock the read operation to return a specific byte
        doAnswer(new Answer<Void>() {
            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                SmbComReadAndX readCmd = invocation.getArgument(0);
                SmbComReadAndXResponse response = invocation.getArgument(1);
                response.dataLength = 1;

        assertFalse(response1.hasError());

        List<Throwable> errors = new ArrayList<>();
        errors.add(new Exception("Test error"));
        SuggestDeleteResponse response2 = new SuggestDeleteResponse(errors, 100);
        assertTrue(response2.hasError());
    }

    @Test
    public void test_getErrors() throws Exception {
        List<Throwable> errors = new ArrayList<>();
        errors.add(new Exception("Error 1"));

          reason: String,
        ) {
          webSocket.close(1000, null)
          latch.countDown()
        }

        override fun onFailure(
          webSocket: WebSocket,
          t: Throwable,
          response: Response?,
        ) {
          t.printStackTrace(System.out)
          latch.countDown()
        }
      },
    )

    public MetadataGraphTransformationException(String message) {
        super(message);
    }

    public MetadataGraphTransformationException(Throwable cause) {
        super(cause);
    }

    public MetadataGraphTransformationException(String message, Throwable cause) {
        super(message, cause);
    }

     */
    public TransportException(final Throwable rootCause) {
        super(rootCause);
    }

    /**
     * Constructs a new TransportException with the specified detail message and cause.
     * @param msg the detail message
     * @param rootCause the cause of this exception
     */
    public TransportException(final String msg, final Throwable rootCause) {
        super(msg, rootCause);
    }

    /**

     * has failed.
     */
    final @Nullable Throwable failure;

    StateSnapshot(State internalState) {
      this(internalState, false, null);
    }

    StateSnapshot(
        State internalState, boolean shutdownWhenStartupFinishes, @Nullable Throwable failure) {
      checkArgument(
          !shutdownWhenStartupFinishes || internalState == STARTING,

@GwtCompatible
final class Platform {
  static boolean isInstanceOfThrowableClass(
      @Nullable Throwable t, Class<? extends Throwable> expectedClass) {
    return expectedClass.isInstance(t);
  }

  static void restoreInterruptIfIsInterruptedException(Throwable t) {
    checkNotNull(t); // to satisfy NullPointerTester
    if (t instanceof InterruptedException) {
      currentThread().interrupt();