*/
    public static final int SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY = 0x10;

    /**
     * Share capability indicating scale-out support.
     */
    public static final int SMB2_SHARE_CAP_SCALEOUT = 0x20;

    /**
     * Share capability indicating cluster support.
     */
    public static final int SMB2_SHARE_CAP_CLUSTER = 0x40;

    /**
     * Share capability indicating asymmetric support.
     */

        final int start = bufferIndex;

        this.fid = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        this.typeOfLock = buffer[bufferIndex];

        if ((this.typeOfLock & 0x10) == 0x10) {
            this.largeFile = true;
        }

        this.newOpLockLevel = buffer[bufferIndex + 1];
        bufferIndex += 2;

        this.timeout = SMBUtil.readInt4(buffer, bufferIndex);

        // Put data at offset 0x20
        SMBUtil.writeInt2(0, ctx, ci); // Reserved
        SMBUtil.writeInt2(0x20, ctx, ci + 2); // DataOffset
        ci += 4;
        SMBUtil.writeInt4(8, ctx, ci); // DataLength
        ci += 4;
        // Name bytes at 0x10
        byte[] name = new byte[] { 'T', 'E', 'S', 'T' };
        System.arraycopy(name, 0, ctx, 0x10, name.length);
        // Data bytes at 0x20

            for (j = srcIndex + 14; src[j] == 0x20; j--) {
                ;
            }
            n = Strings.fromOEMBytes(src, srcIndex, j - srcIndex + 1, this.config);
            hexCode = src[srcIndex + 15] & 0xFF;
            groupName = ((src[srcIndex + 16] & 0x80) == 0x80) == true;
            ownerNodeType = (src[srcIndex + 16] & 0x60) >> 5;

        assertEquals(1, SMBUtil.readInt2(buffer, 8));
        assertEquals(1, SMBUtil.readInt2(buffer, 10));
    }

    /**
     * Test that a large file lock (bit 0x10 set) is encoded and decoded correctly.
     */
    @ParameterizedTest
    @ValueSource(ints = { 0x10, 0x11 })
    void largeFileFlagSet_and_decoded_according_to_type(int type) throws Exception {
        Configuration cfg = mock(Configuration.class);

    void testSmbFlags() {
        assertEquals(0x00, SmbConstants.FLAGS_NONE);
        assertEquals(0x01, SmbConstants.FLAGS_LOCK_AND_READ_WRITE_AND_UNLOCK);
        assertEquals(0x02, SmbConstants.FLAGS_RECEIVE_BUFFER_POSTED);
        assertEquals(0x08, SmbConstants.FLAGS_PATH_NAMES_CASELESS);
        assertEquals(0x10, SmbConstants.FLAGS_PATH_NAMES_CANONICALIZED);
        assertEquals(0x20, SmbConstants.FLAGS_OPLOCK_REQUESTED_OR_GRANTED);

		0xad, 0xef, 0xf4, 0x4d, 0xe7, 0xe, 0x82, 0x7f, 0x48, 0x78, 0x43, 0x24, 0x39,
		0xbf, 0xee, 0xb9, 0x60, 0x68, 0xd0, 0x47, 0x4f, 0xc5, 0xd, 0x6d, 0x90, 0xbf,
		0x3a, 0x98, 0xdf, 0xaf, 0x10, 0x40, 0xc8, 0x9c, 0x2, 0xd6, 0x92, 0xab, 0x3b,
		0x3c, 0x28, 0x96, 0x60, 0x9d, 0x86, 0xfd, 0x73, 0xb7, 0x74, 0xce, 0x7, 0x40,
		0x64, 0x7c, 0xee, 0xea, 0xa3, 0x10, 0xbd, 0x12, 0xf9, 0x85, 0xa8, 0xeb, 0x9f,

                for (j = srcIndex + 14; src[j] == 0x20; j--) {
                    ;
                }
                n = new String(src, srcIndex, j - srcIndex + 1, Name.OEM_ENCODING);
                hexCode = src[srcIndex + 15] & 0xFF;
                groupName = ((src[srcIndex + 16] & 0x80) == 0x80) == true;
                ownerNodeType = (src[srcIndex + 16] & 0x60) >> 5;

        req.addFlags0(0x10);
        int flags0 = (int) getPrivateField(req, "flags0");
        assertTrue((flags0 & 0x10) != 0, "flag should be set after addFlags0");
        // Calling again should combine rather than overwrite
        req.addFlags0(0x20);
        flags0 = (int) getPrivateField(req, "flags0");
        assertTrue((flags0 & 0x20) != 0, "flag should accumulate");
    }

    @Test

     * Supports concurrent multiplexing flag
     */
    int DCERPC_CONC_MPX = 0x10; /* supports concurrent multiplexing */
    /**
     * Did not execute flag - indicates request was not executed
     */
    int DCERPC_DID_NOT_EXECUTE = 0x20;
    /**
     * Maybe flag - indicates 'maybe' call semantics requested
     */
    int DCERPC_MAYBE = 0x40; /* `maybe' call semantics requested */
    /**