beforeProcessingCount++;
            if (shouldThrowException) {
                throw new RuntimeException("Test exception in delayBeforeProcessing");
            }
        }

        @Override
        protected void delayAfterProcessing() {
            afterProcessingCount++;
            if (shouldThrowException) {
                throw new RuntimeException("Test exception in delayAfterProcessing");
            }
        }

      throw t;
    }
  }

  /** Calls threadFail with message "should throw exception". */
  public void threadShouldThrow() {
    threadFail("should throw exception");
  }

  /** Calls threadFail with message "should throw" + exceptionName. */
  public void threadShouldThrow(String exceptionName) {
    threadFail("should throw " + exceptionName);
  }

  /**

   * {@code view} returned by this method will be invalidated, and will throw {@code
   * IllegalStateException} if it is accessed in any way, with the following exceptions:
   *
   * <ul>
   *   <li>{@code view.equals(view)} evaluates to {@code true} (but any other {@code equals(...)}
   *       expression involving {@code view} will throw)
   *   <li>{@code hashCode()} does not throw

    }

    /**
     * Test that getText throws exception when null stream is provided.
     * Note: validateInputStream throws the exception, so the validateCalled flag
     * is never set to true (exception is thrown before flag assignment).
     */
    public void test_getText_throwsExceptionForNullStream() {
        try {

        } catch (Exception e) {
            fail("Should not throw exception in test setup");
        }

        // Execute and verify ChildUrlsException is thrown
        try {
            processor.process(responseData);
            fail("Should throw ChildUrlsException");
        } catch (ChildUrlsException e) {
            // Expected exception

        } catch (final IOException e) {
            throw new CrawlerSystemException("Could not create a temp file.", e);
        }
    }

    /**
     * Validates that the input stream is not null.
     * This is a common validation performed by most extractors.
     *
     * @param in The input stream to validate
     * @throws CrawlerSystemException if the input stream is null
     */

                }
            }

            if (pluginDescriptor == null) {
                throw new IOException("No plugin descriptor found at " + getPluginDescriptorLocation());
            }
        } catch (IOException e) {
            throw new PluginDescriptorParsingException(plugin, pluginFile.getAbsolutePath(), e);
        }

        List<String> errors = new ArrayList<>();

    /**
     * Constructs a new CurlRequest with the specified HTTP method.
     *
     * @param method the HTTP method
     * @throws IllegalArgumentException if method is null
     */
    public CurlRequest(final Method method) {
        if (method == null) {
            throw new IllegalArgumentException("method must not be null");
        }
        this.method = method;
    }

    /**

                throw new InvalidKeyRuntimeException(e);
            } catch (final NoSuchAlgorithmException e) {
                throw new NoSuchAlgorithmRuntimeException(e);
            } catch (final NoSuchPaddingException e) {
                throw new NoSuchPaddingRuntimeException(e);
            } catch (final UnsupportedEncodingException e) {
                throw new UnsupportedEncodingRuntimeException(e);

    }

    /**
     * Initializes the extractor by starting the office manager.
     *
     * @throws CrawlerSystemException if the office manager is null or fails to start
     */
    @PostConstruct
    public void init() {
        if (officeManager == null) {
            throw new CrawlerSystemException("officeManager is null.");
        }
        try {
            officeManager.start();