.build()
    }.also {
      assertThat(it).hasMessage("Content-Encoding already set: gzip")
    }
  }

  private fun bodyToHex(body: RequestBody): String {
    val buffer = Buffer()
    body.writeTo(buffer)
    return buffer.readByteString().hex()
  }

        SMBUtil.writeTime(TEST_LAST_WRITE_TIME, buffer, bufferIndex + 16);
        SMBUtil.writeTime(TEST_CHANGE_TIME, buffer, bufferIndex + 24);
        SMBUtil.writeInt4(TEST_ATTRIBUTES, buffer, bufferIndex + 32);

        // When
        int bytesDecoded = fileBasicInfo.decode(buffer, bufferIndex, buffer.length);

        // Then
        assertEquals(36, bytesDecoded);

import okhttp3.MediaType.Companion.toMediaType
import okhttp3.ResponseBody.Companion.toResponseBody
import okhttp3.internal.and
import okio.Buffer
import okio.BufferedSource
import okio.ByteString
import okio.ByteString.Companion.decodeHex
import okio.ForwardingSource
import okio.buffer
import org.junit.jupiter.api.Test

class ResponseBodyJvmTest {
  @Test
  fun stringEmpty() {
    val body = body("")

            readParams.invoke(cancel, buffer, 0);

            Method readBytes = SmbComNtCancel.class.getDeclaredMethod("readBytesWireFormat", byte[].class, int.class);
            readBytes.setAccessible(true);
            readBytes.invoke(cancel, buffer, 0);

            // Then - buffer should remain unchanged
            assertArrayEquals(originalBuffer, buffer);
        }

        @ParameterizedTest

        assertTrue(result > 0);
        assertTrue(result < dst.length);
        assertEquals((byte) 0x04, dst[0]); // First buffer format byte
    }

    /**
     * Test writeBytesWireFormat with different buffer offsets
     */
    @Test
    @DisplayName("Test writeBytesWireFormat with different buffer offsets")
    public void testWriteBytesWireFormatWithOffset() {
        // Given
        String oldFileName = "old.txt";

        bufferIndex += 8;
        lastWriteTime = readTime(buffer, bufferIndex);
        bufferIndex += 8;
        changeTime = readTime(buffer, bufferIndex);
        bufferIndex += 8;
        extFileAttributes = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        allocationSize = readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        endOfFile = readInt8(buffer, bufferIndex);

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

        buffer[bufferIndex] = (byte) 0x00; // Reserved
        bufferIndex++;
        buffer[bufferIndex++] = (byte) 0x00; // Reserved
        buffer[bufferIndex++] = (byte) 0x00; // Reserved

        totalParameterCount = readInt4(buffer, bufferIndex);
        if (bufDataStart == 0) {

        // Encode to buffer
        byte[] buffer = new byte[50];
        int encodedBytes = original.encode(buffer, 0);

        // Decode to new instance (decode reads 36 bytes, encode writes 40)
        FileBasicInfo decoded = new FileBasicInfo();
        int decodedBytes = decoded.decode(buffer, 0, 36);

        // Verify encoding/decoding

    assertOnFileDescriptor(content = "Hello") { fd ->
      val requestBody = fd.toRequestBody()

      val buffer = Buffer()
      requestBody.writeTo(buffer)
      assertThat(buffer.readUtf8()).isEqualTo("Hello")

      assertThrows(IOException::class.java) {
        requestBody.writeTo(Buffer())
      }
    }
  }

  @Test
  fun testFileDescriptorAfterClose() {

  internal const val CLOSE_NO_STATUS_CODE = 1005

  fun toggleMask(
    cursor: Buffer.UnsafeCursor,
    key: ByteArray,
  ) {
    var keyIndex = 0
    val keyLength = key.size
    do {
      val buffer = cursor.data
      var i = cursor.start
      val end = cursor.end
      if (buffer != null) {
        while (i < end) {