assertFalse(result.getContent().isEmpty());
    }

    /**
     * Test that ZipExtractor handles mixed valid and invalid entries gracefully.
     * Should continue processing valid entries even when some fail.
     */
    public void test_ZipExtractor_mixedEntries_continuesProcessing() throws IOException {
        // Create a ZIP with one valid text file

    public void test_processWithNullResponseData() {
        // Test process method with null ResponseData
        NullResponseProcessor processor = new NullResponseProcessor();

        // Execute - should not throw any exception even with null
        processor.process(null);
    }

    public void test_processWithEmptyResponseData() {
        // Test process method with empty ResponseData

            } catch (final Exception e) {
                logger.warn("Error occurred in onDestroy listener for component: {}", componentName, e);
                // Continue with destruction even if listener fails
            }
        }

        // Close the object if it implements AutoCloseable or Closeable
        final T obj = p.getObject();
        if (obj instanceof AutoCloseable) {

        // destroyObject should continue and close the resource even if listener throws
        factoryWithListener.destroyObject(pooledObject);

        // Resource should still be closed despite listener exception
        assertTrue("Component should be closed even if listener throws", component.isClosed());
    }

    /**
     * Test destroyObject with AutoCloseable component

     * time they are accessed. The value "never" should be used to describe
     * archived URLs.
     *
     * Please note that the value of this tag is considered a hint and not a
     * command. Even though search engine crawlers may consider this information
     * when making decisions, they may crawl pages marked "hourly" less
     * frequently than that, and they may crawl pages marked "yearly" more

            fail("Should not throw exception in test setup");
        }

        // Execute and verify
        try {
            processor.process(responseData);
            fail("Should throw ChildUrlsException even with empty set");
        } catch (ChildUrlsException e) {
            Set<RequestData> childUrls = e.getChildUrlList();
            assertNotNull(childUrls);
            assertEquals(0, childUrls.size());
        }

            assertEquals("Braces should be balanced", openBraces, closeBraces);
        }
    }

    /**
     * Test that InputStream is properly closed even when exception occurs.
     * Verifies try-with-resources cleanup behavior.
     */
    @Test
    public void testResourceLoading_exceptionHandling() {
        try {

import org.dbflute.utflute.core.PlainTestCase;

/**
 * Test class to verify proper resource management in Extractor implementations.
 * This test ensures that resources are properly closed even when exceptions occur.
 */
public class ExtractorResourceManagementTest extends PlainTestCase {
    private static final Logger logger = LogManager.getLogger(ExtractorResourceManagementTest.class);

        final SitemapSet sitemapSet = sitemapsHelper.parse(in);
        final Sitemap[] sitemaps = sitemapSet.getSitemaps();

        // Should parse successfully even without namespace
        assertEquals(2, sitemaps.length);
        assertEquals("http://www.example.com/page1.html", sitemaps[0].getLoc());
        assertEquals("http://www.example.com/page2.html", sitemaps[1].getLoc());

            urlQueue.setUrl("http://www.example.com/page" + i);
            urlQueueList.add(urlQueue);
        }

        urlQueueService.offerAll(sessionId, urlQueueList);

        // Poll items - should work fine even with max size constraint
        int count = 0;
        while (true) {
            final OpenSearchUrlQueue polled = urlQueueService.poll(sessionId);
            if (polled == null) {
                break;