import okio.Buffer
import okio.ByteString

internal fun Dispatcher.wrap(): mockwebserver3.Dispatcher {
  if (this is QueueDispatcher) return this.delegate

  val delegate = this
  return object : mockwebserver3.Dispatcher() {
    override fun dispatch(request: mockwebserver3.RecordedRequest): mockwebserver3.MockResponse = delegate.dispatch(request.unwrap()).wrap()

    override fun peek(): mockwebserver3.MockResponse = delegate.peek().wrap()

            },
            file
        )
    }

    private
    fun getBuildTimestampAsString() =
        buildTimestamp.get().let { timestampFormat.format(it) }

    private
    fun getBuildTimestampAsIsoString() =
        buildTimestamp.get().let { isoTimestampFormat.format(it) }

    private
    fun Logger.logBuildVersion() {
        lifecycle(
            "Version: ${version.get()} " +

  private var serverSocket: ServerSocket? = null

  @BeforeEach fun setUp() {
    executorService = Executors.newCachedThreadPool(threadFactory("HandshakeCertificatesTest"))
  }

  @AfterEach fun tearDown() {
    executorService.shutdown()
    serverSocket?.closeQuietly()
  }

  @Test fun clientAndServer() {
    platform.assumeNotConscrypt()
    platform.assumeNotBouncyCastle()

          message.startsWith("Using PSK to derive early secret") -> Type.Handshake
          else -> Type.Unknown
        }

    override fun toString(): String =
      if (param != null) {
        message + "\n" + param
      } else {
        message
      }
  }

  private fun quietDebug(message: JsseDebugMessage) {
    if (message.message.startsWith("Ignore")) {
      return
    }

    when (message.type) {

import okhttp3.OkHttp

class TestApplication : Application() {
  override fun onCreate() {
    super.onCreate()

    if (isSecondaryProcess()) {
      OkHttp.initialize(applicationContext)
    }
  }

  private fun isSecondaryProcess(): Boolean = getProcess() != packageName

  @SuppressLint("DiscouragedPrivateApi")
  private fun getProcess(): String? =
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {

import java.io.File

@DisableCachingByDefault
abstract class FixProjectHealthTask : DefaultTask() {

    private val errorLogFile = File("gradle-project-health.log")

    @TaskAction
    fun fixProjectHealth() {
        if (!errorLogFile.exists()) {
            println("Error log not found! Run the projectHealth check first and redirect output.")
            return
        }

   */
  private val routePlanner = FakeRoutePlanner(taskFaker = taskFaker)
  private val finder = FastFallbackExchangeFinder(routePlanner, taskRunner)

  @AfterEach
  fun tearDown() {
    taskFaker.close()
    routePlanner.close()
  }

  @Test
  fun takeConnectedConnection() {
    val plan0 = routePlanner.addPlan()
    plan0.connectState = TLS_CONNECTED

    taskRunner.newQueue().execute("connect") {

  override val sink: BufferedSink
}

fun JavaNetSocket.asBufferedSocket(): BufferedSocket = asOkioSocket().asBufferedSocket()

fun OkioSocket.asBufferedSocket(): BufferedSocket =
  object : BufferedSocket {
    private val delegate = this@asBufferedSocket
    override val source = delegate.source.buffer()
    override val sink = delegate.sink.buffer()

    override fun cancel() {
      delegate.cancel()
    }

    protected
    fun sortChanges(originalChanges: List<AcceptedApiChange>) = originalChanges.toMutableList().sortedBy { it.type + '#' + it.member }

    @VisibleForTesting
    data class AcceptedApiChange(
        val type: String?,
        val member: String?,
        val acceptation: String?,
        val changes: List<String>?
    ) {
        override fun toString(): String = "Type: '$type', Member: '$member'"

import org.junit.jupiter.api.Tag
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ArgumentsSource

private val prefix = if (File("samples").exists()) "" else "../../"

private fun mainFiles(): List<File> {
  val directories =
    listOf(
      "$prefix/samples/guide/src/main/java/okhttp3/guide",
      "$prefix/samples/guide/src/main/java/okhttp3/recipes",