snapshot of https://github.com/seaweedfs/seaweedfs.git (master, 2026-09-16; blobs > 131072B omitted)

test/winfsp/deleteonclose.go

@@ -0,0 +1,7 @@
+package winfsp
+
+import "errors"
+
+// errWindowsOnly marks the platforms with no way to ask for delete-on-close,
+// so the test can tell that apart from the flag being refused.
+var errWindowsOnly = errors.New("delete-on-close is a windows flag")

test/winfsp/deleteonclose_other.go

@@ -0,0 +1,9 @@
+//go:build !windows
+
+package winfsp
+
+type handle uintptr
+
+func createDeleteOnClose(path string) (handle, error) { return 0, errWindowsOnly }
+
+func closeHandle(h handle) error { return errWindowsOnly }

test/winfsp/deleteonclose_windows.go

@@ -0,0 +1,24 @@
+package winfsp
+
+import "golang.org/x/sys/windows"
+
+// createDeleteOnClose opens a new file that Windows removes when the last
+// handle to it closes. Installers and editors use this for temporaries, and
+// os has no way to ask for it.
+func createDeleteOnClose(path string) (windows.Handle, error) {
+	p, err := windows.UTF16PtrFromString(path)
+	if err != nil {
+		return windows.InvalidHandle, err
+	}
+	return windows.CreateFile(
+		p,
+		windows.GENERIC_READ|windows.GENERIC_WRITE,
+		windows.FILE_SHARE_READ|windows.FILE_SHARE_WRITE,
+		nil,
+		windows.CREATE_NEW,
+		windows.FILE_ATTRIBUTE_NORMAL|windows.FILE_FLAG_DELETE_ON_CLOSE,
+		0,
+	)
+}
+
+func closeHandle(h windows.Handle) error { return windows.CloseHandle(h) }

test/winfsp/diskfree_other.go

@@ -0,0 +1,9 @@
+//go:build !windows
+
+package winfsp
+
+import "errors"
+
+func getDiskFreeSpace(path string, free, total, totalFree *uint64) error {
+	return errors.New("windows only")
+}

test/winfsp/diskfree_windows.go

@@ -0,0 +1,13 @@
+package winfsp
+
+import (
+	"golang.org/x/sys/windows"
+)
+
+func getDiskFreeSpace(path string, free, total, totalFree *uint64) error {
+	p, err := windows.UTF16PtrFromString(path)
+	if err != nil {
+		return err
+	}
+	return windows.GetDiskFreeSpaceEx(p, free, total, totalFree)
+}

test/winfsp/mount_test.go

