.add("san.com", "sha1/afwiKY3RxoMmLkuRW1l7QsPZTJPwDS2pdDROQjXw8ig=")
        .build()
    client = client.newBuilder().certificatePinner(pinner).build()
    server.enqueue(
      MockResponse.Builder()
        .code(301)
        .addHeader("Location", url.newBuilder().host("san.com").build())
        .build(),
    )
    server.enqueue(MockResponse())
    assertFailsWith<SSLPeerUnverifiedException> {

    val request = Request.Builder().url("https://api.twitter.com/robots.txt").build()

    val clientCertificates =
      HandshakeCertificates.Builder()
        .addPlatformTrustedCertificates()
        .apply {
          if (Build.VERSION.SDK_INT >= 24) {
            addInsecureHost(server.hostName)
          }
        }
        .build()

    client =
      client.newBuilder()

    )
    webServer.enqueue(
      MockResponse.Builder()
        .webSocketUpgrade(serverListener)
        .build(),
    )
    val webSocket: WebSocket = newWebSocket()
    clientListener.assertOpen()
    val server = serverListener.assertOpen()
    webSocket.send("abc")
    serverListener.assertTextMessage("abc")
    server.send("def")
    clientListener.assertTextMessage("def")

        Model model = Model.newBuilder()
                .build(Build.newBuilder()
                        .sourceDirectory("correct")
                        .resources(Arrays.asList(Resource.newBuilder()
                                .directory("${project.build.sourceDirectory}")
                                .build()))
                        .build())
                .build();

        .code(HttpURLConnection.HTTP_MOVED_TEMP)
        .setHeader("Location", otherServer.url("/"))
        .build(),
    )
    otherServer.enqueue(
      MockResponse.Builder()
        .headersDelay(500, TimeUnit.MILLISECONDS)
        .build(),
    )
    val request = Request.Builder().url(server.url("/")).build()
    val call = client.newCall(request)
    call.timeout().timeout(250, TimeUnit.MILLISECONDS)

        .addHeader("Location: /b")
        .streamHandler(body)
        .build(),
    )
    server.enqueue(
      MockResponse.Builder()
        .body("this is /b")
        .build(),
    )
    val call =
      client.newCall(
        Request.Builder()
          .url(server.url("/"))
          .post(AsyncRequestBody())
          .build(),
      )
    call.execute().use { response ->

                    .build());
            options.addOption(Option.builder(FAIL_AT_END)
                    .longOpt("fail-at-end")
                    .desc("Only fail the build afterwards; allow all non-impacted builds to continue")
                    .build());
            options.addOption(Option.builder(FAIL_NEVER)
                    .longOpt("fail-never")
                    .desc("NEVER fail the build, regardless of project result")

*   [Build](https://www.tensorflow.org/install/source) the TensorFlow pip
    package from source.

## Continuous build status

You can find more community-supported platforms and configurations in the
[TensorFlow SIG Build community builds table](https://github.com/tensorflow/build#community-supported-tensorflow-builds).

### Official Builds

            
            - `gcr.io/tensorflow-sigs/build:${{ github.event.number }}-python3.12`
            - `gcr.io/tensorflow-sigs/build:${{ github.event.number }}-python3.11`
            - `gcr.io/tensorflow-sigs/build:${{ github.event.number }}-python3.10`
            - `gcr.io/tensorflow-sigs/build:${{ github.event.number }}-python3.9`
            

        .build()
    assertThat(headers.parseChallenges("WWW-Authenticate"))
      .isEqualTo(listOf(Challenge("Basic", mapOf("realm" to "protected area"))))
  }

  @Test fun basicChallengeWithCharset() {
    val headers =
      Headers.Builder()
        .add("WWW-Authenticate: Basic realm=\"protected area\", charset=\"UTF-8\"")
        .build()