headers: Headers,
    chunkSizes: List<Int>,
    bodySize: Long,
    body: Buffer,
    sequenceNumber: Int,
    failure: IOException?,
    method: String?,
    path: String?,
    handshake: Handshake?,
    requestUrl: HttpUrl?,
  ) {
    this.requestLine = requestLine
    this.headers = headers
    this.chunkSizes = chunkSizes
    this.bodySize = bodySize
    this.body = body
    this.sequenceNumber = sequenceNumber

  )
}

internal fun mockwebserver3.RecordedRequest.unwrap(): RecordedRequest {
  return RecordedRequest(
    requestLine = requestLine,
    headers = headers,
    chunkSizes = chunkSizes,
    bodySize = bodySize,
    body = body,
    sequenceNumber = sequenceNumber,
    failure = failure,
    method = method,
    path = path,
    handshake = handshake,
    requestUrl = requestUrl,
  )
}

    var headers: Headers = recordedRequest.headers
    val header: String? = recordedRequest.getHeader("")
    var chunkSizes: List<Int> = recordedRequest.chunkSizes
    var bodySize: Long = recordedRequest.bodySize
    var body: Buffer = recordedRequest.body
    var utf8Body: String = recordedRequest.body.readUtf8()
    var sequenceNumber: Int = recordedRequest.sequenceNumber

      val bodySize = if (contentLength != -1L) "$contentLength-byte" else "unknown-length"
      logger.log(
        buildString {
          append("<-- ${response.code}")
          if (response.message.isNotEmpty()) append(" ${response.message}")
          append(" ${redactUrl(response.request.url)} (${tookMs}ms")
          if (!logHeaders) append(", $bodySize body")
          append(")")
        },

   * was empty or unchunked.
   */
  val chunkSizes: List<Int>,
  /** The total size of the body of this POST request (before truncation).*/
  val bodySize: Long,
  /** The body of this POST request. This may be truncated. */
  val body: Buffer,
  /**
   * The index of this request on its HTTP connection. Since a single HTTP connection may serve

      }
    } catch (e: IOException) {
      failure = e
    }

    return RecordedRequest(
      requestLine = request,
      headers = headers.build(),
      chunkSizes = chunkSizes,
      bodySize = requestBody.receivedByteCount,
      body = requestBody.buffer,
      sequenceNumber = sequenceNumber,
      socket = socket,
      failure = failure,
    )
  }

  @Throws(IOException::class)

		SetRSTAvoidanceDelay(t, timeout)
		t.Logf("set RST avoidance delay to %v", timeout)

		const bodySize = 5 << 20
		req := []byte(fmt.Sprintf("POST / HTTP/1.1\r\nHost: foo.com\r\nContent-Length: %d\r\n\r\n", bodySize))
		for i := 0; i < bodySize; i++ {
			req = append(req, 'x')
		}

		cst := newClientServerTest(t, mode, HandlerFunc(func(w ResponseWriter, r *Request) {

    val recordedRequest = server.takeRequest()
    assertThat(recordedRequest.bodySize).isEqualTo(1048576)
    assertThat(recordedRequest.chunkSizes).isNotEmpty()
  }

  @Test
  fun uploadBodyLargeChunkedEncoding() {
    upload(true, 1048576, 65536)
    val recordedRequest = server.takeRequest()
    assertThat(recordedRequest.bodySize).isEqualTo(1048576)
    assertThat(recordedRequest.chunkSizes).isNotEmpty()
  }

    var headers: Headers = recordedRequest.headers
    val header: String? = recordedRequest.getHeader("")
    var chunkSizes: List<Int> = recordedRequest.chunkSizes
    var bodySize: Long = recordedRequest.bodySize
    var body: Buffer = recordedRequest.body
    var utf8Body: String = recordedRequest.body.readUtf8()
    var sequenceNumber: Int = recordedRequest.sequenceNumber

        Request(
          url = server.url("/"),
          body = requestBody,
        ),
      )
    assertThat(response.code).isEqualTo(200)
    val request = server.takeRequest()
    assertThat(request.bodySize).isEqualTo(n.toLong())
    if (uploadKind === TransferKind.CHUNKED) {
      assertThat(request.chunkSizes).isNotEmpty()
    } else {
      assertThat(request.chunkSizes).isEmpty()
    }
  }

  @Test