buffer.append(" | ");
            }
        }

        int pad = lastLength - buffer.length();
        lastLength = buffer.length();
        pad(buffer, pad);
        buffer.append('\r');
        out.print(buffer);
        out.flush();
        buffer.setLength(0);
    }

    private void pad(StringBuilder buffer, int spaces) {
        String block = "                                        ";

            this.dataWireFormatReturn = value;
        }

        void setSetupBuffer(byte[] buffer) {
            this.setupBuffer = buffer;
        }

        void setParametersBuffer(byte[] buffer) {
            this.parametersBuffer = buffer;
        }

        void setDataBuffer(byte[] buffer) {
            this.dataBuffer = buffer;
        }
    }

    @BeforeEach
    void setUp() {

    }

    @Override
    public int decode(final byte[] buffer, final int bufferIndex) throws SMBProtocolDecodingException {
        return decode(buffer, bufferIndex, false);
    }

    /**
     * Decodes the SMB2 message from the buffer.
     *
     * @param buffer the buffer containing the message
     * @param bufferIndex the starting position in the buffer
     * @param compound whether this is part of a compound chain

      else -> "MockWebServer{new}"
    }
  }

  /** A buffer wrapper that drops data after [bodyLimit] bytes. */
  private class TruncatingBuffer(
    private var remainingByteCount: Long,
  ) : Sink {
    val buffer = Buffer()
    var receivedByteCount = 0L

    @Throws(IOException::class)
    override fun write(
      source: Buffer,
      byteCount: Long,
    ) {

        setPrivateField(cmd, "maxReferralLevel", 0x12AB);
        byte[] buffer = new byte[100];
        int len = cmd.writeParametersWireFormat(buffer, 0);
        assertTrue(len >= 2);
        // writeInt2 writes in little-endian format (LSB first)
        assertEquals(0xAB, buffer[0] & 0xFF);
        assertEquals(0x12, buffer[1] & 0xFF);
        // Check that the path is written after the referral level

        bufferIndex += 2;
        this.size = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.serverType = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.rflags = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        if (this.version == 3) {
            this.proximity = SMBUtil.readInt2(buffer, bufferIndex);
            bufferIndex += 2;

    /**
     * Buffer type for server checksum signature.
     */
    int SERVER_CHECKSUM = 6;
    /**
     * Buffer type for privilege server (KDC) checksum signature.
     */
    int PRIVSVR_CHECKSUM = 7;

    /**
     * Buffer type for client name information.
     */
    int CLIENT_NAME_TYPE = 0xA;
    /**
     * Buffer type for constrained delegation information.
     */
    int CONSTRAINT_DELEGATIION_TYPE = 0xB;

        info.allocationSize = readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        info.endOfFile = readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        info.numberOfLinks = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        info.deletePending = (buffer[bufferIndex] & 0xFF) > 0;
        bufferIndex++;
        info.directory = (buffer[bufferIndex++] & 0xFF) > 0;
        this.info = info;

        StringBuilder buffer = new StringBuilder(256);
        buffer.append(message);
        buffer.append(" for project ").append(projectId);
        if (pomFile != null) {
            buffer.append(" at ").append(pomFile.getAbsolutePath());
        }
        return buffer.toString();
    }

        if (buffer == null) {
            failedValidations.incrementAndGet();
            throw new SmbException("Response buffer is null");
        }

        if (buffer.length < expectedSize) {
            failedValidations.incrementAndGet();
            bufferOverflowsPrevented.incrementAndGet();
            log.warn("Response buffer too small: {} < {}", buffer.length, expectedSize);