CustomPlugin(WorkerExecutor executor) {
                }

                void apply(Project p) {
                }
            }

            apply plugin: CustomPlugin
        """

        expect:
        fails()
        failure.assertHasCause("Failed to apply plugin class 'CustomPlugin'")
        failure.assertHasCause("Could not create plugin of type 'CustomPlugin'.")

    }

    def "can apply a rule source by id"() {
        when:
        def project = buildProject()
        project.apply plugin: 'custom-rule-source'

        then:
        project.modelRegistry.realize("foo", String) == "bar"
    }

    def "can apply a rule source by type"() {
        when:
        def project = buildProject()
        project.apply type: CustomRuleSource

        then:

    assertFalse(isNumber.apply(null));
  }

  @GwtIncompatible // Predicates.instanceOf
  public void testIsInstanceOf_interface() {
    Predicate<@Nullable Object> isComparable = Predicates.instanceOf(Comparable.class);

    assertTrue(isComparable.apply(1));
    assertTrue(isComparable.apply(2.0f));
    assertTrue(isComparable.apply(""));
    assertFalse(isComparable.apply(null));
  }

fun Response.Builder.commonRequest(request: Request) =
  apply {
    this.request = request
  }

fun Response.Builder.commonProtocol(protocol: Protocol) =
  apply {
    this.protocol = protocol
  }

fun Response.Builder.commonCode(code: Int) =
  apply {
    this.code = code
  }

fun Response.Builder.commonMessage(message: String) =
  apply {
    this.message = message
  }

        plugins.empty

        when:
        container.apply(pluginClass)

        then:
        plugins == []
    }

    def "calls apply on target for type only"() {
        when:
        container.apply(plugin1Class)

        then:
        1 * target.applyImperative(null, { plugin1Class.isInstance(it) })
    }

    def "calls apply on target for id"() {
        when:

        then:
        project.classpathContainers.isEmpty()
    }

    def "Project has some classpath containers"() {
        buildFile <<
        """apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   containers 'containerPath1', 'containerPath2'
               }
           }
        """

        when:

        createDirs("a", "b")
        file("settings.gradle") << 'include "a", "b"'

        and:
        buildFile << """
            project(":a") {
                apply plugin: 'war'
            }
            project(":b") {
                apply plugin: 'java'
                dependencies {
                    implementation project(":a")
                }
                compileJava.doFirst {

            }
        """

        file("sub/build.gradle") << "apply from: 'script.gradle'"
        file("sub/script.gradle") << "someMethod()"

        when:
        run "help"

        then:
        output.contains("from some method")
    }

    @Issue("https://issues.gradle.org/browse/GRADLE-3082")
    def "can use apply block syntax to apply multiple scripts"() {
        given:
        buildScript """

            class SneakyPlugin implements Plugin<Project> {
                public void apply(Project project) {
                    def value = ${read.groovyExpression}
                    println("apply = " + value)

                    // Instance call
                    def sys = System
                    println("apply INSTANCE = " + sys.getProperty("INSTANCE"))

                    // Call from closure

            class Plugin1 implements Plugin {
                void apply(project) {
                    project.rootProject.project(":b").apply(plugin: Plugin2)
                }
            }
            class Plugin2 implements Plugin {
                void apply(project) {

                }
            }

            project(":a").apply plugin: Plugin1
        """
        succeeds("help")