/**
 * Tests for ALPN overriding on Android.
 */
@Tag("Remote")
class AlpnOverrideTest {
  class CustomSSLSocketFactory(
    delegate: SSLSocketFactory,
  ) : DelegatingSSLSocketFactory(delegate) {
    override fun configureSocket(sslSocket: SSLSocket): SSLSocket {
      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        val parameters = sslSocket.sslParameters

 *
 * [rfc_7468]: https://tools.ietf.org/html/rfc7468
 */
fun X509Certificate.certificatePem(): String =
  buildString {
    append("-----BEGIN CERTIFICATE-----\n")
    encodeBase64Lines(encoded.toByteString())
    append("-----END CERTIFICATE-----\n")
  }

internal fun StringBuilder.encodeBase64Lines(data: ByteString) {
  val base64 = data.base64()

  private const val SERVFAIL = 2
  private const val NXDOMAIN = 3
  const val TYPE_A = 0x0001
  const val TYPE_AAAA = 0x001c
  private const val TYPE_PTR = 0x000c
  private val ASCII = Charsets.US_ASCII

  fun encodeQuery(
    host: String,
    type: Int,
  ): ByteString =
    Buffer()
      .apply {
        writeShort(0) // query id
        writeShort(256) // flags with recursion
        writeShort(1) // question count

  private val server = MockWebServer()

  @BeforeEach
  fun setUp() {
    // Default after JDK 14, but we are avoiding tests that assume special setup.
    // System.setProperty("jdk.tls.client.enableSessionTicketExtension", "true")
    // System.setProperty("jdk.tls.server.enableSessionTicketExtension", "true")

    platform.assumeJdk9()
  }

  @Test
  fun testTlsv13Works() {

        listOf("8.13", "99.0"), // 8.13 <=version < 99.0
    )

typealias BuildProjectToSubprojectTestClassTimes = Map<String, Map<String, List<TestClassTime>>>

interface FunctionalTestBucketProvider {
    fun createFunctionalTestsFor(
        stage: Stage,
        testCoverage: TestCoverage,
    ): List<FunctionalTest>
}

class DefaultFunctionalTestBucketProvider(
    val model: CIBuildModel,
    testBucketsJson: File,

  private lateinit var originalDefault: TimeZone

  @BeforeEach
  fun setUp() {
    originalDefault = TimeZone.getDefault()
    // The default timezone should affect none of these tests: HTTP specified GMT, so we set it to
    // something else.
    TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"))
  }

  @AfterEach
  @Throws(Exception::class)
  fun tearDown() {
    TimeZone.setDefault(originalDefault)
  }

  }

  @Test
  fun encodedPair() {
    val body =
      FormBody
        .Builder()
        .add("sim", "ple")
        .build()
    val expected = "sim=ple"
    assertThat(body.contentLength()).isEqualTo(expected.length.toLong())
    val buffer = Buffer()
    body.writeTo(buffer)
    assertThat(buffer.readUtf8()).isEqualTo(expected)
  }

  @Test
  fun encodeMultiplePairs() {
    val body =

      }
    }
  }

  private fun ResponseBody.isEventStream(): Boolean {
    val contentType = contentType() ?: return false
    return contentType.type == "text" && contentType.subtype == "event-stream"
  }

  override fun onFailure(
    call: Call,
    e: IOException,
  ) {
    listener.onFailure(this, e, null)
  }

  override fun request(): Request = request

  override fun cancel() {

import kotlin.time.Duration.Companion.nanoseconds
import okio.buffer
import okio.source
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows

class UtilTest {
  @Test
  fun socketIsHealthy() {
    val localhost = InetAddress.getLoopbackAddress()
    val serverSocket = ServerSocket(0, 1, localhost)

    val socket = Socket()
    socket.connect(serverSocket.localSocketAddress)

      throw e.targetException
    }
  }

  override fun getAcceptedIssuers(): Array<X509Certificate> = delegate.acceptedIssuers

  override fun checkClientTrusted(
    chain: Array<out X509Certificate>,
    authType: String?,
  ) = throw CertificateException("Unsupported operation")

  override fun checkServerTrusted(
    chain: Array<out X509Certificate>,
    authType: String,