fastFallback = false,
      )
    assertThat(routeSelector.hasNext()).isTrue()
    val (ipv4_1, ipv4_2) = dns.allocate(2)
    val (ipv6_1, ipv6_2) = dns.allocateIpv6(2)
    dns[uriHost] = listOf(ipv4_1, ipv4_2, ipv6_1, ipv6_2)

    val selection = routeSelector.next()
    assertThat(selection.routes.map { it.socketAddress.address }).containsExactly(
      ipv4_1,
      ipv4_2,
      ipv6_1,

      "ConnectionAcquired",
      "ConnectionReleased",
    )
  }

  @Test
  @Throws(IOException::class)
  fun secondCallEventSequence() {
    enableTls()
    server.protocols = listOf(Protocol.HTTP_2, Protocol.HTTP_1_1)
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())

    client
      .newCall(Request(server.url("/")))
      .execute()
      .close()

3.x, null would yield a username or password of "null".

#### HttpUrl.queryParameterValues()

The return type of `HttpUrl.queryParameterValues()` is `List<String?>`. Lists that may contain null
are uncommon and Kotlin callers may have incorrectly assigned the result to `List<String>`.


Code Cleanup
------------

IntelliJ and Android Studio offer a **Code Cleanup** feature that will automatically update

        ) {

            assertHasNoInformation()
            assertHasNoWarning()
            assertHasErrors(

                // Kotlin file-facade classes are ignored by the @since rule
                listOf("Class com.example.SourceKt: Is not annotated with @Incubating."),

                added("Field", "cathedral"),
                added("Method", "SourceKt.foo()"),
                added("Method", "SourceKt.fooExt(int)"),

  options.compilerArgs.add("-Xlint:-requires-transitive-automatic")

  // Patch the compileKotlinJvm output classes into the compilation so exporting packages works correctly.
  options.compilerArgs.addAll(
    listOf(
      "--patch-module",
      "$moduleName=${compileKotlinTask.destinationDirectory.get().asFile}",
    ),
  )

  // Use the classpath of the compileKotlinJvm task.

          .newClientBuilder()
          .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
          .sslSocketFactory(
            handshakeCertificates.sslSocketFactory(),
            handshakeCertificates.trustManager,
          ).hostnameVerifier(RecordingHostnameVerifier())
          .build()
      scheme = "https"
    } else {
      server.protocols = listOf(Protocol.H2_PRIOR_KNOWLEDGE)
      client =

    var request = chain.request
    val call = realChain.call
    var followUpCount = 0
    var priorResponse: Response? = null
    var newRoutePlanner = true
    var recoveredFailures = listOf<IOException>()
    while (true) {
      call.enterNetworkInterceptorExchange(request, newRoutePlanner, chain)

      var response: Response
      var closeActiveExchange = true
      try {

    }
  }

  private fun enableProtocol(protocol: Protocol) {
    if (protocol == Protocol.HTTP_2) {
      enableTls()
      client =
        client
          .newBuilder()
          .protocols(listOf(protocol, Protocol.HTTP_1_1))
          .build()
      server.protocols = client.protocols
    }
  }

  private fun enableTls() {
    val handshakeCertificates = platform.localhostHandshakeCertificates()

    serverIps = Dns.SYSTEM.lookup(server.hostName)
    dns[server.hostName] = serverIps
    dns["san.com"] = serverIps
    dns["nonsan.com"] = serverIps
    dns["www.wildcard.com"] = serverIps
    dns["differentdns.com"] = listOf()
    val handshakeCertificates =
      HandshakeCertificates
        .Builder()
        .addTrustedCertificate(rootCa.certificate)
        .build()
    client =
      clientTestRule
        .newClientBuilder()

        } else {
            val isOnCi = buildRunningOnCi.getOrElse(false)
            val isMasterReleaseOrMergeQueueBranch = buildBranch.getOrElse("").let { branch ->
                listOf("master", "release", "gh-readonly-queue/").any { prefix -> branch.startsWith(prefix) }
            }
            return@provider isOnCi && !isMasterReleaseOrMergeQueueBranch
        }
    }