public void visitType(String name) {
                linkElement.appendChild(addType(name, listener));
            }
        });

        linkElement.normalize();
        if (linkElement.getChildNodes().getLength() == 1 && linkElement.getFirstChild() instanceof Element) {
            return linkElement.getFirstChild();
        }
        return linkElement;
    }

        assertNotNull(pacString, "The PacUnicodeString object should not be null.");

        // Verify that the getters return the correct values
        assertEquals(length, pacString.getLength(), "The length should match the value provided in the constructor.");
        assertEquals(maxLength, pacString.getMaxLength(), "The maxLength should match the value provided in the constructor.");

     */
    @Override
    public int encode(final byte[] dst, final int dstIndex) {
        final int len = super.encode(dst, dstIndex);
        final int exp = size();
        final int actual = getLength();
        if (exp != actual) {
            // Log the size mismatch for debugging but don't throw exception
            // This can occur due to padding alignment differences between size8() and pad8()

        byte[] data = new byte[] { 0x04, 0x00, 0x04, 0x00, 0x34, 0x12, 0x00, 0x00 };
        PacDataInputStream pdis = createInputStream(data);
        PacUnicodeString str = pdis.readUnicodeString();
        assertEquals(4, str.getLength());
        assertEquals(4, str.getMaxLength());
        assertEquals(0x1234, str.getPointer());
    }

    @Test
    public void testReadUnicodeStringMalformed() throws IOException {

            int calculatedLength = testEncodedLength;
            setLength(calculatedLength);

            // Now call the ServerMessageBlock2Request's encode which will do the validation
            int exp = size();
            int actual = getLength();
            if (exp != actual) {

            msg.encode(buf);

            if (securityProvider != null) {
                buf.setIndex(0);
                securityProvider.wrap(buf);
            }

            tot = buf.getLength() - 24;
            off = 0;

            while (off < tot) {
                n = tot - off;

                if (24 + n > max_xmit) {
                    msg.flags &= ~DCERPC_LAST_FRAG;

            }

            return !"parent".equals(field.getName());
        }

        private void evaluateArray(Object target) throws ModelInterpolationException {
            int len = Array.getLength(target);
            for (int i = 0; i < len; i++) {
                Object value = Array.get(target, i);
                if (value != null) {
                    if (String.class == value.getClass()) {

                    final Document doc = builder.parse(is);
                    final NodeList nodeList = doc.getElementsByTagName("component");
                    for (int i = 0; i < nodeList.getLength(); i++) {
                        final Node node = nodeList.item(i);
                        final NamedNodeMap attributes = node.getAttributes();
                        if (attributes != null) {

    private boolean isLargeTransfer(SMBMessage message) {
        if (message instanceof Smb2ReadRequest) {
            return ((Smb2ReadRequest)message).getLength() > 1048576;  // 1MB
        }
        if (message instanceof Smb2WriteRequest) {
            return ((Smb2WriteRequest)message).getLength() > 1048576;
        }
        return false;
    }
    
    private boolean isMetadataOperation(SMBMessage message) {

                    if (log.isTraceEnabled()) {
                        log.trace(response.toString());
                        log.trace(Hexdump.toHexString(this.rcv_buf, 0, this.in.getLength()));
                    }

                    response.notify();
                }
            }
        } catch (final SocketTimeoutException ste) {
            log.trace("Socket timeout", ste);