@@ -0,0 +1,251 @@
+// Package winfsp exercises a live SeaweedFS mount on Windows.
+//
+// It runs against whatever is mounted at -mountpoint, so it needs a real
+// WinFsp mount and is skipped otherwise. The CI job drives it; run it by hand
+// with: go test ./test/winfsp -mountpoint=S:\
+package winfsp
+
+import (
+	"bytes"
+	"crypto/rand"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"testing"
+)
+
+var mountPoint = flag.String("mountpoint", "", "a mounted SeaweedFS drive, e.g. S:\\")
+
+// entryCount is the directory width the test builds. The reported case that
+// motivated Windows support is 200k files in one folder; CI uses less so the
+// job stays inside its budget, but the read path is the same.
+var entryCount = flag.Int("entries", 5000, "how many files to put in one directory")
+
+func testRoot(t *testing.T) string {
+	t.Helper()
+	if *mountPoint == "" {
+		t.Skip("no -mountpoint given; this test needs a live WinFsp mount")
+	}
+	dir := filepath.Join(*mountPoint, "winfsp-test-"+t.Name())
+	if err := os.RemoveAll(dir); err != nil && !os.IsNotExist(err) {
+		t.Fatalf("clean %s: %v", dir, err)
+	}
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		t.Fatalf("mkdir %s: %v", dir, err)
+	}
+	t.Cleanup(func() { os.RemoveAll(dir) })
+	return dir
+}
+
+func TestWriteReadRoundTrip(t *testing.T) {
+	dir := testRoot(t)
+	for _, size := range []int{0, 1, 4095, 4096, 1 << 20, 5 << 20} {
+		t.Run(fmt.Sprintf("%dbytes", size), func(t *testing.T) {
+			want := make([]byte, size)
+			if _, err := rand.Read(want); err != nil {
+				t.Fatalf("rand: %v", err)
+			}
+			path := filepath.Join(dir, fmt.Sprintf("file-%d", size))
+			if err := os.WriteFile(path, want, 0644); err != nil {
+				t.Fatalf("write: %v", err)
+			}
+			got, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatalf("read: %v", err)
+			}
+			if !bytes.Equal(got, want) {
+				t.Fatalf("content differs: got %d bytes, want %d", len(got), len(want))
+			}
+			info, err := os.Stat(path)
+			if err != nil {
+				t.Fatalf("stat: %v", err)
+			}
+			if info.Size() != int64(size) {
+				t.Fatalf("stat size = %d, want %d", info.Size(), size)
+			}
+		})
+	}
+}
+
+func TestSeekWriteAndOverwrite(t *testing.T) {
+	dir := testRoot(t)
+	path := filepath.Join(dir, "sparse")
+
+	f, err := os.Create(path)
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+	if _, err := f.WriteAt([]byte("tail"), 4096); err != nil {
+		t.Fatalf("write at offset: %v", err)
+	}
+	if _, err := f.WriteAt([]byte("head"), 0); err != nil {
+		t.Fatalf("write at start: %v", err)
+	}
+	if err := f.Close(); err != nil {
+		t.Fatalf("close: %v", err)
+	}
+
+	got, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read: %v", err)
+	}
+	if len(got) != 4100 {
+		t.Fatalf("size = %d, want 4100", len(got))
+	}
+	if string(got[:4]) != "head" || string(got[4096:]) != "tail" {
+		t.Fatalf("content at the edges is wrong: %q ... %q", got[:4], got[4096:])
+	}
+	if !bytes.Equal(got[4:4096], make([]byte, 4092)) {
+		t.Fatal("the hole between the two writes is not zero-filled")
+	}
+}
+
+func TestRenameAndDelete(t *testing.T) {
+	dir := testRoot(t)
+	src := filepath.Join(dir, "before")
+	dst := filepath.Join(dir, "after")
+
+	if err := os.WriteFile(src, []byte("payload"), 0644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	if err := os.Rename(src, dst); err != nil {
+		t.Fatalf("rename: %v", err)
+	}
+	if _, err := os.Stat(src); !os.IsNotExist(err) {
+		t.Fatalf("old name still resolves: %v", err)
+	}
+	got, err := os.ReadFile(dst)
+	if err != nil {
+		t.Fatalf("read renamed: %v", err)
+	}
+	if string(got) != "payload" {
+		t.Fatalf("content after rename = %q", got)
+	}
+	if err := os.Remove(dst); err != nil {
+		t.Fatalf("remove: %v", err)
+	}
+	if _, err := os.Stat(dst); !os.IsNotExist(err) {
+		t.Fatalf("deleted file still resolves: %v", err)
+	}
+}
+
+func TestDirectoryTree(t *testing.T) {
+	dir := testRoot(t)
+	nested := filepath.Join(dir, "a", "b", "c")
+	if err := os.MkdirAll(nested, 0755); err != nil {
+		t.Fatalf("mkdirall: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(nested, "leaf"), []byte("x"), 0644); err != nil {
+		t.Fatalf("write leaf: %v", err)
+	}
+	info, err := os.Stat(nested)
+	if err != nil {
+		t.Fatalf("stat dir: %v", err)
+	}
+	if !info.IsDir() {
+		t.Fatal("nested path is not reported as a directory")
+	}
+	// A non-empty directory must not be removable.
+	if err := os.Remove(filepath.Join(dir, "a", "b")); err == nil {
+		t.Fatal("removed a non-empty directory")
+	}
+	if err := os.RemoveAll(filepath.Join(dir, "a")); err != nil {
+		t.Fatalf("removeall: %v", err)
+	}
+}
+
+// TestWideDirectory is the case from the report: one folder holding far more
+// entries than Explorer or the Windows WebDAV client cope with.
+func TestWideDirectory(t *testing.T) {
+	dir := testRoot(t)
+	want := make([]string, 0, *entryCount)
+	for i := 0; i < *entryCount; i++ {
+		name := fmt.Sprintf("img-%06d.dat", i)
+		if err := os.WriteFile(filepath.Join(dir, name), []byte{byte(i)}, 0644); err != nil {
+			t.Fatalf("write %s: %v", name, err)
+		}
+		want = append(want, name)
+	}
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		t.Fatalf("readdir: %v", err)
+	}
+	got := make([]string, 0, len(entries))
+	for _, e := range entries {
+		got = append(got, e.Name())
+	}
+	sort.Strings(got)
+	sort.Strings(want)
+	if len(got) != len(want) {
+		t.Fatalf("readdir returned %d entries, want %d", len(got), len(want))
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("entry %d = %q, want %q", i, got[i], want[i])
+		}
+	}
+
+	// Reading the directory twice must be stable; a paging bug shows up here.
+	again, err := os.ReadDir(dir)
+	if err != nil {
+		t.Fatalf("second readdir: %v", err)
+	}
+	if len(again) != len(entries) {
+		t.Fatalf("second readdir returned %d entries, first returned %d", len(again), len(entries))
+	}
+}
+
+func TestConcurrentWriters(t *testing.T) {
+	dir := testRoot(t)
+	const writers = 8
+	const perWriter = 32
+
+	var wg sync.WaitGroup
+	errs := make(chan error, writers)
+	for w := 0; w < writers; w++ {
+		wg.Add(1)
+		go func(w int) {
+			defer wg.Done()
+			for i := 0; i < perWriter; i++ {
+				name := filepath.Join(dir, fmt.Sprintf("w%d-%d", w, i))
+				body := []byte(strings.Repeat(fmt.Sprintf("%d", w), 128))
+				if err := os.WriteFile(name, body, 0644); err != nil {
+					errs <- fmt.Errorf("writer %d: %w", w, err)
+					return
+				}
+			}
+		}(w)
+	}
+	wg.Wait()
+	close(errs)
+	for err := range errs {
+		t.Fatalf("%v", err)
+	}
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		t.Fatalf("readdir: %v", err)
+	}
+	if len(entries) != writers*perWriter {
+		t.Fatalf("got %d files, want %d", len(entries), writers*perWriter)
+	}
+}
+
+func TestStatfsReportsCapacity(t *testing.T) {
+	if *mountPoint == "" {
+		t.Skip("no -mountpoint given; this test needs a live WinFsp mount")
+	}
+	// The drive has to report a size, or Explorer refuses to show it.
+	var free, total, totalFree uint64
+	if err := getDiskFreeSpace(*mountPoint, &free, &total, &totalFree); err != nil {
+		t.Fatalf("GetDiskFreeSpaceEx: %v", err)
+	}
+	if total == 0 {
+		t.Fatal("drive reports zero total bytes")
+	}
+}

