| Rules:
         ⤷ components { ... } @ build.gradle line 37, column 5
         ⤷ MyPlugin#mutateMyComponents(ModelMap<MyComponentInternal>)
    + my
          | Type:   	MyComponent
          | Creator: 	components { ... } @ build.gradle line 37, column 5 > create(my)
          | Rules:
             ⤷ MyPlugin#mutateMyComponents(ModelMap<MyComponentInternal>) > all()
        + publicData

            withZip(
                fileName,
                classEntriesFor(MyPlugin::class.java, MyTask::class.java) + sequenceOf(
                    "META-INF/gradle-plugins/my-plugin.properties" to "implementation-class=org.gradle.kotlin.dsl.integration.MyPlugin".toByteArray(),
                    "my-plugin-version.txt" to versionString.toByteArray(),
                )
            )

                void setName(String name)
            }

            class MyPlugin extends RuleSource {
                @Defaults
                void applyDefaults(Thing thing) {
                    thing.name = "default"
                }
            }

            apply plugin: MyPlugin

            model {
                thing1(Thing) {
                    name = "$name foo"

    private void withBinaryPluginBuild(String projectPath = ".", TestKitSpec testKitSpec = null, String version = "1.0") {
        file("$projectPath/src/main/groovy/my/MyPlugin.groovy") << """

            package my

            import org.gradle.api.*

            class MyPlugin implements Plugin<Project> {
                @Override
                void apply(Project project) {

    }

    @Test
    fun `#buildPluginDependencySpecAccessorsFor`() {

        // given:
        val pluginsJar = jarWithPluginDescriptors(
            file("plugins.jar"),
            "my-plugin" to "MyPlugin",
            "my.own.plugin" to "my.own.Plugin"
        )

        val srcDir = newFolder("src")
        val binDir = newFolder("bin")

        // when:
        withSynchronousIO {

     *
     * <pre>
     * plugins {
     *     id "org.company.myplugin"
     * }
     * </pre>
     * Further constraints (e.g. version number) can be specified by the methods of the return value.
     * <pre>
     * plugins {
     *     id "org.company.myplugin" version "1.3"
     * }
     * </pre>
     *

        settingsFile << """
            include("a")
            include("b")
        """
        buildFile << """
            plugins.apply(my.MyPlugin)
        """
        file("a/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)
        def model = runBuildAction(new FetchCustomModelForEachProjectInTree())

        then:

            class DefaultSampleBinary extends BaseBinarySpec implements SampleBinarySpec {}

            @Managed interface SampleComponent extends ComponentSpec{}

            class MyPlugin implements Plugin<Project> {
                public void apply(Project project) {
                    project.plugins.apply(ComponentModelBasePlugin)
                }

        file("$targetBuildName/src/main/groovy/my/MyPlugin.groovy") << """
            package my

            import ${Project.name}
            import ${Plugin.name}
            import ${Inject.name}
            import ${ToolingModelBuilderRegistry.name}

            abstract class MyPlugin implements Plugin<Project> {
                void apply(Project project) {

            }
        """, "org.gradle.test.MyPlugin", "MyPlugin"

        pluginBuilder.prepareToExecute()

        settingsFile << """
            includeBuild("plugin")
        """

        vcsMapping('org.test:first', first)
        // root build applies a plugin to second
        vcsMapping('org.test:second', second, ['org.gradle.test.MyPlugin'])
        // first build does not inject a plugin in second