implementation 'com.google.guava:guava:19.0'
            }
        """

        file('src/main/groovy/MyPlugin.groovy') << """
            import org.gradle.api.Plugin
            import org.gradle.api.Project
            import com.google.common.collect.Maps

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

    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:

    def getSomeProp() {
        return this
    }
    def conf(Closure cl) {
        cl.delegate = this
        cl.call()
    }
}

class MyPlugin extends RuleSource {
    @Model
    UnmanagedThing thing() { return new UnmanagedThing() }
}
apply plugin: MyPlugin

model {
    thing {
        conf {
            println "outer 1"
        }
        someProp.conf {
            println "outer 2"

            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
              }

    }

    def "only closure literals can be used as rules"() {
        when:
        buildScript """
            class MyPlugin extends RuleSource {
                @Model
                String foo() {
                  "foo"
                }
            }

            apply type: MyPlugin

            def c = {};
            model {
                foo(c)
            }
        """

            ${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")
    }