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.

            configurations {
                gradleApi
                testKit
            }

            dependencies {
                gradleApi gradleApi()
                testKit gradleTestKit()
            }

            task resolveDependencyArtifacts {
                doLast {
                    def resolvedGradleApiArtifacts = configurations.gradleApi.resolve()

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

                    assert dependencies.gradleApi() == dependencies.gradleApi()
                    assert configurations.conf.dependencies.contains(dependencies.gradleApi())
                }
            }
        """

        then:
        succeeds "check"
    }

    @ToBeFixedForConfigurationCache(because = "Task uses the Configuration API")

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

import static org.gradle.util.internal.TextUtil.normaliseFileSeparators

// TODO: This needs a better home - Possibly in the test kit package in the future
@Issue("https://github.com/gradle/gradle-private/issues/3247")
// The gradleApi() dependency has missing JARs unless the test is run with the full Gradle distribution
@Requires([IntegTestPreconditions.NotEmbeddedExecutor, UnitTestPreconditions.NotJava8OnMacOs])

    def cleanup() {
        executers.each { it.cleanup() }
    }

    @Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = "Requires a Gradle distribution on the test-under-test classpath, but gradleApi() does not offer the full distribution")
    def "can apply plugin using ProjectBuilder in a test running with Gradle version under development"() {
        writeSourceFiles()
        expect:
        run TEST_TASK_NAME
    }

     */
    internal
    val gradleKotlinDsl: ClassPath by lazy {
        gradleApi + gradleApiExtensions + gradleKotlinDslJars
    }

    private
    val gradleApi: ClassPath by lazy {
        DefaultClassPath.of(gradleApiJarsProvider())
    }

    /**
     * Generated extensions to the Gradle API.
     */
    private

plugins {
    id 'groovy'
}

repositories {
    mavenCentral()
}

dependencies {
    api gradleApi()
    api localGroovy()
    implementation "org.pegdown:pegdown:1.1.0"

    def "can run spock tests with mock of class using gradleApi"() {
        file("build.gradle") << """
            plugins {
                id("groovy")
            }

            ${mavenCentralRepository()}

            dependencies {
                implementation gradleApi()
                implementation localGroovy()
                ${testFrameworkDependencies}
            }