byte[] paramWords = buffer.array();

        // Call the method to test
        int bytesRead = response.readParameterWordsWireFormat(paramWords, 0);

        // Assert that the correct number of bytes were read
        assertEquals(34, bytesRead);

        // Assert that the serverData fields are populated correctly
        assertEquals(0, response.dialectIndex);

        int bytesRead = response.readParameterWordsWireFormat(buffer, 0);

        // The count should be read from the buffer.
        assertEquals(10L, response.count);
        // The method should return the number of bytes read.
        assertEquals(8, bytesRead);
    }

    /**
     * Test the writeParameterWordsWireFormat method.
     */

        Trans2QueryPathInformation trans = new Trans2QueryPathInformation("anyfile.txt", 0);
        byte[] buffer = new byte[10];

        // When
        int bytesRead = trans.readSetupWireFormat(buffer, 0, 10);

        // Then
        assertEquals(0, bytesRead, "Should read 0 bytes.");
    }

    /**
     * Tests the readParametersWireFormat method.
     */
    @Test
    void testReadParametersWireFormat() {

type countUpReader struct {
	reader    io.Reader
	bytesRead int64
}

// Max bzip2 concurrency across calls. 50% of GOMAXPROCS.
var bz2Limiter = pbzip2.CreateConcurrencyPool((runtime.GOMAXPROCS(0) + 1) / 2)

func (r *countUpReader) Read(p []byte) (n int, err error) {
	n, err = r.reader.Read(p)
	atomic.AddInt64(&r.bytesRead, int64(n))
	return n, err
}

func (r *countUpReader) BytesRead() int64 {
	if r == nil {
		return 0
	}

    val totalBytesToRead = inflater.bytesRead + deflatedBytes.size

    // We cannot read all, as the source does not close.
    // Instead, we ensure that all bytes from source have been processed by inflater.
    do {
      inflaterSource.readOrInflate(buffer, Long.MAX_VALUE)
    } while (inflater.bytesRead < totalBytesToRead && !inflater.finished())

	buf bytes.Buffer
	// total bytes read including header size
	bytesRead int
}

// Close is a no operation closer
func (r *RequestRecorder) Close() error {
	// no-op
	return nil
}

// Read reads from the internal reader and counts/save the body in the memory
func (r *RequestRecorder) Read(p []byte) (n int, err error) {
	n, err = r.Reader.Read(p)
	r.bytesRead += n

	if r.LogBody {
		r.buf.Write(p[:n])
	}

        bufferIndex += 4;
        // setupCount = 0 (1 byte + 1 padding byte)
        buffer[bufferIndex] = 0;
        buffer[bufferIndex + 1] = 0; // padding byte

        int bytesRead = response.readParameterWordsWireFormat(buffer, 0);

        assertEquals(37, bytesRead); // 3 reserved + 32 (8*4) + 2 for setupCount
        assertEquals(10, response.totalParameterCount);

                0x02, 0x00, // numEntries = 2
                0x05, 0x00 // totalAvailableEntries = 5
        };

        int bytesRead = response.readParametersWireFormat(buffer, 0, buffer.length);

        assertEquals(8, bytesRead, "Should read 8 bytes for parameters.");
        assertEquals(0, response.status, "Status should be 0.");

        // Read and verify content
        try (FileInputStream fis = new FileInputStream(tempFile)) {
            byte[] buffer = new byte[1024];
            int bytesRead = fis.read(buffer);
            String content = new String(buffer, 0, bytesRead);
            assertEquals("Test response body", content);
        } finally {
            // Clean up
            tempFile.delete();
        }
    }

          long bytesRead = super.read(sink, byteCount);
          // read() returns the number of bytes read, or -1 if this source is exhausted.
          totalBytesRead += bytesRead != -1 ? bytesRead : 0;
          progressListener.update(totalBytesRead, responseBody.contentLength(), bytesRead == -1);
          return bytesRead;
        }
      };
    }
  }