*/
    public ContainerNotAvailableException(final String componentName, final Throwable cause) {
        super(componentName + " is not available.", cause);
        this.componentName = componentName;
    }

    /**
     * Constructor with cause only.
     * @param cause The cause of the exception.
     */
    public ContainerNotAvailableException(final Throwable cause) {
        super("Container is not available.");

     */
    public PACDecodingException(final Throwable cause) {
        this(null, cause);
    }

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

    }

    /**
     * Test method for
     * {@link org.codelibs.core.exception.ClUnsupportedOperationException#SUnsupportedOperationException(java.lang.String, java.lang.Throwable)}
     * .
     */
    @Test
    public void testSUnsupportedOperationExceptionStringThrowable() {
        final ClUnsupportedOperationException clUnsupportedOperationException =

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

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

     */
    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);
    }

    /**

    @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

        assertTrue(exception instanceof RuntimeException);

        // Should be instance of Exception
        assertTrue(exception instanceof Exception);

        // Should be instance of Throwable
        assertTrue(exception instanceof Throwable);

        // Should not require try-catch (unchecked exception)
        throwUnchecked(); // This compiles without try-catch
    }

    private void throwUnchecked() {

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

/**
 * Tests for SMBProtocolDecodingException covering all constructors and observable behavior.
 */
@ExtendWith(MockitoExtension.class)
public class SMBProtocolDecodingExceptionTest {

    @Mock
    Throwable mockCause;

    @Test
    @DisplayName("No-arg constructor: null message and cause; can be thrown")
    void defaultConstructor_behavesAsExpected() {
        // Arrange & Act

     * @param args
     *            Array of arguments
     * @param cause
     *            The cause of the exception
     */
    public ClSQLException(final String messageCode, final Object[] args, final Throwable cause) {
        this(messageCode, args, null, 0, cause, null);
    }

    /**
     * Creates a {@link ClSQLException}.
     *
     * @param messageCode
     *            Message code
     * @param args