test/winfsp/persistence_test.go

@@ -0,0 +1,186 @@
+package winfsp
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"hash/fnv"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+var (
+	// phase splits the test across a remount: the write phase is run, the
+	// mount is torn down and brought back, then the verify phase runs. Reading
+	// back through the same live mount proves nothing about durability, since
+	// the answer can come from the mount's own caches.
+	phase = flag.String("phase", "", "write or verify; empty skips the persistence test")
+
+	// filerAddr enables a second check, that the bytes reached the filer and
+	// are servable without the mount in the path at all.
+	filerAddr = flag.String("filer", "", "filer host:port to cross-check through, e.g. localhost:8888")
+
+	// persistSubdir is where the fixtures live, under both the mount and the
+	// filer's mount root.
+	persistSubdir = flag.String("persistdir", "winfsp-persist", "directory under the mount to persist into")
+)
+
+type fixture struct {
+	relPath string
+	size    int
+}
+
+// Sizes straddle the boundaries where the write path changes behavior: inline,
+// a single chunk, and several chunks.
+var fixtures = []fixture{
+	{"small.txt", 11},
+	{"medium.bin", 300 << 10},
+	{"multichunk.bin", 9 << 20},
+	{"nested/deep/leaf.bin", 65536},
+	{"unicode-café-日本.txt", 64},
+}
+
+// contentFor derives bytes from the name, so the write and verify phases agree
+// without carrying a manifest between them.
+func contentFor(relPath string, size int) []byte {
+	h := fnv.New64a()
+	h.Write([]byte(relPath))
+	state := h.Sum64() | 1
+	out := make([]byte, size)
+	for i := range out {
+		state ^= state << 13
+		state ^= state >> 7
+		state ^= state << 17
+		out[i] = byte(state)
+	}
+	return out
+}
+
+func TestPersistence(t *testing.T) {
+	if *mountPoint == "" {
+		t.Skip("no -mountpoint given; this test needs a live WinFsp mount")
+	}
+	switch *phase {
+	case "write":
+		persistenceWrite(t)
+	case "verify":
+		persistenceVerify(t)
+	default:
+		t.Skip("no -phase given; run with -phase=write before a remount and -phase=verify after")
+	}
+}
+
+func persistenceWrite(t *testing.T) {
+	root := filepath.Join(*mountPoint, *persistSubdir)
+	if err := os.RemoveAll(root); err != nil && !os.IsNotExist(err) {
+		t.Fatalf("clean %s: %v", root, err)
+	}
+	if err := os.MkdirAll(root, 0755); err != nil {
+		t.Fatalf("mkdir %s: %v", root, err)
+	}
+
+	for _, f := range fixtures {
+		target := filepath.Join(root, filepath.FromSlash(f.relPath))
+		if err := os.MkdirAll(filepath.Dir(target), 0755); err != nil {
+			t.Fatalf("mkdir for %s: %v", f.relPath, err)
+		}
+		// Sync before closing: the mount is killed rather than unmounted, so
+		// anything still queued for flush is legitimately lost. Testing
+		// durability means testing what survives after an explicit sync.
+		if err := writeAndSync(target, contentFor(f.relPath, f.size)); err != nil {
+			t.Fatalf("write %s: %v", f.relPath, err)
+		}
+		t.Logf("wrote %s (%d bytes)", f.relPath, f.size)
+	}
+
+	// Closing the files should have pushed them to the filer. Check that
+	// directly, so a failure here separates "never left the mount" from
+	// "did not survive the remount".
+	if *filerAddr == "" {
+		return
+	}
+	for _, f := range fixtures {
+		want := contentFor(f.relPath, f.size)
+		got, err := fetchFromFiler(*filerAddr, path.Join(*persistSubdir, f.relPath))
+		if err != nil {
+			t.Errorf("fetch %s from filer: %v", f.relPath, err)
+			continue
+		}
+		if !bytes.Equal(got, want) {
+			t.Errorf("filer served %d bytes for %s, want %d", len(got), f.relPath, len(want))
+		}
+	}
+}
+
+func persistenceVerify(t *testing.T) {
+	root := filepath.Join(*mountPoint, *persistSubdir)
+	if _, err := os.Stat(root); err != nil {
+		t.Fatalf("stat %s after remount: %v", root, err)
+	}
+
+	for _, f := range fixtures {
+		target := filepath.Join(root, filepath.FromSlash(f.relPath))
+		got, err := os.ReadFile(target)
+		if err != nil {
+			t.Errorf("read %s after remount: %v", f.relPath, err)
+			continue
+		}
+		want := contentFor(f.relPath, f.size)
+		if len(got) != len(want) {
+			t.Errorf("%s is %d bytes after remount, want %d", f.relPath, len(got), len(want))
+			continue
+		}
+		if !bytes.Equal(got, want) {
+			t.Errorf("%s survived the remount with different content", f.relPath)
+		}
+	}
+
+	// The directory structure has to come back too, not just the files.
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		t.Fatalf("readdir %s after remount: %v", root, err)
+	}
+	if len(entries) == 0 {
+		t.Fatal("mount root directory is empty after remount")
+	}
+
+	if err := os.RemoveAll(root); err != nil {
+		t.Errorf("cleanup: %v", err)
+	}
+}
+
+func writeAndSync(path string, content []byte) error {
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
+	if err != nil {
+		return err
+	}
+	if _, err := f.Write(content); err != nil {
+		f.Close()
+		return err
+	}
+	if err := f.Sync(); err != nil {
+		f.Close()
+		return err
+	}
+	return f.Close()
+}
+
+func fetchFromFiler(addr, filerPath string) ([]byte, error) {
+	endpoint := &url.URL{Scheme: "http", Host: addr, Path: "/" + filerPath}
+	client := &http.Client{Timeout: 60 * time.Second}
+	resp, err := client.Get(endpoint.String())
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("GET %s: %s", endpoint, resp.Status)
+	}
+	return io.ReadAll(resp.Body)
+}

