$repositoriesBlock

            tasks {
                register("assertions") {
                    doLast {
                        val requiredLibs = listOf("kotlin-stdlib-$embeddedKotlinVersion.jar", "kotlin-reflect-$embeddedKotlinVersion.jar")
                        listOf("compileOnlyClasspath", "testRuntimeClasspath").forEach { configuration ->

    enableProtocol(Protocol.HTTP_2)

    val request = Request(server1.url("/"))

    server1.enqueue(refusedStream)
    server2.enqueue(bodyResponse)

    dns[server1.hostName] = listOf(ipv6, ipv4)
    socketFactory[ipv6] = server1.inetSocketAddress
    socketFactory[ipv4] = server2.inetSocketAddress

    client =
      client.newBuilder()
        .fastFallback(false)
        .apply {

    builder.interceptors().addAll(listOf(null) as List<Interceptor>)
    assertFailsWith<IllegalStateException> {
      builder.build()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Null interceptor: [null]")
    }
  }

  @Test fun nullNetworkInterceptorInList() {
    val builder = OkHttpClient.Builder()
    builder.networkInterceptors().addAll(listOf(null) as List<Interceptor>)

            doLast {

                assert(testCompileClasspathFileNames.containsAll(listOf("commons-lang3-3.12.0.jar", "guava-33.0.0-jre.jar")))
                assert(testRuntimeClasspathFileNames.containsAll(listOf("commons-lang3-3.12.0.jar", "guava-33.0.0-jre.jar")))

                assert(integTestCompileClasspathFileNames.containsAll(listOf("guava-29.0-jre.jar"))) { "constraints apply to compile classpath" }

        .build()

    certificatePinner.check("example.com", listOf(certA1.certificate))
  }

  @Test fun successfulFindMatchingPins() {
    val certificatePinner =
      CertificatePinner.Builder()
        .add("first.com", certA1Sha256Pin, certB1Sha256Pin)
        .add("second.com", certC1Sha256Pin)
        .build()

    val expectedPins =
      listOf(
        Pin("first.com", certA1Sha256Pin),

        assertThat(
            reduceGraph(
                mapOf(
                    "a" to listOf("b", "c"),
                    "b" to listOf("e1"),
                    "c" to listOf("d"),
                    "d" to listOf("b", "e2")
                )
            ),
            equalTo(
                mapOf(
                    "a" to setOf("e1", "e2"),

 */
internal
interface AnalysisSchemaComponent {
    fun typeDiscovery(): List<TypeDiscovery> = listOf()
    fun propertyExtractors(): List<PropertyExtractor> = listOf()
    fun functionExtractors(): List<FunctionExtractor> = listOf()
}


/**
 * Provides grouping capabilities for features used in DCL-to-JVM object conversion.
 */
internal

                "Method com.example.Task.setSourceCompatibility(java.lang.String): Is not binary compatible. Reason for accepting this: Upgraded property" to listOf("Method has been removed")
            )
        }
    }

    @Test

        val result = buildClassTrees(
            listOf(
                mapOf("First.class" to emptyList()),
                mapOf(
                    "First.class" to listOf("Second.class", "Third.class"),
                    "Second.class" to emptyList(),
                    "Third.class" to emptyList()
                ),
                mapOf(
                    "First.class" to listOf("Forth.class"),

            ),
            result
        )
        assertEquals(
            listOf(ResolutionError(imports[1], ErrorReason.AmbiguousImport(DefaultFqName("a.c", "C")))),
            analysisContext.errorCollector.errors
        )
    }

    @Test
    fun `does not report errors on the same import appearing more than once`() {
        val imports = listOf(
            importOf("a", "b", "C"),
            importOf("a", "b", "C"),