source = Program.Plugins(fragment)
            )
        )
    }

    private
    fun assertPluginApplicationBehaviorOf(fragment: ProgramSourceFragment, applyPlugins: ResidualProgram.Instruction) {
        val target = mock<Project>()

        val scriptHost = scriptHostWith(target = target)

        val capturedPluginRequests = mutableListOf<PluginRequests>()

            kotlinScriptBasePluginsApplicator
                .apply(project)
        }

        override fun closeTargetScopeOf(scriptHost: KotlinScriptHost<*>) {

            pluginRequestApplicator.applyPlugins(
                PluginRequests.EMPTY,
                scriptHost.scriptHandler as ScriptHandlerInternal,
                null,
                scriptHost.targetScope
            )
        }

        "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 << """

        buildScript applyPlugin()

        expect:
        fails("verify")
        failure.assertThatDescription(startsWith("An exception occurred applying plugin request [id: 'org.my.myplugin', version: '1.0']"))
        failure.assertHasLineNumber(3)
        failure.assertHasCause("throwing plugin")
    }

    private static String applyPlugin() {
        """
            plugins {

            ${buildA.settingsFile.text}
        """
        applyPlugin(buildA, true)
        buildB.settingsFile.text = """
            pluginManagement {
                includeBuild("${pluginBuild.toURI()}")
            }
            includeBuild("${pluginDependencyA.toURI()}")
            ${buildB.settingsFile.text}
        """
        applyPlugin(buildB, true)
        includeBuild buildB

        given:
        applyPlugin()
        fixture.doCheckIn = false

        when:
        succeeds "dummy", "--scan"

        then:
        fixture.issuedNoPluginWarning(output)
    }

    def "does not warns if scan requested but no scan plugin unsupported"() {
        given:
        applyPlugin()

        when:

    @Override
    public ObjectConfigurationAction plugin(final Class<? extends Plugin> pluginClass) {
        actions.add(new Runnable() {
            @Override
            public void run() {
                applyPlugin(pluginClass);
            }
        });
        return this;
    }

    @Override
    public ObjectConfigurationAction plugin(final String pluginId) {
        actions.add(new Runnable() {

import org.gradle.integtests.fixtures.WellBehavedPluginTest

class SwiftLibraryPluginIntegrationTest extends WellBehavedPluginTest {
    def "plugin can build with empty project with static lib"() {
        given:
        applyPlugin()
        buildFile << """
            library.linkage = [Linkage.STATIC]
        """

        expect:
        succeeds mainTask
    }