assertEquals(0x04, SmbConstants.ATTR_SYSTEM);
        assertEquals(0x08, SmbConstants.ATTR_VOLUME);
        assertEquals(0x10, SmbConstants.ATTR_DIRECTORY);
        assertEquals(0x20, SmbConstants.ATTR_ARCHIVE);
        assertEquals(0x800, SmbConstants.ATTR_COMPRESSED);
        assertEquals(0x080, SmbConstants.ATTR_NORMAL);
        assertEquals(0x100, SmbConstants.ATTR_TEMPORARY);
    }

    @Test

     */
    int ATTR_HIDDEN = 0x02;
    /**
     * File is marked a system file
     */
    int ATTR_SYSTEM = 0x04;
    /**
     * File is marked a volume
     */
    int ATTR_VOLUME = 0x08;
    /**
     * File is a directory
     */
    int ATTR_DIRECTORY = 0x10;

    /**
     * Files is marked to be archived
     */
    int ATTR_ARCHIVE = 0x20;

            src[srcIndex + 1 + (i * 18) + 16] = 0x04; // Active flag
        }

        // MAC address
        int macOffset = srcIndex + 1 + (18 * numNames);
        byte[] testMac = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
        System.arraycopy(testMac, 0, src, macOffset, 6);

        // Statistics
        byte[] stats = { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15 };

        byte[] customData = new byte[8];
        customData[0] = 0x01;
        customData[7] = 0x08;

        byte[] machineId = new byte[32];
        machineId[0] = 0x10;
        machineId[31] = 0x20;

        AvSingleHost avSingleHost = new AvSingleHost(customData, machineId);

        assertNotNull(avSingleHost);
        assertEquals(AvPair.MsvAvSingleHost, avSingleHost.getType());

            ownerNodeType = (src[srcIndex + 16] & 0x60) >> 5;
            isBeingDeleted = ((src[srcIndex + 16] & 0x10) == 0x10) == true;
            isInConflict = ((src[srcIndex + 16] & 0x08) == 0x08) == true;
            isActive = ((src[srcIndex + 16] & 0x04) == 0x04) == true;
            isPermanent = ((src[srcIndex + 16] & 0x02) == 0x02) == true;

            /*

        assertEquals(0x10, Smb2TreeConnectResponse.SMB2_SHAREFLAG_AUTO_CACHING);
        assertEquals(0x20, Smb2TreeConnectResponse.SMB2_SHAREFLAG_VDO_CACHING);
        assertEquals(0x1, Smb2TreeConnectResponse.SMB2_SHAREFLAG_DFS);
        assertEquals(0x2, Smb2TreeConnectResponse.SMB2_SHAREFLAG_DFS_ROOT);
        assertEquals(0x100, Smb2TreeConnectResponse.SMB2_SHAREFLAG_RESTRICT_EXCLUSIVE_OPENS);

    private static final int FLAGS_REQUEST_OPLOCK = 0x02;
    private static final int FLAGS_REQUEST_BATCH_OPLOCK = 0x04;

    // Access Mode Encoding for desiredAccess
    private static final int SHARING_COMPATIBILITY = 0x00;
    private static final int SHARING_DENY_READ_WRITE_EXECUTE = 0x10;
    private static final int SHARING_DENY_WRITE = 0x20;
    private static final int SHARING_DENY_READ_EXECUTE = 0x30;

    public static final int SMB2_SHAREFLAG_DFS_ROOT = 0x2;
    /**
     * Share flag indicating that exclusive opens are restricted on this share.
     */
    public static final int SMB2_SHAREFLAG_RESTRICT_EXCLUSIVE_OPENS = 0x100;
    /**
     * Share flag indicating that shared delete is forced for this share.
     */
    public static final int SMB2_SHAREFLAG_FORCE_SHARED_DELETE = 0x200;
    /**

    void fileAttributesTest() {
        assertEquals(0x01, SmbConstants.ATTR_READONLY);
        assertEquals(0x02, SmbConstants.ATTR_HIDDEN);
        assertEquals(0x04, SmbConstants.ATTR_SYSTEM);
        assertEquals(0x08, SmbConstants.ATTR_VOLUME);
        assertEquals(0x10, SmbConstants.ATTR_DIRECTORY);
    }

    /**
     * Test FLAGS constants.
     */
    @Test
    @DisplayName("FLAGS constants are correct")

        assertEquals(0x06, buffer[10]);
        assertEquals(0x07, buffer[11]);
        assertEquals(0x08, buffer[12]);
    }

    @Test
    void testReadOctetArray() {
        byte[] sourceData = { 0x10, 0x11, 0x12, 0x13, 0x14 };
        System.arraycopy(sourceData, 0, buffer, 0, sourceData.length);

        byte[] destData = new byte[5];
        ndrBuffer.readOctetArray(destData, 0, sourceData.length);