def "does not download gradleApi() sources when sources download is disabled"() {
        given:
        executer.withEnvironmentVars('GRADLE_REPO_OVERRIDE': "$server.uri/")

        buildScript """
            apply plugin: "java"
            apply plugin: "idea"
            apply plugin: "eclipse"

            dependencies {
                implementation gradleApi()
            }

    }

    def "apply adds gradleApi dependency to api"() {
        when:
        project.pluginManager.apply(JavaGradlePluginPlugin)

        then:
        project.configurations
            .getByName(JavaGradlePluginPlugin.API_CONFIGURATION)
            .dependencies.find {
            it.files == project.dependencies.gradleApi().files
        }
    }

        !stdOut.toString().contains("BUILD SUCCESSFUL")
    }

    def "can configure Kotlin DSL project with gradleApi() dependency via tooling API"() {
        given:
        buildKotlinFile << """
        plugins {
            java
        }

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

        when:
        def stdOut = new ByteArrayOutputStream()

        """
        expect:
        succeeds("help")

        where:
        expression << [
            "gradleApi()",
            "gradleTestKit()",
            "localGroovy()",
        ]
    }

    def "FileCollectionDependency declared using #expression shows up in related configuration"() {
        given:

                copyPluginDescriptors.from(tasks.pluginDescriptors)
            }
            // ==

            dependencies {
                gradle7CompileOnly(gradleApi()) // We should be able to access different Gradle API versions
                gradle7CompileOnly(localGroovy())
            }

            gradlePlugin {
                plugins.create('greeting') {

    static final String GENERATE_PLUGIN_DESCRIPTORS_TASK_NAME = "pluginDescriptors";
    static final String VALIDATE_PLUGINS_TASK_NAME = "validatePlugins";

    /**
     * Suppress adding the {@code DependencyHandler#gradleApi()} dependency.
     *
     * Experimental property used to test using an external Gradle API dependency.
     */

        def otherDir = file("buildSrc/other")
        otherDir.file("build.gradle") << """
            plugins {
                id("java-library")
            }
            dependencies {
                api gradleApi()
                implementation project(":plugin")
            }
        """

        otherDir.file("src/main/java/SomeOtherPlugin.java") << """
            import ${Project.name};

        Dependency dependency = Mock()

        when:
        def result = dependencyHandler.gradleApi()

        then:
        result == dependency

        and:
        1 * dependencyFactory.createDependency(DependencyFactoryInternal.ClassPathNotation.GRADLE_API) >> dependency
    }

    void "creates Gradle test-kit dependency"() {
        Dependency dependency = Mock()

    }

    @Test
    @Requires(
        IntegTestPreconditions.NotEmbeddedExecutor::class,
        reason = "Requires a Gradle distribution on the test-under-test classpath, but gradleApi() does not offer the full distribution"
    )
    fun `gradle kotlin dsl api is available for test implementation`() {

        withBuildScript(
            """

            plugins {
                `kotlin-dsl`

                        implementationClass = "my.MyPlugin"
                    }
                }
            }

            dependencies {
                compileOnly(gradleApi())
                $testKitDependencies
            }

            ${mavenCentralRepository()}

        """.stripIndent()
        if (testKitSpec) {