@Test
    @DisplayName("Should create SpnegoException with message and cause")
    void testWithMessageAndCause() {
        // Given
        String message = "SPNEGO handshake error";
        RuntimeException cause = new RuntimeException("root cause");

        // When
        SpnegoException ex = new SpnegoException(message, cause);

        // Then
        assertNotNull(ex);
        assertEquals(message, ex.getMessage());

                throw new RuntimeException("Script evaluation failed");
            }
        });

        // Execute and verify exception is propagated
        try {
            scriptExecutor.execute("errorEngine", "test");
            fail("Expected RuntimeException");
        } catch (RuntimeException e) {
            assertEquals("Script evaluation failed", e.getMessage());

    Throwable t = threadFailure.getAndSet(null);
    if (t != null) {
      if (t instanceof Error) {
        throw (Error) t;
      } else if (t instanceof RuntimeException) {
        throw (RuntimeException) t;
      } else if (t instanceof Exception) {
        throw (Exception) t;
      } else {
        AssertionFailedError afe = new AssertionFailedError(t.toString());
        afe.initCause(t);

    assertThrows(SomeError.class, () -> propagate(new SomeError()));
  }

  @J2ktIncompatible
  @GwtIncompatible // propagate
  public void testPropagate_noneDeclared_checked() {
    RuntimeException expected =
        assertThrows(RuntimeException.class, () -> propagate(new SomeCheckedException()));
    assertThat(expected).hasCauseThat().isInstanceOf(SomeCheckedException.class);
  }

  @GwtIncompatible // throwIfInstanceOf

    @Nullable T element;
    List<T> extras;
    final @Nullable Supplier<? extends RuntimeException> exceptionSupplier;

    ToOptionalState(@Nullable Supplier<? extends RuntimeException> exceptionSupplier) {
      this.element = null;
      this.extras = emptyList();
      this.exceptionSupplier = exceptionSupplier;
    }

    RuntimeException multiples(boolean overflow) {
      if (exceptionSupplier != null) {

                for (String error : allErrors) {
                    System.out.println(error);
                }
                throw new RuntimeException("Found " + allErrors.size() + " missing documentation files or anchors.");
            } else {
                System.out.println("All documentation files and anchors from the JSON files were found in the directory.");

   *       RuntimeException}, or an {@link ExecutionError} if the cause is an {@code Error}.
   *   <li>Any {@link InterruptedException} is wrapped in an {@code X} (after restoring the
   *       interrupt).
   *   <li>Any {@link CancellationException} is propagated untouched, as is any other {@link
   *       RuntimeException} (though {@code get} implementations are discouraged from throwing such

        assertTrue(exception instanceof RuntimeCIFSException, "Should extend RuntimeCIFSException");
        assertTrue(exception instanceof RuntimeException, "Should be a RuntimeException");
    }

    @Test
    @DisplayName("Message constructor should create exception with specified message")
    void testMessageConstructor() {
        // Given & When

  public void testSubscriberThrowsException() throws Exception {
    RecordingSubscriberExceptionHandler handler = new RecordingSubscriberExceptionHandler();
    EventBus eventBus = new EventBus(handler);
    RuntimeException exception = new RuntimeException("but culottes have a tendency to ride up!");
    Object subscriber =
        new Object() {
          @Subscribe
          public void throwExceptionOn(String message) {
            throw exception;

  public void testSubscriberThrowsException() throws Exception {
    RecordingSubscriberExceptionHandler handler = new RecordingSubscriberExceptionHandler();
    EventBus eventBus = new EventBus(handler);
    RuntimeException exception = new RuntimeException("but culottes have a tendency to ride up!");
    Object subscriber =
        new Object() {
          @Subscribe
          public void throwExceptionOn(String message) {
            throw exception;