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

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

                        repositories {
                            mavenCentral()
                        }
                        dependencies {
                            "implementation"(gradleApi())
                            "implementation"(kotlin("stdlib"))
                        }
                    }
                    project(":v1") {
                        version = "1.0"
                    }

 *
 * dependencies {
 *   //we will use the Groovy version that ships with Gradle:
 *   implementation localGroovy()
 *
 *   //our plugin requires Gradle API interfaces and classes to compile:
 *   implementation gradleApi()
 *
 *   //we will use the Gradle test-kit to test build logic:
 *   testImplementation gradleTestKit()
 * }
 * </pre>
 *
 * <h3>Client module dependencies</h3>
 *

            .nagUser();

        return dependencyFactory.createModule(notation, configureClosure);
    }

    @Override
    public Dependency gradleApi() {
        return dependencyFactory.createDependency(DependencyFactoryInternal.ClassPathNotation.GRADLE_API);
    }

    @Override
    public Dependency gradleTestKit() {

        'a custom suite'    | 'integTest' | 'integTest(JvmTestSuite)'
    }
    // endregion dependencies - platforms

    // region dependencies - self-resolving dependencies
    def "can add gradleApi dependency to #suiteDesc"() {
        given:
        buildFile << """
            plugins {
                id 'java-library'
            }

            ${mavenCentralRepository()}