* it does.
   *
   * <p>The caller is responsible for ensuring that the returned stream is closed. For example:
   *
   * {@snippet :
   * try (Stream<String> lines = source.lines()) {
   *   lines.map(...)
   *       .filter(...)
   *       .forEach(...);
   * }
   * }
   *
   * @throws IOException if an I/O error occurs while opening the stream

    public void test_rethrowWithWrapping() {
        // Test rethrowing with wrapping
        String originalMessage = "Original theme error";
        String wrapperMessage = "Failed to process theme";

        try {
            try {
                throw new ThemeException(originalMessage);
            } catch (ThemeException e) {
                throw new ThemeException(wrapperMessage, e);
            }

        /*
         * Note the Transport thread isn't running yet so we can
         * read from the socket here.
         */
        try {
            this.socket.setSoTimeout(this.transportContext.getConfig().getConnTimeout());
            if (peekKey() == null) { /* try to read header */
                throw new IOException("transport closed in negotiate");
            }
        } finally {

        // Try RFC 1123 format first
        try {
            final Instant instant = Instant.from(RFC_1123_FORMATTER.parse(value));
            return Date.from(instant);
        } catch (final DateTimeParseException e) {
            // Try fallback
        }
        // Fallback to custom pattern for non-standard formats (e.g., single-digit day)
        try {

     * @return A <code>ZipFile</code> for reading the specified Zip file.
     */
    public static ZipFile create(final String file) {
        assertArgumentNotEmpty("file", file);

        try {
            return new ZipFile(file);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**

    assertThat(e).hasCauseThat().isInstanceOf(InterruptedException.class);
  }

  public void testAwait_countDownLatch_interrupted() {
    Interruptenator interruptenator = new Interruptenator(Thread.currentThread());
    try {
      CountDownLatch latch = new CountDownLatch(1);
      RuntimeException expected =
          assertThrows(RuntimeException.class, () -> GcFinalization.await(latch));
      assertWrapsInterruptedException(expected);

     */
    public static int getInt(final Properties props, final String key, int def) {
        final String s = props.getProperty(key);
        if (s != null) {
            try {
                def = Integer.parseInt(s);
            } catch (final NumberFormatException nfe) {
                log.error("Not a number", nfe);
            }
        }
        return def;
    }

    /**

        // Write test content to file
        try (FileOutputStream fos = new FileOutputStream(testFile)) {
            fos.write(getTestContent().getBytes(StandardCharsets.UTF_8));
        }

        // Create a temporary project.properties file for SystemHelper
        File propFile = File.createTempFile("project", ".properties");
        propFile.deleteOnExit();
        try (FileOutputStream fos = new FileOutputStream(propFile)) {

        Map<String, Object> docMap = new HashMap<>();

        // Note: isTarget requires FessConfig which needs container
        // We can only verify the method handles missing container gracefully
        try {
            generator.isTarget(docMap);
        } catch (IllegalStateException e) {
            // Expected when container is not initialized
            assertTrue(e.getMessage().contains("Not initialized"));
        }

        crawlerContext.sessionId = sdf.format(new Date());
    }

    /**
     * Adds a URL to the crawling queue.
     * @param url The URL to add.
     */
    public void addUrl(final String url) {
        try {
            urlQueueService.add(crawlerContext.sessionId, url);
            if (logger.isDebugEnabled()) {
                logger.debug("Added URL to queue: url={}, sessionId={}", url, crawlerContext.sessionId);
            }