*/
@Suppress("DEPRECATION")
class HeldCertificate(
  @get:JvmName("keyPair") val keyPair: KeyPair,
  @get:JvmName("certificate") val certificate: X509Certificate,
) {
  @JvmName("-deprecated_certificate")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "certificate"),
    level = DeprecationLevel.ERROR,
  )

import javax.inject.Inject


private
val logger = LoggerFactory.getLogger("daemonTracker")


abstract class DaemonTracker : BuildService<DaemonTracker.Params>, AutoCloseable {
    interface Params : BuildServiceParameters {
        val rootProjectDir: DirectoryProperty
    }

    @get:Inject
    abstract val execOperations: ExecOperations

    private

    arch: Arch = Arch.AMD64,
) : BuildType({
        val id = "Util_RerunFlakyTest${os.asName()}${arch.asName()}"
        name = "Rerun Flaky Test - ${os.asName()} ${arch.asName()}"
        description = "Allows you to rerun a selected flaky test 10 times"
        id(id)
        val testJvmVendorParameter = "testJavaVendor"
        val testJvmVersionParameter = "testJavaVersion"
        val testTaskParameterName = "testTask"

  @JvmField @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  var client = clientTestRule.newClient()

  @StartStop
  private val server = MockWebServer()

  @BeforeEach
  fun setUp() {
    platform.assumeOpenJSSE()
  }

  @Test
  fun testTlsv13Works() {
    enableTls()

    server.enqueue(MockResponse(body = "abc"))

    val request = Request(server.url("/"))

open class DelegatingSSLSocketFactory(
  private val delegate: SSLSocketFactory,
) : SSLSocketFactory() {
  @Throws(IOException::class)
  override fun createSocket(): SSLSocket {
    val sslSocket = delegate.createSocket() as SSLSocket
    return configureSocket(sslSocket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: String,
    port: Int,
  ): SSLSocket {

class HeadersKotlinTest {
  @Test fun getOperator() {
    val headers = headersOf("a", "b", "c", "d")
    assertThat(headers["a"]).isEqualTo("b")
    assertThat(headers["c"]).isEqualTo("d")
    assertThat(headers["e"]).isNull()
  }

  @Test fun iteratorOperator() {
    val headers = headersOf("a", "b", "c", "d")

    val pairs = mutableListOf<Pair<String, String>>()
    for ((name, value) in headers) {

 */
class JettyHttpClientTest {
  private val client = HttpClient()

  @StartStop
  private val server = MockWebServer()

  @BeforeEach fun setUp() {
    client.start()
  }

  @AfterEach fun tearDown() {
    client.stop()
  }

  @Test fun get() {
    server.enqueue(MockResponse(body = "hello, Jetty HTTP Client"))

    val request =
      client
        .newRequest(server.url("/").toUri())

import okhttp3.Request

class CancelCall {
  private val executor = Executors.newScheduledThreadPool(1)
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request
        .Builder()
        .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay.
        .build()

    val startNanos = System.nanoTime()
    val call = client.newCall(request)

  }

  fun assertJobs(vararg expectedUrls: String) {
    val actualUrls = calls.map { it.request.url.toString() }
    assertThat(actualUrls).containsExactly(*expectedUrls)
  }

  fun finishJob(url: String) {
    val i = calls.iterator()
    while (i.hasNext()) {
      val call = i.next()
      if (call.request.url.toString() == url) {
        i.remove()
        dispatcherTest.dispatcher.finishedAccessor(call)

class PublicSuffixDatabaseTest {
  private val publicSuffixDatabase = PublicSuffixDatabase.get()

  val pathForTests = okHttpRoot / "okhttp/src/jvmMain/resources" / PUBLIC_SUFFIX_RESOURCE

  @Before
  fun setUp() {
    beforePublicSuffixTest()
  }

  @Test
  fun allPublicSuffixes() {
    val buffer = Buffer()
    FileSystem.SYSTEM.read(pathForTests) {
      val length = readInt()