// Encode "TEST" (0x54 0x45 0x53 0x54)
        // T=0x54: upper nibble 0x5->F(0x46), lower nibble 0x4->E(0x45)
        src[1] = 'F';
        src[2] = 'E'; // T
        // E=0x45: upper nibble 0x4->E(0x45), lower nibble 0x5->F(0x46)
        src[3] = 'E';
        src[4] = 'F'; // E
        // S=0x53: upper nibble 0x5->F(0x46), lower nibble 0x3->D(0x44)
        src[5] = 'F';
        src[6] = 'D'; // S

        }

        @Test
        @DisplayName("DCERPC_PENDING_CANCEL should have correct value")
        void testDcerpcPendingCancel() {
            assertEquals(0x04, DcerpcConstants.DCERPC_PENDING_CANCEL, "DCERPC_PENDING_CANCEL should be 0x04");
        }

        @Test
        @DisplayName("DCERPC_RESERVED_1 should have correct value")
        void testDcerpcReserved1() {

     */
    int DCERPC_LAST_FRAG = 0x02; /* Last fragment */
    /**
     * Pending cancel flag - indicates cancel was pending at sender
     */
    int DCERPC_PENDING_CANCEL = 0x04; /* Cancel was pending at sender */
    /**
     * Reserved flag for future use
     */
    int DCERPC_RESERVED_1 = 0x08;
    /**
     * Supports concurrent multiplexing flag.
     */

        assertEquals(0, alignedBytes);
        assertEquals(4, ndrBuffer.getIndex());
    }

    @Test
    void testWriteOctetArray() {
        byte[] data = { 0x01, 0x02, 0x03, 0x04 };
        ndrBuffer.writeOctetArray(data, 0, data.length);

        assertEquals(data.length, ndrBuffer.getIndex());
        assertEquals(data.length, ndrBuffer.getLength());

	// string "ID"
	o = append(o, 0x86, 0xa2, 0x49, 0x44)
	o = msgp.AppendString(o, z.ID)
	// string "User"
	o = append(o, 0xa4, 0x55, 0x73, 0x65, 0x72)
	o = msgp.AppendString(o, z.User)
	// string "Started"
	o = append(o, 0xa7, 0x53, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64)
	o = msgp.AppendTime(o, z.Started)
	// string "Replicate"
	o = append(o, 0xa9, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65)
	if z.Replicate == nil {

        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,
          0x00, 0x00, 0x00, 0x14,
          0x00, 0x00, 0x00, 0x18,
          0x28, 0x00, 0x00, 0x00,
          0x00, 0x00, 0x00, 0x00,
          0x02, 0x00, 0x00, 0x00,
          0x00, 0x00, 0x00, 0x00

            policyHandle.uuid.time_hi_and_version = (short) 0x3333;
            policyHandle.uuid.clock_seq_hi_and_reserved = (byte) 0x44;
            policyHandle.uuid.clock_seq_low = (byte) 0x55;
            policyHandle.uuid.node = new byte[] { (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06 };

            when(mockNdrBuffer.derive(anyInt())).thenReturn(mockNdrBuffer);

     */
    public static final byte SMB_COM_DELETE_DIRECTORY = (byte) 0x01;

    /**
     * SMB command to close a file handle.
     */
    public static final byte SMB_COM_CLOSE = (byte) 0x04;

    /**
     * SMB command to delete a file.
     */
    public static final byte SMB_COM_DELETE = (byte) 0x06;

    /**
     * SMB command to rename a file.
     */

    void testSetFlagTrue() {
        msg.setFlag(0x4, true);
        assertTrue(msg.getFlag(0x4), "Bit should be set after setFlag(true)");
    }

    @Test
    @DisplayName("setFlag false clears the bit")
    void testSetFlagFalse() {
        msg.setFlag(0x4, true);
        msg.setFlag(0x4, false);
        assertFalse(msg.getFlag(0x4), "Bit should be cleared after setFlag(false)");
    }

        originalPairs.add(new AvFlags(0x12345678));
        originalPairs.add(new AvTimestamp(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }));
        originalPairs.add(new AvTargetName("TESTNAME".getBytes()));
        originalPairs.add(new AvSingleHost(new byte[] { 0x11, 0x22, 0x33, 0x44 }));
        originalPairs.add(new AvChannelBindings(new byte[] { 0x55, 0x66 }));

        byte[] encoded = AvPairs.encode(originalPairs);