this.port = port;
  }

  /** See https://api.slack.com/docs/oauth. */
  public HttpUrl authorizeUrl(String scopes, HttpUrl redirectUrl, ByteString state, String team) {
    HttpUrl.Builder builder = baseUrl.newBuilder("/oauth/authorize")
        .addQueryParameter("client_id", clientId)
        .addQueryParameter("scope", scopes)
        .addQueryParameter("redirect_uri", redirectUrl.toString())

    }

    private static Plugin newPlugin(String artifactId, String... goals) {
        return Plugin.newBuilder()
                .groupId("org.apache.maven.plugins")
                .artifactId(artifactId)
                .executions(Arrays.stream(goals)
                        .map(goal -> PluginExecution.newBuilder()
                                .id("default-" + goal)
                                .goals(List.of(goal))

    }

    private static Plugin newPlugin(String artifactId, String... goals) {
        return Plugin.newBuilder()
                .groupId("org.apache.maven.plugins")
                .artifactId(artifactId)
                .executions(Arrays.stream(goals)
                        .map(goal -> PluginExecution.newBuilder()
                                .id("default-" + goal)
                                .goals(List.of(goal))

    val call =
      client.newCallWithListener(
        Request
          .Builder()
          .url(
            server
              .url("/")
              .newBuilder()
              .host(ipAddress!!)
              .build(),
          ).build(),
      )
    val response = call.execute()
    assertThat(response.code).isEqualTo(200)

    server.enqueue(MockResponse(body = "def"))
    server.enqueue(MockResponse(body = "ghi"))
    client = client.newBuilder().build()
    executeSynchronously("/a").assertBody("abc")
    client = client.newBuilder().build()
    executeSynchronously("/b").assertBody("def")
    client = client.newBuilder().build()
    executeSynchronously("/c").assertBody("ghi")
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)

    )
  }

  @Test
  fun webSocketAndApplicationInterceptors() {
    val interceptedCount = AtomicInteger()
    client =
      client
        .newBuilder()
        .addInterceptor(
          Interceptor { chain: Interceptor.Chain ->
            assertThat(chain.request().body).isNull()
            val response = chain.proceed(chain.request())

    enableTls()
    client =
      client
        .newBuilder()
        .protocols(listOf(protocol, Protocol.HTTP_1_1))
        .build()
    server1.protocols = client.protocols
    server2.protocols = client.protocols
  }

  private fun enableTls() {
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),

  private var client = clientTestRule.newClient()

  @Test
  fun testNetscapeResponse() {
    val cookieManager = CookieManager(null, CookiePolicy.ACCEPT_ORIGINAL_SERVER)
    client =
      client
        .newBuilder()
        .cookieJar(JavaNetCookieJar(cookieManager))
        .build()
    val urlWithIpAddress = urlWithIpAddress(server, "/path/foo")
    server.enqueue(
      MockResponse
        .Builder()
        .addHeader(

    val request = Request(server.url("/"))
    assertConnectionNotReused(request, request)
  }

  @Test
  fun connectionsAreNotReusedIfPoolIsSizeZero() {
    client =
      client
        .newBuilder()
        .connectionPool(ConnectionPool(0, 5, TimeUnit.SECONDS))
        .build()
    server.enqueue(MockResponse(body = "a"))
    server.enqueue(MockResponse(body = "b"))
    val request = Request(server.url("/"))

  }

  public void testConcurrencyLevel_zero() {
    Interners.InternerBuilder builder = Interners.newBuilder();
    assertThrows(IllegalArgumentException.class, () -> builder.concurrencyLevel(0));
  }

  public void testConcurrencyLevel_negative() {
    Interners.InternerBuilder builder = Interners.newBuilder();
    assertThrows(IllegalArgumentException.class, () -> builder.concurrencyLevel(-42));
  }