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(24, ServerMessageBlock2.size8(17));
        }

        @Test
        @DisplayName("Should calculate size8 with alignment")
        void testSize8WithAlignment() {
            assertEquals(8, ServerMessageBlock2.size8(8, 0));
            // size8(10, 2): rem = 10%8 - 2 = 2 - 2 = 0, returns 10
            assertEquals(10, ServerMessageBlock2.size8(10, 2));

                size += size8(ccr.size());
            }
        }
        return size8(size);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

    }

    /**
     * Rounds up the size to 8-byte alignment.
     *
     * @param size the size to align
     * @return the aligned size
     */
    protected static final int size8(final int size) {
        return size8(size, 0);
    }

    /**
     * Rounds up the size to the specified alignment.
     *
     * @param size the size to align
     * @param align the alignment boundary

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

    @Test
    @DisplayName("Test size calculation with empty path")
    void testSizeWithEmptyPath() {
        request = new Smb2CreateRequest(mockConfig, "");

        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 56;
        expectedSize += 8; // size8(1) - empty name gets 1 byte
        expectedSize = ((expectedSize + 7) / 8) * 8; // size8(size)

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

        // Then
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 24;
        int alignedSize = (expectedSize + 7) & ~7; // size8 alignment
        assertEquals(alignedSize, size);
    }

    @Test
    @DisplayName("Should write correct bytes to wire format with session binding")
    void testWriteBytesWireFormatWithSessionBinding() throws Exception {

        }

        @Test
        @DisplayName("Size should be consistent across multiple calls")
        void testSizeConsistency() {
            int size1 = echoRequest.size();
            int size2 = echoRequest.size();

            assertEquals(size1, size2);
        }

        @Test
        @DisplayName("Size should be 72 bytes (64 header + 4 body aligned to 8)")

    }

    @Test
    @DisplayName("Test size method without input buffer")
    void testSizeWithoutInputBuffer() {
        request = new Smb2QueryInfoRequest(mockConfig);

        int size = request.size();

        // Expected size calculation: size8(SMB2_HEADER_LENGTH + 40)
        // size8 rounds up to nearest multiple of 8

    }

    @Test
    @DisplayName("Test size method")
    void testSize() {
        request = new Smb2SetInfoRequest(mockConfig);
        Encodable mockInfo = mock(Encodable.class);
        when(mockInfo.size()).thenReturn(100);
        request.setInfo(mockInfo);

        int size = request.size();

        // Expected size calculation: size8(SMB2_HEADER_LENGTH + 32 + info.size())

        // When
        int shortSize = shortReq.size();
        int longSize = longReq.size();

        // Then
        // SMB2_HEADER_LENGTH + 8 + path.length() * 2 (UTF-16LE)
        int expectedShortSize = Smb2Constants.SMB2_HEADER_LENGTH + 8 + shortPath.length() * 2;
        int expectedLongSize = Smb2Constants.SMB2_HEADER_LENGTH + 8 + longPath.length() * 2;

        // size8 method aligns to 8-byte boundary