plugins {
    id("base")
    id("checkstyle")
    id("codenarc")
    id("net.ltgt.errorprone")
}

open class ErrorProneProjectExtension(
    val disabledChecks: ListProperty<String>
)

open class ErrorProneSourceSetExtension(
    val enabled: Property<Boolean>
)

val errorproneExtension = project.extensions.create<ErrorProneProjectExtension>("errorprone", project.objects.listProperty<String>())

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() {
    val request = fromArgs("-X", "PUT", "-d", "foo", "http://example.com").createRequest()

import model.TestType

const val functionalTestTag = "FunctionalTest"

sealed class ParallelizationMethod {
    open val extraBuildParameters: String
        @JSONField(serialize = false)
        get() = ""

    val name: String = this::class.simpleName!!

    object None : ParallelizationMethod()
    object TestDistribution : ParallelizationMethod() {

    url: HttpUrl,
    header: String,
  ): List<Cookie> {
    val result = mutableListOf<Cookie>()
    var pos = 0
    val limit = header.length
    var pairEnd: Int
    while (pos < limit) {
      pairEnd = header.delimiterOffset(";,", pos, limit)
      val equalsSign = header.delimiterOffset('=', pos, pairEnd)
      val name = header.trimSubstring(pos, equalsSign)
      if (name.startsWith("$")) {

    context.resource.shutdownAll()
  }

  private companion object {
    private val logger = Logger.getLogger(MockWebServerExtension::class.java.name)
    private val namespace = ExtensionContext.Namespace.create(MockWebServerExtension::class.java)
    private val defaultName = MockWebServerExtension::class.java.simpleName
  }

  }

  private val bytesOut = Buffer()
  private val hpackWriter = Hpack.Writer(out = bytesOut)

  @ParameterizedTest
  @ArgumentsSource(StoriesTestProvider::class)
  fun testRoundTrip(story: Story) {
    assumeFalse(
      story === Story.MISSING,
      "Test stories missing, checkout git submodule",
    )

    val newCases = mutableListOf<Case>()
    for (case in story.cases) {

 * Run periodically to refresh the known set of working tests.
 *
 * TODO use filtering to allow skipping acceptable problem tests
 */
fun main() {
  val knownTestFile = File("native-image-tests/src/main/resources/testlist.txt")
  val testSelector = DiscoverySelectors.selectPackage("okhttp3")
  val testClasses =
    findTests(listOf(testSelector))
      .filter { it.isContainer }
      .mapNotNull { (it as? ClassBasedTestDescriptor)?.testClass?.name }

    $("#numSearchOption").prop("selectedIndex", 0);
    return false;
  });

  $result.on("mousedown", "a.link", function(e) {
    var docId = $(this).attr("data-id"),
      rt = $("#rt").val(),
      queryId = $("#queryId").val(),
      order = $(this).attr("data-order"),
      url = $(this).attr("href"),
      buf = [],
      hashIndex,
      hashStr;
    buf.push(contextPath);
    buf.push("/go/?rt=");

      assertThat(event.t).isNull()
    }
  }

  internal data class Open(
    val eventSource: EventSource,
    val response: Response,
  )

  internal data class Failure(
    val t: Throwable?,
    val response: Response?,
  )

  internal object Closed

import java.io.File


class KotlinSourceParser {

    data class ParsedKotlinFiles(

        val ktFiles: List<KtFile>,

        private
        val disposable: Disposable

    ) : AutoCloseable {

        override fun close() {
            Disposer.dispose(disposable)
        }
    }

    private
    val messageCollector: MessageCollector