}

        @Test
        @DisplayName("Should align size to 8-byte boundary")
        void testSizeAlignment() {
            // Test various data lengths to ensure 8-byte alignment
            for (int i = 0; i < 16; i++) {
                request.setData(new byte[i], 0, i);
                int size = request.size();
                assertEquals(0, size % 8, "Size should be aligned to 8-byte boundary");

    }

    /**
     * Gets the page size.
     * @return The page size.
     */
    public int getPageSize() {
        if (pageSize <= 0) {
            pageSize = getDefaultPageSize();
        }
        return pageSize;
    }

    /**
     * Sets the page size.
     * @param pageSize The page size.
     */
    public void setPageSize(final int pageSize) {

        Smb2TreeDisconnectRequest request = new Smb2TreeDisconnectRequest(mockConfig);

        // When
        int size = request.size();

        // Then
        // Verify size includes SMB2_HEADER_LENGTH
        assertTrue(size >= Smb2Constants.SMB2_HEADER_LENGTH);

        // The actual calculation: (SMB2_HEADER_LENGTH + 4 + 7) & ~7

            assertEquals(expectedSize, req.size());
        }

        @Test
        @DisplayName("Should align size to 8-byte boundary")
        void testSizeAlignment() {
            int size = request.size();
            assertEquals(0, size % 8, "Size should be aligned to 8-byte boundary");
        }

        @ParameterizedTest
        @DisplayName("Should calculate size for various lock counts")

        List<AnalyzeToken> tokensTitle = analyzer.analyze(text, "title", lang);
        assertNotNull(tokensTitle);
        assertEquals(2, tokensTitle.size());

        // Test with null field
        List<AnalyzeToken> tokensNull = analyzer.analyze(text, null, lang);
        assertNotNull(tokensNull);
        assertEquals(2, tokensNull.size());
    }

    @Test

    @DisplayName("Should return max transact size")
    void testGetMaxTransactSize() throws Exception {
        // Given
        setPrivateField(response, "maxTransactSize", 1048576);

        // When
        int size = response.getMaxTransactSize();

        // Then
        assertEquals(1048576, size);
    }

    @Test
    @DisplayName("Should return transaction buffer size")

            // When
            int size = copy.size();

            // Then
            assertEquals(HEADER_SIZE, size);
        }

        @Test
        @DisplayName("Should return correct size with single chunk")
        void testSizeWithSingleChunk() {
            // Given
            byte[] sourceKey = new byte[SOURCE_KEY_SIZE];

        byte[] buffer = new byte[104]; // Exact size needed
        int offset = 0;

        setHeaderStart(response, 64);

        // Write structure
        SMBUtil.writeInt2(9, buffer, offset);
        SMBUtil.writeInt2(80 - 64, buffer, offset + 2);
        SMBUtil.writeInt4(24, buffer, offset + 4); // Exact notification size

        // Write notification
        int notifyOffset = 80;

    @Mock
    Configuration cfg;

    // Verifies constructor that accepts Configuration reads the expected values and uses them
    @Test
    @DisplayName("Constructor(Configuration) uses cache size and maximum buffer size from config")
    void constructorUsesConfigurationAndAllocatesWithConfiguredSize() {
        when(cfg.getBufferCacheSize()).thenReturn(2);
        when(cfg.getMaximumBufferSize()).thenReturn(5);

    /**
     * Default maximum receive size (8KB)
     */
    public static final int DEFAULT_MAX_RECEIVE_SIZE = 8192;

    /**
     * Default maximum fragmented size (128KB)
     */
    public static final int DEFAULT_MAX_FRAGMENTED_SIZE = 131072; // 128KB

    /**
     * Default maximum read/write size (1MB)
     */
    public static final int DEFAULT_MAX_READ_WRITE_SIZE = 1048576; // 1MB