listObjectsV2Info ListObjectsV2Info
		err               error
	)

	if r.Header.Get(xMinIOExtract) == "true" && strings.Contains(prefix, archivePattern) {
		// Initiate a list objects operation inside a zip file based in the input params
		listObjectsV2Info, err = listObjectsV2InArchive(ctx, objectAPI, bucket, prefix, token, delimiter, maxKeys, startAfter, r.Header)
	} else {
		// Initiate a list objects operation based on the input params.

        Configuration cfg = mock(Configuration.class);
        return new Smb2SessionSetupResponse(cfg);
    }

    /**
     * Build a minimal SMB2 header for a response at the given offset.
     * The header is prepared as a synchronous response with server-to-redirector flag.
     */
    private void buildHeader(byte[] buf, int start, int status, int command, long sessionId) {

    val body = "hello".toRequestBody()
    val headers = headersOf("User-Agent", "RequestTest")
    val method = "PUT"
    val request =
      Request(
        url = url,
        headers = headers,
        method = method,
        body = body,
      )
    assertThat(request.url).isEqualTo(url)
    assertThat(request.headers).isEqualTo(headers)
    assertThat(request.method).isEqualTo(method)

    @Test
    void testConstructorInvalidVersion() throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);

        // Write header with invalid version
        dos.writeInt(Integer.reverseBytes(1)); // 1 buffer
        dos.writeInt(Integer.reverseBytes(999)); // Invalid version

        // Add minimal buffer entry

		}
	}
}

func testCreate(t *testing.T, w *Writer, wt *WriteTest) {
	header := &FileHeader{
		Name:   wt.Name,
		Method: wt.Method,
	}
	if wt.Mode != 0 {
		header.SetMode(wt.Mode)
	}
	f, err := w.CreateHeader(header)
	if err != nil {
		t.Fatal(err)
	}
	_, err = f.Write(wt.Data)
	if err != nil {
		t.Fatal(err)
	}
}

* `content` - A `str` or `bytes`.
* `status_code` - An `int` HTTP status code.
* `headers` - A `dict` of strings.
* `media_type` - A `str` giving the media type. E.g. `"text/html"`.

FastAPI (actually Starlette) will automatically include a Content-Length header. It will also include a Content-Type header, based on the `media_type` and appending a charset for text types.

            // Create buffer with one v3 referral
            byte[] testBuffer = new byte[100];
            ByteBuffer bb = ByteBuffer.wrap(testBuffer).order(ByteOrder.LITTLE_ENDIAN);

            // DfsReferralResponseBuffer header
            bb.putShort((short) 16); // pathConsumed (will be divided by 2 = 8)
            bb.putShort((short) 1); // numReferrals
            bb.putShort((short) 5); // tflags

<div class="wrapper">
    <jsp:include page="/WEB-INF/view/common/admin/header.jsp"></jsp:include>
    <jsp:include page="/WEB-INF/view/common/admin/sidebar.jsp">
        <jsp:param name="menuCategoryType" value="system"/>
        <jsp:param name="menuType" value="dict"/>
    </jsp:include>
    <div class="content-wrapper">
        <div class="content-header">
            <div class="container-fluid">
                <div class="row mb-2">

  @Test
  fun upgradeRefusedByServer() {
    server.enqueue(MockResponse(body = "normal request"))
    val requestWithUpgrade =
      Request
        .Builder()
        .url(server.url("/"))
        .header("Connection", "upgrade")
        .build()
    client.newCall(requestWithUpgrade).execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.socket).isNull()

    assertThat(connect.headers["Proxy-Connection"]).isEqualTo("Keep-Alive")
    assertThat(connect.headers["Host"]).isEqualTo("android.com:443")
    val get = server.takeRequest()
    assertThat(get.headers["Private"]).isEqualTo("Secret")
    assertThat(get.headers["User-Agent"]).isEqualTo("App 1.0")
    assertThat(hostnameVerifier.calls).containsExactly("verify android.com")
  }

  /**