def setupBuild(Jvm javaVersion) {
        file('buildSrc/build.gradle') << """
            plugins {
                id 'java'
            }

            dependencies {
                implementation(gradleApi())
            }

            tasks.withType(JavaCompile) {
                ${javaVersion == null ? '' : forkingOptions(javaVersion)}
            }
        """

            implementation(project()) // is getImplementation().add(project())

            // Add a dependency on the Gradle API
            implementation(gradleApi()) // is getImplementation().add(gradleApi())

            // Modify a dependency to select test fixtures
            implementation(testFixtures("org:foo:1.0")) // is getImplementation().add(getTestFixtures().modify("org:foo:1.0"))

        try {
            try (PrintWriter writer = new PrintWriter(rootDir.file("build.gradle"))) {
                writer.println("apply plugin: 'java'");
                writer.println(String.format("dependencies { %s gradleApi() }", conf));
                writer.println("jar {");
                if (shouldPreserveTimestamps != null) {
                    writer.println(String.format("preserveFileTimestamps = %s", shouldPreserveTimestamps));

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

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

            gradlePlugin {
                plugins.create('greeting') {

        """
        expect:
        succeeds("help")

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

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

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

    @Override
    void pluginSetsValues() {
        pluginDir.file("src/main/java/SomePlugin.java") << """
            import ${Project.name};

        then:
        dslFixtureFor(GROOVY).assertGradleFilesGenerated()
    }

    public static final String NOT_RUNNING_ON_EMBEDDED_EXECUTER_REASON = "This test runs a build that itself runs a build in a test worker with 'gradleApi()' dependency, which needs to pick up Gradle modules from a real distribution"

    @Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = NOT_RUNNING_ON_EMBEDDED_EXECUTER_REASON)

    }

    PluginUnderTest writeBuildScript() {
        projectDir.file("build.gradle") << """
            apply plugin: 'groovy'
            dependencies {
                implementation gradleApi()
                implementation localGroovy()
            }
        """

        this
    }

    private File generateMetadataFile() {
        def file = metadataFile.touch()

        Container_Boundary(provider, "Kotlin DSL Provider") {

            Component(gradleKotlinDslApi, "Generated `gradleKotlinDslApi()` API JAR", "The Gradle Kotlin DSL API & Kotlin decorated gradleApi()")

            Component(providerFactory, "Gradle ScriptPluginFactory", "Provides script evaluation to Gradle, main entry point")

    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.
     */