private final MavenRepositorySystem repositorySystem;
    private final MavenPluginManager pluginManager;

    @Inject
    public DefaultProjectBuildingHelper(
            ClassRealmManager classRealmManager,
            ProjectRealmCache projectRealmCache,
            MavenRepositorySystem repositorySystem,
            MavenPluginManager pluginManager) {
        this.classRealmManager = classRealmManager;

        project.apply plugin: 'lifecycle-base'

        expect:
        project.plugins.hasPlugin(LifecycleBasePlugin)
    }

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

        then:
        def clean = project.tasks[CLEAN_TASK_NAME]
        clean instanceOf(Delete)
        clean dependsOn()
        clean.group == BUILD_GROUP

class AssemblerPluginTest extends PlatformBaseSpecification {

    def "creates asm source set with conventional locations for components"() {
        when:
        dsl {
            pluginManager.apply AssemblerPlugin
            model {
                components {
                    exe(NativeExecutableSpec)
                }
            }
        }


        then:

        this.plugin = plugin;
    }

    @Override
    public PluginId getPluginId() {
        return plugin.getPluginId();
    }

    @Override
    public void applyTo(PluginManagerInternal pluginManager) {
        pluginManager.apply(plugin);
    }

    def "adds extension with convention for source layout and module name"() {
        given:
        def src = projectDir.file("src/main/swift/main.swift").createFile()

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

        then:
        project.application instanceof SwiftApplication
        project.application.module.get() == "TestApp"

            }
            gradle.settingsEvaluated { settings ->
                if (settings.pluginManager.hasPlugin('${plugin.id}')) {
                    logger.lifecycle("${plugin.id} is already applied")
                } else {
                    logger.lifecycle("Applying ${plugin.className} via init script")
                    settings.pluginManager.apply(initscript.classLoader.loadClass('${plugin.className}'))
                }
            }

        def binary = Stub(DefaultCppBinary)
        binary.name >> name
        binary.names >> Names.of(name)
        binary.targetMachine >> Stub(CppPlatform)

        when:
        project.pluginManager.apply(CppBasePlugin)
        project.components.add(binary)

        then:
        def compileCpp = project.tasks[taskName]
        compileCpp instanceof CppCompile

    }

    @Nullable
    @Override
    public String getPluginVersion() {
        return pluginVersion;
    }

    @Override
    public void applyTo(PluginManagerInternal pluginManager) {
        pluginManager.apply(plugin);
    }

        delegate.apply(action)

    override fun apply(options: Map<String, *>) =
        delegate.apply(options)

    override fun getPluginManager(): PluginManager =
        delegate.pluginManager

    override fun include(projectPaths: Iterable<String>) =
        delegate.include(projectPaths)

    override fun includeFlat(vararg projectNames: String?) =

     * <p>
     * Use {@link PluginManager#hasPlugin(String)} or similar to query for the application of plugins instead of doing so via the plugin container.
     *
     * @return the plugin container
     * @see #apply
     * @see PluginManager#hasPlugin(String)
     */
    PluginContainer getPlugins();

    /**