server.setProtocols(Collections.singletonList(Protocol.H2_PRIOR_KNOWLEDGE));
    server.enqueue(new MockResponse().setBody("hello"));
    server.start();

    OkHttpClient client = new OkHttpClient.Builder()
        .socketFactory(new UnixDomainSocketFactory(socketFile))
        .protocols(Collections.singletonList(Protocol.H2_PRIOR_KNOWLEDGE))
        .build();

    Request request = new Request.Builder()

 * under the License.
 */
package org.apache.maven.repository.legacy;

import javax.inject.Named;
import javax.inject.Singleton;

/**
 * Wagon for testing, for protocols <code>b1</code> and <code>b2</code>
 *
 */
@Named("b")
@Singleton
public class WagonB extends WagonMock {
    public String[] getSupportedProtocols() {
        return new String[] {"b1", "b2"};
    }

      assertThat(response.protocol).isEqualTo(Protocol.HTTP_2)
    }
  }

  @Test
  fun testOkHttpSecureProxiedHttp1() {
    testRequest {
      val client =
        OkHttpClient.Builder()
          .trustMockServer()
          .proxy(Proxy(Proxy.Type.HTTP, it.remoteAddress()))
          .protocols(listOf(Protocol.HTTP_1_1))
          .build()

      val response =

   * [rfc_2817]: http://www.ietf.org/rfc/rfc2817.txt
   */
  fun requiresTunnel(): Boolean {
    if (proxy.type() != Proxy.Type.HTTP) return false
    return (address.sslSocketFactory != null) ||
      (Protocol.H2_PRIOR_KNOWLEDGE in address.protocols)
  }

  override fun equals(other: Any?): Boolean {
    return other is Route &&
      other.address == address &&
      other.proxy == proxy &&
      other.socketAddress == socketAddress
  }

    return delegate!!.supportedProtocols
  }

  override fun getEnabledProtocols(): Array<String> {
    return delegate!!.enabledProtocols
  }

  override fun setEnabledProtocols(protocols: Array<String>) {
    delegate!!.enabledProtocols = protocols
  }

  override fun getSession(): SSLSession {
    return delegate!!.session
  }

  override fun addHandshakeCompletedListener(listener: HandshakeCompletedListener) {

    override fun getEnabledProtocols(): Array<String> {
      return enabledProtocols
    }

    override fun setEnabledProtocols(protocols: Array<String>) {
      this.enabledProtocols = protocols
    }

    override fun getSupportedCipherSuites(): Array<String> {
      return supportedCipherSuites
    }

  private val http2Connection: Http2Connection,
) : ExchangeCodec {
  @Volatile private var stream: Http2Stream? = null

  private val protocol: Protocol =
    if (Protocol.H2_PRIOR_KNOWLEDGE in client.protocols) {
      Protocol.H2_PRIOR_KNOWLEDGE
    } else {
      Protocol.HTTP_2
    }

  @Volatile
  private var canceled = false

  override fun createRequestBody(
    request: Request,
    contentLength: Long,

  optional int32 port = 3;

  // The application protocol for this port.
  // This is used as a hint for implementations to offer richer behavior for protocols that they understand.
  // This field follows standard Kubernetes label syntax.
  // Valid values are either:
  //
  // * Un-prefixed protocol names - reserved for IANA standard service names (as per

# Gets the download command supported by the system (currently either curl or wget)
DOWNLOAD_COMMAND=""
function set_download_command () {
  # Try curl.
  if command -v curl > /dev/null; then
    if curl --version | grep Protocols  | grep https > /dev/null; then
      DOWNLOAD_COMMAND="curl -fLSs --retry 5 --retry-delay 1 --retry-connrefused"
      return
    fi
    echo curl does not support https, will try wget for downloading files.
  else

## Prerequisites

Install Dex by following [Dex Getting Started Guide](https://dexidp.io/docs/getting-started/)

### Start Dex

```
~ ./bin/dex serve dex.yaml