sourceFiles = 200
    testSourceFiles = 50 // verbose tests are time consuming
    filesPerPackage = 5
    linesOfCodePerSourceFile = 150
    numberOfScriptPlugins = 30
    rootProjectTemplates = listOf("root")
    subProjectTemplates = listOf("project-with-source")
    templateArgs = mapOf(
        "fullTestLogging" to true,
        "failedTests" to true,
        "projectDependencies" to true,
        "manyPlugins" to true,

            object : CookieManager() {
              override fun get(
                uri: URI,
                requestHeaders: Map<String, List<String>>,
              ) = mapOf(
                "COOKIE" to listOf("Bar=bar"),
                "cooKIE2" to listOf("Baz=baz"),
              )
            },
          ),
        )
        .build()
    server.enqueue(MockResponse())
    get(server.url("/"))

    testImplementation("junit:junit:4.13")
}

// tag::custom-source-locations[]
sourceSets {
    main {
        groovy {
            setSrcDirs(listOf("src/groovy"))
        }
    }

    test {
        groovy {
            setSrcDirs(listOf("test/groovy"))
        }
    }
}

                    "nested" to PluginTree.PluginGroup(
                        listOf("nested"),
                        linkedMapOf(
                            "plugin-a" to nestedPluginA,
                            "other" to PluginTree.PluginGroup(
                                listOf("nested", "other"),
                                linkedMapOf(

            schemaFromTypes(ReceiverTwo::class, listOf(ReceiverTwo::class))
        }
        assertTrue { exception.message!!.contains("@Adding") }
    }

    @Test
    fun `adding function with no lambda is accepted if it returns Unit`() {
        val schema = schemaFromTypes(ReceiverThree::class, listOf(ReceiverThree::class))

}

dependencies {
    testImplementation("junit:junit:4.13")
}

// tag::define-main[]
sourceSets {
    main {
        java {
            setSrcDirs(listOf("src/java"))
        }
        resources {
            setSrcDirs(listOf("src/resources"))
        }
    }
// end::define-main[]
    test {
        java {
            srcDir("test/java")
        }
        resources {

                )
                endModel("", "", "", 0)
            },
            hasEntry(
                "diagnostics",
                listOf(
                    mapOf(
                        "trace" to listOf(mapOf("kind" to "Unknown")),
                        "input" to listOf(mapOf("name" to ""))
                    )
                )
            )
        )
    }

    private

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

    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
interface ObjectConversionComponent {
    fun runtimePropertyResolvers(): List<RuntimePropertyResolver> = listOf()

        "org/gradle/util/**", // contains Path that clashes with `org.gradle.api.model.Path` imported above. This line should not appear before "org/gradle/api/**"
    )

    val excludes = listOf("**/internal/**")

    private val includePackagePatterns: List<Pattern> by lazy {
        includes.map {
            if (it.endsWith("/**")) {
                Pattern.compile(it.substring(0, it.length - 3).replace("/", "\\.") + "(\\..+)?")