"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"),

                        OperatingSystem.current().isWindows -> requirements = listOf("os=windows", "gbt-dogfooding")
                        OperatingSystem.current().isMacOsX -> requirements = listOf("os=macos", "gbt-dogfooding")
                    }
                } else {
                    requirements = listOf("gbt-dogfooding")
                }

    }
}
// end::dependency-management[]

// tag::configure-target-machines[]
library {
    targetMachines = listOf(machines.linux.x86_64, machines.macOS.x86_64)
}
// end::configure-target-machines[]

// tag::configure-linkages[]
library {
    linkage = listOf(Linkage.STATIC, Linkage.SHARED)
}

        else -> listOf(
            FixedTypeDiscovery(ProjectTopLevelReceiver::class, listOf(projectAccessorsClass)),
            TypesafeProjectAccessorTypeDiscovery()
        )
    }

    override fun runtimePropertyResolvers(): List<RuntimePropertyResolver> = listOf(ProjectPropertyAccessorRuntimeResolver())
}


private
class ProjectPropertyAccessorRuntimeResolver : RuntimePropertyResolver {

    assertThat(listOf(clientCertificate.certificate, clientIntermediate.certificate))
      .isEqualTo(serverHandshake.peerCertificates)
    assertThat(listOf(serverCertificate.certificate, serverIntermediate.certificate))
      .isEqualTo(serverHandshake.localCertificates)
    val clientHandshake = clientHandshakeFuture.get()
    assertThat(listOf(serverCertificate.certificate, serverIntermediate.certificate))

    @TaskAction
    fun action() {
        val outputBytes = ByteArrayOutputStream()
        execOps.exec {
            executable = javaExecutable.get().asFile.absolutePath
            args = listOf("-version")
            standardOutput = outputBytes
            errorOutput = outputBytes
        }
        require(outputBytes.toString("UTF-8").contains("version \"11")) {

                            includes = listOf("org.gradle.*", "gradle.*")
                            limit {
                                minimum = 1.toBigDecimal()
                            }
                        }
                        rule {
                            element = "METHOD"
                            includes = listOf("org.gradle.*", "gradle.*")
                            limit {

    fun asName() = name.lowercase().toCapitalized()

    fun javaInstallationLocations(arch: Arch = Arch.AMD64): String {
        val paths = when {
            this == LINUX ->
                listOf(
                    DefaultJvm(JvmVersion.java7, JvmVendor.oracle),
                    DefaultJvm(JvmVersion.java8, JvmVendor.oracle),
                    DefaultJvm(JvmVersion.java11, JvmVendor.openjdk),

    val badProviders =
      listOf(
        DnsOverHttps.Builder()
          .client(bootstrapClient)
          .url(url)
          .post(true)
          .build(),
      )
    runBatch(badProviders, names)
    println("cached first run\n****************\n")
    names = listOf("google.com", "graph.facebook.com")
    bootstrapClient =
      bootstrapClient.newBuilder()