test/winfsp/semantics_test.go

@@ -0,0 +1,549 @@
+package winfsp
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestTruncate(t *testing.T) {
+	dir := testRoot(t)
+	path := filepath.Join(dir, "resize")
+	original := bytes.Repeat([]byte("abcd"), 4096) // 16 KiB
+
+	if err := os.WriteFile(path, original, 0644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	// Shrink.
+	if err := os.Truncate(path, 100); err != nil {
+		t.Fatalf("truncate down: %v", err)
+	}
+	got, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read after shrink: %v", err)
+	}
+	if len(got) != 100 {
+		t.Fatalf("size after shrink = %d, want 100", len(got))
+	}
+	if !bytes.Equal(got, original[:100]) {
+		t.Fatal("the surviving prefix does not match the original")
+	}
+
+	// Grow: the new space has to read back as zeros, not stale bytes.
+	if err := os.Truncate(path, 8192); err != nil {
+		t.Fatalf("truncate up: %v", err)
+	}
+	got, err = os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read after grow: %v", err)
+	}
+	if len(got) != 8192 {
+		t.Fatalf("size after grow = %d, want 8192", len(got))
+	}
+	if !bytes.Equal(got[100:], make([]byte, 8192-100)) {
+		t.Fatal("extension is not zero-filled")
+	}
+
+	// Truncate to empty.
+	if err := os.Truncate(path, 0); err != nil {
+		t.Fatalf("truncate to zero: %v", err)
+	}
+	if info, err := os.Stat(path); err != nil || info.Size() != 0 {
+		t.Fatalf("stat after zero truncate: size=%v err=%v", info, err)
+	}
+}
+
+func TestAppend(t *testing.T) {
+	dir := testRoot(t)
+	path := filepath.Join(dir, "log")
+
+	for i := 0; i < 5; i++ {
+		f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
+		if err != nil {
+			t.Fatalf("open for append: %v", err)
+		}
+		if _, err := fmt.Fprintf(f, "line %d\n", i); err != nil {
+			t.Fatalf("append: %v", err)
+		}
+		if err := f.Close(); err != nil {
+			t.Fatalf("close: %v", err)
+		}
+	}
+
+	got, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read: %v", err)
+	}
+	want := "line 0\nline 1\nline 2\nline 3\nline 4\n"
+	if string(got) != want {
+		t.Fatalf("appended content = %q, want %q", got, want)
+	}
+}
+
+func TestReadPastEndOfFile(t *testing.T) {
+	dir := testRoot(t)
+	path := filepath.Join(dir, "short")
+	if err := os.WriteFile(path, []byte("12345"), 0644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	f, err := os.Open(path)
+	if err != nil {
+		t.Fatalf("open: %v", err)
+	}
+	defer f.Close()
+
+	buf := make([]byte, 16)
+	n, err := f.ReadAt(buf, 100)
+	if n != 0 {
+		t.Fatalf("read %d bytes past EOF, want 0", n)
+	}
+	if err == nil {
+		t.Fatal("reading past EOF returned no error, want io.EOF")
+	}
+}
+
+func TestErrorPaths(t *testing.T) {
+	dir := testRoot(t)
+
+	t.Run("open missing file", func(t *testing.T) {
+		_, err := os.Open(filepath.Join(dir, "does-not-exist"))
+		if !os.IsNotExist(err) {
+			t.Fatalf("got %v, want a not-exist error", err)
+		}
+	})
+
+	t.Run("exclusive create over existing", func(t *testing.T) {
+		path := filepath.Join(dir, "taken")
+		if err := os.WriteFile(path, []byte("x"), 0644); err != nil {
+			t.Fatalf("write: %v", err)
+		}
+		_, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644)
+		if !os.IsExist(err) {
+			t.Fatalf("got %v, want an already-exists error", err)
+		}
+	})
+
+	t.Run("remove missing file", func(t *testing.T) {
+		if err := os.Remove(filepath.Join(dir, "never-there")); !os.IsNotExist(err) {
+			t.Fatalf("got %v, want a not-exist error", err)
+		}
+	})
+
+	t.Run("mkdir under a file", func(t *testing.T) {
+		path := filepath.Join(dir, "regular")
+		if err := os.WriteFile(path, []byte("x"), 0644); err != nil {
+			t.Fatalf("write: %v", err)
+		}
+		if err := os.Mkdir(filepath.Join(path, "child"), 0755); err == nil {
+			t.Fatal("created a directory underneath a regular file")
+		}
+	})
+
+	t.Run("readdir of a missing directory", func(t *testing.T) {
+		if _, err := os.ReadDir(filepath.Join(dir, "no-such-dir")); err == nil {
+			t.Fatal("listed a directory that does not exist")
+		}
+	})
+}
+
+func TestRenameOverExisting(t *testing.T) {
+	dir := testRoot(t)
+	src := filepath.Join(dir, "src")
+	dst := filepath.Join(dir, "dst")
+
+	if err := os.WriteFile(src, []byte("new"), 0644); err != nil {
+		t.Fatalf("write src: %v", err)
+	}
+	if err := os.WriteFile(dst, []byte("old"), 0644); err != nil {
+		t.Fatalf("write dst: %v", err)
+	}
+	if err := os.Rename(src, dst); err != nil {
+		t.Fatalf("rename over existing: %v", err)
+	}
+	got, err := os.ReadFile(dst)
+	if err != nil {
+		t.Fatalf("read: %v", err)
+	}
+	if string(got) != "new" {
+		t.Fatalf("target holds %q, want the source content", got)
+	}
+	if fi, err := os.Stat(src); !os.IsNotExist(err) {
+		// Both a stale positive and a transient non-ENOENT error land here, and
+		// they indict different layers; a second look says whether it persists.
+		time.Sleep(200 * time.Millisecond)
+		fi2, err2 := os.Stat(src)
+		// A listing reads no per-path cache and the mount's own forgets
+		// within a second, so a name that survives both is back on the filer.
+		listed := dirNames(t, dir)
+		time.Sleep(2 * time.Second)
+		_, errLater := os.Stat(src)
+		t.Fatalf("stat of the renamed-away source did not return not-exist: stat=%v err=%v; 200ms later stat=%v err=%v; past the path cache err=%v; %s lists %v",
+			describeFileInfo(fi), err, describeFileInfo(fi2), err2, errLater, dir, listed)
+	}
+}
+
+// dirNames lists a directory for a failure message, reporting the error in
+// place of the names rather than failing a test that is already failing.
+func dirNames(t *testing.T, dir string) []string {
+	t.Helper()
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return []string{"readdir: " + err.Error()}
+	}
+	names := make([]string, 0, len(entries))
+	for _, entry := range entries {
+		names = append(names, entry.Name())
+	}
+	return names
+}
+
+func TestRenameAcrossDirectories(t *testing.T) {
+	dir := testRoot(t)
+	from := filepath.Join(dir, "from")
+	to := filepath.Join(dir, "to")
+	for _, d := range []string{from, to} {
+		if err := os.Mkdir(d, 0755); err != nil {
+			t.Fatalf("mkdir %s: %v", d, err)
+		}
+	}
+
+	src := filepath.Join(from, "file")
+	dst := filepath.Join(to, "file")
+	if err := os.WriteFile(src, []byte("moved"), 0644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	if err := os.Rename(src, dst); err != nil {
+		t.Fatalf("rename across directories: %v", err)
+	}
+	got, err := os.ReadFile(dst)
+	if err != nil {
+		t.Fatalf("read: %v", err)
+	}
+	if string(got) != "moved" {
+		t.Fatalf("content after move = %q", got)
+	}
+
+	// A directory should move too, children and all.
+	nested := filepath.Join(from, "sub")
+	if err := os.Mkdir(nested, 0755); err != nil {
+		t.Fatalf("mkdir sub: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(nested, "child"), []byte("c"), 0644); err != nil {
+		t.Fatalf("write child: %v", err)
+	}
+	if err := os.Rename(nested, filepath.Join(to, "sub")); err != nil {
+		t.Fatalf("rename directory: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(to, "sub", "child")); err != nil {
+		t.Fatalf("child did not come along: %v", err)
+	}
+}
+
+// TestAwkwardNames covers what has to survive the UTF-16 boundary and the
+// shapes Windows software tends to produce.
+func TestAwkwardNames(t *testing.T) {
+	dir := testRoot(t)
+	names := []string{
+		"café.txt",
+		"日本語のファイル.dat",
+		"emoji-🐟.bin",
+		"with space.txt",
+		"with.many.dots.txt",
+		"UPPER and lower.TXT",
+		"dash-and_underscore.txt",
+		"'quoted'.txt",
+		"(parens).txt",
+		"#hash&amp.txt",
+		strings.Repeat("x", 200) + ".txt",
+	}
+	for _, name := range names {
+		t.Run(name, func(t *testing.T) {
+			path := filepath.Join(dir, name)
+			want := []byte(name)
+			if err := os.WriteFile(path, want, 0644); err != nil {
+				t.Fatalf("write: %v", err)
+			}
+			got, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatalf("read: %v", err)
+			}
+			if !bytes.Equal(got, want) {
+				t.Fatalf("content = %q, want %q", got, want)
+			}
+		})
+	}
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		t.Fatalf("readdir: %v", err)
+	}
+	found := make(map[string]bool, len(entries))
+	for _, e := range entries {
+		found[e.Name()] = true
+	}
+	for _, name := range names {
+		if !found[name] {
+			t.Errorf("%q did not come back from readdir", name)
+		}
+	}
+}
+
+func TestDeepDirectoryNesting(t *testing.T) {
+	dir := testRoot(t)
+	deep := dir
+	for i := 0; i < 24; i++ {
+		deep = filepath.Join(deep, fmt.Sprintf("level%02d", i))
+	}
+	if err := os.MkdirAll(deep, 0755); err != nil {
+		t.Fatalf("mkdirall depth 24: %v", err)
+	}
+	leaf := filepath.Join(deep, "leaf.txt")
+	if err := os.WriteFile(leaf, []byte("bottom"), 0644); err != nil {
+		t.Fatalf("write leaf: %v", err)
+	}
+	got, err := os.ReadFile(leaf)
+	if err != nil {
+		t.Fatalf("read leaf: %v", err)
+	}
+	if string(got) != "bottom" {
+		t.Fatalf("leaf content = %q", got)
+	}
+}
+
+// TestConcurrentSameFile is the interleaving that matters: several handles on
+// one file at once, rather than one writer each on separate files.
+func TestConcurrentSameFile(t *testing.T) {
+	dir := testRoot(t)
+	path := filepath.Join(dir, "shared")
+
+	const writers = 4
+	const blockSize = 4096
+	if err := os.WriteFile(path, make([]byte, writers*blockSize), 0644); err != nil {
+		t.Fatalf("preallocate: %v", err)
+	}
+
+	var wg sync.WaitGroup
+	errs := make(chan error, writers)
+	for w := 0; w < writers; w++ {
+		wg.Add(1)
+		go func(w int) {
+			defer wg.Done()
+			f, err := os.OpenFile(path, os.O_WRONLY, 0644)
+			if err != nil {
+				errs <- fmt.Errorf("writer %d open: %w", w, err)
+				return
+			}
+			defer f.Close()
+			block := bytes.Repeat([]byte{byte('A' + w)}, blockSize)
+			if _, err := f.WriteAt(block, int64(w*blockSize)); err != nil {
+				errs <- fmt.Errorf("writer %d write: %w", w, err)
+			}
+		}(w)
+	}
+	wg.Wait()
+	close(errs)
+	for err := range errs {
+		t.Fatalf("%v", err)
+	}
+
+	got, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read: %v", err)
+	}
+	if len(got) != writers*blockSize {
+		t.Fatalf("size = %d, want %d", len(got), writers*blockSize)
+	}
+	for w := 0; w < writers; w++ {
+		want := bytes.Repeat([]byte{byte('A' + w)}, blockSize)
+		if !bytes.Equal(got[w*blockSize:(w+1)*blockSize], want) {
+			t.Fatalf("block %d was not written whole", w)
+		}
+	}
+}
+
+func TestConcurrentReaders(t *testing.T) {
+	dir := testRoot(t)
+	path := filepath.Join(dir, "read-me")
+	want := contentFor("concurrent-readers", 1<<20)
+	if err := os.WriteFile(path, want, 0644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	// WriteFile's own existence probe ran while the file did not exist, and
+	// WinFsp may serve that answer from its metadata cache for up to the
+	// mount's FileInfoTimeout. Establish visibility once before racing the
+	// readers, so the race exercises concurrent reading rather than the
+	// cache window.
+	deadline := time.Now().Add(3 * time.Second)
+	for {
+		if _, err := os.Stat(path); err == nil {
+			break
+		} else if time.Now().After(deadline) {
+			t.Fatalf("file never became visible: %v", err)
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+
+	var wg sync.WaitGroup
+	errs := make(chan error, 8)
+	for r := 0; r < 8; r++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			got, err := os.ReadFile(path)
+			if err != nil {
+				errs <- err
+				return
+			}
+			if !bytes.Equal(got, want) {
+				errs <- fmt.Errorf("reader saw %d bytes, want %d", len(got), len(want))
+			}
+		}()
+	}
+	wg.Wait()
+	close(errs)
+	for err := range errs {
+		t.Fatalf("%v", err)
+	}
+}
+
+// Hard links are not something WinFsp offers, so the mount has to refuse them
+// rather than appear to succeed.
+func TestHardLinkUnsupported(t *testing.T) {
+	dir := testRoot(t)
+	target := filepath.Join(dir, "original")
+	if err := os.WriteFile(target, []byte("x"), 0644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	if err := os.Link(target, filepath.Join(dir, "hardlink")); err == nil {
+		t.Fatal("hard link creation reported success")
+	}
+}
+
+// Symlinks are refused rather than half-supported: WinFsp needs a reparse
+// point to follow one, and an entry it cannot follow reads back empty.
+func TestSymlinkUnsupported(t *testing.T) {
+	dir := testRoot(t)
+	target := filepath.Join(dir, "target.txt")
+	if err := os.WriteFile(target, []byte("pointed at"), 0644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	if err := os.Symlink(target, filepath.Join(dir, "link.txt")); err == nil {
+		t.Fatal("symlink creation reported success")
+	}
+}
+
+func TestModTimeAdvances(t *testing.T) {
+	dir := testRoot(t)
+	path := filepath.Join(dir, "touched")
+	if err := os.WriteFile(path, []byte("one"), 0644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	first, err := os.Stat(path)
+	if err != nil {
+		t.Fatalf("stat: %v", err)
+	}
+
+	time.Sleep(1100 * time.Millisecond)
+	if err := os.WriteFile(path, []byte("two"), 0644); err != nil {
+		t.Fatalf("rewrite: %v", err)
+	}
+	second, err := os.Stat(path)
+	if err != nil {
+		t.Fatalf("stat again: %v", err)
+	}
+	if !second.ModTime().After(first.ModTime()) {
+		t.Fatalf("mtime did not advance: %v then %v", first.ModTime(), second.ModTime())
+	}
+}
+
+func TestChtimes(t *testing.T) {
+	dir := testRoot(t)
+	path := filepath.Join(dir, "dated")
+	if err := os.WriteFile(path, []byte("x"), 0644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	want := time.Date(2020, 3, 4, 5, 6, 7, 0, time.UTC)
+	if err := os.Chtimes(path, want, want); err != nil {
+		t.Fatalf("chtimes: %v", err)
+	}
+	info, err := os.Stat(path)
+	if err != nil {
+		t.Fatalf("stat: %v", err)
+	}
+	if diff := info.ModTime().UTC().Sub(want); diff > 2*time.Second || diff < -2*time.Second {
+		t.Fatalf("mtime = %v, want about %v", info.ModTime().UTC(), want)
+	}
+}
+
+func TestStatfsIsSelfConsistent(t *testing.T) {
+	if *mountPoint == "" {
+		t.Skip("no -mountpoint given; this test needs a live WinFsp mount")
+	}
+	var free, total, totalFree uint64
+	if err := getDiskFreeSpace(*mountPoint, &free, &total, &totalFree); err != nil {
+		t.Fatalf("GetDiskFreeSpaceEx: %v", err)
+	}
+	if total == 0 {
+		t.Fatal("drive reports zero total bytes")
+	}
+	if free > total {
+		t.Fatalf("free (%d) exceeds total (%d)", free, total)
+	}
+	if totalFree > total {
+		t.Fatalf("total free (%d) exceeds total (%d)", totalFree, total)
+	}
+}
+
+// TestDeleteOnClose covers the pattern Windows software uses for temporaries:
+// the file goes away when the last handle closes, with no explicit delete. A
+// filesystem that ignores the flag leaves the name behind, and the next
+// program to create it gets a collision.
+func TestDeleteOnClose(t *testing.T) {
+	dir := testRoot(t)
+	path := filepath.Join(dir, "ephemeral.tmp")
+
+	h, err := createDeleteOnClose(path)
+	if err != nil {
+		if errors.Is(err, errWindowsOnly) {
+			t.Skip("delete-on-close needs the Win32 create call")
+		}
+		t.Fatalf("open with delete-on-close: %v", err)
+	}
+	if _, err := os.Stat(path); err != nil {
+		closeHandle(h)
+		t.Fatalf("file is not visible while its handle is open: %v", err)
+	}
+	if err := closeHandle(h); err != nil {
+		t.Fatalf("close: %v", err)
+	}
+	if _, err := os.Stat(path); err == nil {
+		t.Fatal("file outlived its last handle")
+	} else if !os.IsNotExist(err) {
+		t.Fatalf("stat after close: %v", err)
+	}
+	// The name has to be free again, which is what the conformance suite
+	// tripped over when an aborted test left its file behind.
+	h, err = createDeleteOnClose(path)
+	if err != nil {
+		t.Fatalf("recreating the same name failed: %v", err)
+	}
+	if err := closeHandle(h); err != nil {
+		t.Fatalf("close after recreate: %v", err)
+	}
+}
+
+func describeFileInfo(fi os.FileInfo) string {
+	if fi == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("{size=%d mode=%v mtime=%s}", fi.Size(), fi.Mode(), fi.ModTime().Format(time.RFC3339Nano))
+}