// Add an include - this should work now
        resource.addInclude("test");

        // Verify the include was added
        assertEquals(1, resource.getIncludes().size(), "Should have one include");
        assertEquals("test", resource.getIncludes().get(0), "Include should be 'test'");

        // Verify that getting resources again still shows the include
        List<Resource> resourcesAfter = project.getResources();

    ExecutorService service = mock(ExecutorService.class);
    application.addDelayedShutdownHook(service, 2, SECONDS);
    verify(service, Mockito.never()).shutdown();
    application.shutdown();
    InOrder shutdownFirst = Mockito.inOrder(service);
    shutdownFirst.verify(service).shutdown();
    shutdownFirst.verify(service).awaitTermination(2, SECONDS);
  }

        // Execute - should not throw any exception
        processor.process(responseData);

        // Verify child URLs are unchanged
        assertEquals(2, responseData.getChildUrlSet().size());
    }

    public void test_noOpBehavior() {
        // Verify that NullResponseProcessor truly does nothing
        NullResponseProcessor processor = new NullResponseProcessor();

            assertTrue(result.success(), "Orchestrator should succeed");

            // Verify only applicable strategy was executed
            verify(mockStrategies.get(0)).apply(Mockito.eq(context), Mockito.any());
            verify(mockStrategies.get(1), Mockito.never()).apply(Mockito.any(), Mockito.any());
            verify(mockStrategies.get(2), Mockito.never()).apply(Mockito.any(), Mockito.any());
        }

        @Test

        }

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

            // Verify all URLs are present

        // Verify
        assertEquals(3, includePatterns.size());
        assertEquals(3, excludePatterns.size());

        // Verify all calls were made
        verify(dataHelper).addIncludeUrlPattern(sessionId, "https://example.com/.*");
        verify(dataHelper).addIncludeUrlPattern(sessionId, "https://test.com/.*");

            strategy.apply(context, pomMap);

            // Verify child groupId was removed (matches parent, can be inferred)
            assertNull(childRoot.child("groupId").orElse(null));
            // Verify child version was kept (differs from parent, cannot be inferred)
            assertNotNull(childRoot.child("version").orElse(null));
            // Verify child artifactId was kept (always required)

        crawlerThread.run();

        verify(urlQueueService, times(1)).poll(anyString());
    }

    /**
     * Test run method with crawler status DONE.
     */
    public void test_run_statusDone() throws Exception {
        crawlerContext.setStatus(CrawlerStatus.DONE);

        crawlerThread.run();

        verify(urlQueueService, times(0)).poll(anyString());
    }

    /**

        final String sessionId = "session1";
        final String urlPattern = "http://example.com/.*";

        urlFilterService.addIncludeUrlFilter(sessionId, urlPattern);

        // Verify the filter is stored
        assertTrue(fesenClient.prepareSearch("fess_crawler.filter")
                .setQuery(QueryBuilders.termQuery("sessionId", sessionId))
                .setSize(0)
                .execute()

        // Execute
        service.updateSessionId(oldSessionId, newSessionId);

        // Verify
        verify(dataHelper).getUrlQueueList(oldSessionId);
        verify(dataHelper).addUrlQueueList(newSessionId, mockQueue);
        verify(dataHelper).removeUrlQueueList(oldSessionId);
    }

    public void test_poll() {
        // Setup
        String sessionId = "session123";