final int length = msg.getLength() - raxr.getDataLength();
            update(data, index, length - SmbConstants.SIGNATURE_OFFSET - 8);
            update(raxr.getData(), raxr.getOffset(), raxr.getDataLength());
        } else {
            update(data, index, msg.getLength() - SmbConstants.SIGNATURE_OFFSET - 8);
        }
        final byte[] signature = digest();

        }
    }

    private static List<Element> elementList(NodeList resourcesNodes) {
        List<Element> nodeList = new ArrayList<>(resourcesNodes.getLength());
        for (int idx = 0; idx < resourcesNodes.getLength(); idx++) {
            nodeList.add((Element) resourcesNodes.item(idx));
        }
        return nodeList;
    }

    }

    @Override
    public void run() {
        int nameTrnId;
        NameServicePacket response;

        try {
            while (thread == Thread.currentThread()) {
                in.setLength(RCV_BUF_SIZE);

                socket.setSoTimeout(closeTimeout);
                socket.receive(in);

                if (LogStream.level > 3) {

            parent.appendChild(document.importNode(element, true));
        }
        NodeList otherContent = classDoc.getClassSection().getChildNodes();
        for (int i = 0; i < otherContent.getLength(); i++) {
            Node child = otherContent.item(i);
            if (child instanceof Element && !((Element) child).getTagName().equals("section")) {
                parent.appendChild(document.importNode(child, true));

            final NodeList snapshotNodeList = doc.getElementsByTagName("snapshot");
            if (snapshotNodeList.getLength() > 0) {
                final NodeList nodeList = snapshotNodeList.item(0).getChildNodes();
                for (int i = 0; i < nodeList.getLength(); i++) {
                    final Node node = nodeList.item(i);
                    if ("timestamp".equalsIgnoreCase(node.getNodeName())) {

        }
    }
    
    private void handleRdmaRead(Smb2ReadRequest request) throws IOException {
        // Allocate buffer for read data
        ByteBuffer readBuffer = bufferManager.allocateBuffer(request.getLength());
        RdmaMemoryRegion readRegion = provider.registerMemory(readBuffer, 
            EnumSet.of(RdmaAccess.LOCAL_WRITE, RdmaAccess.REMOTE_WRITE));
        
        try {

  }

  private fun Snapshot.assertValue(
    index: Int,
    value: String,
  ) {
    getSource(index).use { source ->
      assertThat(sourceAsString(source)).isEqualTo(value)
      assertThat(getLength(index)).isEqualTo(value.length.toLong())
    }
  }

  private fun sourceAsString(source: Source) = source.buffer().readUtf8()

  private fun Editor.assertInoperable() {

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

        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 {

            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;