}

    @Test
    @DisplayName("readParameterWordsWireFormat with a too-short buffer - throws exception")
    void testReadParameterWordsWithShortBuffer() {
        byte[] buffer = new byte[] { 0x00, 0x01, 0x02 }; // only three bytes
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> response.readParameterWordsWireFormat(buffer, 0));
    }

    @Test

        // Simulate address = 192.168.1.1 (0xC0A80101)
        src[srcIndex + 2] = (byte) 0xC0;
        src[srcIndex + 3] = (byte) 0xA8;
        src[srcIndex + 4] = (byte) 0x01;
        src[srcIndex + 5] = (byte) 0x01;

        // Set 'addrEntry' and 'addrIndex' fields in superclass for the response to be stored
        Field addrEntryField = NameServicePacket.class.getDeclaredField("addrEntry");

    void isValid_false_inVariousCases() {
        when(cfg.isTraceResourceUsage()).thenReturn(false);
        stubValidTree(10L, true, true);
        SmbFileHandleImpl h = new SmbFileHandleImpl(cfg, new byte[] { 0x01 }, tree, "//x", 0, 0, 0, 0, 0L);

        assertTrue(h.isValid());

        // Tree id change makes it invalid
        when(tree.getTreeId()).thenReturn(11L);
        assertFalse(h.isValid());

            mockedCrypto.when(Crypto::getMD5).thenReturn(mockMd5);
            HMACT64 hmac = new HMACT64(TEST_KEY);
            hmac.engineUpdate((byte) 0x01);
            verify(mockMd5, times(1)).update((byte) 0x01);
        }
    }

    @Test
    void testEngineUpdateByteArray() throws NoSuchAlgorithmException {
        // Test engineUpdate(byte[] input, int offset, int len)

            byte[] buffer = new byte[32];
            // total allocation units (8 bytes)
            buffer[4] = 0x01;
            // caller available allocation units (8 bytes)
            buffer[12] = 0x01;
            // actual free units (8 bytes) - should be skipped
            buffer[20] = (byte) 0xFF;
            buffer[21] = (byte) 0xFF;

        // Assert
        assertEquals(expectedFlags, queryPolicy.getFlags());
        // Binary check for individual flags
        assertEquals(0x03, queryPolicy.getFlags()); // 0x01 | 0x02 = 0x03
    }

    @Test
    void getOpnum_shouldReturnCorrectValue() {
        // Arrange
        short level = 1;

     */
    UUID DCERPC_UUID_SYNTAX_NDR = new UUID("8a885d04-1ceb-11c9-9fe8-08002b104860");

    /**
     * First fragment flag - indicates first fragment of a multi-fragment message
     */
    int DCERPC_FIRST_FRAG = 0x01; /* First fragment */
    /**
     * Last fragment flag - indicates last fragment of a multi-fragment message
     */
    int DCERPC_LAST_FRAG = 0x02; /* Last fragment */
    /**

        // Act
        pipe.customizeCreate(req, resp);

        // Assert: verify interactions with dependencies
        verify(req, times(1)).addFlags0(0x16);
        verify(resp, times(1)).setExtended(true);
        verify(resp, never()).setExtended(false);
    }

    @Test
    @DisplayName("openPipe returns a handle bound to this pipe")

    // relative to headerStart
    private static final int PRIMARY_SETUP_OFFSET = 61;
    private static final int SECONDARY_PARAMETER_OFFSET = 51;

    private static final int DISCONNECT_TID = 0x01;
    private static final int ONE_WAY_TRANSACTION = 0x02;

    private static final int PADDING_SIZE = 2;

    private final int flags = 0x00;
    private int fid;
    private int pad = 0;
    private int pad1 = 0;

            SMBUtil.writeInt8(500, buffer1, 48);
            SMBUtil.writeInt4(0x01, buffer1, 56);

            response.readBytesWireFormat(buffer1, 0);

            assertEquals(1, response.getCloseFlags());
            assertEquals(1000, response.getAllocationSize());
            assertEquals(500, response.getEndOfFile());
            assertEquals(0x01, response.getFileAttributes());

            // Second read with different values