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.

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

        """

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

    }
    pluginsRuntimeOnly(project(":unit-test-fixtures")) {
        because("This is required for gradleApi()")
    }

publishing {
    publications {
        create<MavenPublication>("maven") {
            artifactId = moduleIdentity.baseName.get()

            from(components["gradleApi"])

            versionMapping {
                allVariants {
                    fromResolutionOf(configurations.externalRuntimeClasspath.get())
                }
            }

            pom {

    def setup() {
        buildFile << """
        apply plugin: 'groovy'

        dependencies {
            implementation localGroovy()
            implementation gradleApi()
        }

        ${mavenCentralRepository()}

        testing {
            suites {
                test {
                    useSpock()
                }
            }
        }

val softwareComponentFactory = project.objects.newInstance(SoftwareComponentFactoryProvider::class.java).factory
val gradleApiComponent = softwareComponentFactory.adhoc("gradleApi")
components.add(gradleApiComponent)

// Published component containing the public Gradle API
gradleApiComponent.addVariantsFromConfiguration(gradleApiElements.get()) {
    mapToMavenScope("compile")

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

import com.gradleup.gr8.EmbeddedJarTask
import com.gradleup.gr8.Gr8Task
import java.util.jar.Attributes

plugins {
    id("gradlebuild.distribution.api-java")
    id("com.gradleup.gr8") version "0.10"
}

description = "Entry point of the Gradle wrapper command"

gradlebuildJava.usedInWorkers()

    def "uses modules to determine gradle API classpath"() {
        when:
        def classpath = provider.findClassPath("GRADLE_API")

        then:
        classpath.asFiles.collect{it.name} == [
            "gradle-worker-main-runtime",
            "gradle-launcher-runtime",
            "gradle-cli-runtime",