def help = events.operation("Apply plugin org.gradle.help-tasks to root project 'single'")
        def java = events.operation("Apply plugin org.gradle.java to root project 'single'")
        def javaBase = events.operation("Apply plugin org.gradle.api.plugins.JavaBasePlugin to root project 'single'")
        def base = events.operation("Apply plugin org.gradle.api.plugins.BasePlugin to root project 'single'")

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

        pojoProject.pluginManager.apply(JavaPlugin)
        def beanProject = TestUtil.createChildProject(project, 'bean')
        beanProject.pluginManager.apply(JavaPlugin)

        beanProject.dependencies {
            runtimeOnly project(path: pojoProject.path)
        }

        when:
        project.pluginManager.apply(EarPlugin)
        project.dependencies {

            "src/integTest/groovy",
            "src/integTest/resources"
        ]

        expectedOrder.each { testFile(it).mkdirs() }

        runEclipseTask """
apply plugin: "java"
apply plugin: "groovy"
apply plugin: "eclipse"

sourceSets {
    integTest {
        resources { srcDir "src/integTest/resources" }
        java { srcDir "src/integTest/java" }

                id("plugin-id").version("1.0").apply(true)
                id("plugin-id").version("2.0") apply true
                id("plugin-id") version "3.0".apply(true) // BUG!
                id("plugin-id") version "4.0" apply true

                id("plugin-id").apply(false).version("1.0")
                id("plugin-id").apply(false) version "2.0"
                id("plugin-id") apply false.version("3.0") // BUG!

    assertEquals(p1.apply(1.0f), p2.apply(1.0f));
    assertEquals(p1.apply(5.0f), p2.apply(5.0f));
  }

  public void testForPredicate() {
    Function<Object, Boolean> alwaysTrue = Functions.forPredicate(Predicates.alwaysTrue());
    Function<Object, Boolean> alwaysFalse = Functions.forPredicate(Predicates.alwaysFalse());

    assertTrue(alwaysTrue.apply(0));
    assertFalse(alwaysFalse.apply(0));

    fun `non reified apply extension on Gradle`() {
        assertNonReifiedApplyExtension<Gradle>()
    }

    @Test
    fun `reified apply extension`() {

        newPluginAwareMock<PluginAware>().run {
            target.apply<AnyPlugin>()
            verify(configurationAction).plugin(AnyPlugin::class.java)
        }
        newPluginAwareMock<Gradle>().run {
            target.apply<GradlePlugin>()

        entryNotDeployed(classpath[1])
    }

    def "Root wtp dependencies and their transitives are deployed to '/'"() {
        given:
        buildFile <<
        """apply plugin: 'java'
           apply plugin: 'war'
           apply plugin: 'eclipse-wtp'
           repositories { $localMaven }
           dependencies { ${implementationConfiguration} 'org.example:example-lib:1.0' }

            return "Apply initialization script '${pathOfScript(script)}' to build"
        } else {
            return "Apply script ${script.name} to build"
        }
    }

    String applyInitScriptPlugin(File script) {
        if (targetVersion.baseVersion >= GradleVersion.version("6.6")) {
            return "Apply script '${pathOfScript(script)}' to build"
        } else {

                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'.")