}
        return Optional.empty();
    }

    @Override
    public Optional<Provider<PluginDependency>> findPlugin(String alias) {
        String normalizedAlias = normalize(alias);
        if (config.hasPlugin(normalizedAlias)) {
            return Optional.of(new PluginFactory(providerFactory, config).createPlugin(normalizedAlias));
        }
        return Optional.empty();
    }

    @Override

        }
        if (hasPlugin(settingsFile, 'SettingsPlugin')) {
            settingsPluginAppId = findPluginApplicationId(targetsSettings())
        }
        if (hasPlugin(buildFile, 'ProjectPlugin')) {
            rootProjectPluginAppId = findPluginApplicationId(targetsProject(':'), pluginClass('ProjectPlugin'))
        }
        if (hasPlugin(subBuildFile, 'ProjectPlugin')) {

            @Override
            public boolean apply(Project project) {
                final boolean hasIdeaPlugin = project.getPlugins().hasPlugin(IdeaPlugin.class);
                final boolean hasScalaPlugin = project.getPlugins().hasPlugin(ScalaBasePlugin.class);
                return hasIdeaPlugin && hasScalaPlugin;
            }
        });
    }

class WarPluginTest extends AbstractProjectBuilderSpec {
    def "applies Java plugin and adds convention"() {
        when:
        project.pluginManager.apply(WarPlugin)

        then:
        project.getPlugins().hasPlugin(JavaPlugin)
        project.convention.plugins.war instanceof WarPluginConvention
    }

    def "creates configurations"() {
        given:
        project.pluginManager.apply(WarPlugin)

        when:

        return bundles.containsKey(normalize(alias));
    }

    public boolean hasVersion(String alias) {
        return versions.containsKey(normalize(alias));
    }

    public boolean hasPlugin(String alias) {
        return plugins.containsKey(normalize(alias));
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

    }

    private static boolean isAlreadyApplied(PluginCoordinates autoAppliedPlugin, PluginContainer pluginContainer) {
        return pluginContainer.hasPlugin(autoAppliedPlugin.getId().getId());
    }

    private static boolean isAlreadyRequestedInPluginsBlock(PluginCoordinates autoAppliedPlugin, PluginRequests requests) {
        for (PluginRequestInternal request : requests) {

    def "applies the java plugin to the project"() {
        when:
        groovyPlugin.apply(project)

        then:
        project.plugins.hasPlugin(JavaPlugin.class);
    }

    def "adds groovy configuration to the project"() {
        given:
        groovyPlugin.apply(project)

        when:

    def setup() {
        project.pluginManager.apply(ScalaBasePlugin)
    }

    def appliesTheJavaPluginToTheProject() {
        expect:
        project.getPlugins().hasPlugin(JavaBasePlugin)
    }

    def addsZincConfigurationToTheProject() {
        when:
        def configuration = project.configurations.getByName(ScalaBasePlugin.ZINC_CONFIGURATION_NAME)

        then:

     *
     * @param id the plugin ID. See {@link #findPlugin(String)} for details about this parameter.
     * @return {@code true} if the plugin has been applied
     * @since 2.3
     */
    boolean hasPlugin(String id);

    /**
     * Executes the given action when the specified plugin is applied.
     * <p>
     * If a plugin with the specified ID has already been applied, the supplied action will be executed immediately.

        project.getPlugins().withType(EarPlugin.class, action);
    }

    private boolean hasWarOrEarPlugin(Project project) {
        return project.getPlugins().hasPlugin(WarPlugin.class) || project.getPlugins().hasPlugin(EarPlugin.class);
    }

    private Set<File> getMainSourceDirs(Project project) {