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

            assertTrue(result);
            verify(mockConfig, times(2)).isAllowCompound("TestServerMessageBlock2Request");
        }

        @Test
        @DisplayName("allowChain should return false when config disallows compound")
        void testAllowChainDisallowed() {
            TestServerMessageBlock2Request nextRequest = new TestServerMessageBlock2Request(mockConfig);

            if (!exists) {
                allowedPaths.add(pattern);
            }
        }

        /**
         * Adds a disallowed path pattern to this directive.
         * Supports wildcards (*) and end-of-path ($) according to RFC 9309.
         * @param path the path pattern to disallow
         */
        public void addDisallow(final String path) {
            final PathPattern pattern = new PathPattern(path);

        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

    }

    /**
     * Initializes the disallowed compound operations based on the provided property string.
     *
     * @param prop comma-separated list of operations to disallow in compound requests
     */
    protected void initDisallowCompound(final String prop) {
        if (prop == null) {
            return;
        }
        final Set<String> disallow = new HashSet<>();

 * <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>
 *

        @DisplayName("Should define isAllow method returning boolean")
        void shouldDefineIsAllow() {
            ACE allowAce = mock(ACE.class);
            ACE denyAce = mock(ACE.class);
            when(allowAce.isAllow()).thenReturn(true);
            when(denyAce.isAllow()).thenReturn(false);

            assertTrue(allowAce.isAllow());
            assertFalse(denyAce.isAllow());
            verify(allowAce).isAllow();

        testBuffer[19] = 0x00;

        // Test decode
        int size = ace.decode(testBuffer, 0, testBuffer.length);

        // Verify results
        assertEquals(32, size);
        assertTrue(ace.isAllow());
        assertEquals(0x03, ace.getFlags());
        assertEquals(0x001200A9, ace.getAccessMask());
        assertNotNull(ace.getSID());
    }

    @Test
    @DisplayName("Test decode with deny ACE")

        // 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"));

http://ExAmPlE.CoM http://other.com/ s:http p:/ h:example.com

# Spaces should fail
http://example\sexample.com

# This should fail
http://Goo%20\sgoo%7C|.com

# U+3000 is mapped to U+0020 (space) which is disallowed
http://GOO\u00a0\u3000goo.com

# Other types of space (no-break, zero-width, zero-width-no-break) are
# name-prepped away to nothing.
# U+200B, U+2060, and U+FEFF, are ignored