def internalProject = TestUtil.createChildProject(project, "internal")

        project.pluginManager.apply(JavaPlugin)
        commonProject.pluginManager.apply(JavaLibraryPlugin)
        toolsProject.pluginManager.apply(JavaLibraryPlugin)
        internalProject.pluginManager.apply(JavaLibraryPlugin)

        when:
        project.dependencies {
            implementation commonProject
        }

    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:

    }

    def "sets tested component to main component when applying C++ library plugin"() {
        when:
        project.pluginManager.apply(CppUnitTestPlugin)

        then:
        project.unitTest.testedComponent.orNull == null

        when:
        project.pluginManager.apply(CppLibraryPlugin)
        project.evaluate()

        then:
        project.unitTest.testedComponent.orNull == project.library
    }

        MojoDescriptor mojoDescriptor = pluginManager.getMojoDescriptor( plugin, goal, session.getCurrentProject(), session.getLocalRepository() );
        assertPluginDescriptor( mojoDescriptor, "org.apache.maven.plugins", "maven-remote-resources-plugin", "1.0-beta-2" );
        MojoExecution mojoExecution = new MojoExecution( mojoDescriptor );
        pluginManager.executeMojo( session, mojoExecution );
        */
    }

        when:
        project.pluginManager.apply(CppLibraryPlugin)
        project.pluginManager.apply(MavenPublishPlugin)
        project.evaluate()

        then:
        def zip = project.tasks.cppHeaders
        zip instanceof Zip
    }

    def "adds publications when maven-publish plugin is applied"() {
        when:
        project.pluginManager.apply(CppLibraryPlugin)

    }

    def "sets tested component to main component when applying Swift library plugin"() {
        when:
        project.pluginManager.apply(XCTestConventionPlugin)

        then:
        project.xctest.testedComponent.orNull == null

        when:
        project.pluginManager.apply(SwiftLibraryPlugin)
        project.evaluate()

        then:
        project.xctest.testedComponent.orNull == project.library
    }

        }

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

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

        then:
        project.pluginManager.pluginContainer.size() == 2
        project.pluginManager.pluginContainer.findPlugin(LifecycleBasePlugin) != null
    }

import static org.gradle.api.reflect.TypeOf.typeOf

class AntlrPluginTest extends AbstractProjectBuilderSpec {

    def addsAntlrPropertiesToEachSourceSet() {
        when:
        project.pluginManager.apply(AntlrPlugin)

        then:
        def main = project.sourceSets.main
        main.antlr.srcDirs == [project.file('src/main/antlr')] as Set

        def test = project.sourceSets.test

class PluginRequestsHandlerTest {

    @Test
    fun `applies plugins after merging auto-applied plugin requests`() {

        // given:
        val pluginManager = mock<PluginManagerInternal>()
        val target = mock<ProjectInternal> {
            on { this.pluginManager } doReturn pluginManager
        }
        val initialRequests = mock<PluginRequests>(name = "initialRequests")

            apply plugin: '$appliedBy'
            operations << "applied"

            assert plugins["$detectedBy"]
            assert plugins.getPlugin("$detectedBy")
            assert pluginManager.hasPlugin("$detectedBy")
            assert pluginManager.findPlugin("$detectedBy").id == "$detectedBy"

            task verify {
                doLast {
                    assert operations[0] == 'applying'