assertEquals(1, urlSet.size());
                String childUrl = urlSet.iterator().next().getUrl();
                assertTrue("Child URL should be properly formed", childUrl.contains("dir1/test3.txt"));
                assertTrue("Child URL should contain 'child' not 'chile'", childUrl.matches(".*dir1/test3\\.txt"));
            }
        } finally {
            if (server != null) {
                server.stop();

    }

    /**
     * Gets the map of child URL extraction rules.
     *
     * @return the child URL rule map
     */
    public Map<String, String> getChildUrlRuleMap() {
        return childUrlRuleMap;
    }

    /**
     * Sets the map of child URL extraction rules.
     *
     * @param childUrlRuleMap the child URL rule map to set
     */

                final StringBuilder headingText = new StringBuilder();
                Node child = heading.getFirstChild();
                while (child != null) {
                    if (child instanceof Text) {
                        headingText.append(((Text) child).getLiteral());
                    }
                    child = child.getNext();
                }
                if (headingText.length() > 0) {

        final String url = (String) objs[2];
        final Throwable e = (Throwable) objs[3];
        if (logger.isDebugEnabled()) {
            logger.debug("Child URL: {} from {}", url, urlQueue.getUrl(), e);
        }
    }

    /**
     * Processes child URLs processing exception log events.
     *
     * @param objs the log objects (should contain UrlQueue and Set of RequestData)
     */

        }
    }

    /**
     * Stores a child URL in the crawling queue with duplicate host handling.
     * This method applies duplicate host conversion before storing the URL.
     *
     * @param childUrl the child URL to store
     * @param parentUrl the parent URL that referenced this child URL
     * @param weight the weight/priority of the child URL
     * @param depth the crawling depth of the child URL
     */

        method.invoke(crawlerThread, "http://example.com/child", "http://example.com/", 1.0f, 2);

        verify(urlQueueService, times(1)).offerAll(anyString(), any());
    }

    /**
     * Test storeChildUrl with depth exceeding maxDepth.
     */
    public void test_storeChildUrl_exceedsMaxDepth() throws Exception {
        when(urlFilter.match("http://example.com/child")).thenReturn(true);

    }

    /**
     * Deletes all child documents that belong to the specified parent document.
     *
     * @param searchEngineClient the search engine client to use for deletion
     * @param id the parent document ID whose children should be deleted
     * @return the number of child documents that were deleted
     */

            return toUrl(uri.getPath());
        }

        /**
         * Constructs a child URL by appending the specified child path to the current URL.
         *
         * @param child The child path to append
         * @return The complete child URL
         */
        public String toChildUrl(final String child) {
            final String url = toUrl();
            if (url.endsWith("/")) {

                        SID.SID_FLAG_RESOLVE_SIDS);
                for (final SID child : children) {
                    if (!sidSet.contains(child)) {
                        processAllowedSIDs(file, child, sidSet);
                    }
                }
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {

                                org.codelibs.jcifs.smb.impl.SID.SID_FLAG_RESOLVE_SIDS);
                for (final SID child : children) {
                    if (!sidSet.contains(child)) {
                        processAllowedSIDs(file, child, sidSet);
                    }
                }
            } catch (final CIFSException e) {
                if (logger.isDebugEnabled()) {