}
                }
            }

            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()

Here is an example of the `named` method being used to configure a task added by a plugin:

[source,groovy]
----
tasks.named("dokkaHtml") {
    outputDirectory.set(buildDir.resolve("dokka"))
}
----

== Task types
Gradle tasks are a subclass of link:{javadocPath}/org/gradle/api/Task.html[`Task`].

        defaultTask."unknownProp"

        then:
        thrown(MissingPropertyException)
    }

    def "can get temporary directory"() {
        given:
        def tmpDir = new File(project.buildDir, "tmp/testTask")

        expect:
        !tmpDir.exists()
        defaultTask.temporaryDir == tmpDir
        tmpDir.isDirectory()
    }

    def "can access services"() {
        expect:

    def "project directory can be used as input"() {
        given:
        def aFile = file("A")
        buildFile << """
        task before {
            def outputFile = new File(buildDir, "output.txt")
            outputs.file outputFile
            outputs.upToDateWhen { false }

            doLast {
                outputFile.parentFile.mkdirs()
                outputFile.text = "OK"

    }

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

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

        if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_1_9)) {
            buildFile << """
                tasks.withType(JavaCompile).configureEach {
                    classpath += files("\${buildDir}/classes/java/main")
                }
            """
        }
    }


    def "generated files with annotations are reprocessed when a file is deleted (#label)"() {

        buildFile << """
            apply plugin: "groovy"
            ${mavenCentralRepository()}
            compileGroovy {
                groovyOptions.with {
                    stubDir = file("\$buildDir/classes/stub")
                    keepStubs = true
                }
            }
        """

        if (java) {
            file("src/main/groovy/Java.java") << java
        }

====
[.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 ->