// Verify results
        assertEquals(36, size);
        assertFalse(ace.isAllow());
        assertEquals(0x10, ace.getFlags());
        assertEquals(0x001F01FF, ace.getAccessMask());
        assertTrue(ace.isInherited());
    }

    @Test
    @DisplayName("Test isInherited with FLAGS_INHERITED flag")
    void testIsInherited() {
        ace.flags = 0x00;

 * FILE_WRITE_DATA</code>) and the target file has the following security
 * descriptor ACEs:
 *
 * <pre>
 * Allow WNET\alice     0x001200A9  Direct
 * Allow Administrators 0x001F01FF  Inherited
 * Allow SYSTEM         0x001F01FF  Inherited
 * </pre>
 *
 * the access check would fail because the direct ACE has an access mask
 * of <code>0x001200A9</code> which doesn't have the

 * FILE_WRITE_DATA</code>) and the target file has the following security
 * descriptor ACEs:
 *
 * <pre>
 * Allow WNET\alice     0x001200A9  Direct
 * Allow Administrators 0x001F01FF  Inherited
 * Allow SYSTEM         0x001F01FF  Inherited
 * </pre>
 *
 * the access check would fail because the direct ACE has an access mask
 * of <code>0x001200A9</code> which doesn't have the

 * FILE_WRITE_DATA</code>) and the target file has the following security
 * descriptor ACEs:
 * <pre>
 * Allow WNET\alice     0x001200A9  Direct
 * Allow Administrators 0x001F01FF  Inherited
 * Allow SYSTEM         0x001F01FF  Inherited
 * </pre>
 * the access check would fail because the direct ACE has an access mask
 * of <code>0x001200A9</code> which doesn't have the

        void testMaximalAccess() throws Exception {
            // Given
            setPrivateField(response, "maximalAccess", 0x001F01FF);

            // When
            int access = response.getMaximalAccess();

            // Then
            assertEquals(0x001F01FF, access, "Should return maximal access value");
        }

        @Test
        @DisplayName("Should decode response from bytes correctly")

        assertEquals((byte) 0x01, response.getShareType());
        assertEquals(0x00000001, response.getShareFlags());
        assertEquals(0x00000008, response.getCapabilities());
        assertEquals(0x001F01FF, response.getMaximalAccess());
    }

    @Test
    @DisplayName("Should not modify buffer during write operation")
    void testWriteDoesNotModifyBuffer() {
        // Given

            assertFalse((aliceDirectACE & ACE.FILE_WRITE_DATA) != 0, "Alice's direct ACE should not allow FILE_WRITE_DATA");

            // Inherited ACE: Allow Administrators 0x001F01FF
            int adminInheritedACE = 0x001F01FF;
            assertTrue((adminInheritedACE & ACE.FILE_READ_DATA) != 0, "Admin inherited ACE should allow FILE_READ_DATA");

     */
    public static final int NETWORK_INTERFACE_CAP_RDMA = 0x00000002;

    /**
     * FSCTL code for querying network interface information
     */
    public static final int FSCTL_QUERY_NETWORK_INTERFACE_INFO = 0x001401FC;

    /**
     * SMB2 session flag indicating channel binding
     */
    public static final int SMB2_SESSION_FLAG_BINDING = 0x01;

    /**
     * Size of network interface info structure in bytes
     */

        right ^= work;
        leftt ^= work << 16;

        work = (right >>> 2 ^ leftt) & 0x33333333;
        leftt ^= work;
        right ^= work << 2;

        work = (right >>> 8 ^ leftt) & 0x00ff00ff;
        leftt ^= work;
        right ^= work << 8;
        right = right << 1 | right >>> 31 & 1;

        work = (leftt ^ right) & 0xaaaaaaaa;
        leftt ^= work;
        right ^= work;

        assertEquals(0x001480F2, Smb2IoctlRequest.FSCTL_SRV_COPYCHUNK_WRITE);
        assertEquals(0x001401D4, Smb2IoctlRequest.FSCTL_LRM_REQUEST_RESILENCY);
        assertEquals(0x001401FC, Smb2IoctlRequest.FSCTL_QUERY_NETWORK_INTERFACE_INFO);
        assertEquals(0x000900A4, Smb2IoctlRequest.FSCTL_SET_REPARSE_POINT);
        assertEquals(0x000601B0, Smb2IoctlRequest.FSCTL_DFS_GET_REFERRALS_EX);