assertFailsWith<IllegalArgumentException> {
      OkHttpClient.Builder()
        .protocols(listOf(Protocol.H2_PRIOR_KNOWLEDGE, Protocol.H2_PRIOR_KNOWLEDGE))
    }.also { expected ->
      assertThat(expected.message).isEqualTo(
        "protocols containing h2_prior_knowledge cannot use other protocols: " +
          "[h2_prior_knowledge, h2_prior_knowledge]",
      )
    }
  }

   * `INADEQUATE_SECURITY`.
   */
  HTTP_2("h2"),

  /**
   * Cleartext HTTP/2 with no "upgrade" round trip. This option requires the client to have prior
   * knowledge that the server supports cleartext HTTP/2.
   *
   * See also [Starting HTTP/2 with Prior Knowledge][rfc_7540_34].
   *
   * [rfc_7540_34]: https://tools.ietf.org/html/rfc7540.section-3.4
   */
  H2_PRIOR_KNOWLEDGE("h2_prior_knowledge"),

  /**

    set(value) {
      val protocolList = value.toImmutableList()
      require(Protocol.H2_PRIOR_KNOWLEDGE !in protocolList || protocolList.size == 1) {
        "protocols containing h2_prior_knowledge cannot use other protocols: $protocolList"
      }
      require(Protocol.HTTP_1_1 in protocolList || Protocol.H2_PRIOR_KNOWLEDGE in protocolList) {
        "protocols doesn't contain http/1.1: $protocolList"
      }

        throw UnknownServiceException(
          "CLEARTEXT communication to $host not permitted by network security policy",
        )
      }
    } else {
      if (Protocol.H2_PRIOR_KNOWLEDGE in route.address.protocols) {
        throw UnknownServiceException("H2_PRIOR_KNOWLEDGE cannot be used with HTTPS")
      }
    }

    val tunnelRequest =
      when {
        route.requiresTunnel() -> createTunnelRequest(route)

        require(Protocol.H2_PRIOR_KNOWLEDGE in protocolsCopy || HTTP_1_1 in protocolsCopy) {
          "protocols must contain h2_prior_knowledge or http/1.1: $protocolsCopy"
        }
        require(Protocol.H2_PRIOR_KNOWLEDGE !in protocolsCopy || protocolsCopy.size <= 1) {
          "protocols containing h2_prior_knowledge cannot use other protocols: $protocolsCopy"
        }

        connectTls(sslSocket, connectionSpec)
        user.secureConnectEnd(handshake)
      } else {
        socket = rawSocket
        protocol =
          when {
            Protocol.H2_PRIOR_KNOWLEDGE in route.address.protocols -> Protocol.H2_PRIOR_KNOWLEDGE
            else -> Protocol.HTTP_1_1
          }
      }

      val connection =
        RealConnection(
          taskRunner = taskRunner,

          .hostnameVerifier(RecordingHostnameVerifier())
          .build()
      scheme = "https"
    } else {
      server.protocols = listOf(Protocol.H2_PRIOR_KNOWLEDGE)
      client =
        clientTestRule.newClientBuilder()
          .protocols(listOf(Protocol.H2_PRIOR_KNOWLEDGE))
          .build()
      scheme = "http"
    }
  }

  @AfterEach fun tearDown() {

        .protocols(listOf(Protocol.H2_PRIOR_KNOWLEDGE))
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.enqueue(MockResponse())
    val call = client.newCall(Request(server.url("/")))
    assertFailsWith<UnknownServiceException> {
      call.execute()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("H2_PRIOR_KNOWLEDGE cannot be used with HTTPS")
    }

    this.withLock {
      successCount++
    }
  }

  @Throws(IOException::class)
  fun start() {
    idleAtNs = System.nanoTime()
    if (protocol == Protocol.HTTP_2 || protocol == Protocol.H2_PRIOR_KNOWLEDGE) {
      startHttp2()
    }
  }

  @Throws(IOException::class)
  private fun startHttp2() {
    val socket = this.socket!!
    val source = this.source!!
    val sink = this.sink!!

    val groovyTest = "$groovyGroup:groovy-test"
    val groovyXml = "$groovyGroup:groovy-xml"
    val gson = "com.google.code.gson:gson"
    val guava = "com.google.guava:guava"
    val h2Database = "com.h2database:h2"
    val hamcrest = "org.hamcrest:hamcrest-core"
    val httpcore = "org.apache.httpcomponents:httpcore"
    val inject = "javax.inject:javax.inject"
    val ivy = "org.apache.ivy:ivy"