val bootstrapClient = OkHttpClient.Builder().cache(appCache).build()

  val dns = DnsOverHttps.Builder().client(bootstrapClient)
    .url("https://dns.google/dns-query".toHttpUrl())
    .bootstrapDnsHosts(InetAddress.getByName("8.8.4.4"), InetAddress.getByName("8.8.8.8"))
    .build()

  val client = bootstrapClient.newBuilder().dns(dns).build()
```

      HeldCertificate.Builder()
        .commonName("localhost")
        .addSubjectAlternativeName("localhost")
        .build()
    val handshakeCertificates =
      HandshakeCertificates.Builder()
        .heldCertificate(heldCertificate)
        .addTrustedCertificate(heldCertificate.certificate)
        .build()

    client =
      client.newBuilder()
        .sslSocketFactory(

            return response.request.newBuilder()
              .header("Authorization", credential)
              .build()
          }
        },
      )
      .build()

  fun run() {
    val request =
      Request.Builder()
        .url("http://publicobject.com/secrets/hellosecret.txt")
        .build()

    client.newCall(request).execute().use { response ->

   * The version string is configured in the root project's `build.gradle`.
   *
   * Note that OkHttp's runtime version may be different from the version specified in your
   * project's build file due to the dependency resolution features of your build tool.
   *
   * [semver]: https://semver.org
   */

      HttpClient.newBuilder()
        .followRedirects(NORMAL)
        .build()

    server.enqueue(
      MockResponse.Builder()
        .body("hello, Java HTTP Client")
        .build(),
    )

    val request =
      HttpRequest.newBuilder(server.url("/").toUri())
        .header("Accept", "text/plain")
        .build()

    val response = httpClient.send(request, BodyHandlers.ofString())

        .build()
    server.protocols = client.protocols
  }

  private fun enableTls() {
    client =
      client.newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .hostnameVerifier(RecordingHostnameVerifier())
        .build()

        .host("host")
        .build()
    assertThat(httpUrl.toString()).isEqualTo("http://user@host/")
    assertThat(httpUrl.toUri().toString()).isEqualTo("http://user@host/")
  }

  @Test
  fun toUriUsernameSpecialCharacters() {
    val url =
      HttpUrl.Builder()
        .scheme("http")
        .host("host")
        .username("=[]:;\"~|?#@^/$%*")
        .build()
    assertThat(url.toString())

  fun main(args: Array<String>) {
    val client =
      OkHttpClient.Builder()
        .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
        .build()
    val call =
      client.newCall(
        Request.Builder()
          .url("https://www.google.ca/")
          .build(),
      )
    val response = call.execute()
    try {
      println(response.code)
      println("PROTOCOL ${response.protocol}")

  private val callFactory: Call.Factory,
) {
  private val moshi = Moshi.Builder().build()

  private val moshiConverterFactory = MoshiConverterFactory.create(moshi)

  private val retrofit =
    Retrofit.Builder()
      .baseUrl(SslLabsService.BASE_URL)
      .addConverterFactory(moshiConverterFactory)
      .callFactory(callFactory)
      .build()

  private val api = retrofit.create(SslLabsService::class.java)

cd $DIR

# Generate the API docs
./gradlew dokkaHtmlMultiModule

mv ./build/dokka/htmlMultiModule docs/5.x

# Copy in special files that GitHub wants in the project root.
cat README.md | grep -v 'project website' > docs/index.md
cp CHANGELOG.md docs/changelogs/changelog.md
cp CONTRIBUTING.md docs/contribute/contributing.md

# Build the site and push the new files up to GitHub
python3 -m venv venv
source venv/bin/activate