* Send multiple fragments
                             */

                            do {
                                doSend0(req);
                            } while (req.hasMoreElements() && req.nextElement() != null);

                            /*
                             * Receive multiple fragments
                             */

        assertFalse(urlFilter.match("https://example.org/"));
        assertFalse(urlFilter.match("ftp://files.example.com/"));
    }

    /**
     * Test match with query parameters and fragments
     */
    public void test_match_urlWithQueryAndFragment() {
        String sessionId = "test-session-011";
        urlFilter.init(sessionId);

        urlFilter.addInclude("https://example.com/search.*");

    // Text Fragment Constants
    // ============================================================

    /** Text fragments feature identifier. */
    public static final String TEXT_FRAGMENTS = "text_fragments";

    /** Text fragment type for query highlighting. */
    public static final String TEXT_FRAGMENT_TYPE_QUERY = "query";

    /** Text fragment type for result highlighting. */

                    // NOP
                }
            }
        }
        return buf.toString();
    }

    /**
     * Normalizes a URL by removing fragments, resolving relative paths, and cleaning up.
     *
     * @param u the URL to normalize
     * @return the normalized URL
     */
    protected String normalizeUrl(final String u) {
        if (u == null) {

     * resolved. If the names cannot be resolved (e.g. due to temporary
     * network failure), the said methods will return default values (usually
     * <code>S-X-Y-Z</code> strings of fragments of).
     * <p>
     * Alternatively <code>getSecurity(true)</code> may be used to resolve all
     * SIDs together and detect network failures.
     *
     * @return array of ACEs

            assertThrows(CIFSException.class, handle::getSessionKey);
        }
    }

    @Nested
    @DisplayName("Send/Receive Fragment Tests")
    class SendReceiveFragmentTests {

        @Test
        @DisplayName("Should send and receive fragment successfully")
        void testDoSendReceiveFragment_Success() throws Exception {
            DcerpcPipeHandle handle = createMockedDcerpcPipeHandle();

    }

    @Nested
    @DisplayName("Constants Validation Tests")
    class ConstantsValidationTests {

        @Test
        @DisplayName("All fragment flags should have unique values")
        void testFragmentFlagsUniqueness() {
            // Verify that fragment flags are unique and follow bit pattern
            assertEquals(1, Integer.bitCount(DcerpcConstants.DCERPC_FIRST_FRAG), "DCERPC_FIRST_FRAG should be a single bit");

    /**
     * Receives a DCERPC fragment from the remote endpoint
     * @param buf the buffer to receive the fragment data
     * @return the number of bytes received
     * @throws IOException if an I/O error occurs during reception
     */
    protected abstract int doReceiveFragment(byte[] buf) throws IOException;

    /**
     * Sends a DCERPC fragment and receives the response in a single operation

        }
        return null;
    }

    @Override
    public String toString() {
        return binding.toString();
    }

    /**
     * Sends a DCERPC fragment to the remote endpoint
     * @param buf the buffer containing the fragment
     * @param off the offset into the buffer
     * @param length the length of data to send
     * @param isDirect whether to use direct transmission

        @Test
        @DisplayName("Should handle basic send/receive fragment methods")
        void testSendReceiveFragmentMethods() throws IOException {
            // Given: Test handle with configured return values
            handle.setDoSendReceiveFragmentReturn(100);
            handle.setDoReceiveFragmentReturn(50);

            // When: Calling fragment methods