}
                task barJar(type: Jar) {
                   archiveBaseName = 'b-bar'
                }
                tasks.withType(Jar) { destinationDirectory = buildDir }
                artifacts {
                    foo fooJar
                    foo2 foo2Jar
                    bar barJar
                }
            }

        """

        when:

            sourceSets.test.output.dir "$buildDir/generatedTestResources", builtBy: 'generateTestResource'
        '''

        //when
        def result = executer.withTasks("classes").run()
        //then
        result.assertTasksExecuted(":compileJava", ":generateResource", ":processResources", ":classes")

        //when

    }

    def "handles concurrent access to changing artifacts"() {
        expect:
        4.times { count ->
            def buildDir = workspace.file(count)
            concurrent.start {
                buildDir.file('build.gradle') << """
import java.util.zip.*

repositories {
    ivy { url '${server.uri}' }
}

configurations {
    compile
}

dependencies {

) {

    val extractedPluginsBlocks = buildDir("kotlin-dsl/plugins-blocks/extracted")

    val compiledPluginsBlocks = buildDir("kotlin-dsl/plugins-blocks/compiled")

    val accessorsMetadata = buildDir("kotlin-dsl/precompiled-script-plugins-metadata/accessors")

    val pluginSpecBuildersMetadata = buildDir("kotlin-dsl/precompiled-script-plugins-metadata/plugin-spec-builders")

            }
        }

        then:
        getComponents()
    }

    static class RootFileRules extends RuleSource {
        @Model
        File someFile(@Path("buildDir") File buildDir) { return new File(buildDir, "something") }
    }

    templateArgs = [
        functionCount: 3
    ]
    subProjectTemplates = ['cpp-source', 'cpp-project']
    daemonMemory = '1G'
}

// Build-builder projects
tasks.register("buildBuilder", RemoteProject) {
    remoteUri = 'https://github.com/blindpirate/build-builder.git'
    // From master branch
    ref = 'b20046b38b5c11213a307f6454a6a71a59a08ba2'
}

tasks.register("installBuildBuilder", GradleBuild) {

        given:
        buildWithSingleSourceFile()

        def buildDir = file("build")
        buildDir.mkdirs()

        expect:
        configurationCacheRun "clean"
        assertStateStored()
        result.assertTasksExecuted(":clean")
        !buildDir.exists()

        when:
        buildDir.mkdirs()
        configurationCacheRun "clean"

        then:

                inputs.files(fileTree(buildDir) { include("**/*.foo")})
                def reportPath = file("\${buildDir}/fooReport.txt")
                outputs.file(reportPath)
                doLast {
                    reportPath.text = "foo"
                }
            }
            task barReport {
                inputs.files(fileTree(buildDir) { include("**/*.bar")})

        installDir.file("lib/application.jar").assertIsFile()

        def builder = new ScriptExecuter()
        builder.workingDir installDir.file('bin')
        builder.executable applicationName
        builder.standardOutput = new ByteArrayOutputStream()
        builder.errorOutput = new ByteArrayOutputStream()

        def result = builder.run()
        result.assertNormalExitValue()
    }

        buildFile << """
            taskWithInputs {
                sources.from(project.files("foo", "bar"))
                outputFile = project.file("\${buildDir}/output.txt")
            }
        """
        file('foo').mkdir()
        file('foo/a').createFile()
        file('foo/b').createFile()
        file('bar').mkdir()
        file('bar/a').createFile()