}

  override fun toString(): String {
    val peerCertificatesString = peerCertificates.map { it.name }.toString()
    return "Handshake{" +
      "tlsVersion=$tlsVersion " +
      "cipherSuite=$cipherSuite " +
      "peerCertificates=$peerCertificatesString " +
      "localCertificates=${localCertificates.map { it.name }}}"
  }

  private val Certificate.name: String
    get() =
      when (this) {

    internal var method: String
    internal var headers: Headers.Builder
    internal var body: RequestBody? = null
    internal var cacheUrlOverride: HttpUrl? = null

    /** A mutable map of tags, or an immutable empty map if we don't have any. */
    internal var tags = mapOf<KClass<*>, Any>()

    constructor() {
      this.method = "GET"
      this.headers = Headers.Builder()
    }

// +structType=atomic
message LabelSelector {
  // matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
  // map is equivalent to an element of matchExpressions, whose key field is "key", the
  // operator is "In", and the values array contains only "value". The requirements are ANDed.
  // +optional
  map<string, string> matchLabels = 1;

        check(this is KtFirAnalysisSession)
        val fir = element.getOrBuildFir(firResolveSession) ?: return emptyList()
        return when (fir) {
            is FirFunctionCall -> fir.getCandidateSymbols().map { it.fir.buildSymbol(firSymbolBuilder) }
            is FirResolvedNamedReference -> listOf(fir.resolvedSymbol.buildSymbol(firSymbolBuilder))
            else -> emptyList()
        }
    }

pkg syscall (freebsd-arm64), const MAP_ALIGNMENT_SHIFT ideal-int
pkg syscall (freebsd-arm64), const MAP_ANON = 4096
pkg syscall (freebsd-arm64), const MAP_ANON ideal-int
pkg syscall (freebsd-arm64), const MAP_ANONYMOUS = 4096
pkg syscall (freebsd-arm64), const MAP_ANONYMOUS ideal-int
pkg syscall (freebsd-arm64), const MAP_COPY = 2
pkg syscall (freebsd-arm64), const MAP_COPY ideal-int
pkg syscall (freebsd-arm64), const MAP_FILE = 0

                        withPsiEntry("reference", ref.element)
                    }
                }
                resolveToPsiElements.map { KotlinResolveResult(it) }.toTypedArray()
            }
        }
    }

        bindingContext[BindingContext.CLASS, psi]
    }

    override val superTypes: List<KtType>
        get() = withValidityAssertion {
            descriptor?.typeConstructor?.supertypes?.map { it.toKtType(analysisContext) } ?: emptyList()
        }

    override fun createPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> = withValidityAssertion {

  override fun execute(command: Runnable) {
    if (shutdown) throw RejectedExecutionException()
    calls.add(command as RealCall.AsyncCall)
  }

  fun assertJobs(vararg expectedUrls: String) {
    val actualUrls = calls.map { it.request.url.toString() }
    assertThat(actualUrls).containsExactly(*expectedUrls)
  }

  fun finishJob(url: String) {
    val i = calls.iterator()
    while (i.hasNext()) {
      val call = i.next()

) : KtFirBasedScope<FirAbstractStarImportingScope>(firScope, analysisSession.firSymbolBuilder) {

    private val imports: List<StarImport> by cached {
        firScope.starImports.map { import ->
            StarImport(
                import.packageFqName,
                import.relativeParentClassName,
                import.resolvedParentClassId
            )
        }
    }

pkg syscall (darwin-arm64), const MAP_HASSEMAPHORE ideal-int
pkg syscall (darwin-arm64), const MAP_JIT = 2048
pkg syscall (darwin-arm64), const MAP_JIT ideal-int
pkg syscall (darwin-arm64), const MAP_NOCACHE = 1024
pkg syscall (darwin-arm64), const MAP_NOCACHE ideal-int
pkg syscall (darwin-arm64), const MAP_NOEXTEND = 256
pkg syscall (darwin-arm64), const MAP_NOEXTEND ideal-int