if (matchesSocket(sslSocket)) {
      val bcSocket = sslSocket as BCSSLSocket

      val sslParameters = bcSocket.parameters

      // Enable ALPN.
      sslParameters.applicationProtocols = Platform.alpnProtocolNames(protocols).toTypedArray()

      bcSocket.parameters = sslParameters
    }
  }

  companion object {
    val factory =
      object : DeferredSocketAdapter.Factory {

import java.util.SortedSet

class TestClassTime(
    val sourceSet: String,
    val buildTimeMs: Int,
)

data class TestCoverageAndBucketSplits(
    val testCoverageUuid: Int,
    val buckets: List<FunctionalTestBucket>,
)

data class FunctionalTestBucket(
    val subprojects: SortedSet<String>,
    val parallelizationMethod: ParallelizationMethod,
) {

internal abstract class NullawayStatusService : BuildService<BuildServiceParameters.None>, Closeable {
    private val projectsWithNullAwayEnabled = ConcurrentHashMap.newKeySet<String>()
    private val projectsWithUncheckedDeps = ConcurrentHashMap.newKeySet<String>()
    private val projectsToEnableNullaway = ConcurrentHashMap.newKeySet<String>()

    private fun ensureProjectNotSeen(projectPath: String) {

      apply {
        val keyStoreFactory = KeyStoreFactory(Configuration.configuration(), MockServerLogger())

        val socketFactory = keyStoreFactory.sslContext().socketFactory

        val trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
        trustManagerFactory.init(keyStoreFactory.loadOrCreateKeyStore())

            }
        }

    private
    val JApiClass.sourceFilePath: String
        get() = if (isKotlin) kotlinSourceFilePath else javaSourceFilePath

    private
    val JApiClass.javaSourceFilePath: String
        get() = fullyQualifiedName
            .replace(".", "/")
            .replace(innerClassesPartRegex, "") + ".java"

    private
    val innerClassesPartRegex =
        "\\$.*".toRegex()

     * @param val the value to write
     * @param dst the destination byte array
     * @param dstIndex the starting index in the destination array
     */
    public static void writeInt4(long val, final byte[] dst, int dstIndex) {
        dst[dstIndex] = (byte) val;
        dstIndex++;
        dst[dstIndex] = (byte) (val >>= 8);
        dst[++dstIndex] = (byte) (val >>= 8);
        dst[++dstIndex] = (byte) (val >> 8);
    }

    }
  }

  data class Response(
    val code: Int,
    val negotiatedProtocol: String,
    val content: String,
  )

  private fun execute(
    engine: HttpEngine,
    executor: ExecutorService,
    url: String,
  ): CompletableFuture<Response> {
    val completableFuture = CompletableFuture<Response>()
    val buffer = Buffer()

    val req =
      engine
        .newUrlRequestBuilder(

internal class SequentialExchangeFinder(
  override val routePlanner: RoutePlanner,
) : ExchangeFinder {
  override fun find(): RealConnection {
    var firstException: IOException? = null
    while (true) {
      if (routePlanner.isCanceled()) throw IOException("Canceled")

      try {
        val plan = routePlanner.plan()

        if (!plan.isReady) {
          val tcpConnectResult = plan.connectTcp()

     */
    public static void toHexChars(int val, final char dst[], final int dstIndex, int size) {
        while (size > 0) {
            final int i = dstIndex + size - 1;
            if (i < dst.length) {
                dst[i] = HEX_DIGITS[val & 0x000F];
            }
            if (val != 0) {
                val >>>= 4;
            }
            size--;
        }
    }

 */
class JavaNetAuthenticator(
  private val defaultDns: Dns = Dns.SYSTEM,
) : okhttp3.Authenticator {
  @Throws(IOException::class)
  override fun authenticate(
    route: Route?,
    response: Response,
  ): Request? {
    val challenges = response.challenges()
    val request = response.request
    val url = request.url
    val proxyAuthorization = response.code == 407
    val proxy = route?.proxy ?: Proxy.NO_PROXY