def setup() {
        executer.requireOwnGradleUserHomeDir()
    }

    static String applyJavaPlugin() {
        applyPlugins(['java'])
    }

    static String applyGroovyPlugin() {
        applyPlugins(['groovy'])
    }

    static String applyPlugins(List<String> plugins) {
        """
            plugins {
                ${plugins.collect { "id '$it'\n"}.join('')}
            }
        """

        }

    private
    fun static(applyPlugins: ResidualProgram.Instruction): Static =
        when (programTarget) {
            ProgramTarget.Project -> Static(
                SetupEmbeddedKotlin,
                applyPlugins,
                ApplyBasePlugins
            )

            else -> Static(
                SetupEmbeddedKotlin,
                applyPlugins
            )
        }

        subject.handle(initialRequests, scriptHandler, target, targetScope)

        // then:
        verify(pluginRequestApplicator).applyPlugins(initialRequests.mergeWith(autoAppliedPlugins), scriptHandler, pluginManager, targetScope)
    }

     * the requested plugins.
     *
     * A null target indicates that no plugin requests should be resolved but only the setup of the given
     * {@link ClassLoaderScope}.
     */
    void applyPlugins(PluginRequests requests, ScriptHandlerInternal scriptHandler, @Nullable PluginManagerInternal target, ClassLoaderScope classLoaderScope);

    @EventScope(Scope.Build.class)
    @StatefulListener

            val pluginManager = get(PluginManagerInternal::class.java)
            val pluginApplicator = get(PluginRequestApplicator::class.java)
            pluginApplicator.applyPlugins(PluginRequests.of(pluginRequests), scriptHandler, pluginManager, targetScope)
        }
        targetScope.lock()
    }
}


private

    ) {
        val initialRequests = pluginRequests ?: PluginRequests.EMPTY
        val autoAppliedPlugins = autoAppliedPluginHandler.getAutoAppliedPlugins(initialRequests, target)
        pluginRequestApplicator.applyPlugins(
            initialRequests.mergeWith(autoAppliedPlugins),
            scriptHandler,
            target.pluginManager,
            targetScope
        )
    }

            PluginRequests allPlugins = initialPluginRequests.mergeWith(autoAppliedPlugins);
            pluginRequestApplicator.applyPlugins(allPlugins, scriptHandler, pluginManager, targetScope);
            // Pass 2, compile everything except buildscript {}, pluginManagement{}, and plugin requests, then run

        "XcodePluginIntegrationTest",
        "IdeaPluginGoodBehaviourTest"
    ])
    def "plugin can build with empty project"() {
        given:
        applyPlugin()

        expect:
        succeeds mainTask
    }

    protected applyPlugin(File target = buildFile) {
        target << "apply plugin: '${getQualifiedPluginId()}'\n"
    }

    protected applyPluginUnqualified(File target = buildFile) {

        useJavadocAndSourceJars()
        applyPlugin()
        addSigningProperties()

        when:
        Sign signTask = signing.sign(jar).first()
        jar.enabled = false

        then:
        signTask.signaturesByKey == [:]
    }

    def "files to sign are de-duplicated"() {
        given:
        useJavadocAndSourceJars()
        applyPlugin()
        addSigningProperties()

            task f { doLast { throw new RuntimeException("failed") } }
        """
    }

    void applyPlugin() {
        settingsFile << plugin.plugins()
    }

    def "detects that the build scan plugin has been [applied=#applied]"() {
        given:
        if (applied) {
            applyPlugin()
        }

        settingsFile << """