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

  @AfterEach
  fun tearDown() {
    server.shutdown()
  }

  @Test
  fun defaultMockResponse() {
    val response = MockResponse()
    assertThat(headersToList(response)).containsExactly("Content-Length: 0")
    assertThat(response.status).isEqualTo("HTTP/1.1 200 OK")
  }

  @Test
  fun setResponseMockReason() {
    val reasons =

        } else {
            outputs.file(artifact)
        }
    }

    private
    fun extractArtifactName(fileName: String): String {
        return jarArtifactRegex.matchEntire(fileName)
            ?.groupValues
            ?.get(1)
            ?: error("Cannot derive artifact name from: $fileName")
    }

    private
    fun minify(artifact: File, keepClasses: Set<String>, jarFile: File): File {

object EventSources {
  @Deprecated(
    message = "required for binary-compatibility!",
    level = DeprecationLevel.HIDDEN,
  )
  @JvmStatic
  fun createFactory(client: OkHttpClient) = createFactory(client as Call.Factory)

  @JvmStatic
  fun createFactory(callFactory: Call.Factory): EventSource.Factory =
    EventSource.Factory { request, listener ->
      val actualRequest =

  private val client = OkHttpClient()

  @Test
  fun passingTest() {
    assertThat("hello").isEqualTo("hello")
  }

  @Test
  fun testMockWebServer() {
    server.enqueue(MockResponse(body = "abc"))
    server.start()

    client.newCall(Request(url = server.url("/"))).execute().use {
      assertThat(it.body.string()).isEqualTo("abc")
    }
  }

  @Test
  fun testExternalSite() {

  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)
  }

        this.bytes = publicSuffixListBytes!!
        this.exceptionBytes = publicSuffixExceptionListBytes!!
      }
    } finally {
      readCompleteLatch.countDown()
    }
  }

  abstract fun listSource(): Source

  override fun ensureLoaded() {
    if (!listRead.get() && listRead.compareAndSet(false, true)) {
      readTheListUninterruptibly()
    } else {
      try {
        readCompleteLatch.await()

  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  @BeforeEach
  fun setup() {
    // BCX509ExtendedTrustManager not supported in TlsUtil.newTrustManager
    platform.assumeNotBouncyCastle()
  }

  @Test fun `untrusted host in insecureHosts connects successfully`() {
    val serverCertificates = platform.localhostHandshakeCertificates()

    fun <T : Any?> executeQuery(apiSourceFile: ApiSourceFile.Java, query: JavaSourceQuery<T>): T =
        openJavaCompilationUnitsByFile
            .computeIfAbsent(apiSourceFile.currentFile) { JavaParser().parse(it).getResult().get() }
            .accept(query.visitor, null)
            ?: query.defaultValue

      .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

  private var hasErrors = false

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    if (hasErrors) {
      source.skip(byteCount)
      return
    }
    try {
      super.write(source, byteCount)
    } catch (e: IOException) {
      hasErrors = true
      onException(e)
    }
  }

  override fun flush() {
    if (hasErrors) {
      return
    }
    try {