when:
        TestFile file = expectPathResolved('path')

        then:
        fileOperations.file('path') == file
    }

    def resolvesFileWithValidation() {
        TestFile file = tmpDir.file('path')
        resolver.resolve('path', PathValidation.EXISTS) >> file

        expect:
        fileOperations.file('path', PathValidation.EXISTS) == file
    }

    def resolvesURI() {
        when:

        )
    }

    def "can filter the elements of a tree using a closure that receives a File"() {
        given:
        file('files/one.txt').createFile()
        file('files/a/two.txt').createFile()
        file('files/b/ignore.txt').createFile()
        file('other/other-one.txt').createFile()
        file('other/a/other-ignore.txt').createFile()
        buildFile """

        registry.isOutputOwnedByBuild(file('build/outputs/other/even-an-other-dir'))
        registry.isOutputOwnedByBuild(file('outputs/even-an-other-dir'))
        !registry.isOutputOwnedByBuild(file('build'))
        !registry.isOutputOwnedByBuild(file('output'))
        !registry.isOutputOwnedByBuild(file('build/output'))
        !registry.isOutputOwnedByBuild(file('different-file/build/outputs'))
    }

        def dir = rootDir.createDir("a/b")
        def file = dir.file("c.txt").createFile()
        file << "Hello world"
        def link = rootDir.file("a/d").createDir().file("e.txt")
        link.createLink(file)

        when:
        def visited = walkDirForPaths(walkerInstance, rootDir, new PatternSet())

        then:
        visited.contains(file.canonicalPath)
        visited.contains(link.canonicalPath)

        File file = new File(tempDirFile, "file-" + counter.incrementAndGet());
        boolean created = file.createNewFile();
        blackhole.consume(created);
    }

    @Benchmark
    public void createFileJava7(Blackhole blackhole) throws IOException {
        Path file = Files.createFile(tempDirPath.resolve("file-" + counter.incrementAndGet()));
        blackhole.consume(file);

            project.file("other.jar"),
            project.file("groovy-${groovyVersion}.jar"),
            project.file("groovy-ant-${groovyVersion}.jar"),
            project.file("groovy-astbuilder-${groovyVersion}.jar"),
            project.file("groovy-console-${groovyVersion}.jar"),
            project.file("groovy-datetime-${groovyVersion}.jar"),
            project.file("groovy-dateutil-${groovyVersion}.jar"),

    assert response.status_code == 200, response.text
    assert response.json() == {"file_size": 14}


def test_post_large_file(tmp_path):
    default_pydantic_max_size = 2**16
    path = tmp_path / "test.txt"
    path.write_bytes(b"x" * (default_pydantic_max_size + 1))

    client = TestClient(app)
    with path.open("rb") as file:
        response = client.post("/files/", files={"file": file})

        def original = file.makeOlder().lastModified()

        when:
        touch(file)

        then:
        file.file
        file.lastModified() > original
        file.length() == 0
    }

    def "does not use fallback for touching non-empty files"() {
        given:
        def fileAttributeView = Stub(BasicFileAttributeView) {

        def file = tmpDir.file("file")
        file.text = "123"
        def link = tmpDir.file("link")
        link.createLink(file)
        def linkToLink = tmpDir.file("linkToLink")
        linkToLink.createLink(link)

        expect:
        def stat = accessor.stat(linkToLink)
        stat.type == FileType.RegularFile
        assertSameLastModified(stat, file)
        stat.length == 3

		default:
		}

		wantEvent := fsnotify.Event{Name: file, Op: fsnotify.Write}
		fakeWatcher.InjectEvent(file, wantEvent)
		gotEvent := <-watcher.Events(file)
		if gotEvent != wantEvent {
			t.Fatalf("Events() failed: got %v want %v", gotEvent, wantEvent)
		}

		wantError := fmt.Errorf("error=%v", file)
		fakeWatcher.InjectError(file, wantError)
		gotError := <-watcher.Errors(file)
		if gotError != wantError {