// Then
        // Size should be aligned to 8 bytes: SMB2_HEADER_LENGTH + 32
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 32;
        // The size8 method aligns to 8-byte boundary
        int alignedSize = (expectedSize + 7) & ~7;
        assertEquals(alignedSize, size);
    }

    @Test
    @DisplayName("Should write correct bytes to wire format")
    void testWriteBytesWireFormat() {

	PDEPD R1, R2, R3                        // 7c231138
	PEXTD R1, R2, R3                        // 7c231178
	PLBZ 1234(R1), $0, R3                   // 06000000886104d260000000
	// Note, PLD crosses a 64B boundary, and a nop is inserted between PLBZ and PLD
	PLD 1234(R1), $0, R3                    // 04000000e46104d2
	PLFD 1234(R1), $0, F3                   // 06000000c86104d2
	PLFS 1234567890(R4), $0, F3             // 06004996c06402d2

        thread2.start();

        thread1.join();
        thread2.join();

        // Should complete without errors
        assertNotNull(urlFilter);
    }

    /**
     * Test boundary conditions
     */
    public void test_boundaryConditions() {
        String sessionId = "test-session-024";
        urlFilter.init(sessionId);

        // Test empty pattern
        urlFilter.addInclude("");

    }

    @Test
    @DisplayName("size should return correct message size")
    void testSize() {
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 24;
        // size8 method rounds up to 8-byte boundary
        int expectedAlignedSize = (expectedSize + 7) & ~7;

        assertEquals(expectedAlignedSize, request.size());
    }

    @Test
    @DisplayName("writeBytesWireFormat should write correct structure")

            // String data in UTF-16LE
            buf.writeOctetArray(wideBytes, 0, wideBytes.length);
            buf.enc_ndr_short(0); // Wide null terminator

            // Pad to 4-byte boundary
            int padding = (4 - ((wideBytes.length + 2) % 4)) % 4;
            for (int i = 0; i < padding; i++) {
                buf.enc_ndr_small(0);
            }
        }
    }

    /**

        assertEquals(0, result);

        result = response.readDataWireFormat(null, 0, 0);
        assertEquals(0, result);
    }

    @Test
    @DisplayName("Test boundary conditions for buffer offsets")
    void testBoundaryConditions() {
        byte[] smallBuffer = new byte[10];

        // Test with maximum offset

        assertEquals(Smb2Constants.SMB2_HEADER_LENGTH + 8, Smb2QueryDirectoryResponse.OVERHEAD);
    }

    @Test
    @DisplayName("Test readBytesWireFormat with buffer boundary conditions")
    void testReadBytesWireFormatBufferBoundary() throws Exception {
        response = new Smb2QueryDirectoryResponse(mockConfig, Smb2QueryDirectoryRequest.FILE_BOTH_DIRECTORY_INFO);

        assertEquals(largeData.length, pairs.get(0).getRaw().length, "Data length should match");
    }

    /**
     * Test with data that has exact boundary conditions
     */
    @Test
    @DisplayName("Handle exact boundary data size")
    void testExactBoundarySize() throws CIFSException {
        // Test with data that ends exactly at the position where EOL should be checked

   *
   * @throws NoSuchElementException if this set is empty
   */
  public abstract Range<C> range();

  /**
   * Returns the minimal range with the given boundary types for which all values in this set are
   * {@linkplain Range#contains(Comparable) contained} within the range.
   *
   * <p>Note that this method will return ranges with unbounded endpoints if {@link BoundType#OPEN}

query.highlight.tag.pre=<strong>
# Tag to use after highlighted text.
query.highlight.tag.post=</strong>
# Boundary characters for query highlighting.
query.highlight.boundary.chars=u0009u000Au0013u0020
# Maximum scan for query highlight boundaries.
query.highlight.boundary.max.scan=20
# Scanner type for query highlight boundaries.
query.highlight.boundary.scanner=chars
# Encoder type for query highlighting.
query.highlight.encoder=default