fsnotify_test.go - third_party/github.com/fsnotify/fsnotify - Git at Google

 package fsnotify

 import (
 	"errors"
 	"fmt"
 	"io/fs"
 	"os"
 	"path/filepath"
 	"reflect"
 	"runtime"
 	"sort"
 	"strings"
 	"sync"
 	"sync/atomic"
 	"syscall"
 	"testing"
 	"time"

 	"github.com/fsnotify/fsnotify/internal"
 )

 // Set soft open file limit to the maximum; on e.g. OpenBSD it's 512/1024.
 //
 // Go 1.19 will always do this when the os package is imported.
 //
 // https://go-review.googlesource.com/c/go/+/393354/
 func init() {
 	internal.SetRlimit()
 	enableRecurse = true
 }

 func TestScript(t *testing.T) {
 	err := filepath.Walk("./testdata", func(path string, info fs.FileInfo, err error) error {
 		if err != nil || info.IsDir() {
 			return err
 		}
 		n := strings.Split(filepath.ToSlash(path), "/")
 		t.Run(strings.Join(n[1:], "/"), func(t *testing.T) {
 			t.Parallel()
 			d, err := os.ReadFile(path)
 			if err != nil {
 				t.Fatal(err)
 			}
 			parseScript(t, string(d))
 		})
 		return nil
 	})
 	if err != nil {
 		t.Fatal(err)
 	}
 }

 // Multiple writes to a file with the same fd.
 func TestWatchMultipleWrite(t *testing.T) {
 	t.Parallel()
 	w := newCollector(t)
 	w.collect(t)
 	tmp := t.TempDir()

 	echoAppend(t, "data", tmp, "file")
 	addWatch(t, w.w, tmp)
 	fp, err := os.OpenFile(join(tmp, "file"), os.O_RDWR, 0)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if _, err := fp.Write([]byte("X")); err != nil {
 		t.Fatal(err)
 	}
 	if err := fp.Sync(); err != nil {
 		t.Fatal(err)
 	}
 	eventSeparator()
 	if _, err := fp.Write([]byte("Y")); err != nil {
 		t.Fatal(err)
 	}
 	if err := fp.Close(); err != nil {
 		t.Fatal(err)
 	}

 	cmpEvents(t, tmp, w.stop(t), newEvents(t, `
 		write  /file  # write X
 		write  /file  # write Y
 	`))
 }

 // Remove watched file with open fd
 func TestWatchRemoveOpenFd(t *testing.T) {
 	if runtime.GOOS == "windows" {
 		t.Skip("Windows hard-locks open files so this will never work")
 	}

 	t.Parallel()
 	tmp := t.TempDir()
 	w := newCollector(t)
 	w.collect(t)

 	touch(t, tmp, "/file")

 	fp, err := os.Open(join(tmp, "/file"))
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer fp.Close()

 	addWatch(t, w.w, tmp, "/file")
 	rm(t, tmp, "/file")

 	cmpEvents(t, tmp, w.stop(t), newEvents(t, `
 		remove   /file

 		# inotify will just emit a CHMOD for the unlink, but won't actually
 		# emit a REMOVE until the descriptor is closed. Bit odd, but not much
 		# we can do about it. The REMOVE is tested in TestInotifyDeleteOpenFile()
 		linux:
 			chmod  /file
 	`))
 }

 // Remove watched directory
 func TestWatchRemoveWatchedDir(t *testing.T) {
 	if runtime.GOOS == "dragonfly" {
 		t.Skip("broken: inconsistent events") // TODO
 	}

 	t.Parallel()
 	tmp := t.TempDir()
 	w := newCollector(t)
 	w.collect(t)

 	touch(t, tmp, "a")
 	touch(t, tmp, "b")
 	touch(t, tmp, "c")
 	touch(t, tmp, "d")
 	touch(t, tmp, "e")
 	touch(t, tmp, "f")
 	touch(t, tmp, "g")
 	mkdir(t, tmp, "h")
 	mkdir(t, tmp, "h", "a")
 	mkdir(t, tmp, "i")
 	mkdir(t, tmp, "i", "a")
 	mkdir(t, tmp, "j")
 	mkdir(t, tmp, "j", "a")
 	addWatch(t, w.w, tmp)
 	rmAll(t, tmp)

 	if runtime.GOOS != "windows" {
 		cmpEvents(t, tmp, w.stop(t), newEvents(t, `
 				remove    /
 				remove    /a
 				remove    /b
 				remove    /c
 				remove    /d
 				remove    /e
 				remove    /f
 				remove    /g
 				remove    /h
 				remove    /i
 				remove    /j`))
 		return
 	}

 	// ReadDirectoryChangesW gives undefined results: not all files are
 	// always present. So test only that 1) we got the directory itself, and
 	// 2) we don't get events for unspected files.
 	var (
 		events = w.stop(t)
 		found  bool
 	)
 	for _, e := range events {
 		if e.Name == tmp && e.Has(Remove) {
 			found = true
 			continue
 		}
 		if filepath.Dir(e.Name) != tmp {
 			t.Errorf("unexpected event: %s", e)
 		}
 	}
 	if !found {
 		t.Fatalf("didn't see directory in:\n%s", events)
 	}
 }

 func TestClose(t *testing.T) {
 	chanClosed := func(t *testing.T, w *Watcher) {
 		t.Helper()

 		// Need a small sleep as Close() on kqueue does all sorts of things,
 		// which may take a little bit.
 		switch runtime.GOOS {
 		case "freebsd", "openbsd", "netbsd", "dragonfly", "darwin", "solaris", "illumos":
 			time.Sleep(50 * time.Millisecond)
 		}

 		tim := time.NewTimer(50 * time.Millisecond)
 	loop:
 		for {
 			select {
 			default:
 				t.Fatal("blocking on Events")
 			case <-tim.C:
 				t.Fatalf("Events not closed")
 			case _, ok := <-w.Events:
 				if !ok {
 					break loop
 				}
 			}
 		}

 		select {
 		default:
 			t.Fatal("blocking on Errors")
 		case err, ok := <-w.Errors:
 			if ok {
 				t.Fatalf("Errors not closed; read:\n\t%s", err)
 			}
 		}
 	}

 	t.Run("close", func(t *testing.T) {
 		t.Parallel()

 		w := newWatcher(t)
 		if err := w.Close(); err != nil {
 			t.Fatal(err)
 		}
 		chanClosed(t, w)

 		var done int32
 		go func() {
 			w.Close()
 			atomic.StoreInt32(&done, 1)
 		}()

 		eventSeparator()
 		if atomic.LoadInt32(&done) == 0 {
 			t.Fatal("double Close() test failed: second Close() call didn't return")
 		}

 		if err := w.Add(t.TempDir()); err == nil {
 			t.Fatal("expected error on Watch() after Close(), got nil")
 		}
 	})

 	// Make sure that Close() works even when the Events channel isn't being
 	// read.
 	t.Run("events not read", func(t *testing.T) {
 		t.Parallel()

 		tmp := t.TempDir()
 		w := newWatcher(t, tmp)

 		touch(t, tmp, "file")
 		rm(t, tmp, "file")
 		eventSeparator()
 		if err := w.Close(); err != nil {
 			t.Fatal(err)
 		}

 		// TODO: windows backend doesn't work well here; can't easily fix it.
 		//       Need to rewrite things a bit.
 		if runtime.GOOS != "windows" {
 			chanClosed(t, w)
 		}
 	})

 	// Make sure that calling Close() while REMOVE events are emitted doesn't race.
 	t.Run("close while removing files", func(t *testing.T) {
 		t.Parallel()
 		tmp := t.TempDir()

 		files := make([]string, 0, 200)
 		for i := 0; i < 200; i++ {
 			f := join(tmp, fmt.Sprintf("file-%03d", i))
 			touch(t, f, noWait)
 			files = append(files, f)
 		}

 		w := newWatcher(t, tmp)

 		startC, stopC, errC := make(chan struct{}), make(chan struct{}), make(chan error)
 		go func() {
 			for {
 				select {
 				case <-w.Errors:
 				case <-w.Events:
 				case <-stopC:
 					return
 				}
 			}
 		}()
 		rmDone := make(chan struct{})
 		go func() {
 			<-startC
 			for _, f := range files {
 				rm(t, f, noWait)
 			}
 			rmDone <- struct{}{}
 		}()
 		go func() {
 			<-startC
 			errC <- w.Close()
 		}()
 		close(startC)
 		defer close(stopC)
 		if err := <-errC; err != nil {
 			t.Fatal(err)
 		}

 		<-rmDone
 	})

 	// Make sure Close() doesn't race when called more than once; hard to write
 	// a good reproducible test for this, but running it 150 times seems to
 	// reproduce it in ~75% of cases and isn't too slow (~0.06s on my system).
 	t.Run("double close", func(t *testing.T) {
 		t.Run("default", func(t *testing.T) {
 			t.Parallel()

 			for i := 0; i < 150; i++ {
 				w, err := NewWatcher()
 				if err != nil {
 					if strings.Contains(err.Error(), "too many") { // syscall.EMFILE
 						time.Sleep(100 * time.Millisecond)
 						continue
 					}
 					t.Fatal(err)
 				}
 				go w.Close()
 				go w.Close()
 				go w.Close()
 			}
 		})
 		t.Run("buffered=4096", func(t *testing.T) {
 			t.Parallel()

 			for i := 0; i < 150; i++ {
 				w, err := NewBufferedWatcher(4096)
 				if err != nil {
 					if strings.Contains(err.Error(), "too many") { // syscall.EMFILE
 						time.Sleep(100 * time.Millisecond)
 						continue
 					}
 					t.Fatal(err)
 				}
 				go w.Close()
 				go w.Close()
 				go w.Close()
 			}
 		})
 	})

 	t.Run("closes channels after read", func(t *testing.T) {
 		if runtime.GOOS == "netbsd" {
 			t.Skip("flaky") // TODO
 		}

 		t.Parallel()

 		tmp := t.TempDir()

 		w := newCollector(t, tmp)
 		w.collect(t)
 		touch(t, tmp, "qwe")
 		touch(t, tmp, "asd")

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

 		chanClosed(t, w.w)
 	})

 	t.Run("error after closed", func(t *testing.T) {
 		t.Parallel()

 		tmp := t.TempDir()
 		w := newWatcher(t, tmp)
 		if err := w.Close(); err != nil {
 			t.Fatal(err)
 		}

 		file := join(tmp, "file")
 		touch(t, file)
 		if err := w.Add(file); !errors.Is(err, ErrClosed) {
 			t.Fatalf("wrong error for Add: %#v", err)
 		}
 		if err := w.Remove(file); err != nil {
 			t.Fatalf("wrong error for Remove: %#v", err)
 		}
 		if l := w.WatchList(); l != nil { // Should return an error, but meh :-/
 			t.Fatalf("WatchList not nil: %#v", l)
 		}
 	})
 }

 func TestAdd(t *testing.T) {
 	t.Run("doesn't exist", func(t *testing.T) {
 		t.Parallel()
 		tmp := t.TempDir()

 		w := newWatcher(t)
 		err := w.Add(join(tmp, "non-existent"))
 		if err == nil {
 			t.Fatal("err is nil")
 		}

 		// TODO(v2): errors for this are inconsistent; should be fixed in v2. See #144
 		switch runtime.GOOS {
 		case "linux":
 			if _, ok := err.(syscall.Errno); !ok {
 				t.Errorf("wrong error type: %[1]T: %#[1]v", err)
 			}
 		case "windows":
 			if _, ok := err.(*os.SyscallError); !ok {
 				t.Errorf("wrong error type: %[1]T: %#[1]v", err)
 			}
 		default:
 			if _, ok := err.(*fs.PathError); !ok {
 				t.Errorf("wrong error type: %[1]T: %#[1]v", err)
 			}
 		}
 	})

 	t.Run("permission denied", func(t *testing.T) {
 		if runtime.GOOS == "windows" {
 			t.Skip("chmod doesn't work on Windows") // TODO: see if we can make a file unreadable
 		}

 		t.Parallel()

 		tmp := t.TempDir()
 		dir := join(tmp, "dir-unreadable")
 		mkdir(t, dir)
 		touch(t, dir, "/file")
 		chmod(t, 0, dir)

 		w := newWatcher(t)
 		defer func() {
 			w.Close()
 			chmod(t, 0o755, dir) // Make TempDir() cleanup work
 		}()
 		err := w.Add(dir)
 		if err == nil {
 			t.Fatal("error is nil")
 		}
 		if !errors.Is(err, internal.UnixEACCES) {
 			t.Errorf("not unix.EACCESS: %T %#[1]v", err)
 		}
 		if !errors.Is(err, internal.SyscallEACCES) {
 			t.Errorf("not syscall.EACCESS: %T %#[1]v", err)
 		}
 	})

 	t.Run("add same path twice", func(t *testing.T) {
 		tmp := t.TempDir()
 		w := newCollector(t)
 		if err := w.w.Add(tmp); err != nil {
 			t.Fatal(err)
 		}
 		if err := w.w.Add(tmp); err != nil {
 			t.Fatal(err)
 		}

 		w.collect(t)
 		touch(t, tmp, "file")
 		rm(t, tmp, "file")

 		cmpEvents(t, tmp, w.events(t), newEvents(t, `
 			create /file
 			remove /file
 		`))
 	})
 }

 func TestRemove(t *testing.T) {
 	t.Run("works", func(t *testing.T) {
 		t.Parallel()

 		tmp := t.TempDir()
 		touch(t, tmp, "file")

 		w := newCollector(t)
 		w.collect(t)
 		addWatch(t, w.w, tmp)
 		if err := w.w.Remove(tmp); err != nil {
 			t.Fatal(err)
 		}

 		time.Sleep(200 * time.Millisecond)
 		echoAppend(t, "data", tmp, "file")
 		chmod(t, 0o700, tmp, "file")

 		have := w.stop(t)
 		if len(have) > 0 {
 			t.Errorf("received events; expected none:\n%s", have)
 		}
 	})

 	t.Run("remove same dir twice", func(t *testing.T) {
 		t.Parallel()

 		tmp := t.TempDir()

 		touch(t, tmp, "file")

 		w := newWatcher(t)
 		defer w.Close()

 		addWatch(t, w, tmp)

 		if err := w.Remove(tmp); err != nil {
 			t.Fatal(err)
 		}
 		err := w.Remove(tmp)
 		if err == nil {
 			t.Fatal("no error")
 		}
 		if !errors.Is(err, ErrNonExistentWatch) {
 			t.Fatalf("wrong error: %T", err)
 		}
 	})

 	// Make sure that concurrent calls to Remove() don't race.
 	t.Run("no race", func(t *testing.T) {
 		t.Parallel()

 		tmp := t.TempDir()
 		touch(t, tmp, "file")

 		for i := 0; i < 10; i++ {
 			w := newWatcher(t)
 			defer w.Close()
 			addWatch(t, w, tmp)

 			done := make(chan struct{})
 			go func() {
 				defer func() { done <- struct{}{} }()
 				w.Remove(tmp)
 			}()
 			go func() {
 				defer func() { done <- struct{}{} }()
 				w.Remove(tmp)
 			}()
 			<-done
 			<-done
 			w.Close()
 		}
 	})

 	// Make sure file handles are correctly released.
 	//
 	// regression test for #42 see https://gist.github.com/timshannon/603f92824c5294269797
 	t.Run("", func(t *testing.T) {
 		w := newWatcher(t)
 		defer w.Close()

 		// consume the events
 		var werr error
 		var wg sync.WaitGroup
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			for {
 				select {
 				case werr = <-w.Errors:
 					return
 				case <-w.Events:
 				}
 			}
 		}()

 		tmp := t.TempDir()
 		dir := join(tmp, "child")
 		addWatch(t, w, tmp)
 		mkdir(t, dir)
 		addWatch(t, w, dir) // start watching child
 		rmWatch(t, w, dir)  // stop watching child
 		rmAll(t, dir)       // delete child dir

 		// Child dir should no longer exist
 		_, err := os.Stat(dir)
 		if err == nil {
 			t.Fatalf("dir %q should no longer exist!", dir)
 		}
 		if _, ok := err.(*os.PathError); err != nil && !ok {
 			t.Errorf("Expected a PathError, got %v", err)
 		}

 		w.Close()
 		wg.Wait()

 		if werr != nil {
 			t.Fatal(werr)
 		}
 	})

 	t.Run("remove with ... when non-recursive", func(t *testing.T) {
 		supportsRecurse(t)
 		t.Parallel()

 		tmp := t.TempDir()
 		w := newWatcher(t)
 		addWatch(t, w, tmp)

 		if err := w.Remove(join(tmp, "...")); err == nil {
 			t.Fatal("err was nil")
 		}
 		if err := w.Remove(tmp); err != nil {
 			t.Fatal(err)
 		}
 	})
 }

 func TestEventString(t *testing.T) {
 	tests := []struct {
 		in   Event
 		want string
 	}{
 		{Event{}, `[no events]   ""`},
 		{Event{Name: "/file", Op: 0}, `[no events]   "/file"`},

 		{Event{Name: "/file", Op: Chmod | Create},
 			`CREATE|CHMOD  "/file"`},
 		{Event{Name: "/file", Op: Rename},
 			`RENAME        "/file"`},
 		{Event{Name: "/file", Op: Remove},
 			`REMOVE        "/file"`},
 		{Event{Name: "/file", Op: Write | Chmod},
 			`WRITE|CHMOD   "/file"`},
 	}

 	for _, tt := range tests {
 		t.Run("", func(t *testing.T) {
 			have := tt.in.String()
 			if have != tt.want {
 				t.Errorf("\nhave: %q\nwant: %q", have, tt.want)
 			}
 		})
 	}
 }

 func TestWatchList(t *testing.T) {
 	t.Parallel()

 	tmp := t.TempDir()
 	file := join(tmp, "file")
 	other := join(tmp, "other")

 	touch(t, file)
 	touch(t, other)

 	w := newWatcher(t, file, tmp)
 	defer w.Close()

 	have := w.WatchList()
 	sort.Strings(have)
 	want := []string{tmp, file}
 	if !reflect.DeepEqual(have, want) {
 		t.Errorf("\nhave: %s\nwant: %s", have, want)
 	}
 }

 func TestOpHas(t *testing.T) {
 	tests := []struct {
 		name string
 		o    Op
 		h    Op
 		want bool
 	}{
 		{
 			name: "single bit match",
 			o:    Remove,
 			h:    Remove,
 			want: true,
 		},
 		{
 			name: "single bit no match",
 			o:    Remove,
 			h:    Create,
 			want: false,
 		},
 		{
 			name: "two bits match",
 			o:    Remove | Create,
 			h:    Create,
 			want: true,
 		},
 		{
 			name: "two bits no match",
 			o:    Remove | Create,
 			h:    Chmod,
 			want: false,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			if got := tt.o.Has(tt.h); got != tt.want {
 				t.Errorf("Has() = %v, want %v", got, tt.want)
 			}
 		})
 	}
 }

 func BenchmarkWatch(b *testing.B) {
 	do := func(b *testing.B, w *Watcher) {
 		tmp := b.TempDir()
 		file := join(tmp, "file")
 		err := w.Add(tmp)
 		if err != nil {
 			b.Fatal(err)
 		}

 		var wg sync.WaitGroup
 		wg.Add(1)
 		go func() {
 			for {
 				select {
 				case err, ok := <-w.Errors:
 					if !ok {
 						wg.Done()
 						return
 					}
 					b.Error(err)
 				case _, ok := <-w.Events:
 					if !ok {
 						wg.Done()
 						return
 					}
 				}
 			}
 		}()

 		b.ResetTimer()
 		for n := 0; n < b.N; n++ {
 			fp, err := os.Create(file)
 			if err != nil {
 				b.Fatal(err)
 			}
 			err = fp.Close()
 			if err != nil {
 				b.Fatal(err)
 			}
 		}
 		err = w.Close()
 		if err != nil {
 			b.Fatal(err)
 		}
 		wg.Wait()
 	}

 	b.Run("default", func(b *testing.B) {
 		w, err := NewWatcher()
 		if err != nil {
 			b.Fatal(err)
 		}
 		do(b, w)
 	})
 	b.Run("buffered=1", func(b *testing.B) {
 		w, err := NewBufferedWatcher(1)
 		if err != nil {
 			b.Fatal(err)
 		}
 		do(b, w)
 	})
 	b.Run("buffered=1024", func(b *testing.B) {
 		w, err := NewBufferedWatcher(1024)
 		if err != nil {
 			b.Fatal(err)
 		}
 		do(b, w)
 	})
 	b.Run("buffered=4096", func(b *testing.B) {
 		w, err := NewBufferedWatcher(4096)
 		if err != nil {
 			b.Fatal(err)
 		}
 		do(b, w)
 	})
 }

 func BenchmarkAddRemove(b *testing.B) {
 	do := func(b *testing.B, w *Watcher) {
 		tmp := b.TempDir()
 		b.ResetTimer()
 		for n := 0; n < b.N; n++ {
 			if err := w.Add(tmp); err != nil {
 				b.Fatal(err)
 			}
 			if err := w.Remove(tmp); err != nil {
 				b.Fatal(err)
 			}
 		}
 	}

 	b.Run("default", func(b *testing.B) {
 		w, err := NewWatcher()
 		if err != nil {
 			b.Fatal(err)
 		}
 		do(b, w)
 	})
 	b.Run("buffered=1", func(b *testing.B) {
 		w, err := NewBufferedWatcher(1)
 		if err != nil {
 			b.Fatal(err)
 		}
 		do(b, w)
 	})
 	b.Run("buffered=1024", func(b *testing.B) {
 		w, err := NewBufferedWatcher(1024)
 		if err != nil {
 			b.Fatal(err)
 		}
 		do(b, w)
 	})
 	b.Run("buffered=4096", func(b *testing.B) {
 		w, err := NewBufferedWatcher(4096)
 		if err != nil {
 			b.Fatal(err)
 		}
 		do(b, w)
 	})
 }
	package fsnotify

	import (
	"errors"
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"reflect"
	"runtime"
	"sort"
	"strings"
	"sync"
	"sync/atomic"
	"syscall"
	"testing"
	"time"

	"github.com/fsnotify/fsnotify/internal"
	)

	// Set soft open file limit to the maximum; on e.g. OpenBSD it's 512/1024.
	//
	// Go 1.19 will always do this when the os package is imported.
	//
	// https://go-review.googlesource.com/c/go/+/393354/
	func init() {
	internal.SetRlimit()
	enableRecurse = true
	}

	func TestScript(t *testing.T) {
	err := filepath.Walk("./testdata", func(path string, info fs.FileInfo, err error) error {
	if err != nil \|\| info.IsDir() {
	return err
	}
	n := strings.Split(filepath.ToSlash(path), "/")
	t.Run(strings.Join(n[1:], "/"), func(t *testing.T) {
	t.Parallel()
	d, err := os.ReadFile(path)
	if err != nil {
	t.Fatal(err)
	}
	parseScript(t, string(d))
	})
	return nil
	})
	if err != nil {
	t.Fatal(err)
	}
	}

	// Multiple writes to a file with the same fd.
	func TestWatchMultipleWrite(t *testing.T) {
	t.Parallel()
	w := newCollector(t)
	w.collect(t)
	tmp := t.TempDir()

	echoAppend(t, "data", tmp, "file")
	addWatch(t, w.w, tmp)
	fp, err := os.OpenFile(join(tmp, "file"), os.O_RDWR, 0)
	if err != nil {
	t.Fatal(err)
	}
	if _, err := fp.Write([]byte("X")); err != nil {
	t.Fatal(err)
	}
	if err := fp.Sync(); err != nil {
	t.Fatal(err)
	}
	eventSeparator()
	if _, err := fp.Write([]byte("Y")); err != nil {
	t.Fatal(err)
	}
	if err := fp.Close(); err != nil {
	t.Fatal(err)
	}

	cmpEvents(t, tmp, w.stop(t), newEvents(t, `
	write /file # write X
	write /file # write Y
	`))
	}

	// Remove watched file with open fd
	func TestWatchRemoveOpenFd(t *testing.T) {
	if runtime.GOOS == "windows" {
	t.Skip("Windows hard-locks open files so this will never work")
	}

	t.Parallel()
	tmp := t.TempDir()
	w := newCollector(t)
	w.collect(t)

	touch(t, tmp, "/file")

	fp, err := os.Open(join(tmp, "/file"))
	if err != nil {
	t.Fatal(err)
	}
	defer fp.Close()

	addWatch(t, w.w, tmp, "/file")
	rm(t, tmp, "/file")

	cmpEvents(t, tmp, w.stop(t), newEvents(t, `
	remove /file

	# inotify will just emit a CHMOD for the unlink, but won't actually
	# emit a REMOVE until the descriptor is closed. Bit odd, but not much
	# we can do about it. The REMOVE is tested in TestInotifyDeleteOpenFile()
	linux:
	chmod /file
	`))
	}

	// Remove watched directory
	func TestWatchRemoveWatchedDir(t *testing.T) {
	if runtime.GOOS == "dragonfly" {
	t.Skip("broken: inconsistent events") // TODO
	}

	t.Parallel()
	tmp := t.TempDir()
	w := newCollector(t)
	w.collect(t)

	touch(t, tmp, "a")
	touch(t, tmp, "b")
	touch(t, tmp, "c")
	touch(t, tmp, "d")
	touch(t, tmp, "e")
	touch(t, tmp, "f")
	touch(t, tmp, "g")
	mkdir(t, tmp, "h")
	mkdir(t, tmp, "h", "a")
	mkdir(t, tmp, "i")
	mkdir(t, tmp, "i", "a")
	mkdir(t, tmp, "j")
	mkdir(t, tmp, "j", "a")
	addWatch(t, w.w, tmp)
	rmAll(t, tmp)

	if runtime.GOOS != "windows" {
	cmpEvents(t, tmp, w.stop(t), newEvents(t, `
	remove /
	remove /a
	remove /b
	remove /c
	remove /d
	remove /e
	remove /f
	remove /g
	remove /h
	remove /i
	remove /j`))
	return
	}

	// ReadDirectoryChangesW gives undefined results: not all files are
	// always present. So test only that 1) we got the directory itself, and
	// 2) we don't get events for unspected files.
	var (
	events = w.stop(t)
	found bool
	)
	for _, e := range events {
	if e.Name == tmp && e.Has(Remove) {
	found = true
	continue
	}
	if filepath.Dir(e.Name) != tmp {
	t.Errorf("unexpected event: %s", e)
	}
	}
	if !found {
	t.Fatalf("didn't see directory in:\n%s", events)
	}
	}

	func TestClose(t *testing.T) {
	chanClosed := func(t testing.T, w Watcher) {
	t.Helper()

	// Need a small sleep as Close() on kqueue does all sorts of things,
	// which may take a little bit.
	switch runtime.GOOS {
	case "freebsd", "openbsd", "netbsd", "dragonfly", "darwin", "solaris", "illumos":
	time.Sleep(50 * time.Millisecond)
	}

	tim := time.NewTimer(50 * time.Millisecond)
	loop:
	for {
	select {
	default:
	t.Fatal("blocking on Events")
	case <-tim.C:
	t.Fatalf("Events not closed")
	case _, ok := <-w.Events:
	if !ok {
	break loop
	}
	}
	}

	select {
	default:
	t.Fatal("blocking on Errors")
	case err, ok := <-w.Errors:
	if ok {
	t.Fatalf("Errors not closed; read:\n\t%s", err)
	}
	}
	}

	t.Run("close", func(t *testing.T) {
	t.Parallel()

	w := newWatcher(t)
	if err := w.Close(); err != nil {
	t.Fatal(err)
	}
	chanClosed(t, w)

	var done int32
	go func() {
	w.Close()
	atomic.StoreInt32(&done, 1)
	}()

	eventSeparator()
	if atomic.LoadInt32(&done) == 0 {
	t.Fatal("double Close() test failed: second Close() call didn't return")
	}

	if err := w.Add(t.TempDir()); err == nil {
	t.Fatal("expected error on Watch() after Close(), got nil")
	}
	})

	// Make sure that Close() works even when the Events channel isn't being
	// read.
	t.Run("events not read", func(t *testing.T) {
	t.Parallel()

	tmp := t.TempDir()
	w := newWatcher(t, tmp)

	touch(t, tmp, "file")
	rm(t, tmp, "file")
	eventSeparator()
	if err := w.Close(); err != nil {
	t.Fatal(err)
	}

	// TODO: windows backend doesn't work well here; can't easily fix it.
	// Need to rewrite things a bit.
	if runtime.GOOS != "windows" {
	chanClosed(t, w)
	}
	})

	// Make sure that calling Close() while REMOVE events are emitted doesn't race.
	t.Run("close while removing files", func(t *testing.T) {
	t.Parallel()
	tmp := t.TempDir()

	files := make([]string, 0, 200)
	for i := 0; i < 200; i++ {
	f := join(tmp, fmt.Sprintf("file-%03d", i))
	touch(t, f, noWait)
	files = append(files, f)
	}

	w := newWatcher(t, tmp)

	startC, stopC, errC := make(chan struct{}), make(chan struct{}), make(chan error)
	go func() {
	for {
	select {
	case <-w.Errors:
	case <-w.Events:
	case <-stopC:
	return
	}
	}
	}()
	rmDone := make(chan struct{})
	go func() {
	<-startC
	for _, f := range files {
	rm(t, f, noWait)
	}
	rmDone <- struct{}{}
	}()
	go func() {
	<-startC
	errC <- w.Close()
	}()
	close(startC)
	defer close(stopC)
	if err := <-errC; err != nil {
	t.Fatal(err)
	}

	<-rmDone
	})

	// Make sure Close() doesn't race when called more than once; hard to write
	// a good reproducible test for this, but running it 150 times seems to
	// reproduce it in ~75% of cases and isn't too slow (~0.06s on my system).
	t.Run("double close", func(t *testing.T) {
	t.Run("default", func(t *testing.T) {
	t.Parallel()

	for i := 0; i < 150; i++ {
	w, err := NewWatcher()
	if err != nil {
	if strings.Contains(err.Error(), "too many") { // syscall.EMFILE
	time.Sleep(100 * time.Millisecond)
	continue
	}
	t.Fatal(err)
	}
	go w.Close()
	go w.Close()
	go w.Close()
	}
	})
	t.Run("buffered=4096", func(t *testing.T) {
	t.Parallel()

	for i := 0; i < 150; i++ {
	w, err := NewBufferedWatcher(4096)
	if err != nil {
	if strings.Contains(err.Error(), "too many") { // syscall.EMFILE
	time.Sleep(100 * time.Millisecond)
	continue
	}
	t.Fatal(err)
	}
	go w.Close()
	go w.Close()
	go w.Close()
	}
	})
	})

	t.Run("closes channels after read", func(t *testing.T) {
	if runtime.GOOS == "netbsd" {
	t.Skip("flaky") // TODO
	}

	t.Parallel()

	tmp := t.TempDir()

	w := newCollector(t, tmp)
	w.collect(t)
	touch(t, tmp, "qwe")
	touch(t, tmp, "asd")

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

	chanClosed(t, w.w)
	})

	t.Run("error after closed", func(t *testing.T) {
	t.Parallel()

	tmp := t.TempDir()
	w := newWatcher(t, tmp)
	if err := w.Close(); err != nil {
	t.Fatal(err)
	}

	file := join(tmp, "file")
	touch(t, file)
	if err := w.Add(file); !errors.Is(err, ErrClosed) {
	t.Fatalf("wrong error for Add: %#v", err)
	}
	if err := w.Remove(file); err != nil {
	t.Fatalf("wrong error for Remove: %#v", err)
	}
	if l := w.WatchList(); l != nil { // Should return an error, but meh :-/
	t.Fatalf("WatchList not nil: %#v", l)
	}
	})
	}

	func TestAdd(t *testing.T) {
	t.Run("doesn't exist", func(t *testing.T) {
	t.Parallel()
	tmp := t.TempDir()

	w := newWatcher(t)
	err := w.Add(join(tmp, "non-existent"))
	if err == nil {
	t.Fatal("err is nil")
	}

	// TODO(v2): errors for this are inconsistent; should be fixed in v2. See #144
	switch runtime.GOOS {
	case "linux":
	if _, ok := err.(syscall.Errno); !ok {
	t.Errorf("wrong error type: %[1]T: %#[1]v", err)
	}
	case "windows":
	if _, ok := err.(*os.SyscallError); !ok {
	t.Errorf("wrong error type: %[1]T: %#[1]v", err)
	}
	default:
	if _, ok := err.(*fs.PathError); !ok {
	t.Errorf("wrong error type: %[1]T: %#[1]v", err)
	}
	}
	})

	t.Run("permission denied", func(t *testing.T) {
	if runtime.GOOS == "windows" {
	t.Skip("chmod doesn't work on Windows") // TODO: see if we can make a file unreadable
	}

	t.Parallel()

	tmp := t.TempDir()
	dir := join(tmp, "dir-unreadable")
	mkdir(t, dir)
	touch(t, dir, "/file")
	chmod(t, 0, dir)

	w := newWatcher(t)
	defer func() {
	w.Close()
	chmod(t, 0o755, dir) // Make TempDir() cleanup work
	}()
	err := w.Add(dir)
	if err == nil {
	t.Fatal("error is nil")
	}
	if !errors.Is(err, internal.UnixEACCES) {
	t.Errorf("not unix.EACCESS: %T %#[1]v", err)
	}
	if !errors.Is(err, internal.SyscallEACCES) {
	t.Errorf("not syscall.EACCESS: %T %#[1]v", err)
	}
	})

	t.Run("add same path twice", func(t *testing.T) {
	tmp := t.TempDir()
	w := newCollector(t)
	if err := w.w.Add(tmp); err != nil {
	t.Fatal(err)
	}
	if err := w.w.Add(tmp); err != nil {
	t.Fatal(err)
	}

	w.collect(t)
	touch(t, tmp, "file")
	rm(t, tmp, "file")

	cmpEvents(t, tmp, w.events(t), newEvents(t, `
	create /file
	remove /file
	`))
	})
	}

	func TestRemove(t *testing.T) {
	t.Run("works", func(t *testing.T) {
	t.Parallel()

	tmp := t.TempDir()
	touch(t, tmp, "file")

	w := newCollector(t)
	w.collect(t)
	addWatch(t, w.w, tmp)
	if err := w.w.Remove(tmp); err != nil {
	t.Fatal(err)
	}

	time.Sleep(200 * time.Millisecond)
	echoAppend(t, "data", tmp, "file")
	chmod(t, 0o700, tmp, "file")

	have := w.stop(t)
	if len(have) > 0 {
	t.Errorf("received events; expected none:\n%s", have)
	}
	})

	t.Run("remove same dir twice", func(t *testing.T) {
	t.Parallel()

	tmp := t.TempDir()

	touch(t, tmp, "file")

	w := newWatcher(t)
	defer w.Close()

	addWatch(t, w, tmp)

	if err := w.Remove(tmp); err != nil {
	t.Fatal(err)
	}
	err := w.Remove(tmp)
	if err == nil {
	t.Fatal("no error")
	}
	if !errors.Is(err, ErrNonExistentWatch) {
	t.Fatalf("wrong error: %T", err)
	}
	})

	// Make sure that concurrent calls to Remove() don't race.
	t.Run("no race", func(t *testing.T) {
	t.Parallel()

	tmp := t.TempDir()
	touch(t, tmp, "file")

	for i := 0; i < 10; i++ {
	w := newWatcher(t)
	defer w.Close()
	addWatch(t, w, tmp)

	done := make(chan struct{})
	go func() {
	defer func() { done <- struct{}{} }()
	w.Remove(tmp)
	}()
	go func() {
	defer func() { done <- struct{}{} }()
	w.Remove(tmp)
	}()
	<-done
	<-done
	w.Close()
	}
	})

	// Make sure file handles are correctly released.
	//
	// regression test for #42 see https://gist.github.com/timshannon/603f92824c5294269797
	t.Run("", func(t *testing.T) {
	w := newWatcher(t)
	defer w.Close()

	// consume the events
	var werr error
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
	defer wg.Done()
	for {
	select {
	case werr = <-w.Errors:
	return
	case <-w.Events:
	}
	}
	}()

	tmp := t.TempDir()
	dir := join(tmp, "child")
	addWatch(t, w, tmp)
	mkdir(t, dir)
	addWatch(t, w, dir) // start watching child
	rmWatch(t, w, dir) // stop watching child
	rmAll(t, dir) // delete child dir

	// Child dir should no longer exist
	_, err := os.Stat(dir)
	if err == nil {
	t.Fatalf("dir %q should no longer exist!", dir)
	}
	if _, ok := err.(*os.PathError); err != nil && !ok {
	t.Errorf("Expected a PathError, got %v", err)
	}

	w.Close()
	wg.Wait()

	if werr != nil {
	t.Fatal(werr)
	}
	})

	t.Run("remove with ... when non-recursive", func(t *testing.T) {
	supportsRecurse(t)
	t.Parallel()

	tmp := t.TempDir()
	w := newWatcher(t)
	addWatch(t, w, tmp)

	if err := w.Remove(join(tmp, "...")); err == nil {
	t.Fatal("err was nil")
	}
	if err := w.Remove(tmp); err != nil {
	t.Fatal(err)
	}
	})
	}

	func TestEventString(t *testing.T) {
	tests := []struct {
	in Event
	want string
	}{
	{Event{}, `[no events] ""`},
	{Event{Name: "/file", Op: 0}, `[no events] "/file"`},

	{Event{Name: "/file", Op: Chmod \| Create},
	`CREATE\|CHMOD "/file"`},
	{Event{Name: "/file", Op: Rename},
	`RENAME "/file"`},
	{Event{Name: "/file", Op: Remove},
	`REMOVE "/file"`},
	{Event{Name: "/file", Op: Write \| Chmod},
	`WRITE\|CHMOD "/file"`},
	}

	for _, tt := range tests {
	t.Run("", func(t *testing.T) {
	have := tt.in.String()
	if have != tt.want {
	t.Errorf("\nhave: %q\nwant: %q", have, tt.want)
	}
	})
	}
	}

	func TestWatchList(t *testing.T) {
	t.Parallel()

	tmp := t.TempDir()
	file := join(tmp, "file")
	other := join(tmp, "other")

	touch(t, file)
	touch(t, other)

	w := newWatcher(t, file, tmp)
	defer w.Close()

	have := w.WatchList()
	sort.Strings(have)
	want := []string{tmp, file}
	if !reflect.DeepEqual(have, want) {
	t.Errorf("\nhave: %s\nwant: %s", have, want)
	}
	}

	func TestOpHas(t *testing.T) {
	tests := []struct {
	name string
	o Op
	h Op
	want bool
	}{
	{
	name: "single bit match",
	o: Remove,
	h: Remove,
	want: true,
	},
	{
	name: "single bit no match",
	o: Remove,
	h: Create,
	want: false,
	},
	{
	name: "two bits match",
	o: Remove \| Create,
	h: Create,
	want: true,
	},
	{
	name: "two bits no match",
	o: Remove \| Create,
	h: Chmod,
	want: false,
	},
	}
	for _, tt := range tests {
	t.Run(tt.name, func(t *testing.T) {
	if got := tt.o.Has(tt.h); got != tt.want {
	t.Errorf("Has() = %v, want %v", got, tt.want)
	}
	})
	}
	}

	func BenchmarkWatch(b *testing.B) {
	do := func(b testing.B, w Watcher) {
	tmp := b.TempDir()
	file := join(tmp, "file")
	err := w.Add(tmp)
	if err != nil {
	b.Fatal(err)
	}

	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
	for {
	select {
	case err, ok := <-w.Errors:
	if !ok {
	wg.Done()
	return
	}
	b.Error(err)
	case _, ok := <-w.Events:
	if !ok {
	wg.Done()
	return
	}
	}
	}
	}()

	b.ResetTimer()
	for n := 0; n < b.N; n++ {
	fp, err := os.Create(file)
	if err != nil {
	b.Fatal(err)
	}
	err = fp.Close()
	if err != nil {
	b.Fatal(err)
	}
	}
	err = w.Close()
	if err != nil {
	b.Fatal(err)
	}
	wg.Wait()
	}

	b.Run("default", func(b *testing.B) {
	w, err := NewWatcher()
	if err != nil {
	b.Fatal(err)
	}
	do(b, w)
	})
	b.Run("buffered=1", func(b *testing.B) {
	w, err := NewBufferedWatcher(1)
	if err != nil {
	b.Fatal(err)
	}
	do(b, w)
	})
	b.Run("buffered=1024", func(b *testing.B) {
	w, err := NewBufferedWatcher(1024)
	if err != nil {
	b.Fatal(err)
	}
	do(b, w)
	})
	b.Run("buffered=4096", func(b *testing.B) {
	w, err := NewBufferedWatcher(4096)
	if err != nil {
	b.Fatal(err)
	}
	do(b, w)
	})
	}

	func BenchmarkAddRemove(b *testing.B) {
	do := func(b testing.B, w Watcher) {
	tmp := b.TempDir()
	b.ResetTimer()
	for n := 0; n < b.N; n++ {
	if err := w.Add(tmp); err != nil {
	b.Fatal(err)
	}
	if err := w.Remove(tmp); err != nil {
	b.Fatal(err)
	}
	}
	}

	b.Run("default", func(b *testing.B) {
	w, err := NewWatcher()
	if err != nil {
	b.Fatal(err)
	}
	do(b, w)
	})
	b.Run("buffered=1", func(b *testing.B) {
	w, err := NewBufferedWatcher(1)
	if err != nil {
	b.Fatal(err)
	}
	do(b, w)
	})
	b.Run("buffered=1024", func(b *testing.B) {
	w, err := NewBufferedWatcher(1024)
	if err != nil {
	b.Fatal(err)
	}
	do(b, w)
	})
	b.Run("buffered=4096", func(b *testing.B) {
	w, err := NewBufferedWatcher(4096)
	if err != nil {
	b.Fatal(err)
	}
	do(b, w)
	})
	}