void testReadUShortOutOfBounds() {
        byte[] a = new byte[] { 0x02 };
        assertThrows(IndexOutOfBoundsException.class, () -\u003e NtlmMessage.readUShort(a, 0));
    }

    @Test
    @DisplayName("readULong throws on too short array")
    void testReadULongOutOfBounds() {
        byte[] a = new byte[] { 0x01, 0x02, 0x03 };
        assertThrows(IndexOutOfBoundsException.class, () -\u003e NtlmMessage.readULong(a, 0));

            ASN1ObjectIdentifier[] mechs = new ASN1ObjectIdentifier[] { OID_KRB, OID_NTLM };
            int flags = NegTokenInit.DELEGATION | NegTokenInit.INTEGRITY;
            byte[] mechToken = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05 };
            byte[] mic = new byte[] { (byte) 0xAA, (byte) 0xBB, (byte) 0xCC };

            NegTokenInit original = new NegTokenInit(mechs, flags, mechToken, mic);

            isBeingDeleted = ((src[srcIndex + 16] & 0x10) == 0x10) == true;
            isInConflict = ((src[srcIndex + 16] & 0x08) == 0x08) == true;
            isActive = ((src[srcIndex + 16] & 0x04) == 0x04) == true;
            isPermanent = ((src[srcIndex + 16] & 0x02) == 0x02) == true;

            /*
             * The NbtAddress object used to query this node will be in the list

            // Skip idFileSystem (4 bytes)
            buffer[4] = 0x08; // sectPerAlloc = 8
            buffer[8] = 0x00;
            buffer[9] = 0x10; // alloc = 4096
            buffer[12] = 0x00;
            buffer[13] = 0x08; // free = 2048
            buffer[16] = 0x00;
            buffer[17] = 0x02; // bytesPerSect = 512

        // Verify that flags are set correctly (DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG)
        // The actual values for DCERPC_FIRST_FRAG and DCERPC_LAST_FRAG are typically 0x01 and 0x02 respectively.
        int expectedFlags = 0x01 | 0x02; // DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG
        assertEquals(expectedFlags, msrpcSamrOpenDomain.getFlags(), "flags should be initialized to DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG");

        byte[] params = { 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00 };
        response.readParametersWireFormat(params, 0, params.length);

        // Data block: 2 entries
        byte[] data = new byte[100];
        // Entry 1: SHARE1, type 0 (Disk), remark "Remark 1"
        System.arraycopy("SHARE1".getBytes(StandardCharsets.US_ASCII), 0, data, 0, 6);
        data[14] = 0x00;
        data[15] = 0x00; // type = 0

        // Tag [1] IMPLICIT, content is 0x01 0x02 0x03
        byte[] data = new byte[] { (byte) 0xA1, 0x03, 0x01, 0x02, 0x03 };
        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        ASN1InputStream ais = new ASN1InputStream(bais);
        byte[] result = ASN1Util.readUnparsedTagged(1, 10, ais);
        assertArrayEquals(new byte[] { 0x01, 0x02, 0x03 }, result);
    }

    @Test

        }

        @ParameterizedTest
        @DisplayName("Should read different oplock levels correctly")
        @ValueSource(bytes = { 0x00, 0x01, 0x02, 0x08, (byte) 0xFF })
        void testReadDifferentOplockLevels(byte oplockLevel) throws Exception {
            byte[] buffer = createValidOplockBreakBuffer(oplockLevel, createTestData(16));

    static final int FLAGS_RETURN_ADDITIONAL_INFO = 0x01;
    static final int FLAGS_REQUEST_OPLOCK = 0x02;
    static final int FLAGS_REQUEST_BATCH_OPLOCK = 0x04;

    // Access Mode Encoding for desiredAccess
    static final int SHARING_COMPATIBILITY = 0x00;
    static final int SHARING_DENY_READ_WRITE_EXECUTE = 0x10;
    static final int SHARING_DENY_WRITE = 0x20;
    static final int SHARING_DENY_READ_EXECUTE = 0x30;

        // Group SID with 2 sub-authorities
        testBuffer[44] = 0x01; // revision
        testBuffer[45] = 0x02; // sub-authority count
        testBuffer[46] = 0x00; // identifier authority
        testBuffer[47] = 0x00;
        testBuffer[48] = 0x00;
        testBuffer[49] = 0x00;
        testBuffer[50] = 0x00;
        testBuffer[51] = 0x05;
        SMBUtil.writeInt4(32, testBuffer, 52); // sub-authority 1