new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };

        Smb2LeaseKey key = new Smb2LeaseKey(originalBytes);
        byte[] retrievedKey = key.getKey();

        // Modify the retrieved key
        retrievedKey[0] = (byte) 0xFF;

        // Original key should remain unchanged
        assertEquals(0x01, key.getKey()[0]);
    }

                assertTrue(flag >= 0x00 && flag <= 0xFF,
                        String.format("Fragment flag 0x%02X should be in valid byte range 0x00-0xFF", flag));
            }
        }

        @Test
        @DisplayName("RPC packet flags should be within byte range")
        void testRpcPacketFlagsRange() {
            // Verify that RPC packet flags are within byte range (0x00-0xFF)

     */
    @Test
    @DisplayName("Test byte array fields (encryptionKey and guid)")
    public void testByteArrayFields() {
        // Test encryptionKey
        byte[] key = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
        serverData.encryptionKey = key;
        assertNotNull(serverData.encryptionKey);
        assertArrayEquals(key, serverData.encryptionKey);

        // Test with empty array

    private Smb2LeaseKey testKey;
    private int testState;

    @BeforeEach
    void setUp() {
        byte[] keyBytes = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };
        testKey = new Smb2LeaseKey(keyBytes);
        testState = Smb2LeaseState.SMB2_LEASE_READ_WRITE;
        leaseContext = new LeaseV1CreateContextRequest(testKey, testState);

     */
    int RPC_PT_REQUEST = 0x00;
    /**
     * Ping packet type
     */
    int RPC_PT_PING = 0x01;
    /**
     * Response packet type
     */
    int RPC_PT_RESPONSE = 0x02;
    /**
     * Fault packet type - indicates an error
     */
    int RPC_PT_FAULT = 0x03;
    /**
     * Bind packet type - establishes context
     */
    int RPC_PT_BIND = 0x0B;
    /**

        this.hexCode = (src[srcIndex + TYPE_OFFSET] & 0xFF) - 0x41 << 4;
        this.hexCode |= (src[srcIndex + TYPE_OFFSET + 1] & 0xFF) - 0x41 & 0x0F;
        return SCOPE_OFFSET + readScopeWireFormat(src, srcIndex + SCOPE_OFFSET);
    }

    int writeScopeWireFormat(final byte[] dst, int dstIndex) {
        if (this.scope == null) {
            dst[dstIndex] = (byte) 0x00;
            return 1;
        }

            if (tmp[i] != (byte) ' ') {
                length = i + 1;
            }
        }
        try {
            name = new String(tmp, 0, length, Name.OEM_ENCODING);
        } catch (final UnsupportedEncodingException uee) {}
        hexCode = (src[srcIndex + TYPE_OFFSET] & 0xFF) - 0x41 << 4;
        hexCode |= (src[srcIndex + TYPE_OFFSET + 1] & 0xFF) - 0x41 & 0x0F;

        @Test
        @DisplayName("Various byte values are converted to uppercase hex")
        void testHexConversion() {
            byte[] challenge = new byte[] { (byte) 0x00, (byte) 0x0F, (byte) 0x10, (byte) 0x7F, (byte) 0x80, (byte) 0xFF };
            UniAddress dc = mock(UniAddress.class);
            when(dc.toString()).thenReturn("DC");

            NtlmChallenge nc = new NtlmChallenge(challenge, dc);

        assertEquals(34, bytesRead);

        // Assert that the serverData fields are populated correctly
        assertEquals(0, response.dialectIndex);
        assertEquals(0x0F, serverData.securityMode);
        assertEquals(0x01, serverData.security);
        assertTrue(serverData.encryptedPasswords);
        assertTrue(serverData.signaturesEnabled);
        assertTrue(serverData.signaturesRequired);

        final char[] c = new char[2 * size];
        for (int i = 0, j = 0; i < size; i++) {
            c[j] = HEX_DIGITS[src[srcIndex + i] >> 4 & 0x0F];
            j++;
            c[j++] = HEX_DIGITS[src[srcIndex + i] & 0x0F];
        }
        return new String(c);
    }

    /**
     * Converts a byte array to a hexadecimal string representation.
     *