// given: same init, settings & build files all applying same script
        val same = withFile("same.gradle.kts", """println("Same script on ${'$'}this")""")
        val sameApply = """apply(from = "same.gradle.kts")"""
        val initScriptFile = withFile("same.init.gradle.kts", sameApply)

        val initializationFile = cachedInitializationFile(initScriptFile, false, true)

    fun `can configure custom kotlin options on a kotlin-dsl project`() {

        withDefaultSettingsIn("buildSrc")
        val buildSrcBuildScript = withKotlinDslPluginIn("buildSrc")
        withFile("buildSrc/src/main/kotlin/MyDataObject.kt", "data object MyDataObject")
        withBuildScript("println(MyDataObject)")
        buildAndFail("help").apply {

    operator fun String.invoke(subFolders: FoldersDslExpression): File =
        (+this).withFolders(subFolders)

    operator fun String.unaryPlus(): File =
        canonicalFile(this).apply { mkdirs() }

    fun withFile(fileName: String, content: String = ""): File =
        canonicalFile(fileName).apply {
            parentFile.mkdirs()
            writeText(content)
        }

    fun existing(fileName: String): File =

public class MediumChildMap<T> extends AbstractListChildMap<T> {
    protected MediumChildMap(List<Entry<T>> children) {
        super(children);
    }

    @Override
    public <RESULT> RESULT withNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, RESULT> handler) {
        for (Entry<T> entry : entries) {

            withClassJar("some.JAR", DeepThought::class.java),
            withClassJar("some.zip", LightThought::class.java),
            withClassJar("some.tar.gz", ZeroThought::class.java),
            withFile("some.xml")
        )

        ClassBytesRepository(
            platformClassLoader = ClassLoaderUtils.getPlatformClassLoader(),
            classPathFiles = entries
        ).use { repository ->

    @SuppressWarnings("unchecked")
    public static <T> EmptyChildMap<T> getInstance() {
        return (EmptyChildMap<T>) INSTANCE;
    }

    private EmptyChildMap() {
    }

    @Override
    public <R> R withNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, R> handler) {
        return handler.handleUnrelatedToAnyChild();
    }

    @Override

class GroovyInteroperabilityIntegrationTest : AbstractKotlinIntegrationTest() {

    @Test
    fun `can call GroovyObject methods in withGroovyBuilder`() {
        withDefaultSettings()

        withFile(
            "groovy.gradle",
            """
            class MyExtension {
                String server = 'default'

                def configureServerName(serverName) {

    @LeaksFileHandles("Kotlin Compiler Daemon working directory")
    fun `can use accessors for plugins in the buildSrc classpath`() {

        withKotlinBuildSrc()
        withFile(
            "buildSrc/src/main/kotlin/my/plugin-a.gradle.kts",
            """
            package my
            println("*my.plugin-a*")
            """
        )

        withDefaultSettings()

			oldObj: "baz",
			schema: withRule(stringType, `
				!oldSelf.hasValue() || self == "bar"
			`),
		},
		{
			name:   "integer",
			obj:    1,
			oldObj: 2,
			schema: withRule(integerType, `
				!oldSelf.hasValue() || self == 1
			`),
		},
		{
			name:   "number",
			obj:    1.1,
			oldObj: 2.2,
			schema: withRule(numberType, `

            }

            println("buildSrc build script classpath kotlin compiler version " + KotlinCompilerVersion.VERSION)
            """
        )
        withFile(
            "buildSrc/src/main/kotlin/my-plugin.gradle.kts",
            "apply(plugin = \"kotlin\")"
        )

        withBuildScript(
            """