if (!testData.scheme.isEmpty() && !HTTP_URL_SCHEMES.contains(testData.scheme)) {
      System.err.println("Ignoring unsupported scheme ${testData.scheme}")
      return
    }

    if (!testData.base!!.startsWith("https:") &&
      !testData.base!!.startsWith("http:") &&
      testData.base != "about:blank"
    ) {
      System.err.println("Ignoring unsupported base ${testData.base}")
      return
    }

    try {

private fun sendRequest(
  url: String,
  client: OkHttpClient,
) {
  val req = Request.Builder().url(url).build()

  client.newCall(req).execute().use {
    println(url)
    println("""Content-Encoding: ${it.networkResponse?.header("Content-Encoding")}""")
    println("| ${it.body.string().replace("\n", "\n| ")}")
  }

      client.start()
      val request = SimpleHttpRequests.get("https://google.com/robots.txt")
      val response = client.execute(request, LoggingCallback).get()

      println("Protocol ${response.version}")
      println("Response ${response.code}")
      println("${response.body.bodyText.substring(0, 20)}...")

      Assert.assertEquals(ProtocolVersion("HTTP", 2, 0), response.version)
    }
  }
}

        System.out.println("my-bucketname is created successfully");
      }

      boolean isVersioningEnabled =
          minioClient.isVersioningEnabled(
              IsVersioningEnabledArgs.builder().bucket("my-bucketname").build());
      if (isVersioningEnabled) {
        System.out.println("Bucket versioning is enabled");
      } else {
        System.out.println("Bucket versioning is disabled");
      }

        ArrayMap<String, String> m = new ArrayMap<String, String>();
        m.put("1", "d");
        m.put("2", "d");
        System.out.println("remove before:" + m);
        m.remove("2");
        System.out.println("remove after:" + m);
        assertThat(m.containsKey("2"), is(not(true)));
        assertThat(m.containsKey("1"), is(true));
        assertThat(m.get("1"), is("d"));

        if (done) {
          System.out.println("completed");
        } else {
          if (firstUpdate) {
            firstUpdate = false;
            if (contentLength == -1) {
              System.out.println("content-length: unknown");
            } else {
              System.out.format("content-length: %d\n", contentLength);
            }
          }

          System.out.println(bytesWritten);

    val proxyServer1 = InetAddress.getByAddress("proxyServer1", byteArrayOf(127, 0, 0, 2))
    val proxyServer2 = InetAddress.getByAddress("proxyServer2", byteArrayOf(127, 0, 0, 3))

    println("Proxy Server 1 is ${server1.socketAddress}")
    println("Proxy Server 2 is ${server2.socketAddress}")

    // Since myproxy:8008 won't resolve, redirect with DNS to proxyServer1
    // Then redirect socket connection to server1

      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println("Server: " + response.header("Server"));
      System.out.println("Date: " + response.header("Date"));
      System.out.println("Vary: " + response.headers("Vary"));
    }
  }

  public static void main(String... args) throws Exception {
    new AccessHeaders().run();
  }

	if resp.StatusCode != http.StatusOK {
		// uncomment this for debugging when needed.
		// reqBytes, _ := httputil.DumpRequest(req, false)
		// fmt.Println(string(reqBytes))
		// respBytes, _ := httputil.DumpResponse(resp, true)
		// fmt.Println(string(respBytes))
		return nil, errors.New(resp.Status)
	}

	claims := map[string]any{}
	if err = json.NewDecoder(resp.Body).Decode(&claims); err != nil {

        }

        this.macSigningKey = macSigningKey;
        this.bypass = bypass;
        this.updates = 0;
        this.signSequence = 0;

        if (LogStream.level >= 5) {
            log.println("macSigningKey:");
            Hexdump.hexdump(log, macSigningKey, 0, macSigningKey.length);
        }
    }

    /**
     * Constructs a new signing digest using transport and authentication credentials.
     *