dst[dstIndex + 2 * i + 2] = (byte) ((tmp[i] & 0x0F) + 0x41);
            }
            for (; i < 15; i++) {
                dst[dstIndex + 2 * i + 1] = (byte) 0x43;
                dst[dstIndex + 2 * i + 2] = (byte) 0x41;
            }
            dst[dstIndex + TYPE_OFFSET] = (byte) (((hexCode & 0xF0) >> 4) + 0x41);

     * 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 */
    /**
     * Object UUID flag - if true, a non-nil object UUID is present
     */
    int DCERPC_OBJECT_UUID = 0x80; /* if true, a non-nil object UUID */

            assertEquals(0x25, testBlock.getCommand());
            assertNull(testBlock.getPath());
        }

        @Test
        @DisplayName("Test constructor with config, command, and path")
        void testConstructorWithPath() {
            testBlock = new TestServerMessageBlock(mockConfig, (byte) 0x25, "\\test\\path");

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        testRequestBuffer = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        testResponseBuffer = new byte[] { 0x05, 0x06, 0x07, 0x08 };
        negotiation = new SmbNegotiation(mockRequest, mockResponse, testRequestBuffer, testResponseBuffer);
    }

    @Test
    @DisplayName("Constructor should properly initialize all fields")

    @DisplayName("Test buffer management")
    void testBufferManagement() {
        byte[] buffer = new byte[1024];
        buffer[0] = 0x42;

        transaction.setBuffer(buffer);

        byte[] released = transaction.releaseBuffer();
        assertSame(buffer, released);
        assertEquals(0x42, released[0]);

        // After release, getting buffer again should return null
        assertNull(transaction.releaseBuffer());

            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);

        int flags = NegTokenInit.DELEGATION | NegTokenInit.MUTUAL_AUTHENTICATION | NegTokenInit.INTEGRITY;
        byte[] mechToken = new byte[] { 0x01, 0x02, 0x03 };
        byte[] mic = new byte[] { (byte) 0xFE, 0x55 };

        NegTokenInit init = new NegTokenInit(mechs, flags, mechToken, mic);
        byte[] bytes = init.toByteArray();

        NegTokenInit parsed = new NegTokenInit(bytes);

      0xfd,
      0x1ffb,
      0x7fff0,
      0x1ffc,
      0x3ffc,
      0x22,
      0x7ffd,
      0x3,
      0x23,
      0x4,
      0x24,
      0x5,
      0x25,
      0x26,
      0x27,
      0x6,
      0x74,
      0x75,
      0x28,
      0x29,
      0x2a,
      0x7,
      0x2b,
      0x76,
      0x2c,
      0x8,
      0x9,
      0x2d,

            Type2Message message = new Type2Message(mockContext);
            byte[] testContext =
                    new byte[] { (byte) 0x11, (byte) 0x22, (byte) 0x33, (byte) 0x44, (byte) 0x55, (byte) 0x66, (byte) 0x77, (byte) 0x88 };

            // When
            message.setContext(testContext);

            // Then
            assertArrayEquals(testContext, message.getContext());
        }

        when(response.getMid()).thenReturn(mid);
        response.setMid(mid);
        assertEquals(mid, response.getMid());

        // Test command methods
        int command = 0x25;
        doNothing().when(response).setCommand(command);
        when(response.getCommand()).thenReturn(command);
        response.setCommand(command);
        assertEquals(command, response.getCommand());