when:
        project.pluginManager.apply(JavaBasePlugin)

        then:
        project.extensions.extensionsSchema.find { it.name == "sourceSets" }.publicType == typeOf(SourceSetContainer)
    }

    def "properties on convention and extension are synchronized"() {
        when:
        project.pluginManager.apply(JavaBasePlugin)

        then:

}

func TestPluginRegistration(t *testing.T) {
	defer cleanup(t)

	pluginManager := newTestPluginManager(socketDir)

	// Start the plugin manager
	stopChan := make(chan struct{})
	defer close(stopChan)
	go func() {
		sourcesReady := config.NewSourcesReady(func(_ sets.Set[string]) bool { return true })
		pluginManager.Run(sourcesReady, stopChan)
	}()

	// Add handler for device plugin

    def "applies base plugin"() {
        when:
        project.pluginManager.apply(JavaPlatformPlugin)

        then:
        project.plugins.findPlugin(BasePlugin)
    }

    def "adds configurations to the project"() {
        given:
        project.pluginManager.apply(JavaPlatformPlugin)

        when:

        return tasks.asList()[0]
    }

    @Issue("GRADLE-3523")
    def "does not prevent build authors to register root nodes of type File"() {
        when:
        project.pluginManager.apply(RootFileRules)
        project.pluginManager.apply(NativeComponentModelPlugin)
        project.model {
            components {
                exe(NativeExecutableSpec)
            }
        }

        then:

        result.getFound(request).applyTo(pluginManager)

        then:
        1 * pluginManager.apply(impl)
        1 * pluginRegistry.lookup(DefaultPluginId.of("foo")) >> impl
    }

    def "can resolve qualified"() {
        when:
        def request = request("org.gradle.foo")
        def result = resolver.resolve(request)
        result.getFound(request).applyTo(pluginManager)

        then:

        def appProject = TestUtil.createChildProject(project, "app")

        when:
        project.pluginManager.apply(JavaPlugin)
        commonProject.pluginManager.apply(JavaPlugin)
        middleProject.pluginManager.apply(JavaPlugin)
        appProject.pluginManager.apply(JavaPlugin)

        appProject.dependencies {
            implementation middleProject
        }

        when:
        dsl {
            apply plugin: LanguageBasePlugin
        }

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

    def "registers LanguageSourceSet"() {
        when:
        dsl {

        }

    private
    fun projectAndPluginManagerMocks(): Pair<Project, PluginManager> {
        val pluginManager = mock<PluginManager>()
        val project = mock<Project> {
            on { getPluginManager() } doReturn pluginManager
            on { project } doAnswer { it.mock as Project }
        }
        return Pair(project, pluginManager)
    }

    private
    fun CharSequence.count(text: CharSequence): Int =

    def "tasks description reflects whether project has sub-projects or not"() {
        given:
        def child = TestUtil.createChildProject(project, "child")

        when:
        project.pluginManager.apply(HelpTasksPlugin)
        child.pluginManager.apply(HelpTasksPlugin)

        then:

import org.gradle.api.plugins.PluginContainer
import org.gradle.api.plugins.PluginManager


open class PluginAwareScript internal constructor(
    private val host: KotlinScriptHost<PluginAware>
) : PluginAware {

    override fun getPlugins(): PluginContainer =
        host.target.plugins

    override fun getPluginManager(): PluginManager =
        host.target.pluginManager