* connects successfully. This kicks off new attempts every 250 ms until a connect succeeds.
 */
internal class FastFallbackExchangeFinder(
  override val routePlanner: RoutePlanner,
  private val taskRunner: TaskRunner,
) : ExchangeFinder {
  private val connectDelayNanos = TimeUnit.MILLISECONDS.toNanos(250L)
  private var nextTcpConnectAtNanos = Long.MIN_VALUE

  /**

import okio.FileSystem
import okio.Path.Companion.toPath

fun main(vararg args: String) {
  val data = loadIdnaMappingTableData()
  val file = generateMappingTableFile(data)
  file.writeTo(File(args[0]))
}

fun loadIdnaMappingTableData(): IdnaMappingTableData {
  val path = "/okhttp3/internal/idna/IdnaMappingTable.txt".toPath()
  val table =
    FileSystem.RESOURCES.read(path) {
      readPlainTextIdnaMappingTable()
    }

  override fun intercept(chain: Interceptor.Chain): Response {
    val call = chain.call()
    val cache = chain.cache
    val cacheCandidate = cache?.get(chain.request().requestForCache())

    val now = System.currentTimeMillis()

    val strategy = CacheStrategy.Factory(now, chain.request(), cacheCandidate).compute()
    val networkRequest = strategy.networkRequest
    val cacheResponse = strategy.cacheResponse

import org.gradle.api.logging.Logging
import org.gradle.api.specs.Spec
import org.gradle.kotlin.dsl.*
import org.gradle.util.GradleVersion
import java.io.File


private
val dirVersionPattern = "\\d+\\.\\d+(\\.\\d+)?(-\\w+)*(-\\d{14}[+-]\\d{4})?".toRegex()


val logger = Logging.getLogger("gradlebuild.cleanup")


/**
 * Removes state for versions that we're unlikely to ever need again, such as old snapshot versions.
 */

	}

	var val noncurrentExpiration
	err := d.DecodeElement(&val, &startElement)
	if err != nil {
		return err
	}
	if val.MaxNoncurrentVersions > 0 {
		val.NewerNoncurrentVersions = val.MaxNoncurrentVersions
	}
	*n = NoncurrentVersionExpiration{
		XMLName:                 val.XMLName,
		NoncurrentDays:          val.NoncurrentDays,
		NewerNoncurrentVersions: val.NewerNoncurrentVersions,
	}
	n.set = true

class Http2Server(
  private val baseDirectory: File,
  private val sslSocketFactory: SSLSocketFactory,
) : Http2Connection.Listener() {
  private fun run() {
    val serverSocket = ServerSocket(8888)
    serverSocket.reuseAddress = true
    while (true) {
      var socket: Socket? = null
      try {
        socket = serverSocket.accept()
        val sslSocket = doSsl(socket)

import org.gradle.api.file.DirectoryProperty
import org.gradle.api.provider.Property


interface BuildEnvironmentExtension {
    val gitCommitId: Property<String>
    val gitBranch: Property<String>
    val scriptTemplateCommitId: Property<String>
    val repoRoot: DirectoryProperty
    val rootProjectBuildDir: DirectoryProperty

class AndroidSocketAdapterTest(
  val adapter: SocketAdapter,
) {
  val context: SSLContext by lazy {
    val provider: Provider = Conscrypt.newProviderBuilder().provideTrustManager(true).build()

    SSLContext.getInstance("TLS", provider).apply {
      init(null, null, null)
    }
  }

  @Test
  fun testMatchesSupportedSocket() {
    val socketFactory = context.socketFactory

        )
        val linuxPaths =
            listOf(
                "%linux.java8.oracle.64bit%",
                "%linux.java11.openjdk.64bit%",
                "%linux.java17.openjdk.64bit%",
                "%linux.java21.openjdk.64bit%",
                "%linux.java25.openjdk.64bit%",
                "%linux.java26.openjdk.64bit%",
            )
        val expectedInstallationPaths = linuxPaths.joinToString(",")

      }
    }

  private val backend = TaskRunner.RealBackend(threadFactory)
  private val taskRunner = TaskRunner(backend)
  private val queue = taskRunner.newQueue()

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

  @Test fun test() {
    val t1 = System.nanoTime() / 1e6

    val delays = mutableListOf(TimeUnit.MILLISECONDS.toNanos(1000), -1L)