}

  /** Proxy to throw a {@link RuntimeException} out of the {@link #get()} method. */
  public static class BadFuture extends SimpleForwardingListenableFuture<Integer> {
    protected BadFuture(ListenableFuture<Integer> delegate) {
      super(delegate);
    }

    @Override
    public Integer get() {
      throw new BadFutureRuntimeException();
    }
  }

     */
    public void test_throwAndCatch() {
        try {
            throw new CrawlerSystemException("Test throw");
        } catch (CrawlerSystemException e) {
            assertEquals("Test throw", e.getMessage());
            assertNull(e.getCause());
        }

        try {
            throw new CrawlerSystemException("Test with cause", new IllegalArgumentException("Cause"));

        // results in an IOException, as no default handler should be found.
        assertThrows(IOException.class, () -> {
            handler.openConnection(new URL("unknownprotocol://somehost/path"));
        }, "Should throw IOException for an unknown protocol.");
    }

    @Test
    void testSetURLStreamHandlerFactory_SuccessFirstTime() {
        // This test verifies that a URLStreamHandlerFactory can be successfully set.

     * @throws UnsupportedOperationException always thrown as this method is not supported
     */
    @Override
    public boolean checkUserLoginable(final LoginCredential credential) {
        throw new UnsupportedOperationException("checkUserLoginable is not supported.");
    }

    /**
     * Checks the credential using the provided credential checker.
     * This method is not supported in the Fess implementation.

        MavenStaxWriter writer = new MavenStaxWriter();
        try {
            writer.write(sWriter, model.getDelegate());
        } catch (IOException | XMLStreamException e) {
            throw new ModelInterpolationException("Cannot serialize project model for interpolation.", e);
        }

        String serializedModel = sWriter.toString();

                    return extractor.getText(is, params);
                }
            }
        } catch (final CrawlingAccessException e) {
            throw e;
        } catch (final Exception e) {
            throw new ExtractException("Failed to extract data.", e);
        } finally {
            if (dfos != null && !dfos.isInMemory()) {
                final File file = dfos.getFile();

    void createContext_rejectsShortNetbiosHost() {
        Kerb5Authenticator auth = new Kerb5Authenticator((Subject) null);

        // Using an uppercase short name (no dot) must throw an unsupported operation
        SmbUnsupportedOperationException ex =
                assertThrows(SmbUnsupportedOperationException.class, () -> auth.createContext(tc, null, "SERVER", new byte[0], false));

 * loader as the rest of Guava, this thread would keep an indirect strong reference to the class
 * loader and prevent it from being garbage collected. This poses a problem for environments where
 * you want to throw away the class loader. For example, dynamically reloading a web application or
 * unloading an OSGi bundle.
 *
 * <p>{@code com.google.common.base.FinalizableReferenceQueue} loads this class in its own class

     */
    public void addExtractor(final String key, final Extractor extractor) {
        if (StringUtil.isBlank(key)) {
            throw new CrawlerSystemException("Extractor key (MIME type) is null or blank. Cannot register extractor without a valid key.");
        }
        if (extractor == null) {
            throw new CrawlerSystemException("Extractor instance is null. Cannot register null extractor.");
        }

    super(Preconditions.checkNotNull(in));
  }

  /** This method will throw an {@link UnsupportedOperationException}. */
  @CanIgnoreReturnValue // to skip a line
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public String readLine() {
    throw new UnsupportedOperationException("readLine is not supported");
  }

  @Override