file("build", "publications", "ivyJava", "ivy.xml.asc").text
    }

    def "signs Gradle metadata"() {
        given:
        buildFile << """
            apply plugin: 'ivy-publish'
            apply plugin: 'maven-publish'
            ${keyInfo.addAsPropertiesScript()}

            publishing {
                publications {
                    ivy(IvyPublication) {

    def "can create xcode project for Swift application with xctest"() {
        requireSwiftToolChain()

        given:
        buildFile << """
            apply plugin: 'swift-application'
            apply plugin: 'xctest'
        """

        def app = new SwiftAppWithXCTest()
        app.writeToProject(testDirectory)

        when:
        succeeds("xcode")

        then:

                println "apply defaults"
              }

              @Mutate void customPeople(ModelSet<Person> people) {
                println "configure"
              }

              @Finalize void finalPeople(ModelSet<Person> people) {
                println "finalize"
              }
            }

            apply type: Rules

            model {

                        t.getMap().set(map);
                    });
                }
            }
        """

        buildFile << """
            apply plugin: SomeOtherPlugin
            apply plugin: SomePlugin
        """

        when:
        run("someTask")

        then:
        outputContains("flag = false")
        outputContains("message = some other value")

                }
            }

            class MyComponentCreationPlugin implements Plugin<Project> {
                void apply(final Project project) {
                    project.apply(plugin:MyComponentDeclarationModel)
                }

                static class Rules extends RuleSource {
                    @Mutate

                void applyMessages(@Path("tasks") ModelElement tasks) {
                    println "as model element: $tasks"
                    println "name: $tasks.name"
                }
            }

            apply type: MyPlugin
        '''

        when:
        run()

        then:
        output.contains "as map: ModelMap<Task> 'tasks'"
        output.contains("as container:")

    @Managed interface OtherSampleBinary extends SampleBinary {}
    @Managed interface LibrarySourceSet extends LanguageSourceSet {}

    class MyBinaryDeclarationModel implements Plugin<Project> {
        void apply(final Project project) {}

        static class ComponentModel extends RuleSource {
            @ComponentType
            void registerLibrary(TypeBuilder<SampleLibrary> builder) {}

            @Mutate

        settingsFile << """
            include 'lib', 'app'
        """
        buildFile << """
            apply plugin: 'swiftpm-export'
            project(':lib') {
                apply plugin: 'swift-library'
            }
            project(':app') {
                apply plugin: 'swift-application'
            }
        """

        file("app/src/main/swift/main.swift") << "// main"

import org.gradle.language.base.LanguageSourceSet

@UnsupportedWithConfigurationCache(because = "software model")
class RuleSourceAppliedByRuleMethodIntegrationTest extends AbstractIntegrationSpec {
    def "@Rule method can apply rules to a particular target"() {
        buildFile << '''
            @Managed
            interface Thing {
                String getName()
                void setName(String name)
            }

        val sameContent = """println("Same script content on ${'$'}this")"""
        withMultiProjectBuild(left = sameContent, right = sameContent).apply {

            // when: first use
            buildForCacheInspection("help").apply {
                compilationTrace(projectRoot) {
                    assertScriptCompile(settingsFile.stage1)
                    assertNoScriptCompile(settingsFile.stage2)