"my-bundles",
            "my-versions",
            "my-plugins",
            "my-bundle",
            "my-plugin",
            "my-version",
            "myBundles",
            "myPlugins",
            "myVersions",
            "bundlesOfMe",
            "pluginsOfMe",
            "versionsOfMe",
        ]
    }

    @VersionCatalogProblemTestFor(

     | provides a specific path to the Tomcat instance. To use this, your plugin configuration might
     | hypothetically look like:
     |
     | ...
     | <plugin>
     |   <groupId>org.myco.myplugins</groupId>
     |   <artifactId>myplugin</artifactId>
     |
     |   <configuration>
     |     <tomcatLocation>${tomcatPath}</tomcatLocation>
     |   </configuration>
     | </plugin>
     | ...
     |

            }

            apply plugin: MyPlugin
        '''

        expect:
        fails 'model'
        failure.assertHasCause("Exception thrown while executing model rule: MyPlugin#rules")
        failure.assertHasCause("broken")
    }

    def "@Rules method is not executed when target is not required"() {
        buildFile << '''
            class MyPlugin extends RuleSource {
                @Model

  MyPlugin.Rules#subjectOnly(MyPlugin.MyThing2)
    subject:
      - <no path> MyPlugin.MyThing2 (parameter 1) [*]

  MyPlugin.Rules#thing1(MyPlugin.MyThing2)
    inputs:
      - <no path> MyPlugin.MyThing2 (parameter 1) [*]
'''
    }

    def "unbound rule by-path subject and inputs are reported"() {
        given:
        buildScript """
            class MyPlugin {

        buildScript """
            class MyPlugin {
                class Rules extends RuleSource {
                }
            }

            apply type: MyPlugin
        """

        then:
        fails "tasks"

        and:
        failure.assertHasCause("Failed to apply plugin class 'MyPlugin'")
        failure.assertHasCause('''Type MyPlugin.Rules is not a valid rule source:

    }

    def "cannot create tasks during config of task"() {
        given:
        buildFile << """
            class MyPlugin extends RuleSource {
                @Mutate
                void addTasks(ModelMap<Task> tasks) {

    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");

            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)

        when:
        buildScript """
            class MyPlugin {
              static class Rules extends RuleSource {
                @Model
                String foo() {
                  "foo"
                }
              }
            }

            apply type: MyPlugin

            model {
              foo {
                $code
              }

            ${ruleBasedTasks()}

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

            apply type: MyPlugin

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