assertFalse(robotsTxt.allows("/store/public/sale", "PriorityBot")); // Most specific disallow
        assertFalse(robotsTxt.allows("/store/public/sale/item", "PriorityBot"));

        // Test SameLengthBot - Allow wins when same length as Disallow
        // Disallow: /page, Allow: /page
        assertTrue(robotsTxt.allows("/page", "SameLengthBot")); // Allow takes precedence

User-agent: PriorityBot
Disallow: /store
Allow: /store/public
Disallow: /store/public/sale

# Test Allow vs Disallow with same length (Allow wins)
User-agent: SameLengthBot
Disallow: /page
Allow: /page

# Test multiple wildcards
User-agent: MultiWildcardBot
Disallow: /*.cgi*
Disallow: /*?*id=*

# Test literal $ in middle of pattern
User-agent: DollarBot
Disallow: /price$info

Disallow: /test/

# Case 9: Special characters in paths
User-agent: SpecialCharBot
Disallow: /path with spaces/
Disallow: /path%20encoded/
Disallow: /path?query=value
Disallow: /path#fragment
Allow: /unicode/日本語/

# Case 10: Multiple User-agents in sequence
User-agent: Bot1
User-agent: Bot2
User-agent: Bot3
Disallow: /shared/

# Case 11: Sitemap with various formats
Sitemap: http://example.com/sitemap.xml

 *
 * <p>Key features:</p>
 * <ul>
 *   <li>Supports multiple user-agent directives with pattern matching</li>
 *   <li>Handles Allow and Disallow rules for path-based access control</li>
 *   <li>Manages crawl delay settings per user agent</li>
 *   <li>Stores sitemap URLs listed in robots.txt</li>
 * </ul>
 *

 * <li>Disallow and Allow directives with pattern matching</li>
 * <li>Wildcard (*) in paths - matches any sequence of characters</li>
 * <li>End-of-path ($) matching - matches the end of URL path</li>
 * <li>Crawl-delay directive</li>
 * <li>Sitemap directive</li>
 * <li>Comment support (#)</li>
 * <li>Priority-based matching (longest match wins, Allow beats Disallow at equal length)</li>
 * </ul>
 *

        directive.addDisallow("/admin/");
        directive.addDisallow("/private/");

        String[] disallows = directive.getDisallows();
        assertEquals(2, disallows.length);
        assertEquals("/admin/", disallows[0]);
        assertEquals("/private/", disallows[1]);
    }

    public void test_directiveAddDisallowNoDuplicates() {
        // Test that addDisallow doesn't add duplicates

     */
    protected void initDisallowCompound(final String prop) {
        if (prop == null) {
            return;
        }
        final Set<String> disallow = new HashSet<>();
        final StringTokenizer st = new StringTokenizer(prop, ",");
        while (st.hasMoreTokens()) {
            disallow.add(st.nextToken().trim());
        }

        this.redirectHttpStatusPattern = redirectHttpStatusPattern;
    }

    /**
     * Sets whether to use robots.txt disallow rules.
     *
     * @param useRobotsTxtDisallows True to use disallow rules, false otherwise
     */
    public void setUseRobotsTxtDisallows(final boolean useRobotsTxtDisallows) {
        this.useRobotsTxtDisallows = useRobotsTxtDisallows;
    }

        // Check protocol versions
        assertNotNull(testConfig.getMinimumVersion());
        assertNotNull(testConfig.getMaximumVersion());

        // Check disallow compound
        assertNotNull(testConfig.disallowCompound);
        assertTrue(testConfig.disallowCompound.contains("Smb2SessionSetupRequest"));
        assertTrue(testConfig.disallowCompound.contains("Smb2TreeConnectRequest"));

    /*
     * Note that we allow (in contravention of a strict interpretation of the relevant RFCs) domain
     * parts other than the last may begin with a digit (for example, "3com.com"). It's important to
     * disallow an initial digit in the last part; it's the only thing that stops an IPv4 numeric
     * address like 127.0.0.1 from looking like a valid domain name.
     */

    if (isFinalPart && DIGIT_MATCHER.matches(part.charAt(0))) {