file("$childBuildName/src/main/groovy/my/MyExtension.groovy") << """
            import ${Property.name}

            interface MyExtension {
                Property<String> getMessage()
            }
        """
    }

    private void addModelImplementation(String targetBuildName) {
        file("$targetBuildName/src/main/groovy/my/MyModel.groovy") << """
            package my

            id = "gradlebuild.performance-test"
            implementationClass = "gradlebuild.performance.PerformanceTestPlugin"
        }
    }
}

tasks.compileGroovy.configure {
    classpath = sourceSets.main.get().compileClasspath
}
tasks.compileKotlin.configure {
    libraries.from(files(tasks.compileGroovy))

        withImplementationDependencyOn("project-a", dependencyA)
        withFile("project-a/src/main/kotlin/my-plugin-a.gradle.kts")

        and:
        withImplementationDependencyOn("project-b", dependencyB)
        withFile("project-b/src/main/kotlin/my-plugin-b.gradle.kts")

        expect:
        assertClassPathFor(
            file("project-a/src/main/kotlin/my-plugin-a.gradle.kts"),
            [dependencyA] as Set,

 * limitations under the License.
 */

import gradlebuild.configureAsRuntimeJarClasspath

plugins {
    java
}

interface LaunchableJar {
    /**
     * The main class for the application. Can be undefined.
     */
    val mainClassName: Property<String>
}

val app = extensions.create<LaunchableJar>("app")

        }
    }

    @Test
    fun `accessors to __untyped__ kotlin lambda extensions are typed Any`() {

        withDefaultSettings()
        withKotlinBuildSrc()
        withFile(
            "buildSrc/src/main/kotlin/my.gradle.kts",
            """
            extensions.add("lambdaExtension", { name: String ->
                name.toUpperCase()
            })
            """
        )

        withBuildScript(

    @Test
    fun `can access project extensions`() {
        withKotlinBuildSrc()
        withFile("buildSrc/src/main/kotlin/MyExtension.kt", """
            interface MyExtension {
                fun some(message: String) { println(message) }
            }
        """)
        withFile("buildSrc/src/main/kotlin/my-plugin.gradle.kts", """
            extensions.create<MyExtension>("my")
            tasks.register("noop")

                implementation gradleApi()
                implementation localGroovy()
            }
        """
    }

    @Override
    void pluginSetsValues() {
        pluginDir.file("src/main/groovy/SomePlugin.groovy") << """
            import ${Project.name}
            import ${Plugin.name}

            public class SomePlugin implements Plugin<Project> {
                void apply(Project project) {

        withKotlinDslPluginIn("external-plugins").appendText("""group = "test"""")
        withFile("external-plugins/src/main/kotlin/applied-output.gradle.kts", outputFrom("applied-output plugin"))
        withFile(
            "external-plugins/src/main/kotlin/applied-output-fails.gradle.kts", """
            ${outputFrom("applied-output-fails plugin")}
            TODO("applied-output-fails plugin application failure")

import org.gradle.api.tasks.TaskAction

class FilePropertyGroovyInterOpIntegrationTest extends AbstractFilePropertyGroovyInterOpIntegrationTest {
    @Override
    void taskDefinition() {
        pluginDir.file("src/main/groovy/ProducerTask.groovy") << """
            import ${DefaultTask.name}
            import ${RegularFileProperty.name}
            import ${TaskAction.name}
            import ${OutputFile.name}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.declarativedsl.evaluator.main

import org.gradle.internal.declarativedsl.evaluator.conventions.ConventionDefinitionRegistrar
import org.gradle.internal.declarativedsl.evaluator.conventions.SoftwareTypeConventionRepository