}
            return true
        }
    }

    @get:OutputFile
    abstract val outputFile: RegularFileProperty

    @get:CompileClasspath
    abstract val classpath: ConfigurableFileCollection

    @get:Input
    abstract val excludes: ListProperty<String>

    @get:Input
    abstract val includes: ListProperty<String>

    init {
        excludes.convention(DEFAULT_EXCLUDES)

  private var runCallCount = 0

  /** Queues with tasks that are currently executing their [TaskQueue.activeTask]. */
  private val busyQueues = mutableListOf<TaskQueue>()

  /** Queues not in [busyQueues] that have non-empty [TaskQueue.futureTasks]. */
  private val readyQueues = mutableListOf<TaskQueue>()

  private val runnable: Runnable =
    object : Runnable {
      override fun run() {
        var task: Task =
          withLock {

 */
@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)