gopls/internal/filewatcher/filewatcher_test.go - tools - Git at Google

 // Copyright 2025 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package filewatcher_test

 import (
 	"cmp"
 	"fmt"
 	"maps"
 	"os"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"testing"
 	"time"

 	"golang.org/x/sync/errgroup"
 	"golang.org/x/tools/gopls/internal/filewatcher"
 	"golang.org/x/tools/gopls/internal/protocol"
 	"golang.org/x/tools/gopls/internal/settings"
 	"golang.org/x/tools/gopls/internal/util/moremaps"
 	"golang.org/x/tools/internal/robustio"
 	"golang.org/x/tools/internal/testfiles"
 	"golang.org/x/tools/txtar"
 )

 // tryFSOperation executes a function `op` with retry logic, making it resilient
 // to transient errors. It attempts the operation up to 5 times with exponential
 // backoff. Retries occur only if the error is ephemeral.
 func tryFSOperation(op func() error) error {
 	var (
 		delay = 50 * time.Millisecond
 		err   error
 	)

 	for range 5 {
 		if err = op(); !robustio.IsEphemeralError(err) {
 			return err
 		}

 		time.Sleep(delay)
 		delay *= 2
 	}

 	return err // return last error encountered
 }

 func TestFileWatcher(t *testing.T) {
 	testCases := []struct {
 		name           string
 		initWorkspace  string
 		changes        func(root string) error
 		expectedEvents map[protocol.FileEvent]struct{}
 	}{
 		{
 			name: "create file",
 			initWorkspace: `
 -- foo.go --
 package foo
 `,
 			changes: func(root string) error {
 				return os.WriteFile(filepath.Join(root, "bar.go"), []byte("package main"), 0644)
 			},
 			expectedEvents: map[protocol.FileEvent]struct{}{
 				{URI: "bar.go", Type: protocol.Created}: {},
 			},
 		},
 		{
 			name: "modify file",
 			initWorkspace: `
 -- foo.go --
 package foo
 `,
 			changes: func(root string) error {
 				return os.WriteFile(filepath.Join(root, "foo.go"), []byte("package main // modified"), 0644)
 			},
 			expectedEvents: map[protocol.FileEvent]struct{}{
 				{URI: "foo.go", Type: protocol.Changed}: {},
 			},
 		},
 		{
 			name: "delete file",
 			initWorkspace: `
 -- foo.go --
 package foo
 -- bar.go --
 package bar
 `,
 			changes: func(root string) error {
 				return os.Remove(filepath.Join(root, "foo.go"))
 			},
 			expectedEvents: map[protocol.FileEvent]struct{}{
 				{URI: "foo.go", Type: protocol.Deleted}: {},
 			},
 		},
 		{
 			name: "rename file",
 			initWorkspace: `
 -- foo.go --
 package foo
 `,
 			changes: func(root string) error {
 				return os.Rename(filepath.Join(root, "foo.go"), filepath.Join(root, "bar.go"))
 			},
 			expectedEvents: map[protocol.FileEvent]struct{}{
 				{URI: "foo.go", Type: protocol.Deleted}: {},
 				{URI: "bar.go", Type: protocol.Created}: {},
 			},
 		},
 		{
 			name: "create directory",
 			initWorkspace: `
 -- foo.go --
 package foo
 `,
 			changes: func(root string) error {
 				return os.Mkdir(filepath.Join(root, "bar"), 0755)
 			},
 			expectedEvents: map[protocol.FileEvent]struct{}{
 				{URI: "bar", Type: protocol.Created}: {},
 			},
 		},
 		{
 			name: "delete directory",
 			initWorkspace: `
 -- foo/bar.go --
 package foo
 `,
 			changes: func(root string) error {
 				return os.RemoveAll(filepath.Join(root, "foo"))
 			},
 			expectedEvents: map[protocol.FileEvent]struct{}{
 				// We only assert that the directory deletion event exists,
 				// because file system event behavior is inconsistent across
 				// platforms when deleting a non-empty directory.
 				// e.g. windows-amd64 may only emit a single dir removal event,
 				// freebsd-amd64 report dir removal before file removal,
 				// linux-amd64 report the reverse order.
 				// Therefore, the most reliable and cross-platform compatible
 				// signal is the deletion event for the directory itself.
 				{URI: "foo", Type: protocol.Deleted}: {},
 			},
 		},
 		{
 			name: "rename directory",
 			initWorkspace: `
 -- foo/bar.go --
 package foo
 `,
 			changes: func(root string) error {
 				return os.Rename(filepath.Join(root, "foo"), filepath.Join(root, "baz"))
 			},
 			expectedEvents: map[protocol.FileEvent]struct{}{
 				{URI: "foo", Type: protocol.Deleted}:        {},
 				{URI: "baz", Type: protocol.Created}:        {},
 				{URI: "baz/bar.go", Type: protocol.Created}: {},
 			},
 		},
 		// TODO(hxjiang): test for symlink to a dir.
 	}

 	for _, tt := range testCases {
 		t.Run(tt.name, func(t *testing.T) {
 			for _, mode := range []settings.FileWatcherMode{settings.FileWatcherFSNotify, settings.FileWatcherPoll} {
 				t.Run(string(mode), func(t *testing.T) {
 					// "poll" mode is portable, so we can run it on all OS.
 					if mode == settings.FileWatcherFSNotify {
 						switch runtime.GOOS {
 						case "darwin", "linux", "windows":
 						default:
 							t.Skip("unsupported OS")
 						}
 					}

 					fs, err := txtar.FS(txtar.Parse([]byte(tt.initWorkspace)))
 					if err != nil {
 						t.Fatal(err)
 					}
 					root := testfiles.CopyToTmp(t, fs)

 					var (
 						all      = maps.Clone(tt.expectedEvents)
 						foundAll = make(chan struct{})

 						gots []protocol.FileEvent
 					)

 					eventsHandler := func(events []protocol.FileEvent) {
 						// Trim prefix for readability.
 						for i := range events {
 							rel := strings.TrimPrefix(events[i].URI.Path(), root+string(filepath.Separator))
 							events[i].URI = protocol.DocumentURI(filepath.ToSlash(rel))
 						}

 						gots = append(gots, events...)

 						if len(all) == 0 {
 							return
 						}

 						for _, got := range events {
 							delete(all, got)
 							if len(all) == 0 {
 								close(foundAll)
 								return
 							}
 						}

 					}
 					errHandler := func(err error) {
 						t.Errorf("error from watcher: %v", err)
 					}

 					w, err := filewatcher.New(mode, nil, eventsHandler, errHandler)
 					if err != nil {
 						t.Fatal(err)
 					}
 					defer func() {
 						if err := w.Close(); err != nil {
 							t.Errorf("failed to close the file watcher: %v", err)
 						}
 					}()

 					if err := w.WatchDir(root); err != nil {
 						t.Fatal(err)
 					}

 					// For poll watcher, we need to ensure mtime changes. The test
 					// cases use os.WriteFile which updates mtime. However, if the
 					// test runs too fast, mtime might not change (if resolution
 					// is low). Poll watcher checks mtime.
 					if mode == settings.FileWatcherPoll {
 						time.Sleep(10 * time.Millisecond)
 					}
 					// The poll watcher periodically scans the directory in the
 					// background.
 					// On Windows, the file system enforces mandatory file locking.
 					// If the test attempts to modify files while the watcher is
 					// reading them, Windows will reject the modification with a
 					// sharing or permission error. We use tryFSOperation to
 					// retry the modification until the watcher releases the
 					// file lock.
 					//
 					// However this also means other process (maybe the user)
 					// will encounter this problem while the poll watcher is
 					// scanning through the dir.
 					if err := tryFSOperation(func() error {
 						return tt.changes(root)
 					}); err != nil {
 						t.Fatal(err)
 					}

 					select {
 					case <-foundAll:
 					case <-time.After(30 * time.Second):
 						if len(all) != 0 {
 							var want strings.Builder
 							for e := range tt.expectedEvents {
 								fmt.Fprintf(&want, "URI: %s type: %v\n", e.URI, e.Type)
 							}
 							var got strings.Builder
 							for _, e := range gots {
 								fmt.Fprintf(&got, "URI: %s type: %v\n", e.URI, e.Type)
 							}
 							t.Errorf("found %v matching events slice\nwant sequences:\n%s\nall got:\n%s", len(tt.expectedEvents)-len(all), want.String(), got.String())
 						}

 					}
 				})
 			}
 		})
 	}
 }

 func TestBrokenSymlink(t *testing.T) {
 	if runtime.GOOS != "darwin" {
 		t.Skip("unsupported OS")
 	}

 	root := t.TempDir()

 	// watchErrs is used to capture watch errors during directory monitoring.
 	// This mechanism allows the test to assert that specific directory watches
 	// initially fail and subsequently recover upon fixing the broken symlink.
 	watchErrs := make(chan error, 10)
 	filewatcher.SetAfterAddHook(func(path string, watchErr error) {
 		rel, err := filepath.Rel(root, path)
 		if err != nil {
 			return
 		}
 		if rel == "foo" {
 			if watchErr == nil {
 				close(watchErrs)
 			} else {
 				watchErrs <- watchErr
 			}
 		}
 	})
 	defer filewatcher.SetAfterAddHook(nil)

 	var (
 		gots     []protocol.FileEvent
 		matched  int
 		foundAll = make(chan struct{})
 	)
 	wants := []protocol.FileEvent{
 		// "foo" create event from fsnotify and synthesized create event
 		// for all entries under foo.
 		{URI: "foo", Type: protocol.Created},
 		{URI: "foo/a.go", Type: protocol.Created},
 		{URI: "foo/b.go", Type: protocol.Created},
 		{URI: "foo/from.go", Type: protocol.Created},
 		// "to.go" creation from fsnotify.
 		{URI: "to.go", Type: protocol.Created},
 		// file creation event after watch retry succeeded.
 		{URI: "foo/new.go", Type: protocol.Created},
 	}
 	eventsHandler := func(events []protocol.FileEvent) {
 		gots = append(gots, events...)

 		if matched == len(wants) {
 			return
 		}

 		for _, got := range events {
 			want := protocol.FileEvent{
 				URI:  protocol.URIFromPath(filepath.Join(root, string(wants[matched].URI))),
 				Type: wants[matched].Type,
 			}
 			if want == got {
 				matched++
 			}
 			if matched == len(wants) {
 				close(foundAll)
 				return
 			}
 		}

 	}
 	errHandler := func(err error) {
 		t.Errorf("error from watcher: %v", err)
 	}
 	w, err := filewatcher.New(settings.FileWatcherFSNotify, nil, eventsHandler, errHandler)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer func() {
 		if err := w.Close(); err != nil {
 			t.Errorf("failed to close the file watcher: %v", err)
 		}
 	}()

 	if err := w.WatchDir(root); err != nil {
 		t.Fatal(err)
 	}

 	{
 		// Prepare a dir with with broken symbolic link.
 		// foo                       <- 1st
 		// ├── from.go -> root/to.go <- 1st
 		// ├── a.go                  <- 1st
 		// └── b.go                  <- 1st

 		to := filepath.Join(root, "to.go")

 		archive := txtar.Parse([]byte(`
 -- a.go --
 package a
 -- b.go --
 package b
 `))
 		tmp := filepath.Join(t.TempDir(), "foo")
 		for _, f := range archive.Files {
 			path := filepath.Join(tmp, f.Name)
 			if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
 				t.Fatalf("fail to create dir %v", err)
 			}
 			if err := os.WriteFile(path, f.Data, 0644); err != nil {
 				t.Fatalf("fail to write file %v", err)
 			}
 		}

 		// Create the symbolic link to a non-existing file. This would
 		// cause the watch registration for dir "foo" to fail.
 		if err := os.Symlink(to, filepath.Join(tmp, "from.go")); err != nil {
 			t.Fatalf("fail to create symlink file %v", err)
 		}

 		// Move the directory containing the broken symlink into place
 		// to avoids a flaky test where the directory could be watched
 		// before the symlink is created. See golang/go#74782.
 		if err := os.Rename(tmp, filepath.Join(root, "foo")); err != nil {
 			t.Fatalf("fail to rename file %v", err)
 		}

 		// root
 		// ├── foo                          <- 2nd (Move)
 		// │   ├── a.go                     <- 2nd (Move)
 		// │   ├── b.go                     <- 2nd (Move)
 		// │   ├── from.go -> ../../to.go   <- 2nd (Move)
 		// │   └── new.go                   <- 4th (Create)
 		// └── to.go                        <- 3rd (Create)

 		// Should be able to capture watch error while trying to watch dir "foo".
 		if err := <-watchErrs; err == nil {
 			t.Errorf("did not capture watch registration failure for dir foo")
 		}

 		// The file watcher should retry watch registration and eventually succeed
 		// watching for all dir under 'foo' after the file got created.
 		{
 			if err := os.WriteFile(to, []byte("package main"), 0644); err != nil {
 				t.Errorf("fail to write file %v", err)
 			}

 			timer := time.NewTimer(30 * time.Second)
 			defer timer.Stop()

 		outer:
 			for {
 				select {
 				case _, ok := <-watchErrs:
 					if !ok {
 						break outer
 					}
 				case <-timer.C:
 					t.Errorf("timed out after 30s waiting for watches on foo to be established")
 				}
 			}
 		}

 		// Once the watch registration is done, file events under the
 		// dir "foo" should be captured
 		if err := os.WriteFile(filepath.Join(root, "foo", "new.go"), []byte("package main"), 0644); err != nil {
 			t.Fatalf("fail to write file %v", err)
 		}
 	}

 	select {
 	case <-foundAll:
 	case <-time.After(30 * time.Second):
 		if matched != len(wants) {
 			var want strings.Builder
 			for _, e := range wants {
 				fmt.Fprintf(&want, "URI: %s type: %v\n", e.URI, e.Type)
 			}
 			var got strings.Builder
 			for _, e := range gots {
 				fmt.Fprintf(&got, "URI: %s type: %v\n", strings.TrimPrefix(e.URI.Path(), root+"/"), e.Type)
 			}
 			t.Errorf("found %v matching events slice\nwant sequences:\n%s\nall got:\n%s", matched, &want, &got)
 		}

 	}
 }

 func TestStress(t *testing.T) {
 	for _, mode := range []settings.FileWatcherMode{settings.FileWatcherPoll, settings.FileWatcherFSNotify} {
 		t.Run(string(mode), func(t *testing.T) {
 			// "poll" mode is portable, so we can run it on all OS.
 			if mode == settings.FileWatcherFSNotify {
 				switch runtime.GOOS {
 				case "darwin", "linux", "windows":
 				default:
 					t.Skip("unsupported OS")
 				}
 			}

 			const parallelism = 100 // number of parallel instances of each kind of operation

 			root := t.TempDir()

 			mkdir := func(base string) func() error {
 				return func() error {
 					return os.Mkdir(filepath.Join(root, base), 0755)
 				}
 			}
 			write := func(base string) func() error {
 				return func() error {
 					return os.WriteFile(filepath.Join(root, base), []byte("package main"), 0644)
 				}
 			}
 			remove := func(base string) func() error {
 				return func() error {
 					return os.Remove(filepath.Join(root, base))
 				}
 			}
 			rename := func(old, new string) func() error {
 				return func() error {
 					return os.Rename(filepath.Join(root, old), filepath.Join(root, new))
 				}
 			}

 			wants := make(map[protocol.FileEvent]bool)
 			want := func(base string, t protocol.FileChangeType) {
 				wants[protocol.FileEvent{URI: protocol.URIFromPath(filepath.Join(root, base)), Type: t}] = true
 			}

 			for i := range parallelism {
 				// Create files and dirs that will be deleted or renamed later.
 				if err := cmp.Or(
 					mkdir(fmt.Sprintf("delete-dir-%d", i))(),
 					mkdir(fmt.Sprintf("old-dir-%d", i))(),
 					write(fmt.Sprintf("delete-file-%d.go", i))(),
 					write(fmt.Sprintf("old-file-%d.go", i))(),
 				); err != nil {
 					t.Fatal(err)
 				}

 				// Add expected notification events to the "wants" set.
 				want(fmt.Sprintf("file-%d.go", i), protocol.Created)
 				want(fmt.Sprintf("delete-file-%d.go", i), protocol.Deleted)
 				want(fmt.Sprintf("old-file-%d.go", i), protocol.Deleted)
 				want(fmt.Sprintf("new-file-%d.go", i), protocol.Created)
 				want(fmt.Sprintf("dir-%d", i), protocol.Created)
 				want(fmt.Sprintf("delete-dir-%d", i), protocol.Deleted)
 				want(fmt.Sprintf("old-dir-%d", i), protocol.Deleted)
 				want(fmt.Sprintf("new-dir-%d", i), protocol.Created)
 			}

 			foundAll := make(chan struct{})

 			eventsHandler := func(events []protocol.FileEvent) {
 				if len(wants) == 0 { // avoid closing twice
 					return
 				}
 				for _, e := range events {
 					delete(wants, e)
 				}
 				if len(wants) == 0 {
 					close(foundAll)
 				}
 			}
 			errHandler := func(err error) {
 				// Work around test flake go.dev/issue/78366 due to Windows'
 				// regrettable locking of files during reads.
 				if runtime.GOOS == "windows" && strings.Contains(err.Error(), "being used by another process") {
 					t.Log(err)
 					return
 				}

 				t.Errorf("error from watcher: %v", err)
 			}
 			w, err := filewatcher.New(mode, nil, eventsHandler, errHandler)
 			if err != nil {
 				t.Fatal(err)
 			}
 			defer func() {
 				if err := w.Close(); err != nil {
 					t.Errorf("failed to close the file watcher: %v", err)
 				}
 			}()

 			if err := w.WatchDir(root); err != nil {
 				t.Fatal(err)
 			}

 			// Spin up multiple goroutines, to perform 6 file system operations i.e.
 			// create, delete, rename of file or directory. For deletion and rename,
 			// the goroutine deletes / renames files or directories created before the
 			// watcher starts.
 			var g errgroup.Group
 			for id := range parallelism {
 				ops := []func() error{
 					write(fmt.Sprintf("file-%d.go", id)),
 					remove(fmt.Sprintf("delete-file-%d.go", id)),
 					rename(fmt.Sprintf("old-file-%d.go", id), fmt.Sprintf("new-file-%d.go", id)),
 					mkdir(fmt.Sprintf("dir-%d", id)),
 					remove(fmt.Sprintf("delete-dir-%d", id)),
 					rename(fmt.Sprintf("old-dir-%d", id), fmt.Sprintf("new-dir-%d", id)),
 				}
 				for _, f := range ops {
 					g.Go(func() error {
 						return tryFSOperation(f)
 					})
 				}
 			}
 			if err := g.Wait(); err != nil {
 				t.Fatal(err)
 			}

 			select {
 			case <-foundAll:
 			case <-time.After(30 * time.Second):
 				if len(wants) > 0 {
 					t.Errorf("missing expected events: %#v", moremaps.KeySlice(wants))
 				}
 			}
 		})
 	}
 }
	// Copyright 2025 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package filewatcher_test

	import (
	"cmp"
	"fmt"
	"maps"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"testing"
	"time"

	"golang.org/x/sync/errgroup"
	"golang.org/x/tools/gopls/internal/filewatcher"
	"golang.org/x/tools/gopls/internal/protocol"
	"golang.org/x/tools/gopls/internal/settings"
	"golang.org/x/tools/gopls/internal/util/moremaps"
	"golang.org/x/tools/internal/robustio"
	"golang.org/x/tools/internal/testfiles"
	"golang.org/x/tools/txtar"
	)

	// tryFSOperation executes a function `op` with retry logic, making it resilient
	// to transient errors. It attempts the operation up to 5 times with exponential
	// backoff. Retries occur only if the error is ephemeral.
	func tryFSOperation(op func() error) error {
	var (
	delay = 50 * time.Millisecond
	err error
	)

	for range 5 {
	if err = op(); !robustio.IsEphemeralError(err) {
	return err
	}

	time.Sleep(delay)
	delay *= 2
	}

	return err // return last error encountered
	}

	func TestFileWatcher(t *testing.T) {
	testCases := []struct {
	name string
	initWorkspace string
	changes func(root string) error
	expectedEvents map[protocol.FileEvent]struct{}
	}{
	{
	name: "create file",
	initWorkspace: `
	-- foo.go --
	package foo
	`,
	changes: func(root string) error {
	return os.WriteFile(filepath.Join(root, "bar.go"), []byte("package main"), 0644)
	},
	expectedEvents: map[protocol.FileEvent]struct{}{
	{URI: "bar.go", Type: protocol.Created}: {},
	},
	},
	{
	name: "modify file",
	initWorkspace: `
	-- foo.go --
	package foo
	`,
	changes: func(root string) error {
	return os.WriteFile(filepath.Join(root, "foo.go"), []byte("package main // modified"), 0644)
	},
	expectedEvents: map[protocol.FileEvent]struct{}{
	{URI: "foo.go", Type: protocol.Changed}: {},
	},
	},
	{
	name: "delete file",
	initWorkspace: `
	-- foo.go --
	package foo
	-- bar.go --
	package bar
	`,
	changes: func(root string) error {
	return os.Remove(filepath.Join(root, "foo.go"))
	},
	expectedEvents: map[protocol.FileEvent]struct{}{
	{URI: "foo.go", Type: protocol.Deleted}: {},
	},
	},
	{
	name: "rename file",
	initWorkspace: `
	-- foo.go --
	package foo
	`,
	changes: func(root string) error {
	return os.Rename(filepath.Join(root, "foo.go"), filepath.Join(root, "bar.go"))
	},
	expectedEvents: map[protocol.FileEvent]struct{}{
	{URI: "foo.go", Type: protocol.Deleted}: {},
	{URI: "bar.go", Type: protocol.Created}: {},
	},
	},
	{
	name: "create directory",
	initWorkspace: `
	-- foo.go --
	package foo
	`,
	changes: func(root string) error {
	return os.Mkdir(filepath.Join(root, "bar"), 0755)
	},
	expectedEvents: map[protocol.FileEvent]struct{}{
	{URI: "bar", Type: protocol.Created}: {},
	},
	},
	{
	name: "delete directory",
	initWorkspace: `
	-- foo/bar.go --
	package foo
	`,
	changes: func(root string) error {
	return os.RemoveAll(filepath.Join(root, "foo"))
	},
	expectedEvents: map[protocol.FileEvent]struct{}{
	// We only assert that the directory deletion event exists,
	// because file system event behavior is inconsistent across
	// platforms when deleting a non-empty directory.
	// e.g. windows-amd64 may only emit a single dir removal event,
	// freebsd-amd64 report dir removal before file removal,
	// linux-amd64 report the reverse order.
	// Therefore, the most reliable and cross-platform compatible
	// signal is the deletion event for the directory itself.
	{URI: "foo", Type: protocol.Deleted}: {},
	},
	},
	{
	name: "rename directory",
	initWorkspace: `
	-- foo/bar.go --
	package foo
	`,
	changes: func(root string) error {
	return os.Rename(filepath.Join(root, "foo"), filepath.Join(root, "baz"))
	},
	expectedEvents: map[protocol.FileEvent]struct{}{
	{URI: "foo", Type: protocol.Deleted}: {},
	{URI: "baz", Type: protocol.Created}: {},
	{URI: "baz/bar.go", Type: protocol.Created}: {},
	},
	},
	// TODO(hxjiang): test for symlink to a dir.
	}

	for _, tt := range testCases {
	t.Run(tt.name, func(t *testing.T) {
	for _, mode := range []settings.FileWatcherMode{settings.FileWatcherFSNotify, settings.FileWatcherPoll} {
	t.Run(string(mode), func(t *testing.T) {
	// "poll" mode is portable, so we can run it on all OS.
	if mode == settings.FileWatcherFSNotify {
	switch runtime.GOOS {
	case "darwin", "linux", "windows":
	default:
	t.Skip("unsupported OS")
	}
	}

	fs, err := txtar.FS(txtar.Parse([]byte(tt.initWorkspace)))
	if err != nil {
	t.Fatal(err)
	}
	root := testfiles.CopyToTmp(t, fs)

	var (
	all = maps.Clone(tt.expectedEvents)
	foundAll = make(chan struct{})

	gots []protocol.FileEvent
	)

	eventsHandler := func(events []protocol.FileEvent) {
	// Trim prefix for readability.
	for i := range events {
	rel := strings.TrimPrefix(events[i].URI.Path(), root+string(filepath.Separator))
	events[i].URI = protocol.DocumentURI(filepath.ToSlash(rel))
	}

	gots = append(gots, events...)

	if len(all) == 0 {
	return
	}

	for _, got := range events {
	delete(all, got)
	if len(all) == 0 {
	close(foundAll)
	return
	}
	}

	}
	errHandler := func(err error) {
	t.Errorf("error from watcher: %v", err)
	}

	w, err := filewatcher.New(mode, nil, eventsHandler, errHandler)
	if err != nil {
	t.Fatal(err)
	}
	defer func() {
	if err := w.Close(); err != nil {
	t.Errorf("failed to close the file watcher: %v", err)
	}
	}()

	if err := w.WatchDir(root); err != nil {
	t.Fatal(err)
	}

	// For poll watcher, we need to ensure mtime changes. The test
	// cases use os.WriteFile which updates mtime. However, if the
	// test runs too fast, mtime might not change (if resolution
	// is low). Poll watcher checks mtime.
	if mode == settings.FileWatcherPoll {
	time.Sleep(10 * time.Millisecond)
	}
	// The poll watcher periodically scans the directory in the
	// background.
	// On Windows, the file system enforces mandatory file locking.
	// If the test attempts to modify files while the watcher is
	// reading them, Windows will reject the modification with a
	// sharing or permission error. We use tryFSOperation to
	// retry the modification until the watcher releases the
	// file lock.
	//
	// However this also means other process (maybe the user)
	// will encounter this problem while the poll watcher is
	// scanning through the dir.
	if err := tryFSOperation(func() error {
	return tt.changes(root)
	}); err != nil {
	t.Fatal(err)
	}

	select {
	case <-foundAll:
	case <-time.After(30 * time.Second):
	if len(all) != 0 {
	var want strings.Builder
	for e := range tt.expectedEvents {
	fmt.Fprintf(&want, "URI: %s type: %v\n", e.URI, e.Type)
	}
	var got strings.Builder
	for _, e := range gots {
	fmt.Fprintf(&got, "URI: %s type: %v\n", e.URI, e.Type)
	}
	t.Errorf("found %v matching events slice\nwant sequences:\n%s\nall got:\n%s", len(tt.expectedEvents)-len(all), want.String(), got.String())
	}

	}
	})
	}
	})
	}
	}

	func TestBrokenSymlink(t *testing.T) {
	if runtime.GOOS != "darwin" {
	t.Skip("unsupported OS")
	}

	root := t.TempDir()

	// watchErrs is used to capture watch errors during directory monitoring.
	// This mechanism allows the test to assert that specific directory watches
	// initially fail and subsequently recover upon fixing the broken symlink.
	watchErrs := make(chan error, 10)
	filewatcher.SetAfterAddHook(func(path string, watchErr error) {
	rel, err := filepath.Rel(root, path)
	if err != nil {
	return
	}
	if rel == "foo" {
	if watchErr == nil {
	close(watchErrs)
	} else {
	watchErrs <- watchErr
	}
	}
	})
	defer filewatcher.SetAfterAddHook(nil)

	var (
	gots []protocol.FileEvent
	matched int
	foundAll = make(chan struct{})
	)
	wants := []protocol.FileEvent{
	// "foo" create event from fsnotify and synthesized create event
	// for all entries under foo.
	{URI: "foo", Type: protocol.Created},
	{URI: "foo/a.go", Type: protocol.Created},
	{URI: "foo/b.go", Type: protocol.Created},
	{URI: "foo/from.go", Type: protocol.Created},
	// "to.go" creation from fsnotify.
	{URI: "to.go", Type: protocol.Created},
	// file creation event after watch retry succeeded.
	{URI: "foo/new.go", Type: protocol.Created},
	}
	eventsHandler := func(events []protocol.FileEvent) {
	gots = append(gots, events...)

	if matched == len(wants) {
	return
	}

	for _, got := range events {
	want := protocol.FileEvent{
	URI: protocol.URIFromPath(filepath.Join(root, string(wants[matched].URI))),
	Type: wants[matched].Type,
	}
	if want == got {
	matched++
	}
	if matched == len(wants) {
	close(foundAll)
	return
	}
	}

	}
	errHandler := func(err error) {
	t.Errorf("error from watcher: %v", err)
	}
	w, err := filewatcher.New(settings.FileWatcherFSNotify, nil, eventsHandler, errHandler)
	if err != nil {
	t.Fatal(err)
	}
	defer func() {
	if err := w.Close(); err != nil {
	t.Errorf("failed to close the file watcher: %v", err)
	}
	}()

	if err := w.WatchDir(root); err != nil {
	t.Fatal(err)
	}

	{
	// Prepare a dir with with broken symbolic link.
	// foo <- 1st
	// ├── from.go -> root/to.go <- 1st
	// ├── a.go <- 1st
	// └── b.go <- 1st

	to := filepath.Join(root, "to.go")

	archive := txtar.Parse([]byte(`
	-- a.go --
	package a
	-- b.go --
	package b
	`))
	tmp := filepath.Join(t.TempDir(), "foo")
	for _, f := range archive.Files {
	path := filepath.Join(tmp, f.Name)
	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
	t.Fatalf("fail to create dir %v", err)
	}
	if err := os.WriteFile(path, f.Data, 0644); err != nil {
	t.Fatalf("fail to write file %v", err)
	}
	}

	// Create the symbolic link to a non-existing file. This would
	// cause the watch registration for dir "foo" to fail.
	if err := os.Symlink(to, filepath.Join(tmp, "from.go")); err != nil {
	t.Fatalf("fail to create symlink file %v", err)
	}

	// Move the directory containing the broken symlink into place
	// to avoids a flaky test where the directory could be watched
	// before the symlink is created. See golang/go#74782.
	if err := os.Rename(tmp, filepath.Join(root, "foo")); err != nil {
	t.Fatalf("fail to rename file %v", err)
	}

	// root
	// ├── foo <- 2nd (Move)
	// │ ├── a.go <- 2nd (Move)
	// │ ├── b.go <- 2nd (Move)
	// │ ├── from.go -> ../../to.go <- 2nd (Move)
	// │ └── new.go <- 4th (Create)
	// └── to.go <- 3rd (Create)

	// Should be able to capture watch error while trying to watch dir "foo".
	if err := <-watchErrs; err == nil {
	t.Errorf("did not capture watch registration failure for dir foo")
	}

	// The file watcher should retry watch registration and eventually succeed
	// watching for all dir under 'foo' after the file got created.
	{
	if err := os.WriteFile(to, []byte("package main"), 0644); err != nil {
	t.Errorf("fail to write file %v", err)
	}

	timer := time.NewTimer(30 * time.Second)
	defer timer.Stop()

	outer:
	for {
	select {
	case _, ok := <-watchErrs:
	if !ok {
	break outer
	}
	case <-timer.C:
	t.Errorf("timed out after 30s waiting for watches on foo to be established")
	}
	}
	}

	// Once the watch registration is done, file events under the
	// dir "foo" should be captured
	if err := os.WriteFile(filepath.Join(root, "foo", "new.go"), []byte("package main"), 0644); err != nil {
	t.Fatalf("fail to write file %v", err)
	}
	}

	select {
	case <-foundAll:
	case <-time.After(30 * time.Second):
	if matched != len(wants) {
	var want strings.Builder
	for _, e := range wants {
	fmt.Fprintf(&want, "URI: %s type: %v\n", e.URI, e.Type)
	}
	var got strings.Builder
	for _, e := range gots {
	fmt.Fprintf(&got, "URI: %s type: %v\n", strings.TrimPrefix(e.URI.Path(), root+"/"), e.Type)
	}
	t.Errorf("found %v matching events slice\nwant sequences:\n%s\nall got:\n%s", matched, &want, &got)
	}

	}
	}

	func TestStress(t *testing.T) {
	for _, mode := range []settings.FileWatcherMode{settings.FileWatcherPoll, settings.FileWatcherFSNotify} {
	t.Run(string(mode), func(t *testing.T) {
	// "poll" mode is portable, so we can run it on all OS.
	if mode == settings.FileWatcherFSNotify {
	switch runtime.GOOS {
	case "darwin", "linux", "windows":
	default:
	t.Skip("unsupported OS")
	}
	}

	const parallelism = 100 // number of parallel instances of each kind of operation

	root := t.TempDir()

	mkdir := func(base string) func() error {
	return func() error {
	return os.Mkdir(filepath.Join(root, base), 0755)
	}
	}
	write := func(base string) func() error {
	return func() error {
	return os.WriteFile(filepath.Join(root, base), []byte("package main"), 0644)
	}
	}
	remove := func(base string) func() error {
	return func() error {
	return os.Remove(filepath.Join(root, base))
	}
	}
	rename := func(old, new string) func() error {
	return func() error {
	return os.Rename(filepath.Join(root, old), filepath.Join(root, new))
	}
	}

	wants := make(map[protocol.FileEvent]bool)
	want := func(base string, t protocol.FileChangeType) {
	wants[protocol.FileEvent{URI: protocol.URIFromPath(filepath.Join(root, base)), Type: t}] = true
	}

	for i := range parallelism {
	// Create files and dirs that will be deleted or renamed later.
	if err := cmp.Or(
	mkdir(fmt.Sprintf("delete-dir-%d", i))(),
	mkdir(fmt.Sprintf("old-dir-%d", i))(),
	write(fmt.Sprintf("delete-file-%d.go", i))(),
	write(fmt.Sprintf("old-file-%d.go", i))(),
	); err != nil {
	t.Fatal(err)
	}

	// Add expected notification events to the "wants" set.
	want(fmt.Sprintf("file-%d.go", i), protocol.Created)
	want(fmt.Sprintf("delete-file-%d.go", i), protocol.Deleted)
	want(fmt.Sprintf("old-file-%d.go", i), protocol.Deleted)
	want(fmt.Sprintf("new-file-%d.go", i), protocol.Created)
	want(fmt.Sprintf("dir-%d", i), protocol.Created)
	want(fmt.Sprintf("delete-dir-%d", i), protocol.Deleted)
	want(fmt.Sprintf("old-dir-%d", i), protocol.Deleted)
	want(fmt.Sprintf("new-dir-%d", i), protocol.Created)
	}

	foundAll := make(chan struct{})

	eventsHandler := func(events []protocol.FileEvent) {
	if len(wants) == 0 { // avoid closing twice
	return
	}
	for _, e := range events {
	delete(wants, e)
	}
	if len(wants) == 0 {
	close(foundAll)
	}
	}
	errHandler := func(err error) {
	// Work around test flake go.dev/issue/78366 due to Windows'
	// regrettable locking of files during reads.
	if runtime.GOOS == "windows" && strings.Contains(err.Error(), "being used by another process") {
	t.Log(err)
	return
	}

	t.Errorf("error from watcher: %v", err)
	}
	w, err := filewatcher.New(mode, nil, eventsHandler, errHandler)
	if err != nil {
	t.Fatal(err)
	}
	defer func() {
	if err := w.Close(); err != nil {
	t.Errorf("failed to close the file watcher: %v", err)
	}
	}()

	if err := w.WatchDir(root); err != nil {
	t.Fatal(err)
	}

	// Spin up multiple goroutines, to perform 6 file system operations i.e.
	// create, delete, rename of file or directory. For deletion and rename,
	// the goroutine deletes / renames files or directories created before the
	// watcher starts.
	var g errgroup.Group
	for id := range parallelism {
	ops := []func() error{
	write(fmt.Sprintf("file-%d.go", id)),
	remove(fmt.Sprintf("delete-file-%d.go", id)),
	rename(fmt.Sprintf("old-file-%d.go", id), fmt.Sprintf("new-file-%d.go", id)),
	mkdir(fmt.Sprintf("dir-%d", id)),
	remove(fmt.Sprintf("delete-dir-%d", id)),
	rename(fmt.Sprintf("old-dir-%d", id), fmt.Sprintf("new-dir-%d", id)),
	}
	for _, f := range ops {
	g.Go(func() error {
	return tryFSOperation(f)
	})
	}
	}
	if err := g.Wait(); err != nil {
	t.Fatal(err)
	}

	select {
	case <-foundAll:
	case <-time.After(30 * time.Second):
	if len(wants) > 0 {
	t.Errorf("missing expected events: %#v", moremaps.KeySlice(wants))
	}
	}
	})
	}
	}