PluginDependencySpec version(@Nullable String version);

    /**
     * Specify the version of the plugin to depend on.
     *
     * <pre>
     * plugins {
     *     id "org.company.myplugin" version libs.versions.myplugin
     * }
     * </pre>
     *
     * @param version the version provider, for example as found in a version catalog
     * @return this
     *
     * @since 7.2
     */

        """)
        buildFile << """
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)
        fetchModelFails()

        then:
        fixture.assertStateStoredAndDiscarded {
            projectConfigured(":buildSrc")
            modelsCreated(":")
            problem("Plugin class 'my.MyPlugin': Project ':' cannot access 'Project.extensions' functionality on subprojects", 2)

    def "dependencies of builds tested with TestKit in debug mode are instrumented and violations are reported"() {
        given:
        file("included/src/main/java/MyPlugin.java") << """
            import org.gradle.api.*;

            public class MyPlugin implements Plugin<Project> {
                @Override
                public void apply(Project project) {
                    String returned = System.getProperty("my.property");

        def op = ops.first()
        op.details.pluginClass == "MyPlugin"
        op.details.buildPath == ":"
        op.details.targetPath == null
    }

    def "captures setting plugin"() {
        when:
        settingsFile << """
            class MyPlugin implements Plugin {
                void apply(t) {}
            }

            apply plugin: MyPlugin
        """

        succeeds("help")

        then:

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

        when:
        executer.withArguments(ENABLE_CLI)

            ${ruleBasedTasks()}

            class MyPlugin extends RuleSource {
                @Mutate
                void applyMessages(ModelMap<EchoTask> tasks) {
                    tasks.afterEach {
                        message += " message!"
                    }
                }
            }

            apply type: MyPlugin

            task foo(type: EchoTask) { message = 'custom' }

        task(':b').originPlugin.displayName == "MyPlugin"
    }

    def "reports task origin for tasks defined in configuration callbacks"() {
        given:
        buildFile << """
            apply plugin: MyPlugin

            configurations {
                foo
            }

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

        writeBuildSrcPlugin("buildSrc", "MyPlugin")
        buildFile << """
            apply plugin: MyPlugin
            // nuke buildSrc classes so we can't use them
            project.delete(file("buildSrc/build/classes"))
        """
        when:
        succeeds("myTaskMyPlugin")
        then:
        outputContains("From MyPlugin")
    }

        settingsFile << """
            include("a")
            include("b")
        """
        buildFile << """
            plugins.apply(my.MyPlugin)
        """
        file("a/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """
        // Intentionally don't apply to project b. Should split this case (some projects don't have the model available) out into a separate test

        when:

            apply(plugin: MyPlugin, to: gradle)
            class MyPlugin implements Plugin<Gradle> {
                void apply(Gradle gradle) {}
            }
        """

        when:
        runBuild("tasks")

        then:
        getPluginConfigurationOperationResult(":").getPluginApplicationResults().findAll { it.plugin.displayName.contains("MyPlugin") }.empty
    }