sources.hasDependencyAlias('boo', 'getBoo', "with <b>no version specified</b>")

        sources.hasPlugin('fooPlugin', 'getFooPlugin', "with version <b>1.0</b>")
        sources.hasPlugin('barPlugin', 'getBarPlugin', "with version reference <b>barVersion</b>")
        sources.hasPlugin('bazPlugin', 'getBazPlugin', "with <b>no version specified</b>")
    }

    @VersionCatalogProblemTestFor(

class LifecycleBasePluginTest extends AbstractProjectBuilderSpec {

    def "can apply plugin by id"() {
        given:
        project.apply plugin: 'lifecycle-base'

        expect:
        project.plugins.hasPlugin(LifecycleBasePlugin)
    }

    public void createsTasksAndAppliesMappings() {
        when:
        project.pluginManager.apply(LifecycleBasePlugin)

        then:

        mapNotNull { it.id as? ProjectComponentIdentifier }

    private
    fun Sequence<Project>.withJavaBasePlugin() =
        filter { it.plugins.hasPlugin(JavaBasePlugin::class.java) }

    private
    fun Sequence<Project>.allSourceSetsRoots() =
        flatMap { it.sourceSets.flatMap { it.allSource.srcDirs }.asSequence() }

    private
    val Project.sourceSets

        project = TestUtil.create(temporaryFolder).rootProject()
        project.pluginManager.apply(GroovyBasePlugin)
    }

    @Test void appliesTheJavaBasePluginToTheProject() {
        assertTrue(project.getPlugins().hasPlugin(JavaBasePlugin));
    }

    @Test void appliesMappingsToNewSourceSet() {
        def sourceSet = project.sourceSets.create('custom')
        assertThat(sourceSet.groovy.displayName, equalTo("custom Groovy source"))

        when:
        project.pluginManager.apply(JavaBasePlugin)

        then:
        project.plugins.hasPlugin(ReportingBasePlugin)
        project.plugins.hasPlugin(BasePlugin)
        project.plugins.hasPlugin(JvmEcosystemPlugin)
        project.convention.plugins.java instanceof JavaPluginConvention
        project.extensions.sourceSets.is(project.convention.plugins.java.sourceSets)

    def appliesBaseReportingPluginAndAddsConventionObject() {
        when:
        plugin.apply(project)

        then:
        project.plugins.hasPlugin(ReportingBasePlugin.class)
        project.convention.getPlugin(ProjectReportsPluginConvention.class)
    }

    def addsTasksToProject() {
        when:
        plugin.apply(project);

        then:

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

    def "applies reporting-base plugin"() {
        expect:
        project.plugins.hasPlugin(ReportingBasePlugin)
    }

    def "adds codenarc configuration"() {
        def config = project.configurations.findByName("codenarc")

        expect:
        config != null
        !config.visible

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