assertNull(e.getCause());
    }

    /**
     * Test the constructor with a cause.
     */
    @Test
    void testCauseConstructor() {
        Throwable cause = new RuntimeException("Root cause");
        PACDecodingException e = new PACDecodingException(cause);
        // When constructed with only a cause, the implementation passes (null, cause) to super

    }

    @Test
    public void test_constructor_withMessageAndCause() {
        // Test constructor with message and cause
        String message = "Dictionary operation failed";
        Exception cause = new RuntimeException("Underlying error");
        DictionaryException exception = new DictionaryException(message, cause);

        assertNotNull(exception);
        assertEquals(message, exception.getMessage());

     */
    @Test
    @DisplayName("toString with root cause contains stack trace")
    void testToStringWithRootCause() {
        RuntimeException cause = new RuntimeException("boom");
        SmbException ex = new SmbException(0, cause);
        assertTrue(ex.toString().contains("RuntimeException"), "String representation must include the root cause stack trace");
    }

    /**

  @Benchmark
  void oldRepeat(long reps) {
    for (int i = 0; i < reps; i++) {
      String x = oldRepeat(originalString, count);
      if (x.length() != (originalString.length() * count)) {
        throw new RuntimeException("Wrong length: " + x);
      }
    }
  }

  private static String oldRepeat(String string, int count) {
    // If this multiplication overflows, a NegativeArraySizeException or

  static final class YetAnotherCheckedException extends Exception {}

  static final class SomeUncheckedException extends RuntimeException {}

  static final class SomeChainingException extends RuntimeException {
    public SomeChainingException(Throwable cause) {
      super(cause);
    }
  }

  private TestExceptions() {}

  static class SomeOtherCheckedException extends Exception {}

  static class YetAnotherCheckedException extends Exception {}

  static class SomeUncheckedException extends RuntimeException {}

  static class SomeChainingException extends RuntimeException {
    public SomeChainingException(Throwable cause) {
      super(cause);
    }
  }

  private TestExceptions() {}

    @Test
    public void test_nestedExceptions() {
        // Test nested exception handling
        Exception innerCause = new IllegalArgumentException("Invalid LDAP parameter");
        RuntimeException middleCause = new RuntimeException("LDAP configuration error", innerCause);
        LdapOperationException exception = new LdapOperationException("LDAP operation failed", middleCause);

                    new ProjectExecutionEvent(session, currentProject, t));

            // rethrow original errors and runtime exceptions
            if (t instanceof RuntimeException runtimeException) {
                throw runtimeException;
            }
            if (t instanceof Error error) {
                throw error;
            }
        } finally {
            session.setCurrentProject(null);

  public void testRuntimeExceptionFromGet() {
    RuntimeException e = new IllegalArgumentException("foo not found");
    ListenableFuture<String> f = UncheckedThrowingFuture.throwingRuntimeException(e);
    MockCallback callback = new MockCallback(e);
    addCallback(f, callback, directExecutor());
  }

  public void testOnSuccessThrowsRuntimeException() throws Exception {
    RuntimeException exception = new RuntimeException();

        StringBuilder buf = new StringBuilder();
        Exception exception = new RuntimeException("Test error message");

        monitorTarget.appendException(buf, exception);
        assertTrue(buf.toString().startsWith("\"exception\":\""));
        assertTrue(buf.toString().contains("Test error message"));
        assertTrue(buf.toString().contains("RuntimeException"));
    }

    // Test appendException method with nested exception