void configure(PersistableConfigurationObject object) {
        }
    }

    def readsObjectFromFile() {
        File inputFile = new File('input')

        when:
        def result = generator.read(inputFile)

        then:
        result == object
        1 * object.load(inputFile)
        0 * _._
    }

    def createsDefaultObject() {
        when:
        def result = generator.defaultInstance()

    private TestFile inputFile = file('input.txt')
    private TestFile cacheOriginInputFile = file('cache-origin.txt')
    private TestFile outputFile = file('build/output.txt')
    private String cacheableTask = ':cacheableTask'
    private BuildCacheOperationFixtures cacheOperations = new BuildCacheOperationFixtures(executer, temporaryFolder)

    def setup() {
        inputFile.text = 'This is the input'

    StringBuilder builder = new StringBuilder();

    URL url = ResourceUtil.getResource(getClass().getName().replace('.', '/') + ".txt");

    File inputFile = URLUtil.toFile(url);

    File outputFile = new File(inputFile.getParentFile(), ".out");

    /**
     * @throws Exception
     */
    @Test
    public void testIsToOs() throws Exception {
        final int result = copy(is, os);

                @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:

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