override fun writeTo(sink: BufferedSink) {
      executorService.schedule({
        try {
          delegate.writeTo(sink)
          sink.close()
        } catch (e: IOException) {
          throw RuntimeException(e)
        }
      }, delayMillis, TimeUnit.MILLISECONDS)
    }
  }

    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();

                    content = content.replaceAll(rule.getKey(), rule.getValue());
                }
                resultData.setData(content.getBytes());
            } catch (Exception e) {
                throw new RuntimeException(e);
            }

            return resultData;
        }

        @Override
        public Object getData(AccessResultData<?> accessResultData) {
            if (accessResultData == null) {

     */
    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);

   *
   * @throws IllegalStateException if the instance is absent ({@link #isPresent} returns {@code
   *     false}); depending on this <i>specific</i> exception type (over the more general {@link
   *     RuntimeException}) is discouraged
   */
  public abstract T get();

  /**
   * Returns the contained instance if it is present; {@code defaultValue} otherwise. If no default

 *   <li>An explicit {@code if/throw} (as illustrated below) is always acceptable; we still
 *       recommend using our {@link VerifyException} exception type. Throwing a plain {@link
 *       RuntimeException} is frowned upon.
 *   <li>Use of {@link java.util.Objects#requireNonNull(Object)} is generally discouraged, since
 *       {@link #verifyNotNull(Object)} and {@link Preconditions#checkNotNull(Object)} perform the

    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();

  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);

            @Override
            public void onDestroy(PooledObject<CloseableTestComponent> p) {
                throw new RuntimeException("Test exception in listener");
            }
        };

        CrawlerPooledObjectFactory<CloseableTestComponent> factoryWithListener = createFactory("closeableComponent", listener);

Gradle Wrapper SPDX-License-Identifier: Apache-2.0 Main-Class: org.gradle.wrapper.GradleWrapperMain Enable-Native-Access: ALL-UNNAMED org/gradle/cli/CommandLineArgumentE.class package org.gradle.cli; public final class CommandLineArgumentE extends RuntimeException { public void CommandLineArgumentE(String); } org/gradle/cli/CommandLineOption.class package org.gradle.cli; public final class CommandLineOption { public final java.util.HashSet options; public Class argumentType; public String description;...