def "re-evaluating the owner in #evaluator throws exception when intermediate owner is involved"() {
        def otherOwner = createOwner()

        when:
        evaluator.apply(owner) {
            evaluator.apply(otherOwner) {
                evaluator.apply(this.owner) {}
            }
        }

        then:
        EvaluationContext.CircularEvaluationException ex = thrown()

        failure.assertHasCause("Failed to apply plugin 'broken'")
        failure.assertHasCause("throwing plugin")
    }

    def "reports failure to apply plugin by type"() {
        buildFile << '''
apply plugin: BrokenPlugin

class BrokenPlugin implements Plugin<Project> {
    void apply(Project target) {
        throw new Exception('throwing plugin')
    }
}
'''

        when:
        fails()

        project.pluginManager.apply(SwiftPackageManagerExportPlugin)

        project.pluginManager.apply("swift-application")
        lib1Project.pluginManager.apply("swift-library")
        lib2Project.pluginManager.apply("swift-library")
        lib3Project.pluginManager.apply("swift-library")

        project.application.sourceCompatibility = SwiftVersion.SWIFT3

configure(project(':subprojectA')) {
    apply plugin: 'java'
    apply plugin: 'idea'
    java.targetCompatibility = '1.6'
}

configure(project(':subprojectB')) {
    apply plugin: 'java'
    apply plugin: 'idea'
    java.targetCompatibility = '1.7'
}

configure(project(':subprojectC')) {
    apply plugin: 'java'
    apply plugin: 'idea'
    java.targetCompatibility = '1.8'
}

    }

    def "has description"() {
        when:
        wtpPlugin.apply(project)

        then:
        wtpPlugin.lifecycleTask.get().description
        wtpPlugin.cleanTask.get().description
    }

    def "does not break when eclipse and eclipseWtp applied"() {
        expect:
        project.apply plugin: 'eclipse'
        project.apply plugin: 'eclipse-wtp'
    }

            buildFile << """
                apply plugin: 'swift-library'
                apply plugin: 'xcode'
            """
            fixture.library.writeToProject(it)
        }
        def commit = repo.commit('initial commit')

        and:
        singleProjectBuild("app") {
            buildFile << """
                apply plugin: 'swift-application'
                apply plugin: 'xcode'

        def build = file('build.gradle')
        build << """
project(':impl') {
  apply plugin: 'java'
  apply plugin: 'war'
  apply plugin: 'eclipse-wtp'

  dependencies { implementation project(':contrib') }

  eclipse.project.name = 'cool-impl'
}

project(':contrib') {
  apply plugin: 'java'
  apply plugin: 'eclipse-wtp'
  //should not have war nor ear applied

            allprojects {
                apply plugin: 'xcode'
            }
            apply plugin: 'swift-application'
            project(':app') {
                apply plugin: 'swift-application'
                dependencies {
                    implementation project(':greeter')
                }
            }
            project(':greeter') {
                apply plugin: 'swift-library'
            }
"""

    }

    def "can apply a rule source by id"() {
        when:
        def project = buildProject()
        project.apply plugin: 'custom-rule-source'

        then:
        project.modelRegistry.realize("foo", String) == "bar"
    }

    def "can apply a rule source by type"() {
        when:
        def project = buildProject()
        project.apply type: CustomRuleSource

        then:

        given:
        project.getPlugins().apply(IdeaPlugin)
        project.getPlugins().apply(JavaPlugin)
        moduleProject.getPlugins().apply(JavaPlugin)
        moduleProject.sourceCompatibility = 1.5
        project.sourceCompatibility = 1.5

        def iml = Mock(IdeaModuleIml)
        def module = TestUtil.newInstance(IdeaModule, moduleProject, iml)
        expect: