}
    assertCrc(0xd022db97, descending);
  }

  public void testScsiReadCommand() {
    // Test SCSI read command.
    byte[] scsiReadCommand =
        new byte[] {
          0x01, (byte) 0xc0, 0x00, 0x00,
          0x00, 0x00, 0x00, 0x00,
          0x00, 0x00, 0x00, 0x00,
          0x00, 0x00, 0x00, 0x00,
          0x14, 0x00, 0x00, 0x00,
          0x00, 0x00, 0x04, 0x00,

    /** Maximum supported SMB Direct protocol version (1.0) */
    public static final int MAX_VERSION = 0x0100; // SMB Direct 1.0
    /** SMB Direct negotiate request message type */
    public static final int NEGOTIATE_REQUEST = 0x01;

    // Message fields
    private int minVersion = MIN_VERSION;
    private int maxVersion = MAX_VERSION;
    private int reserved = 0;
    private int creditsRequested = RdmaCapabilities.DEFAULT_SEND_CREDIT_TARGET;

        byte[] buffer = new byte[10];
        // sid = 1
        writeInt2(1, buffer, 0);
        // numEntries = 2
        writeInt2(2, buffer, 2);
        // isEndOfSearch = true
        buffer[4] = 0x01;
        buffer[5] = 0x00;
        // eaErrorOffset = 3
        writeInt2(3, buffer, 6);
        // lastNameOffset = 4
        writeInt2(4, buffer, 8);

            // When: Creating close handle message
            samr.SamrCloseHandle message = new samr.SamrCloseHandle(mockPolicyHandle);

            // Then: Should have correct opnum and handle
            assertEquals(0x01, message.getOpnum());
            assertEquals(mockPolicyHandle, message.handle);
        }

        @Test
        @DisplayName("Should encode input parameters correctly")

        // 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);
        assertEquals(50, serverData.maxMpxCount);

        @Test
        @DisplayName("Should have correct values for inheritance flags")
        void shouldHaveCorrectInheritanceFlags() {
            assertEquals(0x01, ACE.FLAGS_OBJECT_INHERIT, "FLAGS_OBJECT_INHERIT should be 0x01");
            assertEquals(0x02, ACE.FLAGS_CONTAINER_INHERIT, "FLAGS_CONTAINER_INHERIT should be 0x02");
            assertEquals(0x04, ACE.FLAGS_NO_PROPAGATE, "FLAGS_NO_PROPAGATE should be 0x04");

            buffer[i] = 0x00;
        }

        // Reserved (2 bytes)
        buffer[22] = 0x00;
        buffer[23] = 0x00;

        // TID (2 bytes)
        buffer[24] = 0x01;
        buffer[25] = 0x00;

        // PID (2 bytes)
        buffer[26] = 0x02;
        buffer[27] = 0x00;

        // UID (2 bytes)
        buffer[28] = 0x03;
        buffer[29] = 0x00;

    static final int FILE_SYNCHRONOUS_IO_ALERT = 0x00000010;
    static final int FILE_SYNCHRONOUS_IO_NONALERT = 0x00000020;

    // security flags
    static final int SECURITY_CONTEXT_TRACKING = 0x01;
    static final int SECURITY_EFFECTIVE_ONLY = 0x02;

    private int rootDirectoryFid;

    private final int extFileAttributes;

    private final int shareAccess;

    private int createDisposition;

            dst[dstIndex + 2 * i + 1] = (byte) (((tmp[i] & 0xF0) >> 4) + 0x41);
            dst[dstIndex + 2 * i + 2] = (byte) ((tmp[i] & 0x0F) + 0x41);
        }
        for (; i < 15; i++) {
            dst[dstIndex + 2 * i + 1] = (byte) 0x43;
            dst[dstIndex + 2 * i + 2] = (byte) 0x41;
        }
        dst[dstIndex + TYPE_OFFSET] = (byte) (((this.hexCode & 0xF0) >> 4) + 0x41);

    /**
     * Generic read permission
     */
    int GENERIC_READ = 0x80000000; // 31

    /**
     * Inheritance flag: child objects inherit this ACE
     */
    int FLAGS_OBJECT_INHERIT = 0x01;
    /**
     * Inheritance flag: child containers inherit this ACE
     */
    int FLAGS_CONTAINER_INHERIT = 0x02;
    /**
     * Inheritance flag: inheritance stops after one level
     */