*
 *  * A DNS lookup failed
 *  * The configuration is incapable of carrying the request, such as when the client is configured
 *    to use `H2_PRIOR_KNOWLEDGE` but the URL's scheme is `https:`.
 *  * Preemptive proxy authentication failed.
 *
 * Planning failures are not necessarily fatal. For example, even if we can't DNS lookup the first
 * proxy in a list, looking up a subsequent one may succeed.

          directory = cacheDirectory,
          // 1 MiB.
          maxSize = 10L * 1024L * 1024L,
        ),
      )
      .build()

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

    val response1Body =
      client.newCall(request).execute().use {
        if (!it.isSuccessful) throw IOException("Unexpected code $it")

        .socketFactory(new UnixDomainSocketFactory(socketFile))
        .protocols(Collections.singletonList(Protocol.H2_PRIOR_KNOWLEDGE))
        .build();

    Request request = new Request.Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {
      System.out.println(response.body().string());
    }

    server.shutdown();

      .assertLogMatch(Regex("""cacheConditionalHit: Response\{protocol=h2, code=200, message=, url=$url\}"""))
      .assertLogMatch(Regex("""cacheHit: Response\{protocol=h2, code=200, message=, url=$url\}"""))
      .assertLogMatch(Regex("""cacheMiss"""))
      .assertLogMatch(Regex("""satisfactionFailure: Response\{protocol=h2, code=200, message=, url=$url\}"""))
      .assertNoMoreLogs()
  }

  private fun request(): Request.Builder {

  private OAuthSessionFactory sessionFactory;

  /** Guarded by this. */
  private OAuthSession session;

  public SlackClient(SlackApi slackApi) {
    this.slackApi = slackApi;
  }

  /** Shows a browser URL to authorize this app to act as this user. */
  public void requestOauthSession(String scopes, String team) throws Exception {
    if (sessionFactory == null) {
      sessionFactory = new OAuthSessionFactory(slackApi);

    assertThat(parse(url, "ab=c\u0009d")).isNull()
    assertThat(parse(url, "a\u001fb=cd")).isNull()
    assertThat(parse(url, "ab=c\u001fd")).isNull()
    assertThat(parse(url, "a\u007fb=cd")).isNull()
    assertThat(parse(url, "ab=c\u007fd")).isNull()
    assertThat(parse(url, "a\u0080b=cd")).isNull()
    assertThat(parse(url, "ab=c\u0080d")).isNull()
    assertThat(parse(url, "a\u00ffb=cd")).isNull()
    assertThat(parse(url, "ab=c\u00ffd")).isNull()

        Request.Builder()
          .url(server.url("/"))
          .build(),
      )
    call.cancel()
    call.cancel()
    assertThat(listener.recordedEventTypes()).containsExactly("Canceled")
  }

  private fun assertSuccessfulEventOrder(responseMatcher: Matcher<Response?>?) {
    val call =
      client.newCall(
        Request.Builder()
          .url(server.url("/"))
          .build(),
      )

  }

  private void drainQueue() throws Exception {
    for (HttpUrl url; (url = queue.take()) != null; ) {
      if (!fetchedUrls.add(url)) {
        continue;
      }

      Thread currentThread = Thread.currentThread();
      String originalName = currentThread.getName();
      currentThread.setName("Crawler " + url);
      try {
        fetch(url);
      } catch (IOException e) {

  @ValueSource(booleans = [true, false])
  fun successfulCallEventSequence() {
    server!!.enqueue(MockResponse(body = "abc"))
    val call =
      client.newCall(
        Request.Builder()
          .url(server!!.url("/"))
          .build(),
      )
    val response = call.execute()
    assertThat(response.code).isEqualTo(200)
    assertThat(response.body.string()).isEqualTo("abc")
    response.body.close()

    val endpointUrl = server.url("/endpoint")

    var request =
      Request.Builder()
        .url(endpointUrl)
        .header("Content-Type", "application/xml")
        .put(ValidRequestBody())
        .build()
    client.newCall(request).execute().use {
      assertEquals(201, it.code)
    }

    request =
      Request.Builder()
        .url(endpointUrl)
        .head()