class KotlinBuildScriptIntegrationTest : AbstractKotlinIntegrationTest() {

    @Test
    fun `can apply plugin using ObjectConfigurationAction syntax`() {

        withSettings(
            """
            rootProject.name = "foo"
            include("bar")
            """
        )

        withBuildScript(
            """

            open class ProjectPlugin : Plugin<Project> {

class DistributionPluginIntegrationTest extends WellBehavedPluginTest {
    @Override
    String getMainTask() {
        return "distZip"
    }

    def setup() {
        file("settings.gradle").text = "rootProject.name='TestProject'"
        file("someFile").createFile()
        using m2
    }

    def createTaskForCustomDistribution() {
        when:
        buildFile << """
            apply plugin:'distribution'

    }

    def "test framework can be set to the same value twice"() {
        given:
        file('src/test/java/MyTest.java') << standaloneTestClass

        settingsFile << "rootProject.name = 'Sample'"
        buildFile << """
            test {
                $configureTestFramework
                $configureTestFramework
            }
        """.stripIndent()

        expect:

            pluginManagement {
                includeBuild("ecosystem-plugin")
            }

            plugins {
                id("org.gradle.experimental.jvm-ecosystem")
            }

            rootProject.name = "root-project"

            include(":libA")
            include(":libB")
            include(":libC")

        """.stripIndent()

        if (config.subProjects != 0) {

}

rootProject.name = "tutorial"
include("app")
----
=====
[.multi-language-sample]
=====
.settings.gradle
[source, groovy]
----
plugins {
    // Apply the foojay-resolver plugin to allow automatic download of JDKs
    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.7.0'
}

rootProject.name = 'tutorial'
include('app')
----
=====

            }
        """
        settingsFile << "rootProject.name = 'client-runner'"

        file("test-project/build.gradle") << "println 'Hello from ' + gradle.gradleVersion"
        file("test-project/settings.gradle") << "rootProject.name = 'target-project'"
        file("src/main/java/ToolingApiCompatibilityClient.java").java("""

        }
    }

    def "tasks are not run in parallel if destroy files overlap with output files"() {
        given:
        withParallelThreads(2)
        buildFile << """
            def dir = rootProject.file("dir")

            aPing.destroyables.register dir

            bPing.outputs.file dir
        """

        expect:
        2.times {

        createDirs("nested", "other")
        settingsFile << "include 'nested', 'other'"
        buildFile << """
            project(":other") {
                tasks.create("foo") {
                    rootProject.${code}
                }
            }
        """

        expect:
        succeeds "foo"

        where:
        [description, code] << INVALID_CALL_FROM_LAZY_CONFIGURATION
    }

    }

    def "serializes root project ProjectComponentSelector"() {
        given:
        def selector = new DefaultProjectComponentSelector(new DefaultBuildIdentifier(path(":build")), Path.ROOT, Path.ROOT, "rootProject", ImmutableAttributes.EMPTY, capabilities())

        when:
        def result = serialize(selector, serializer)

        then:
        result.identityPath == selector.identityPath

class LockingInteractionsIntegrationTest extends AbstractHttpDependencyResolutionTest {

    def lockfileFixture = new LockfileFixture(testDirectory: testDirectory)

    def setup() {
        settingsFile << "rootProject.name = 'locking-interactions'"
    }

    def 'locking constraints do not bring back excluded modules'() {
        def foo = mavenRepo.module('org', 'foo', '1.0').publish()