void testWriteReadSymmetry(int value, boolean isInt2) {
        byte[] buffer = new byte[10];

        if (isInt2) {
            SessionServicePacket.writeInt2(value, buffer, 0);
            int result = SessionServicePacket.readInt2(buffer, 0);
            assertEquals(value & 0xFFFF, result);
        } else {
            SessionServicePacket.writeInt4(value, buffer, 0);
            int result = SessionServicePacket.readInt4(buffer, 0);

        )

        synchronized(this@Relay) {
          // Append new upstream bytes into the buffer. Trim it to its max size.
          buffer.write(upstreamBuffer, upstreamBytesRead)
          if (buffer.size > bufferMaxSize) {
            buffer.skip(buffer.size - bufferMaxSize)
          }

          // Now that the file and buffer have bytes, adjust upstreamPos.
          ******@****.***amPos += upstreamBytesRead
        }

    @Override
    int readSetupWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    int readParametersWireFormat(final byte[] buffer, int bufferIndex, final int len) {
        final int start = bufferIndex;

        status = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        converter = readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        bufferIndex += 4;

        final int outputOffset = SMBUtil.readInt4(buffer, bufferIndex) + getHeaderStart();
        bufferIndex += 4;

        final int outputCount = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        this.ioctlFlags = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        bufferIndex += 4; // Reserved2

    host: String,
    type: Int,
  ): ByteString =
    Buffer()
      .apply {
        writeShort(0) // query id
        writeShort(256) // flags with recursion
        writeShort(1) // question count
        writeShort(0) // answerCount
        writeShort(0) // authorityResourceCount
        writeShort(0) // additional

        val nameBuf = Buffer()
        val labels = host.split('.').dropLastWhile { it.isEmpty() }

        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        EnumSet<RdmaAccess> access = EnumSet.of(RdmaAccess.LOCAL_READ, RdmaAccess.LOCAL_WRITE);

        RdmaMemoryRegion region = provider.registerMemory(buffer, access);
        assertNotNull(region, "Memory region should not be null");
        assertEquals(buffer, region.getBuffer(), "Buffer should match");

    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.chunksWritten = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.chunkBytesWritten = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.totalBytesWritten = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

    }

    @Override
    protected void process(ByteBuffer buffer) {
      b += CHUNK_SIZE;
      processM(buffer.getLong());
    }

    @Override
    protected void processRemaining(ByteBuffer buffer) {
      b += buffer.remaining();
      for (int i = 0; buffer.hasRemaining(); i += 8) {
        finalM ^= (buffer.get() & 0xFFL) << i;
      }
    }

    @Override

     */
    @Test
    void testReadSetupWireFormat() {
        byte[] buffer = new byte[10];
        int result = netServerEnum2.readSetupWireFormat(buffer, 0, 10);
        assertEquals(0, result);
    }

    /**
     * Test the readParametersWireFormat method.
     */
    @Test
    void testReadParametersWireFormat() {
        byte[] buffer = new byte[10];

    }

    /**
     * Encodes this NDR object into the specified buffer
     * @param dst the destination buffer for encoding
     * @throws NdrException if encoding fails
     */
    public abstract void encode(NdrBuffer dst) throws NdrException;

    /**
     * Decodes this NDR object from the specified buffer
     * @param src the source buffer for decoding
     * @throws NdrException if decoding fails
     */