def "can apply plugin by id"() {
        when:
        dsl {
            apply plugin: 'component-base'
        }

        then:
        project.pluginManager.pluginContainer.hasPlugin(ComponentBasePlugin)
    }

    def "applies lifecycle base plugin only"() {
        when:
        dsl {
            apply plugin: ComponentBasePlugin
        }

        then:

    String getToolchainName() {
        "clang"
    }

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

        expect:
        project.plugins.hasPlugin(pluginClass)
    }

    def "makes a Clang tool chain available"() {
        when:
        register()

        then:
        toolchain instanceof ClangToolChain

    @Override
    String getToolchainName() {
        "gcc"
    }

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

        expect:
        project.plugins.hasPlugin(pluginClass)
    }

    def "makes a Gcc tool chain available"() {
        when:
        register()

        then:
        toolchain instanceof GccToolChain

        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