}

  @Test
  fun headersPostNoLength() {
    setLevel(Level.HEADERS)
    server.enqueue(MockResponse())
    val body: RequestBody =
      object : RequestBody() {
        override fun contentType() = PLAIN

        override fun writeTo(sink: BufferedSink) {
          sink.writeUtf8("Hi!")
        }
      }
    val response = client.newCall(request().post(body).build()).execute()

		return
	}

	// Ensure body content type is opaque to ensure that request body has not
	// been interpreted as form data.
	contentType := r.Header.Get("Content-Type")
	if contentType != "application/octet-stream" {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrBadRequest), r.URL)
		return
	}

	// Validate operation
	operation := mux.Vars(r)["operation"]

		if err != nil && len(mfs) == 0 {
			writeErrorResponseJSON(r.Context(), w, toAdminAPIErr(r.Context(), err), r.URL)
			return
		}

		contentType := expfmt.Negotiate(r.Header)
		w.Header().Set("Content-Type", string(contentType))

		enc := expfmt.NewEncoder(w, contentType)
		for _, mf := range mfs {
			if err := enc.Encode(mf); err != nil {
				// client may disconnect for any reasons

        // logger.debug(response.asString());
        return response;
    }

    protected Response checkDeleteMethod(final String path) {
        return given().contentType("application/json").header("Authorization", getTestToken()).delete(getApiPath() + "/" + path);
    }

    protected List<Map<String, Object>> getItemList(final Map<String, Object> body) {

    assertThat(body.value(0)).isEqualTo("c+=& d")
    assertThat(body.value(1)).isEqualTo("final frontier")
    assertThat(body.value(2)).isEqualTo("%25")
    assertThat(body.contentType().toString()).isEqualTo(
      "application/x-www-form-urlencoded",
    )
    val expected = "a%2B%3D%26+b=c%2B%3D%26+d&space%2C+the=final+frontier&%2525=%2525"

}

// Eliminate the non-compressible objects.
func excludeForCompression(header http.Header, object string, cfg compress.Config) bool {
	objStr := object
	contentType := header.Get(xhttp.ContentType)
	if !cfg.Enabled {
		return true
	}

	if crypto.Requested(header) && !cfg.AllowEncrypted {
		return true
	}

    server.enqueue(MockResponse())

    // Call 1: set a deadline on the request body.
    val requestBody1: RequestBody =
      object : RequestBody() {
        override fun contentType(): MediaType = "text/plain".toMediaType()

        override fun writeTo(sink: BufferedSink) {
          sink.writeUtf8("abc")
          sink.timeout().deadline(5, TimeUnit.SECONDS)
        }
      }

			if err != nil {
				err = msgp.WrapError(err, "RestoreOngoing")
				return
			}
		case "ContentType":
			z.ContentType, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ContentType")
				return
			}
		case "ContentEncoding":
			z.ContentEncoding, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {

		return
	}

	if _, _, err := globalBucketMetadataSys.GetReplicationConfig(ctx, bucket); err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	w.Header().Set(xhttp.ContentType, string(mimeJSON))

	enc := json.NewEncoder(w)
	stats := globalReplicationStats.Load().getLatestReplicationStats(bucket)
	bwRpt := globalNotificationSys.GetBandwidthReports(ctx, bucket)
	bwMap := bwRpt.BucketStats

    server.enqueue(MockResponse())
    val call =
      client.newCall(
        Request(
          url = server.url("/"),
          body =
            object : RequestBody() {
              override fun contentType(): MediaType? = null

              @Throws(
                IOException::class,
              )
              override fun writeTo(sink: BufferedSink) {
                for (i in 0..9) {