In this context, properties in Gradle act as references to the actual values behind them, allowing Gradle to track inputs and outputs between tasks.

For the input of our task, we use a `DirectoryProperty` from Gradle.
We annotate it with `@InputDirectory` to indicate that it is an input to the task:

====
[.multi-language-sample]
=====
.buildSrc/src/main/kotlin/GenerateReportTask.kt
[source,kotlin]

        def debugExeFileProp = project.objects.fileProperty()
        def linkTaskProp = project.objects.property(LinkExecutable)
        def installDirProp = project.objects.directoryProperty()
        def installTaskProp = project.objects.property(InstallExecutable)

        def executable = Stub(ConfigurableComponentWithExecutable)
        executable.name >> "windowsDebug"

            abstract class ZipSrc extends DefaultTask {
                @Internal
                int countResolved

                @Internal
                abstract DirectoryProperty getSources()

                @InputFiles
                abstract ConfigurableFileCollection getSourceFiles()

                @OutputFile
                abstract RegularFileProperty getZipFile()

        isolationMode << ISOLATION_MODES
    }

    def "can provide directory property parameters with isolation mode #isolationMode"() {
        buildFile << """
            ${parameterWorkAction('DirectoryProperty', 'println parameters.testParam.get().getAsFile().name')}

            task runWork(type: ParameterTask) {
                isolationMode = ${isolationMode}
                parameters {

                destinationDir = file('build/extract')
            }
            interface ExtracterParameters extends WorkParameters {
                RegularFileProperty getArchiveFile()
                DirectoryProperty getDestinationDir()
                Property<Integer> getIndex()
            }
            abstract class Extracter implements WorkAction<ExtracterParameters> {
                @Inject

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.tasks.options

import org.gradle.api.file.DirectoryProperty
import org.gradle.api.file.RegularFileProperty
import org.gradle.api.internal.tasks.TaskOptionsGenerator
import org.gradle.api.provider.ListProperty
import org.gradle.api.provider.Property

    def "zipping against non-task provider doesn't lose task dependencies"() {
        given:
        buildFile """
            abstract class Foo extends DefaultTask {
                @OutputDirectory abstract DirectoryProperty getOutDir()
                @TaskAction void foo() {
                    def dir = outDir.get().asFile
                    assert new File(dir, 'baz').createNewFile()
                }
            }

        fixture.workActionThatCreatesFiles.constructorAction = "this.objectFactory = objectFactory"
        fixture.workActionThatCreatesFiles.action += """
            objectFactory.fileProperty()
            objectFactory.directoryProperty()
            objectFactory.fileCollection()
            objectFactory.fileTree()
            objectFactory.property(String)
            objectFactory.listProperty(String)

                @Internal
                final Property<Directory> propValue

                @Inject
                SomeTask(ObjectFactory objects) {
                    propValue = objects.directoryProperty()
                }

                @TaskAction
                void run() {
                    println "value = " + value
                    println "value.child = " + value.dir("child")

        createDirs("a", "b")
        settingsFile << "include 'a', 'b'"
        buildFile << """
            project(':a') {
                task classes {
                    ext.outputDir = objects.directoryProperty()
                    outputs.dir(outputDir)
                    outputDir.set(layout.buildDirectory.dir("classes"))
                }
                artifacts {
                    compile classes.outputDir