setField(session, "sessionId", 99L);

        when(enc.encryptMessage(any(byte[].class), eq(99L))).thenReturn(new byte[] { 9, 9 });
        when(enc.decryptMessage(any(byte[].class))).thenReturn(new byte[] { 7, 7 });

        assertTrue(session.isEncryptionEnabled());
        assertSame(enc, session.getEncryptionContext());

        byte[] encOut = session.encryptMessage(new byte[] { 1, 2, 3 });

    @DisplayName("Test multiple property settings")
    void testMultiplePropertySettings() {
        // Given
        long mid = 99999L;
        long asyncId = 88888L;
        int credits = 5;
        int treeId = 77;

        // When
        Smb2CancelRequest request = new Smb2CancelRequest(mockConfig, mid, asyncId);
        request.setRequestCredits(credits);
        request.setTid(treeId);

        // Then

        // size8 rounds up to nearest multiple of 8
        int expectedRawSize = Smb2Constants.SMB2_HEADER_LENGTH + 32 + 100;
        int expectedSize = (expectedRawSize + 7) & ~7; // Round up to nearest 8
        assertEquals(expectedSize, size);
    }

    @Test
    @DisplayName("Test writeBytesWireFormat method")
    void testWriteBytesWireFormat() {

        int expectedLongSize = Smb2Constants.SMB2_HEADER_LENGTH + 8 + longPath.length() * 2;

        // size8 method aligns to 8-byte boundary
        int alignedShortSize = (expectedShortSize + 7) & ~7;
        int alignedLongSize = (expectedLongSize + 7) & ~7;

        assertEquals(alignedShortSize, shortSize);
        assertEquals(alignedLongSize, longSize);
    }

    @Test

        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() {
        // Given

        Subject: CN = consoleAdmin
        Subject Public Key Info:
            Public Key Algorithm: ED25519
                ED25519 Public-Key:
                pub:
                    5a:91:87:b8:77:fe:d4:af:d9:c7:c7:ce:55:ae:74:
                    aa:f3:f1:fe:04:63:9b:cb:20:97:61:97:90:94:fa:
                    12:8b
        X509v3 extensions:
            X509v3 Key Usage: critical
                Digital Signature

        void testSize() {
            int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 4;
            // size8 rounds up to 8-byte boundary
            int expectedAlignedSize = (expectedSize + 7) & ~7;

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

        @Test
        @DisplayName("Size should be consistent across multiple calls")
        void testSizeConsistency() {

		}
	}
}

func TestFormatNumeric(t *testing.T) {
	vectors := []struct {
		in   int64
		want string
		ok   bool
	}{
		// Test base-8 (octal) encoded values.
		{0, "0\x00", true},
		{7, "7\x00", true},
		{8, "\x80\x08", true},
		{077, "77\x00", true},
		{0100, "\x80\x00\x40", true},
		{0, "0000000\x00", true},
		{0123, "0000123\x00", true},
		{07654321, "7654321\x00", true},

    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")
    void testWriteBytesWireFormat() {

	_ = x[ErrSignatureDoesNotMatch-71]
	_ = x[ErrMethodNotAllowed-72]
	_ = x[ErrInvalidPart-73]
	_ = x[ErrInvalidPartOrder-74]
	_ = x[ErrMissingPart-75]
	_ = x[ErrAuthorizationHeaderMalformed-76]
	_ = x[ErrMalformedPOSTRequest-77]
	_ = x[ErrPOSTFileRequired-78]
	_ = x[ErrSignatureVersionNotSupported-79]
	_ = x[ErrBucketNotEmpty-80]
	_ = x[ErrAllAccessDisabled-81]
	_ = x[ErrPolicyInvalidVersion-82]
	_ = x[ErrMissingFields-83]