class BadRunnableException extends RuntimeException {}

    Runnable bad =
        () -> {
          throw new BadRunnableException();
        };

    future.set(1);
    future.addListener(bad, directExecutor()); // BadRunnableException must not propagate.
  }

  public void testMisbehavingListenerLaterDone() {
    class BadRunnableException extends RuntimeException {}

      }
    } else {
      super.getSelectedProtocol(sslSocket)
    }

  companion object {
    val isSupported: Boolean =
      try {
        // Trigger an early exception over a fatal error, prefer a RuntimeException over Error.
        Class.forName("org.openjsse.net.ssl.OpenJSSE", false, OpenJSSEPlatform::class.java.classLoader)

        true
      } catch (_: ClassNotFoundException) {
        false
      }

      runCalled = true;
      assertEquals(State.RUNNING, state());

      enterRun.countDown();
      try {
        exitRun.await();
      } catch (InterruptedException e) {
        throw new RuntimeException(e);
      }
    }

    @Override
    protected void shutDown() {
      assertTrue(startUpCalled);
      assertTrue(runCalled);
      assertFalse(shutDownCalled);
      shutDownCalled = true;

                }
                field.setAccessible(true);
                field.set(this, value);
            } catch (Exception e) {
                throw new RuntimeException("Failed to set field " + fieldName, e);
            }
        }

        protected Object getFieldValue(String fieldName) {
            try {
                Field field = null;

        assertFalse(exception.isRetryable());
    }

    @Test
    @DisplayName("Should create exception with cause")
    void testCreationWithCause() {
        // Given
        Exception cause = new RuntimeException("Original error");

        // When
        exception = new SmbOperationException(SmbOperationException.ErrorCode.CONNECTION_FAILED, "Failed to connect", cause);

        // Then

        linkRepository.load(linksFile.get().asFile)

        findAll(doc, 'apilink').each { Element element ->
            String className = element.'@class'
            if (!className) {
                throw new RuntimeException('No "class" attribute specified for <apilink> element.')
            }
            String methodName = element.'@method'

            def classMetaData = linkRepository.get(className)

            inquireSecContextPrep = extendedGSSContextClassPrep.getMethod("inquireSecContext", inquireTypeClass);
        } catch (ClassNotFoundException | NoSuchMethodException | RuntimeException ex) {
            if (log.isDebugEnabled()) {
                log.debug("Failed to initalize ExtendedGSSContext initializdation for OracleJDK / OpenJDK", ex);
            }
        }

      Callable<T> callable, long timeoutDuration, TimeUnit timeoutUnit) throws ExecutionException {
    checkNotNull(callable);
    checkNotNull(timeoutUnit);
    try {
      return callable.call();
    } catch (RuntimeException e) {
      throw new UncheckedExecutionException(e);
    } catch (Exception e) {
      restoreInterruptIfIsInterruptedException(e);
      throw new ExecutionException(e);
    } catch (Error e) {

          .put(NullPointerException.class, e -> e instanceof NullPointerException)
          .put(NumberFormatException.class, e -> e instanceof NumberFormatException)
          .put(RuntimeException.class, e -> e instanceof RuntimeException)
          .put(SomeCheckedException.class, e -> e instanceof SomeCheckedException)
          .put(SomeError.class, e -> e instanceof SomeError)

    assertThrows(
        RuntimeException.class,
        () ->
            doParallelCacheOp(
                count,
                n ->
                    cache
                        .asMap()
                        .compute(
                            key,
                            (k, v) -> {
                              throw new RuntimeException();
                            })));
  }