{ tests1, tests2 -> tests1 != tests2 },
    )
}

fun determineScenarioTestDurations(
    os: Os,
    performanceTestDurations: OperatingSystemToTestProjectPerformanceTestDurations,
): Map<String, List<PerformanceTestDuration>> = performanceTestDurations.getOrDefault(os, emptyMap())

fun determineScenariosFor(
    performanceTestSpec: PerformanceTestSpec,

  private val socketAdapterFactory: Factory,
) : SocketAdapter {
  private var delegate: SocketAdapter? = null

  override fun isSupported(): Boolean = true

  override fun matchesSocket(sslSocket: SSLSocket): Boolean = socketAdapterFactory.matchesSocket(sslSocket)

  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<Protocol>,
  ) {

        ?.let { Platform.Companion.get().getHandshakeServerNames(it) }
        ?: listOf()

  fun shutdownInput() {
    javaNetSocket.shutdownInput()
  }

  fun shutdownOutput() {
    javaNetSocket.shutdownOutput()
  }

  /** Sleeps [nanos], throwing if the socket is closed before that period has elapsed. */
  fun sleepWhileOpen(nanos: Long) {
    var ms = nanos / 1_000_000L
    val ns = nanos - (ms * 1_000_000L)

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

	public final fun client ()Lokhttp3/OkHttpClient;
	public final fun includeIPv6 ()Z
	public fun lookup (Ljava/lang/String;)Ljava/util/List;
	public final fun post ()Z
	public final fun resolvePrivateAddresses ()Z
	public final fun resolvePublicAddresses ()Z
	public final fun url ()Lokhttp3/HttpUrl;
}

public final class okhttp3/dnsoverhttps/DnsOverHttps$Builder {
	public fun <init> ()V

  internal val plansToCancel = CopyOnWriteArrayList<RoutePlanner.Plan>()

  override fun timeout(): Timeout = timeout

  @SuppressWarnings("CloneDoesntCallSuperClone") // We are a final type & this saves clearing state.
  override fun clone(): Call = RealCall(client, originalRequest, forWebSocket)

  override fun request(): Request = originalRequest

  /**

    ).filter { it.isSupported() }

  override fun trustManager(sslSocketFactory: SSLSocketFactory): X509TrustManager? =
    socketAdapters
      .find { it.matchesSocketFactory(sslSocketFactory) }
      ?.trustManager(sslSocketFactory)

  override fun newSSLContext(): SSLContext {
    StrictMode.noteSlowCall("newSSLContext")

    return super.newSSLContext()
  }

            subprojects.map { it.name },
        )

    override fun getName(testCoverage: TestCoverage) =
        truncateName("${testCoverage.asName()} (${subprojects.joinToString(",") { it.name }})")

    override fun getDescription(testCoverage: TestCoverage) = "${testCoverage.asName()} for ${subprojects.joinToString(", ") { it.name }}"

  @Throws(InterruptedException::class)
  override fun dispatch(request: RecordedRequest): MockResponse = throw UnsupportedOperationException("unexpected call")

  override fun peek(): MockResponse = throw UnsupportedOperationException("unexpected call")

  fun enqueueResponse(response: MockResponse) {
    delegate.enqueue(response.wrap())
  }

  override fun shutdown() {
    delegate.close()
  }

   * https://github.com/square/okhttp/issues/8078
   */
  @Test fun `inflate returns finished before bytesRead reaches input length`() {
    val inflater = MessageInflater(false)
    val message = "53621260020000".decodeHex()
    assertThat(inflater.inflate(message)).isEqualTo("22021002".decodeHex())
  }

  @Test fun `deflate golden value`() {
    val deflater = MessageDeflater(false)