[source,kotlin]
----
abstract class CreateFileTask : DefaultTask() {
    @Input
    val fileText = "HELLO FROM MY TASK"

    @Input
    val fileName = "myfile.txt"

    @OutputFile
    val myFile: File = File(fileName)

    @TaskAction
    fun action() {
        myFile.createNewFile()
        myFile.writeText(fileText)
    }
}

tasks.register<CreateFileTask>("createFileTask") {

    @get:Input
    abstract val fileText: Property<String>                                         // <2>

    @Input
    val fileName = "myfile.txt"

    @OutputFile
    val myFile: File = File(fileName)

    @TaskAction
    fun action() {
        myFile.createNewFile()
        myFile.writeText(fileText.get())
    }
}

// Define a plugin

    def "file backed text resource"() {
        when:
        run("generateConfigFile")
        run("fileText")

        then:
        result.assertTasksExecuted(":fileText")
        file("output.txt").text == "my config"

        when:
        run("fileText")

        then:
        result.assertTasksSkipped(":fileText")
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)

}

class KaResolveExtensionFileForTests(
    private val fileName: String,
    private val packageName: FqName,
    topLevelClassifiersNames: Set<String>,
    topLevelCallableNames: Set<String>,
    private val fileText: String,
    private val navigationTargetsProvider: KaResolveExtensionNavigationTargetsProvider? = null
) : KaResolveExtensionFile() {

}

dependencies {
    sharedConfig generateConfigZip.outputs.files
}

task stringText(type: MyTask) {
    config = resources.text.fromString("my config")
    output = project.file("output.txt")
}

task fileText(type: MyTask) {
    config = resources.text.fromFile("config.txt")
    output = project.file("output.txt")
}

task fileCollectionText(type: MyTask) {
    config = resources.text.fromFile(generateConfigFile.get())

            }*/
        }

        where:
        accessKind          | inputRead
        "file"              | (TestFile it) -> { UndeclaredFileAccess.fileText(testFilePath(it)) }
        "file system entry" | (TestFile it) -> { UndeclaredFileAccess.fileExists(testFilePath(it)) }
        "directory content" | (TestFile it) -> { UndeclaredFileAccess.directoryContent(testFilePath(it)) }

                fileName = name,
                packageName = packageName,
                topLevelClassifiersNames = classifierNames,
                topLevelCallableNames = callableNames,
                fileText = originalContent,
            )
        }
    }

    @OptIn(TestInfrastructureInternals::class)
    fun configure(builder: TestConfigurationBuilder) = with(builder) {
        defaultDirectives {

                "new File(\"$directoryPath\").listFiles((java.io.FilenameFilter) (File dit, String f) -> true)"
            }
        }
    }

    static UndeclaredFileAccess fileText(String filePath) {
        new UndeclaredFileAccess(filePath) {
            @Override
            String getKotlinExpression() {
                "File(\"$filePath\").readText()"
            }

        where:
        testCase                                        | fileAccess
        "reading text with default encoding"            | (TestFile it) -> { UndeclaredFileAccess.fileText(testFilePath(it)) }
        "reading text with customized encoding"         | (TestFile it) -> { UndeclaredFileAccess.fileTextWithEncoding(testFilePath(it)) }

var errLimitExceeded = errors.New("the maximum store limit reached")

// QueueStore - Filestore for persisting items.
type QueueStore[_ any] struct {
	sync.RWMutex
	entryLimit uint64
	directory  string
	fileExt    string

	entries map[string]int64 // key -> modtime as unix nano
}

// NewQueueStore - Creates an instance for QueueStore.
func NewQueueStore[I any](directory string, limit uint64, ext string) *QueueStore[I] {