"""

        expect:
        succeeds()
    }

    def "can create instance of interface with read-only RegularFileProperty property"() {
        buildFile """
            interface Thing {
                RegularFileProperty getValue()
            }

            extensions.create("thing", Thing)
            assert thing.value.toString() == "extension 'thing' property 'value'"

                abstract DirectoryProperty getSources()

                @InputFiles
                abstract ConfigurableFileCollection getSourceFiles()

                @OutputFile
                abstract RegularFileProperty getZipFile()

                ZipSrc() {
                    // We need a way to count access times, that is why I ended up with configuring it in the task so it has access to countResolved.

                }
                artifacts."default" producer.outputFile
            }

            class Producer extends DefaultTask {
                @OutputFile
                final RegularFileProperty outputFile = project.objects.fileProperty()

                @TaskAction
                def go() {
                    outputFile.get().asFile.text = "output"
                }
            }
        """

Gradle provides two specialized `Property` subtypes for dealing with values of these types:

            }

            abstract class InputFilesTask extends DefaultTask {
                @InputFiles abstract ListProperty<FileSystemLocation> getInFiles()
                @OutputFile abstract RegularFileProperty getOutFile()
                @TaskAction def go() {
                    outFile.get().asFile.text = inFiles.get()*.asFile.name.sort().join(',')
                }
            }

    def "task #annotation file property is implicitly finalized when task starts execution"() {
        buildFile << """
            class SomeTask extends DefaultTask {
                ${annotation}
                final RegularFileProperty prop = project.objects.fileProperty()

                @TaskAction
                void go() {
                    println "value: " + prop.get()
                }
            }

        "DirectoryProperty"           | "objects.directoryProperty()"         | "null"               | "null"
        "RegularFileProperty"         | "objects.fileProperty()"              | "file('abc')"        | new File('abc')
        "RegularFileProperty"         | "objects.fileProperty()"              | "null"               | "null"

 * 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
import org.gradle.api.provider.SetProperty

        where:
        isolationMode << ISOLATION_MODES
    }

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

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

                }
            }
            abstract class ProduceString : DefaultTask() {
                @get:OutputFile
                abstract val outputFile: RegularFileProperty
                @TaskAction
                fun printString() {
                    outputFile.get().asFile.writeText("absent")
                }
            }