server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse(body = "def"))

    // Call 1: set a deadline on the response body.
    val request1 = Request.Builder().url(server.url("/")).build()
    val response1 = client.newCall(request1).execute()
    val body1 = response1.body.source()
    assertThat(body1.readUtf8()).isEqualTo("abc")
    body1.timeout().deadline(5, TimeUnit.SECONDS)

	// Seek back to beginning.
	body.Seek(0, 0)

	// Add body
	req.Body = io.NopCloser(body)
	req.ContentLength = contentLength

	return req, nil
}

func assembleStreamingChunks(req *http.Request, body io.ReadSeeker, chunkSize int64,
	secretKey, signature string, currTime time.Time) (*http.Request, error,
) {
	regionStr := globalSite.Region
	var stream []byte
	var buffer []byte

    val userRequest = chain.request()
    val requestBuilder = userRequest.newBuilder()

    val body = userRequest.body
    if (body != null) {
      val contentType = body.contentType()
      if (contentType != null) {
        requestBuilder.header("Content-Type", contentType.toString())
      }

      val contentLength = body.contentLength()
      if (contentLength != -1L) {

 * closes its response body. If you invoke [Call.execute] or implement [Callback.onResponse] you
 * must close this body by calling any of the following methods:
 *
 * * `Response.close()`
 * * `Response.body().close()`
 * * `Response.body().source().close()`
 * * `Response.body().charStream().close()`
 * * `Response.body().byteStream().close()`
 * * `Response.body().bytes()`
 * * `Response.body().string()`
 *

    requestBody2.writeUtf8("request body\n")
    requestBody2.close()
    val responseBody2 = response2.body.source()
    assertThat(responseBody2.readUtf8Line())
      .isEqualTo("response body")
    assertTrue(responseBody2.exhausted())
    body.awaitSuccess()

    // No more requests attempted!
    (call.request().body as AsyncRequestBody?)!!.assertNoMoreSinks()
  }

    assertThat(request.body).isNull()
    assertThat(request.tags).isEmpty()
  }

  @Test
  fun constructorNoMethod() {
    val url = "https://example.com/".toHttpUrl()
    val body = "hello".toRequestBody()
    val headers = headersOf("User-Agent", "RequestTest")
    val request =
      Request(
        url = url,
        headers = headers,
        body = body,
      )

    public JsonResponse<ApiResult> post$setting(final EditBody body) {
        validateApi(body, messages -> {});
        validateAttributes(body.attributes, this::throwValidationErrorApi);
        body.crudMode = CrudMode.EDIT;
        final Group entity = getGroup(body).orElseGet(() -> {
            throwValidationErrorApi(messages -> {
                messages.addErrorsCrudCouldNotFindCrudTable(GLOBAL, body.id);
            });
            return null;

    open fun head(): Builder = commonHead()

    open fun post(body: RequestBody): Builder = commonPost(body)

    @JvmOverloads
    open fun delete(body: RequestBody? = commonEmptyRequestBody): Builder = commonDelete(body)

    open fun put(body: RequestBody): Builder = commonPut(body)

    open fun patch(body: RequestBody): Builder = commonPatch(body)

    open fun method(
      method: String,

    }

    protected EditBody createEditBody(final SynonymItem entity, final String dictId) {
        final EditBody body = new EditBody();
        body.id = entity.getId();
        body.dictId = dictId;
        body.inputs = entity.getInputsValue();
        body.outputs = entity.getOutputsValue();
        return body;
    }

    }

    protected EditBody createEditBody(final StemmerOverrideItem entity, final String dictId) {
        final EditBody body = new EditBody();
        body.id = entity.getId();
        body.dictId = dictId;
        body.input = entity.getInput();
        body.output = entity.getOutput();
        return body;
    }