val request = server.takeRequest()
    assertThat(request.body.readUtf8()).isEqualTo("request")
  }

  @Test
  fun testH2PriorKnowledgeServerFallback() {
    try {
      server.protocols = listOf(Protocol.H2_PRIOR_KNOWLEDGE, Protocol.HTTP_1_1)
      fail<Unit>()
    } catch (expected: IllegalArgumentException) {
      assertThat(expected.message).isEqualTo(

        cipherSuites,
        tlsVersions,
      )
  }

  @Suppress("DEPRECATION")
  companion object {
    // Most secure but generally supported list.
    private val RESTRICTED_CIPHER_SUITES =
      listOf(
        // TLSv1.3.
        CipherSuite.TLS_AES_128_GCM_SHA256,
        CipherSuite.TLS_AES_256_GCM_SHA384,
        CipherSuite.TLS_CHACHA20_POLY1305_SHA256,

    val dispatcher: Dispatcher = client.dispatcher()
    val proxy: Proxy? = client.proxy()
    val protocols: List<Protocol> = client.protocols()
    val connectionSpecs: List<ConnectionSpec> = client.connectionSpecs()
    val interceptors: List<Interceptor> = client.interceptors()
    val networkInterceptors: List<Interceptor> = client.networkInterceptors()
    val eventListenerFactory: EventListener.Factory = client.eventListenerFactory()

            }
        }

        fun assertProjectAreSplitByGradleVersionCorrectly(buckets: List<List<String>>, testType: TestType, functionalTests: List<BaseGradleBuildType>) {
            buckets.forEachIndexed { index: Int, startEndVersion: List<String> ->
                assertTrue(functionalTests[index].name.contains("(${startEndVersion[0]} <= gradle <${startEndVersion[1]})"))

    expectedCipherSuites.add(CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256.javaName)
    expectedCipherSuites.add(CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA.javaName)
    if (listOf<String>(*socket.supportedCipherSuites).contains("TLS_FALLBACK_SCSV")) {
      expectedCipherSuites.add("TLS_FALLBACK_SCSV")
    }
    assertThat(socket.enabledCipherSuites)

        }
    }

    private fun computeTargetModules(module: KtModule): List<KtModule> {
        return when (module) {
            is KtDanglingFileModule -> listOf(module.contextModule, module)
            else -> listOf(module)
        }
    }

    private fun runFir2Ir(
        session: LLFirSession,
        firFiles: List<FirFile>,
        fir2IrExtensions: Fir2IrExtensions,

        )
    }

    private
    fun packageHeader(tree: CachingLightTree, node: LighterASTNode): List<FailingResult> =
        when {
            tree.children(node).isNotEmpty() -> listOf(tree.unsupportedNoOffset(node, node, UnsupportedLanguageFeature.PackageHeader))
            else -> listOf()
        }

    private
    fun import(tree: CachingLightTree, node: LighterASTNode): ElementResult<Import> =

    }

    private fun createScopesWithKind(firScopes: Iterable<IndexedValue<FirScope>>): List<KaScopeWithKind> {
        return firScopes.map { (index, firScope) ->
            KaScopeWithKind(convertToKtScope(firScope), getScopeKind(firScope, index), token)
        }
    }

    private fun flattenFirScope(firScope: FirScope): List<FirScope> = when (firScope) {

        fastFallback = false,
      )
    assertThat(routeSelector.hasNext()).isTrue()
    val (ipv4_1, ipv4_2) = dns.allocate(2)
    val (ipv6_1, ipv6_2) = dns.allocateIpv6(2)
    dns[uriHost] = listOf(ipv4_1, ipv4_2, ipv6_1, ipv6_2)

    val selection = routeSelector.next()
    assertThat(selection.routes.map { it.socketAddress.address }).containsExactly(
      ipv4_1,
      ipv4_2,
      ipv6_1,

            """.trimIndent(),
            resolutionDump
        )
    }

    @Test
    fun `can use the merge result as an input`() {
        val docs = listOf(
            resolvedDocument("x = 1"),
            resolvedDocument("y = 2"),
            resolvedDocument("configuring { a = 3 }"),
            resolvedDocument("configuring { b = 4 }")
        )