/**
     * Decompresses data into a provided buffer.
     *
     * @param compressedData the compressed data buffer
     * @param offset the offset in the compressed data buffer
     * @param length the length of compressed data
     * @param outputBuffer the output buffer for decompressed data
     * @param outputOffset the offset in the output buffer
     * @param algorithm the compression algorithm that was used

		}
		if size > maxChunkSize {
			cr.err = errChunkTooBig
			return n, cr.err
		}
	}

	if cap(cr.buffer) < size {
		cr.buffer = make([]byte, size)
	} else {
		cr.buffer = cr.buffer[:size]
	}

	// Now, we read the payload.
	_, err = io.ReadFull(cr.reader, cr.buffer)
	if err == io.EOF && size != 0 {
		err = io.ErrUnexpectedEOF
	}
	if err != nil && err != io.EOF {
		cr.err = err

            _dst.enc_ndr_referent(this.name.buffer, 1);
            _dst.enc_ndr_short(this.dns_domain.length);
            _dst.enc_ndr_short(this.dns_domain.maximum_length);
            _dst.enc_ndr_referent(this.dns_domain.buffer, 1);
            _dst.enc_ndr_short(this.dns_forest.length);
            _dst.enc_ndr_short(this.dns_forest.maximum_length);
            _dst.enc_ndr_referent(this.dns_forest.buffer, 1);

        throw new NoSuchFieldException("Field " + fieldName + " not found");
    }

    private String readNullTerminatedString(byte[] buffer, int offset) {
        int end = offset;
        while (end < buffer.length && buffer[end] != 0) {
            end++;
        }
        return new String(buffer, offset, end - offset);
    }

        void testUnicodeStringEncodeNullBuffer() throws NdrException {
            // Given: A unicode string with null buffer
            rpc.unicode_string unicodeString = new rpc.unicode_string();
            unicodeString.length = (short) 0;
            unicodeString.maximum_length = (short) 0;
            unicodeString.buffer = null;

            when(mockSmbPipeHandleInternal.recv(buf, 0, buf.length)).thenAnswer(invocation -> {
                byte[] buffer = invocation.getArgument(0);
                buffer[0] = 5; // Valid PDU version
                buffer[1] = 0; // Valid PDU type
                Encdec.enc_uint16le((short) 50, buffer, 8); // Fragment length
                return 30; // Initial bytes received
            });

    @Test
    void testReadSetupWireFormat() {
        byte[] buffer = new byte[10];
        int result = response.readSetupWireFormat(buffer, 0, 10);
        assertEquals(0, result, "readSetupWireFormat should always return 0.");
    }

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

   * most [BufferedSource] instances, but not of [Buffer].
   */
  private fun responseBody(content: String): ResponseBody {
    val data = Buffer().writeUtf8(content)
    val source: Source =
      object : Source {
        var closed = false

        override fun close() {
          closed = true
        }

        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {

            bufferIndex += 2;
            bufferIndex += 2; // reserved
            writeInt2(dataLength, buffer, bufferIndex);
            bufferIndex += 2;
            writeInt2(dataOffset, buffer, bufferIndex);
        }

        @Test
        public void testReadParameterWordsWireFormat() {
            int bytesRead = response.readParameterWordsWireFormat(buffer, 0);

        SMBUtil.writeTime(testTime, buffer, 32); // changeTime
        SMBUtil.writeInt8(1024L, buffer, 40); // endOfFile
        SMBUtil.writeInt8(2048L, buffer, 48); // allocationSize
        SMBUtil.writeInt4(0x20, buffer, 56); // extFileAttributes
        SMBUtil.writeInt4(512, buffer, 64); // eaSize

        // Decode
        fileBothDirectoryInfo.decode(buffer, 0, buffer.length);