server.useHttps(handshakeCertificates.sslSocketFactory())

    val dns =
      Dns {
        Dns.SYSTEM.lookup(server.hostName)
      }

    val client =
      clientTestRule
        .newClientBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).dns(dns)
        .build()

    server.enqueue(MockResponse())

/kind documentation
/kind feature

Optionally add one or more of the following kinds if applicable:
/kind api-change
/kind deprecation
/kind failing-test
/kind flake
/kind regression
-->

#### What this PR does / why we need it:

#### Which issue(s) this PR is related to:
<!--
Please link relevant issues to help with tracking.

To automatically close the linked issue(s) when this PR is merged,

integration with OIDC/OpenID based identity provider environments. This allows the generation of temporary credentials with pre-defined access policies for applications/users to interact with MinIO object storage.

Calling AssumeRoleWithWebIdentity does not require the use of MinIO root or IAM credentials. Therefore, you can distribute an application (for example, on mobile devices) that requests temporary security credentials without including MinIO long lasting credentials in the application. Instead,...

        SmbComWriteAndXResponse response = new SmbComWriteAndXResponse();
        byte[] dst = new byte[0];

        int bytesWritten = response.writeParameterWordsWireFormat(dst, 0);

        // This method does nothing and should return 0.
        assertEquals(0, bytesWritten);
    }

    /**
     * Test the writeBytesWireFormat method.
     */
    @Test
    void testWriteBytesWireFormat() {

     */
    @Test
    public void testWriteParameterWordsWireFormat() {
        byte[] dst = new byte[10];
        int dstIndex = 0;
        // This method does nothing and should return 0.
        assertEquals(0, response.writeParameterWordsWireFormat(dst, dstIndex));
    }

    /**
     * Test of writeBytesWireFormat method, of class SmbComQueryInformationResponse.
     */

        .newBuilder()
        .dns {
          Dns.SYSTEM.lookup("sni.cloudflaressl.com")
        }.build()

    val request =
      Request
        .Builder()
        .url("https://cloudflare-dns.com/cdn-cgi/trace")
        .build()
    client.newCall(request).execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.protocol).isEqualTo(Protocol.HTTP_2)

## Get started

### 1. Prerequisites

Install MinIO - [MinIO Quickstart Guide](https://docs.min.io/community/minio-object-store/operations/deployments/baremetal-deploy-minio-on-redhat-linux.html).

### 2. Run MinIO in federated mode

Bucket lookup from DNS federation requires two dependencies

- etcd (for bucket DNS service records)

development.here = true

# The title of environment (e.g. local or integration or production)
environment.title = Local Development

# Does it enable the Framework internal debug? (true only when emergency)
framework.debug = false

# one day: 86400000, three days: 259200000, five days: 432000000, one week: 604800000, one year: 31556926000

    int NT_STATUS_PIPE_BROKEN = 0xC000014b;
    /** The specified local group does not exist */
    int NT_STATUS_NO_SUCH_ALIAS = 0xC0000151;
    /** The user has not been granted the requested logon type at this computer */
    int NT_STATUS_LOGON_TYPE_NOT_GRANTED = 0xC000015b;
    /** The SAM database does not have a computer account for this workstation trust relationship */

     * @throws CurlException if the content does not exist.
     */
    public InputStream getContentAsStream() throws IOException {
        if (contentCache == null) {
            if (contentException != null) {
                throw new CurlException("The content does not exist.", contentException);
            } else {
                throw new CurlException("The content does not exist.");
            }
        }