factory.setOnDestroyListener(new OnDestroyListener<TestComponent>() {
            @Override
            public void onDestroy(PooledObject<TestComponent> p) {
                throw new RuntimeException("Test exception in listener");
            }
        });

        try {
            factory.destroyObject(pooledObject);
            fail("Should propagate exception from listener");

        ComponentUtil.register(new WebConfigService() {
            @Override
            public OptionalEntity<WebConfig> getWebConfig(final String id) {
                throw new RuntimeException("Test exception");
            }

            @Override
            public OptionalEntity<WebConfig> getWebConfigByName(String name) {
                return OptionalEntity.empty();
            }

            assertFalse(testBlock.isReceived());
        }

        @Test
        @DisplayName("Test exception state")
        void testExceptionState() {
            Exception testException = new RuntimeException("Test error");

            assertNull(testBlock.getException());

            testBlock.exception(testException);
            assertEquals(testException, testBlock.getException());
        }

        when(mockContext.getConfig()).thenReturn(mockConfig);
        when(mockConfig.getLanManCompatibility()).thenReturn(3);
        when(mockTransport.getServerEncryptionKey()).thenThrow(new RuntimeException("Test exception"));

        assertThrows(SmbException.class, () -> new SMB1SigningDigest(mockTransport, mockAuth));
    }

    @Test
    @DisplayName("Test update method with valid data")

    public static void registerSmbURLHandler() {
        String ver, pkgs;

        ver = System.getProperty("java.version");
        if (ver.startsWith("1.1.") || ver.startsWith("1.2.")) {
            throw new RuntimeException("jcifs.smb1-0.7.0b4+ requires Java 1.3 or above. You are running " + ver);
        }
        pkgs = System.getProperty("java.protocol.handler.pkgs");
        if (pkgs == null) {

        when(pipe.ensureTreeConnected()).thenReturn(tree);
        when(tree.acquire()).thenReturn(tree);

        // Use doThrow for unchecked exception wrapping the CIFSException
        doThrow(new RuntimeException(new CIFSException("session fail"))).when(tree).getSession();

        Exception ex = assertThrows(Exception.class, handle::getSessionKey);
        assertTrue(

        throws InvocationTargetException, IllegalAccessException {
      try {
        return constructor.newInstance(args);
      } catch (InstantiationException e) {
        throw new RuntimeException(constructor + " failed.", e);
      }
    }

    /**
     * If the class is parameterized, such as {@link java.util.ArrayList ArrayList}, this returns
     * {@code ArrayList<E>}.
     */

  private V load(K key) throws ExecutionException {
    long startTime = ticker.read();
    V calculatedValue;
    try {
      calculatedValue = loader.load(key);
      put(key, calculatedValue);
    } catch (RuntimeException e) {
      statsCounter.recordLoadException(ticker.read() - startTime);
      throw new UncheckedExecutionException(e);
    } catch (Exception e) {
      statsCounter.recordLoadException(ticker.read() - startTime);

     */
    protected ExtractData getExtractData(final Extractor extractor, final InputStream in, final Map<String, String> params) {
        try {
            return extractor.getText(in, params);
        } catch (final RuntimeException e) {
            if (!fessConfig.isCrawlerIgnoreContentException()) {
                throw e;
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Could not get a text.", e);

    public static final WithExceptionalConstructor INSTANCE =
        new WithExceptionalConstructor("whatever");

    public WithExceptionalConstructor() {
      throw new RuntimeException();
    }

    private WithExceptionalConstructor(String unused) {}
  }

  private static class WithPublicConstant {
    @Keep public static final WithPublicConstant INSTANCE = new WithPublicConstant();