[out] policy_handle *handle);

	[op(0x3e)]
	int SamrConnect4([in,string,unique] wchar_t *system_name,
			[in] uint32_t unknown,
			[in] uint32_t access_mask,
			[out] policy_handle *handle);

	[op(0x07)]
	int SamrOpenDomain([in] policy_handle *handle,
			[in] uint32_t access_mask,
			[in] sid_t *sid,
			[out] policy_handle *domain_handle);

	typedef struct {
		uint32_t idx;
		unicode_string name;

        queryPolicy = new MsrpcQueryInformationPolicy(mockPolicyHandle, level, mockNdrObject);

        // Act
        int opnum = queryPolicy.getOpnum();

        // Assert
        assertEquals(0x07, opnum); // Expected opnum for LsarQueryInformationPolicy
    }

    @Test
    void multipleInstances_shouldBeIndependent() {
        // Arrange
        short level1 = 1;
        short level2 = 2;

	if err != nil {
		return
	}
	err = en.WriteBool(z.Group)
	if err != nil {
		err = msgp.WrapError(err, "Group")
		return
	}
	// write "Owner"
	err = en.Append(0xa5, 0x4f, 0x77, 0x6e, 0x65, 0x72)
	if err != nil {
		return
	}
	err = en.WriteString(z.Owner)
	if err != nil {
		err = msgp.WrapError(err, "Owner")
		return
	}
	// write "Quorum"

    }

    @Test
    @DisplayName("writeSecurityBuffer copies data and sets fields")
    void testWriteSecurityBufferNonZero() {
        byte[] dest = new byte[8 + 4];
        byte[] payload = { 0x55, 0x66, 0x77 };
        NtlmMessage.writeSecurityBuffer(dest, 0, 8, payload);
        assertEquals(3, NtlmMessage.readUShort(dest, 0), "Length field must be 3");

        final int len = str.length();
        int ch, size = 0;
        byte[] dst;

        for (int i = 0; i < len; i++) {
            ch = str.charAt(i);
            size += ch > 0x07F ? ch > 0x7FF ? 3 : 2 : 1;
        }
        dst = new byte[size];
        writeShort(size);
        try {
            Encdec.enc_utf8(str, dst, 0, size);
        } catch (final IOException ioe) {

        case 0x00:
            return "This folder only";
        case 0x03:
            return "This folder, subfolders and files";
        case 0x0B:
            return "Subfolders and files only";
        case 0x02:
            return "This folder and subfolders";
        case 0x0A:
            return "Subfolders only";
        case 0x01:

    void toStringInclusion() {
        Configuration cfg = mock(Configuration.class);
        SmbComLockingAndX cmd = new SmbComLockingAndX(cfg);
        setField(cmd, "fid", 42);
        setField(cmd, "typeOfLock", (byte) 0x07);
        setField(cmd, "newOpLockLevel", (byte) 0x02);
        String repr = cmd.toString();
        assertTrue(repr.contains("fid=42"));
        assertTrue(repr.contains("typeOfLock=7"));

		return
	}
	err = en.WriteString(z.Creds.SessionToken)
	if err != nil {
		err = msgp.WrapError(err, "Creds", "SessionToken")
		return
	}
	// write "Snowball"
	err = en.Append(0xa8, 0x53, 0x6e, 0x6f, 0x77, 0x62, 0x61, 0x6c, 0x6c)
	if err != nil {
		return
	}
	err = z.Snowball.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "Snowball")
		return
	}
	return
}

        // Test with known test vector
        // Using test vector from RFC 2104 adapted for HMACT64
        byte[] key = new byte[16];
        Arrays.fill(key, (byte) 0x0b);
        byte[] data = "Hi There".getBytes();

        // Expected result calculated manually for HMACT64 with this key and data
        HMACT64 hmac = new HMACT64(key);
        hmac.engineUpdate(data, 0, data.length);

        final int start = di;
        int ch;
        final int strlen = str.length();

        for (int i = 0; di < dlim && i < strlen; i++) {
            ch = str.charAt(i);
            if (ch >= 0x0001 && ch <= 0x007F) {
                dst[di] = (byte) ch;
                di++;
            } else {
                if (ch > 0x07FF) {
                    if (dlim - di < 3) {
                        break;