listOf("9.0", "99.0"), // 9.0 <=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,

     */
    abstract val usesFutureStdlib: Property<Boolean>

    /**
     * The JVM version that all JVM code in this compilation will target.
     */
    abstract val targetJvmVersion: Property<Int>

    fun Project.from(sourceSet: SourceSet) {
        associate(tasks.named<JavaCompile>(sourceSet.getCompileTaskName("java")))
        plugins.withType<GroovyBasePlugin>() {

      .build()
  }

  internal fun lookupDecompressor(encoding: String): DecompressionAlgorithm? =
    algorithms.find {
      it.encoding.equals(encoding, ignoreCase = true)
    }

  /**
   * A decompression algorithm such as Gzip. Must provide the Accept-Encoding value and decompress a Source.
   */
  interface DecompressionAlgorithm {
    val encoding: String

    fun decompress(compressedSource: BufferedSource): Source

  }

  @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 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 {
    val sslSocket = delegate.createSocket(host, port) as SSLSocket

  private val handler =
    object : Handler() {
      override fun publish(logRecord: LogRecord) {
        logs += "${logRecord.level}: ${logRecord.message}"
      }

      override fun flush() {
      }

      override fun close() {
      }
    }

  private var previousLevel: Level? = null

  override fun beforeEach(context: ExtensionContext?) {
    previousLevel = logger.level

      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,

import okhttp3.RequestBody
import okio.Buffer

class MainTest {
  @Test
  fun simple() {
    val request = fromArgs("http://example.com").createRequest()
    assertThat(request.method).isEqualTo("GET")
    assertThat(request.url.toString()).isEqualTo("http://example.com/")
    assertThat(request.body).isNull()
  }

  @Test
  @Throws(IOException::class)
  fun put() {

    }
  }

  internal fun useAsSocket() {
    javaNetSocket.soTimeout = 0
    noNewExchanges()
  }

  override fun route(): Route = route

  override fun cancel() {
    // Close the raw socket so we don't end up doing synchronous I/O.
    rawSocket.closeQuietly()
  }

  override fun socket(): JavaNetSocket = javaNetSocket

import okhttp3.Response
import okhttp3.internal.closeQuietly
import okio.IOException

suspend fun Call.executeAsync(): Response =
  suspendCancellableCoroutine { continuation ->
    continuation.invokeOnCancellation {
      this.cancel()
    }
    this.enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {