def setup() {
        pluginDir.file("build.gradle") << """
            plugins {
                id("java-library")
            }
            dependencies {
                api gradleApi()
            }
        """
        pluginDir.file("src/main/java/Params.java") << """
            import ${Property.name};
            import ${Internal.name};

            public interface Params {

// tag::external-task-build[]
plugins {
    id 'groovy'
// end::external-task-build[]
    id 'maven-publish'
// tag::external-task-build[]
}

// tag::gradle-api-dependencies[]
dependencies {
    implementation gradleApi()
}
// end::gradle-api-dependencies[]
// end::external-task-build[]

repositories {
    mavenCentral()
}

dependencies {
    testImplementation 'junit:junit:4.13'
}

group = 'org.gradle'

tasks.validatePlugins {
    enableStricterValidation = true
}

// Remove gradleApi() and gradleTestKit() as we want to compile/run against Gradle modules
// TODO consider splitting `java-gradle-plugin` to provide only what's necessary here
configurations.all {
    withDependencies {
        remove(project.dependencies.gradleApi())
        remove(project.dependencies.gradleTestKit())
    }
}

            </tr>
            <tr>
                <td>module</td>
            </tr>
            <tr>
                <td>project</td>
            </tr>
            <tr>
                <td>gradleApi</td>
            </tr>
            <tr>
                <td>gradleTestKit</td>
            </tr>
            <tr>
                <td>localGroovy</td>
            </tr>
            <tr>

        given:
        buildScript """
            plugins {
                id 'java'
            }

            ${mavenCentralRepository()}
            dependencies {
                implementation gradleApi()
                implementation 'net.java.dev.jna:jna:4.1.0'
                testImplementation 'junit:junit:4.13'
            }
        """.stripIndent()

        file('src/test/java/JnaDoesWork.java') << """

        """

        file("buildSrc/testplugin/build.gradle") << """
            apply plugin: "groovy"

            dependencies {
                implementation localGroovy()
                implementation gradleApi()
            }
        """

        def pluginSource = file("buildSrc/testplugin/src/main/groovy/testplugin/TestPlugin.groovy") << """
            package testplugin
            import org.gradle.api.Plugin

        project.getPluginManager().apply(GroovyPlugin.class);

        DependencyHandler dependencies = project.getDependencies();
        dependencies.add(JvmConstants.API_CONFIGURATION_NAME, dependencies.gradleApi());
        dependencies.add(JvmConstants.API_CONFIGURATION_NAME, dependencies.localGroovy());
    }

    def setup() {
        pluginDir.file("build.gradle") << """
            plugins {
                id("java-library")
            }
            dependencies {
                api gradleApi()
            }
        """
    }

    abstract void taskDefinition();

    abstract void taskWithNestedBeanDefinition();

    @Override
    void pluginDefinesTask() {

            plugins {
                kotlin("jvm") version embeddedKotlinVersion
            }

            ${mavenCentralRepository(GradleDsl.KOTLIN)}

            dependencies {
                implementation(gradleApi())
                implementation(kotlin("stdlib"))
            }

            tasks.withType<KotlinCompile>().configureEach {

    def setup() {
        pluginDir.file("build.gradle") << """
            plugins {
                id("groovy")
            }
            dependencies {
                implementation gradleApi()
                implementation localGroovy()
            }
        """
        pluginDir.file("src/main/groovy/Params.groovy") << """
            import ${Property.name}
            import ${Internal.name}