private
    fun getRelocatedPackages(files: Sequence<Path>): List<String> = mutableListOf<String>().apply {
        implementation.collectPackages(files.toList()).dump(false, this::add)
    }

    @Test
    fun `generates a curated list of package prefixes from directories`() {

  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(eventRecorder))
      .build()

  @AfterEach
  fun after() {
    listener.assertExhausted()
  }

  @Test
  fun event() {
    server.enqueue(
      MockResponse
        .Builder()
        .body(
          """
          |data: hey
          |
          |
          """.trimMargin(),

      }
      remainingByteCount -= toRead
      receivedByteCount += byteCount
    }

    @Throws(IOException::class)
    override fun flush() {
    }

    override fun timeout(): Timeout = Timeout.NONE

    @Throws(IOException::class)
    override fun close() {
    }
  }

  /** Processes HTTP requests layered over HTTP/2. */
  private inner class Http2SocketHandler(

      responseBuilder
    }
  }

  override fun reportedContentLength(response: Response): Long =
    when {
      !response.promisesBody() -> 0L
      else -> response.headersContentLength()
    }

  override fun openResponseBodySource(response: Response): Source = stream!!.source

  override fun peekTrailers(): Headers? = stream!!.peekTrailers()

  override fun cancel() {
    canceled = true

      .fastFallback(fastFallback)
      .build()

  @BeforeEach
  fun setUp() {
    platform.assumeNotOpenJSSE()
    platform.assumeNotBouncyCastle()
    listener.forbidLock(get(client.connectionPool))
    listener.forbidLock(client.dispatcher)
  }

  @Test
  fun successfulCallEventSequence() {
    server.enqueue(MockResponse(body = "abc"))
    val call =
      client.newCall(

        }

        override fun flush() {}

        override fun close() {}
      }

    private fun readClientRandom(param: String): String? {
      val matchResult = randomRegex.find(param)

      return if (matchResult != null) {
        matchResult.groupValues[1].replace(" ", "")
      } else {
        null
      }
    }

    override fun secureConnectStart(call: Call) {

)
class KotlinSourceModernTest {
  @Test @Ignore
  fun dispatcherFromMockWebServer() {
    val dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse = TODO()

        override fun peek(): MockResponse = TODO()

        override fun shutdown() = TODO()
      }
  }

  @Test @Ignore
  fun mockResponse() {
    var mockResponse: MockResponse = MockResponse()

    private class PushObserverCancel : PushObserver {
      override fun onRequest(
        streamId: Int,
        requestHeaders: List<Header>,
      ): Boolean = true

      override fun onHeaders(
        streamId: Int,
        responseHeaders: List<Header>,
        last: Boolean,
      ): Boolean = true

      @Throws(IOException::class)
      override fun onData(
        streamId: Int,
        source: BufferedSource,

/**
 * Simple non-reflection SocketAdapter for BouncyCastle.
 */
class BouncyCastleSocketAdapter : SocketAdapter {
  override fun matchesSocket(sslSocket: SSLSocket): Boolean = sslSocket is BCSSLSocket

  override fun isSupported(): Boolean = isSupported

  override fun getSelectedProtocol(sslSocket: SSLSocket): String? {
    val s = sslSocket as BCSSLSocket

    return when (val protocol = s.applicationProtocol) {

   * messages.
   */
  open fun onOpen(
    webSocket: WebSocket,
    response: Response,
  ) {
  }

  /** Invoked when a text (type `0x1`) message has been received. */
  open fun onMessage(
    webSocket: WebSocket,
    text: String,
  ) {
  }

  /** Invoked when a binary (type `0x2`) message has been received. */
  open fun onMessage(
    webSocket: WebSocket,
    bytes: ByteString,