０ => 0
１ => 1
２ => 2
３ => 3
４ => 4
５ => 5
６ => 6
７ => 7
８ => 8
９ => 9

① => 1\u0020
② => 2\u0020
③ => 3\u0020
④ => 4\u0020
⑤ => 5\u0020
⑥ => 6\u0020
⑦ => 7\u0020
⑧ => 8\u0020
⑨ => 9\u0020

！ => !
？ => ?
＃ => #
％ => %
＆ => &
＠ => @
＋ => +
－ => -
＊ => *
／ => /
＝ => =
＄ => $
＾ => ^
： => :
； => ;
’ => '

        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

        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

        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

        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 + 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]

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

    assertTrue(Range.open(3, 7).isConnected(Range.closed(5, 6)));
    assertFalse(Range.closed(3, 5).isConnected(Range.closed(7, 8)));
    assertFalse(Range.closed(3, 5).isConnected(Range.closedOpen(7, 7)));
  }

  private static void checkContains(Range<Integer> range) {
    assertFalse(range.contains(4));
    assertTrue(range.contains(5));
    assertTrue(range.contains(7));
    assertFalse(range.contains(8));