final int start = dstIndex;
        writeInt2(nameTrnId, dst, dstIndex);
        dst[dstIndex + OPCODE_OFFSET] = (byte) ((isResponse ? 0x80 : 0x00) + (opCode << 3 & 0x78) + (isAuthAnswer ? 0x04 : 0x00)
                + (isTruncated ? 0x02 : 0x00) + (isRecurDesired ? 0x01 : 0x00));
        dst[dstIndex + OPCODE_OFFSET + 1] = (byte) ((isRecurAvailable ? 0x80 : 0x00) + (isBroadcast ? 0x10 : 0x00) + (resultCode & 0x0F));

        writeInt2(this.nameTrnId, dst, dstIndex);
        dst[dstIndex + OPCODE_OFFSET] = (byte) ((this.isResponse ? 0x80 : 0x00) + (this.opCode << 3 & 0x78)
                + (this.isAuthAnswer ? 0x04 : 0x00) + (this.isTruncated ? 0x02 : 0x00) + (this.isRecurDesired ? 0x01 : 0x00));
        dst[dstIndex + OPCODE_OFFSET + 1] =

            sid = readInt2(buffer, bufferIndex);
            bufferIndex += 2;
        }
        numEntries = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        isEndOfSearch = ((buffer[bufferIndex] & 0x01) == 0x01) == true;
        bufferIndex += 2;
        eaErrorOffset = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        lastNameOffset = readInt2(buffer, bufferIndex);
        bufferIndex += 2;

public class AvFlagsTest {

    /**
     * Test constructor with raw bytes.
     */
    @Test
    void testAvFlagsByteArrayConstructor() {
        // Test with a positive integer
        byte[] rawBytes = new byte[] { 0x01, 0x02, 0x03, 0x04 }; // Represents 0x04030201 (little-endian)
        AvFlags avFlags = new AvFlags(rawBytes);
        assertNotNull(avFlags, "AvFlags object should not be null");

    }

    @Test
    @DisplayName("parsing malformed token throws IOException")
    void testMalformedToken() {
        byte[] bad = new byte[] { 0x01, 0x02, 0x03 }; // not a valid ASN.1 tagged object
        assertThrows(IOException.class, () -> new NegTokenTarg(bad), "Malformed byte[] should cause IOException");
    }

    @Test

    }

    /**
     * Test file attribute constants.
     */
    @Test
    @DisplayName("File attribute constants are correct")
    void fileAttributesTest() {
        assertEquals(0x01, SmbConstants.ATTR_READONLY);
        assertEquals(0x02, SmbConstants.ATTR_HIDDEN);
        assertEquals(0x04, SmbConstants.ATTR_SYSTEM);
        assertEquals(0x08, SmbConstants.ATTR_VOLUME);

        @DisplayName("Should write request structure correctly")
        void testWriteBytesWireFormat() {
            // Setup
            request.setPadding((byte) 2);
            request.setReadFlags((byte) 0x01);
            request.setReadLength(4096);
            request.setOffset(8192L);
            request.setMinimumCount(512);
            request.setRemainingBytes(1024);

            byte[] buffer = new byte[256];

	o = append(o, 0xa4, 0x73, 0x74, 0x61, 0x74)
	o = msgp.AppendUint8(o, uint8(z.status))
	// string "rec"
	o = append(o, 0xa3, 0x72, 0x65, 0x63)
	o = msgp.AppendBool(o, z.recursive)
	// string "v"
	o = append(o, 0xa1, 0x76)
	o = msgp.AppendUint8(o, z.dataVersion)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *metacache) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field

            // 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")

        // Mock times (8 bytes each)
        for (int i = 0; i < 32; i++) {
            buffer[i] = (byte) (i % 256);
        }

        // Mock attributes (4 bytes)
        buffer[32] = 0x01;
        buffer[33] = 0x00;
        buffer[34] = 0x00;
        buffer[35] = 0x00;

        return buffer;
    }

    private byte[] createMockFileStandardInfoBuffer() {