future.get()
        """
    }

    def "background job executor runs jobs submitted at configuration time"() {
        given:
        buildFile << """
            import ${CompletableFuture.name}

            def executors = $executors
            CompletableFuture.runAsync({
                println "backgroundJobExecutor.executed"

    def setup() {
        blockingServer.start()

        createDirs("a", "b", "c")
        settingsFile << """
            include 'a', 'b', 'c'
        """
        buildFile << """
            allprojects {
                task ping {
                    def projectName = project.name
                    doLast {

    def "implementation of nested property in Groovy build script is tracked"() {
        setupTaskClassWithActionProperty()
        buildFile << """
            task myTask(type: TaskWithActionProperty) {
                action = ${originalImplementation}
            }
        """

        buildFile.makeOlder()

        when:
        run 'myTask'
        then:
        executedAndNotSkipped(':myTask')

        when:

        given:
        mavenHttpRepo.module('group', 'projectA', '1.0').publish()
        def projectA = mavenHttpRepo.module('group', 'projectA', '1.5').publish()

        buildFile << createBuildFile(mavenHttpRepo.uri)
        buildFile << """
            repositories.all {
                metadataSources {
                    mavenPom()
                    artifact()
                }
            }
        """

        settingsFile << "include 'child', 'child:child'"

        buildFile << """
allprojects { task thing }
"""
        when:
        run "chi:chi:th"

        then:
        result.assertTasksExecuted(":child:child:thing")
    }

    def "can use camel case to match software model tasks"() {
        buildFile << """
            model {
                tasks {

            include 'a', 'b'
        '''.stripIndent()
        def buildSrcFile = file('buildSrc/build.gradle')
        def aBuildFile = file('a/build.gradle')
        def bBuildFile = file('b/build.gradle')
        [buildSrcFile, buildFile, aBuildFile, bBuildFile].each { it << '' }

        when:
        def events = ProgressEvents.create()
        withConnection {
            ProjectConnection connection ->

import java.util.concurrent.CopyOnWriteArrayList

@FluidDependenciesResolveTest
class DependencyResolveRulesIntegrationTest extends AbstractIntegrationSpec {
    ResolveTestFixture resolve = new ResolveTestFixture(buildFile)

    def setup() {
        settingsFile << """
            rootProject.name = 'test'
        """
    }

    /**
     * Test demonstrating current (not necessarily desired) behaviour
     */

    }

    def useRepository(Repository... repo) {
        buildFile << """
repositories {
"""
        repo.each {
            buildFile << "ivy { url '${it.uri}' }\n"
        }
        buildFile << """
}
"""
    }

import spock.lang.Issue

import java.nio.file.Files

class SigningConfigurationsIntegrationSpec extends SigningIntegrationSpec {

    def "signing configurations"() {
        given:
        buildFile << """
            configurations {
                meta
            }

            signing {
                ${signingConfiguration()}
                sign configurations.archives, configurations.meta

    }

    def "Dependencies of a non-wtp project have no wtp deployment attributes"() {
        given:
        createDirs("sub")
        settingsFile << "include 'sub'"
        buildFile <<
        """apply plugin: 'java'
           repositories { $localMaven }
           dependencies {
               ${implementationConfiguration} 'org.example:example-api:1.0'