}
        }

        and: "a build using a relocated build dir"
        buildFile << """
            plugins {
                id 'java-library'
            }

            project.buildDir = project.file('new-location')

            ${defineVerifyTask('zip')}

            def theArchive = rootProject.file('test.zip')

            tasks.register('verify', VerifyTask) {

                group = 'test'
                version = '1.0'
                def jar = tasks.create("jar_$version", Jar) {
                    archiveBaseName = "test"
                    destinationDirectory = buildDir
                    archiveVersion = project.version
                }
                configurations['default'].outgoing.artifact(jar)
            }
        '''
        fixture.prepare()
    }

                    }
                }
            }

            project(':lib') {
                apply plugin: 'base'
                task jar(type: Jar) {
                    destinationDirectory = buildDir
                    archiveFileName = 'lib.jar'
                    doLast {
                        ${server.callFromBuild('jar')}
                    }
                }
                artifacts {

                }
            }
            task customTask(type: NonCacheableTask) {
                inputFile = file("input.txt")
                outputFile = file("\$buildDir/output.txt")
                outputs.cacheIf { true }
            }
            compileJava.dependsOn customTask
        """

        when:
        withBuildCache().run "jar"
        then:

        given:
        def javaProject = new StaleOutputJavaProject(testDirectory, buildDirName)
        buildFile << "apply plugin: 'java'"

        if (!defaultDir) {
            buildFile << """
                buildDir = '$javaProject.buildDirName'
            """
        }

        when:
        result = runWithMostRecentFinalRelease(JAR_TASK_NAME)

        then:
        javaProject.mainClassFile.assertIsFile()

    }

    private String configSyncTask() {
        """
            task resolve(type: Sync) {
                from configurations.deps
                into "\$buildDir/libs"
            }
        """
    }

    private void assertDependencyListingReadTimeout(String group, String module, String version) {

====
[.multi-language-sample]
=====
.app/build.gradle.kts
[source,kotlin]
----
tasks.compileJava {
    // Modify the task behavior
    doLast {
        val outputDir = File("$buildDir/compiledClasses")
        outputDir.mkdirs()

        val compiledFiles = sourceSets["main"].output.files
        compiledFiles.forEach { compiledFile ->

                @TaskAction
                void consume() { print("Consumer ran") }
            }

            def producer = tasks.register('producer', Producer) {
                foo.set(project.layout.buildDir.dir('fooDir'))
            }

            tasks.register('consumer', Consumer) {
                foo = producer.flatMap { it.foo }
            }
        """
        expect:
        succeeds("consumer")

     */
    void prepare(@DelegatesTo(CheckTaskBuilder) Closure closure = {}) {
        def builder = new CheckTaskBuilder()
        closure.delegate = builder
        closure.run()
        if (builder.configs.isEmpty()) {
            builder.config(config, "checkDeps")
        }

        def existingScript = buildFile.exists() ? buildFile.text : ""

        """
            task freeJar(type: Jar) { archiveFileName = '$prefix-free.jar' }
            task paidJar(type: Jar) { archiveFileName = '$prefix-paid.jar' }
            tasks.withType(Jar) { destinationDirectory = buildDir }
            configurations.compile.outgoing.variants {
                free {
                    attributes.attribute(flavor, 'free')
                    artifact freeJar
                }
                paid {