* non-nullable {@code cause}, as many users expect to find one.
   */
  public ExecutionError(@Nullable String message, @Nullable Error cause) {
    super(message, cause);
  }

  /**
   * Creates a new instance with {@code null} as its detail message and the given cause. Prefer to
   * provide a non-nullable {@code cause}, as many users expect to find one.
   */

        });

        // Test throwing and catching with cause
        RuntimeException cause = new RuntimeException("Cause");
        TransportException thrown = assertThrows(TransportException.class, () -> {
            throw new TransportException(cause);
        });
        assertEquals(cause, thrown.getCause());

        // Test throwing and catching with message and cause

        // Then
        assertSame(cause, exception.getCause(), "Crypto cause should be preserved");
        assertEquals(cause.toString(), exception.getMessage(), "Message should be cause.toString() when only cause is provided");
    }

    @Test
    @DisplayName("Message and cause constructor should preserve both crypto parameters")
    void testMessageAndCauseConstructor() {

        }
    }

    @Test
    @DisplayName("Cause-only constructor: preserves provided cause; no interactions with cause")
    void causeOnlyConstructor_preservesCause_andNoInteractions() {
        // Arrange & Act
        SMBProtocolDecodingException ex = new SMBProtocolDecodingException(mockCause);

        // Assert cause propagation
        assertSame(mockCause, ex.getCause(), "Cause should be exactly the provided instance");

        // Test constructor with message and cause
        String message = "Query parsing failed";
        Exception cause = new IllegalArgumentException("Invalid query syntax");

        SearchQueryException exception = new SearchQueryException(message, cause);

        assertEquals(message, exception.getMessage());
        assertEquals(cause, exception.getCause());

        // Test constructor with message and cause
        String message = "Test error message";
        Throwable cause = new RuntimeException("Underlying cause");
        SearchEngineClientException exception = new SearchEngineClientException(message, cause);

        assertNotNull(exception);
        assertEquals(message, exception.getMessage());
        assertEquals(cause, exception.getCause());
    }

        // Arrange - use a real cause so message is derived from cause.toString()
        Throwable cause = new IllegalStateException("proto mismatch");
        String expectedMessage = cause.toString();

        // Act
        SMBProtocolDowngradeException ex = new SMBProtocolDowngradeException(cause);

        // Assert - cause preserved, message derived from cause
        assertSame(cause, ex.getCause());

  /**
   * Creates a new instance with the given detail message and cause. Prefer to provide a
   * non-nullable {@code cause}, as many users expect to find one.
   */
  public UncheckedExecutionException(@Nullable String message, @Nullable Throwable cause) {
    super(message, cause);
  }

  /**
   * Creates a new instance with {@code null} as its detail message and the given cause. Prefer to

        // Expect the message to be set correctly and cause to be null
        assertEquals(errorMessage, e.getMessage());
        assertNull(e.getCause());
    }

    /**
     * Test the constructor with a cause.
     */
    @Test
    void testCauseConstructor() {
        Throwable cause = new RuntimeException("Root cause");
        PACDecodingException e = new PACDecodingException(cause);

        return OptionalThing.of(asJson(createFailureBean(Status.BAD_REQUEST, createMessage(resource, cause))));
    }

    @Override
    public OptionalThing<ApiResponse> handleServerException(final ApiFailureResource resource, final Throwable cause) {
        return OptionalThing.of(asJson(createFailureBean(Status.SYSTEM_ERROR, createMessage(resource, cause))));
    }