@get:InputFile @get:PathSensitive(PathSensitivity.NONE) var inputFile: File? = null
                @get:OutputFile var outputFile: File? = null
                @TaskAction fun doSomething() {
                    outputFile!!.apply {
                        parentFile.mkdirs()
                        writeText(inputFile!!.readText())
                        appendText("$suffix")
                    }

        file(buildFileName) << """
            tasks.register("myTask") {
              ${variableDefinition} inputFile = file("input/marker")
              inputs.files(inputFile)
              outputs.files("build/marker")
              doLast {
                println("value: " + inputFile.${readTextMethod})
              }
            }
        """

        when:
        succeeds(":myTask")
        then:

    }

    private static ClassPath fromInstrumentingArtifactTransformOutput(List<File> inputFiles) {
        Map<File, File> transformedEntries = Maps.newLinkedHashMapWithExpectedSize(inputFiles.size());
        for (int i = 0; i < inputFiles.size();) {
            File markerFile = inputFiles.get(i++);
            FileMarker fileMarker = FileMarker.of(markerFile.getName());
            switch (fileMarker) {

        def inputFile = file("included/inputs/input.txt")
        inputFile.text = "first"
        singleProjectBuild("included") {
            buildFile << """
                task someTask {
                    def inputFile = file("inputs/input.txt")
                    def outputFile = file("build/output.txt")
                    inputs.file inputFile
                    outputs.file outputFile

package org.myorg;

import org.gradle.api.DefaultTask;
import org.gradle.api.file.ConfigurableFileCollection;
import org.gradle.api.tasks.InputFiles;
import org.gradle.api.tasks.TaskAction;

// tag::snippet[]
abstract public class DataProcessing extends DefaultTask {

    @InputFiles
    abstract public ConfigurableFileCollection getDataFiles();

    @TaskAction
    public void process() {

	tests := []struct {
		name        string
		wantConfigs int
		inputFile   string
		wantErr     bool
	}{
		{
			name:        "errors if unable to unmarshal bytes",
			inputFile:   "",
			wantConfigs: 0,
			wantErr:     true,
		},
		{
			name:        "loads valid ztunnel config_dump",
			inputFile:   "testdata/dump.json",
			wantConfigs: 27,
			wantErr:     false,
		},
	}

        when:
        File inputFile = new File(RandomStringUtils.randomAlphanumeric(10))
        then:
        inputFile == assertInWindowsPathLengthLimitation(inputFile);

        when:
        inputFile = new File(RandomStringUtils.randomAlphanumeric(261))
        assertInWindowsPathLengthLimitation(inputFile);
        then:
        def e = thrown(GradleException);

    }

    def "arguments can be passed by using argument providers"() {
        given:
        def inputFile = file("input.txt")
        def outputFile = file("out.txt")
        buildFile << """
            abstract class MyApplicationJvmArguments implements CommandLineArgumentProvider {
                @InputFile
                @PathSensitive(PathSensitivity.NONE)
                abstract RegularFileProperty getInputFile()

            properties['prop'] = propertyValue
        }
    }

    def loadsFromPropertiesFile() {
        def inputFile = tmpDir.file('input.properties')
        inputFile.text = 'prop=value'

        when:
        object.load(inputFile)

        then:
        propertyValue == 'value'
    }

    def loadsFromDefaultResource() {
        when:
        object.loadDefaults()

        result.assertHasErrorOutput("Possible solutions:")
        result.assertHasErrorOutput("1. Annotate with @InputFile for regular files.")
        result.assertHasErrorOutput("2. Annotate with @InputFiles for collections of files.")
        result.assertHasErrorOutput(". If you want to track the path, return File.absolutePath as a String and keep @Input.")