"-PtestJavaVersion=${os.perfTestJavaVersion.major}",
                "-PtestJavaVendor=${os.perfTestJavaVendor}",
                "-PautoDownloadAndroidStudio=true",
                "-PrunAndroidStudioInHeadlessMode=true",
                os.javaInstallationLocations()
            )
        )
    }

    id("${model.projectId}_TestPerformanceTest")
    name = "Test performance test tasks - Java8 Linux"

    object : Runnable {
      override fun run() {
        var incrementedRunCallCount = false
        while (true) {
          val task =
            ******@****.***ck {
              if (!incrementedRunCallCount) {
                incrementedRunCallCount = true
                runCallCount++
              }
              awaitTaskToRun()
            } ?: return

    socket.enabledCipherSuites = arrayOf("SSL_A")
    val connectionSpec =
      ConnectionSpec.Builder(true)
        .tlsVersions(TlsVersion.TLS_1_0)
        .cipherSuites("SSL_A")
        .build()
    applyConnectionSpec(connectionSpec, socket, true)
    assertArrayEquals(
      arrayOf("SSL_A", "SSL_FALLBACK_SCSV"),
      socket.enabledCipherSuites,
    )
  }

  @Test

    socketFactory[ipv6] = server1.inetSocketAddress
    socketFactory[ipv4] = server2.inetSocketAddress

    client =
      client.newBuilder()
        .fastFallback(true)
        .apply {
          retryOnConnectionFailure = true
        }
        .build()

    executeSynchronously(request)
      .assertBody("body")

    assertThat(client.routeDatabase.failedRoutes).isEmpty()

    taskRunner.lock.withLock {
      yieldUntil()
    }
  }

  /** Process the queue until [condition] returns true. */
  private tailrec fun yieldUntil(
    strategy: ResumePriority = ResumePriority.AfterEnqueuedTasks,
    condition: () -> Boolean = { true },
  ) {
    taskRunner.assertThreadHoldsLock()
    val self = currentTask

    val yieldCompleteTask =
      object : SerialTask {

  }
  return -1
}

/** Returns true if we should void putting this this header in an exception or toString(). */
internal fun isSensitiveHeader(name: String): Boolean {
  return name.equals("Authorization", ignoreCase = true) ||
    name.equals("Cookie", ignoreCase = true) ||
    name.equals("Proxy-Authorization", ignoreCase = true) ||
    name.equals("Set-Cookie", ignoreCase = true)
}

internal fun Char.parseHexDigit(): Int =

            registerMultiProvider<KtSimpleNameExpression> { nameReferenceExpression ->
                when (nameReferenceExpression.readWriteAccess(useResolveForReadWrite = true)) {
                    ReferenceAccess.READ -> arrayOf(KtFirSimpleNameReference(nameReferenceExpression, isRead = true))
                    ReferenceAccess.WRITE -> arrayOf(KtFirSimpleNameReference(nameReferenceExpression, isRead = false))

        when {
            ctMember is CtMethod && ctMember.isSynthetic -> true // synthetic members cannot have kdoc
            ctMember is CtClass -> ktFile.ktClassOf(ctMember)?.isDocumentedAsSince(version) == true
            ktFile.ktClassOf(ctDeclaringClass)?.isDocumentedAsSince(version) == true -> true
            else -> when (ctMember) {

            if (partCount == 0) throw ProtocolException("expected at least 1 part")
            noMoreParts = true
            return null
          }

          2, 3 -> {
            // " " or "\t" Ignore whitespace and keep looking.
            whitespace = true
            continue@afterBoundaryLoop
          }

          -1 -> throw ProtocolException("unexpected characters after boundary")

NAMESPACE     NAME         REVISION     PROGRAMMED
default       waypoint     default      True