return gradleKotlinDsl();
        }
        return null;
    }

    private ClassPath gradleApi() {
        if (gradleApi == null) {
            gradleApi = initGradleApi();
        }
        return gradleApi;
    }

    private ClassPath initGradleApi() {
        // This gradleApi() method creates a Gradle API classpath based on real jars for embedded test running.

        then:
        result.assertTaskNotSkipped(':compileTestJava')
    }

    def "gradleApi dependency API does not include test-kit JAR"() {
        when:
        buildFile << """
            dependencies {
                testImplementation gradleApi()
            }
            verifyTestKitJars {
                doLast {
                    def jarFiles = libsDir.listFiles()

        List<File> gradleApi = getClassPath(GRADLE_API);
        testKitClasspath.removeAll(gradleApi);

        ImmutableSet.Builder<File> builder = ImmutableSet.builder();
        builder.add(relocatedDepsJar(testKitClasspath, RuntimeShadedJarType.TEST_KIT));
        builder.addAll(gradleApiFileCollection(gradleApi));
        return builder.build();
    }

    }

    protected void prepareGroovyPluginTest(String pluginApplyBody) {
        file("producer/build.gradle") << """
            apply plugin: 'groovy'
            dependencies {
                implementation gradleApi()
            }
        """

        file("producer/src/main/groovy/SomePlugin.groovy") << """
            ${getDefaultImports().collect { "import " + it }.join("\n")}

    def copyPluginDescriptors = rootSpec.addChild()
    copyPluginDescriptors.into('META-INF/gradle-plugins')
    copyPluginDescriptors.from(tasks.pluginDescriptors)
}

dependencies {
    gradle7CompileOnly(gradleApi()) // <4>
}
// end::add-plugin-variant[]

// tag::consume-plugin-variant[]
configurations.configureEach {
    if (canBeResolved && name.startsWith(gradle7.name))  {
        attributes {

    val copyPluginDescriptors = rootSpec.addChild()
    copyPluginDescriptors.into("META-INF/gradle-plugins")
    copyPluginDescriptors.from(tasks.pluginDescriptors)
}

dependencies {
    "gradle7CompileOnly"(gradleApi()) // <4>
}
// end::add-plugin-variant[]

// tag::consume-plugin-variant[]
configurations.configureEach {
    if (isCanBeResolved && name.startsWith(gradle7.name))  {
        attributes {

        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());
    }

            plugins {
                kotlin("jvm") version embeddedKotlinVersion
            }

            ${mavenCentralRepository(GradleDsl.KOTLIN)}

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

            tasks.withType<KotlinCompile>().configureEach {