-// Copyright 2010 The Go Authors. All rights reserved.\r
-// Use of this source code is governed by a BSD-style\r
-// license that can be found in the LICENSE file.\r
+// Copyright 2010 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 fsnotify
"time"
)
-// An atomic counter\r
+// An atomic counter
type counter struct {
val int32
}
}
func TestFsnotifyMultipleOperations(t *testing.T) {
- // Create an fsnotify watcher instance and initialize it\r
+ // Create an fsnotify watcher instance and initialize it
watcher, err := NewWatcher()
if err != nil {
t.Fatalf("NewWatcher() failed: %s", err)
}
- // Receive errors on the error channel on a separate goroutine\r
+ // Receive errors on the error channel on a separate goroutine
go func() {
for err := range watcher.Error {
t.Fatalf("error received: %s", err)
const testDir string = "_test"
const testDirToMoveFiles string = "_test2"
- // Create directory to watch\r
+ // Create directory to watch
if err := os.Mkdir(testDir, 0777); err != nil {
t.Fatalf("Failed to create test directory: %s", err)
}
defer os.RemoveAll(testDir)
- // Create directory to that's not watched\r
+ // Create directory to that's not watched
if err := os.Mkdir(testDirToMoveFiles, 0777); err != nil {
t.Fatalf("Failed to create test directory: %s", err)
}
const testFile string = "_test/TestFsnotifySeq.testfile"
const testFileRenamed string = "_test2/TestFsnotifySeqRename.testfile"
- // Add a watch for testDir\r
+ // Add a watch for testDir
err = watcher.Watch(testDir)
if err != nil {
t.Fatalf("Watcher.Watch() failed: %s", err)
}
- // Receive events on the event channel on a separate goroutine\r
+ // Receive events on the event channel on a separate goroutine
eventstream := watcher.Event
var createReceived, modifyReceived, deleteReceived, renameReceived counter
done := make(chan bool)
go func() {
for event := range eventstream {
- // Only count relevant events\r
+ // Only count relevant events
if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) {
t.Logf("event received: %s", event)
if event.IsDelete() {
done <- true
}()
- // Create a file\r
- // This should add at least one event to the fsnotify event queue\r
+ // Create a file
+ // This should add at least one event to the fsnotify event queue
var f *os.File
f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
f.Sync()
f.Close()
- time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete\r
+ time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete
cmd := exec.Command("mv", testFile, testFileRenamed)
err = cmd.Run()
t.Fatalf("rename failed: %s", err)
}
- // Modify the file outside of the watched dir\r
+ // Modify the file outside of the watched dir
f, err = os.Open(testFileRenamed)
if err != nil {
t.Fatalf("open test renamed file failed: %s", err)
f.Sync()
f.Close()
- time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete\r
+ time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete
- // Recreate the file that was moved\r
+ // Recreate the file that was moved
f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
t.Fatalf("creating test file failed: %s", err)
}
f.Close()
- time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete\r
+ time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete
- // We expect this event to be received almost immediately, but let's wait 500 ms to be sure\r
+ // We expect this event to be received almost immediately, but let's wait 500 ms to be sure
time.Sleep(500 * time.Millisecond)
cReceived := createReceived.value()
if cReceived != 2 {
t.Fatalf("incorrect number of rename+delete events received after 500 ms (%d vs %d)", rReceived+dReceived, 1)
}
- // Try closing the fsnotify instance\r
+ // Try closing the fsnotify instance
t.Log("calling Close()")
watcher.Close()
t.Log("waiting for the event channel to become closed...")
}
func TestFsnotifyMultipleCreates(t *testing.T) {
- // Create an fsnotify watcher instance and initialize it\r
+ // Create an fsnotify watcher instance and initialize it
watcher, err := NewWatcher()
if err != nil {
t.Fatalf("NewWatcher() failed: %s", err)
}
- // Receive errors on the error channel on a separate goroutine\r
+ // Receive errors on the error channel on a separate goroutine
go func() {
for err := range watcher.Error {
t.Fatalf("error received: %s", err)
const testDir string = "_test"
- // Create directory to watch\r
+ // Create directory to watch
if err := os.Mkdir(testDir, 0777); err != nil {
t.Fatalf("Failed to create test directory: %s", err)
}
const testFile string = "_test/TestFsnotifySeq.testfile"
- // Add a watch for testDir\r
+ // Add a watch for testDir
err = watcher.Watch(testDir)
if err != nil {
t.Fatalf("Watcher.Watch() failed: %s", err)
}
- // Receive events on the event channel on a separate goroutine\r
+ // Receive events on the event channel on a separate goroutine
eventstream := watcher.Event
var createReceived, modifyReceived, deleteReceived counter
done := make(chan bool)
go func() {
for event := range eventstream {
- // Only count relevant events\r
+ // Only count relevant events
if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) {
t.Logf("event received: %s", event)
if event.IsDelete() {
done <- true
}()
- // Create a file\r
- // This should add at least one event to the fsnotify event queue\r
+ // Create a file
+ // This should add at least one event to the fsnotify event queue
var f *os.File
f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
f.Sync()
f.Close()
- time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete\r
+ time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete
os.Remove(testFile)
- time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete\r
+ time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete
- // Recreate the file\r
+ // Recreate the file
f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
t.Fatalf("creating test file failed: %s", err)
}
f.Close()
- time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete\r
+ time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete
- // Modify\r
+ // Modify
f, err = os.OpenFile(testFile, os.O_WRONLY, 0666)
if err != nil {
t.Fatalf("creating test file failed: %s", err)
f.Sync()
f.Close()
- time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete\r
+ time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete
- // Modify\r
+ // Modify
f, err = os.OpenFile(testFile, os.O_WRONLY, 0666)
if err != nil {
t.Fatalf("creating test file failed: %s", err)
f.Sync()
f.Close()
- time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete\r
+ time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete
- // We expect this event to be received almost immediately, but let's wait 500 ms to be sure\r
+ // We expect this event to be received almost immediately, but let's wait 500 ms to be sure
time.Sleep(500 * time.Millisecond)
cReceived := createReceived.value()
if cReceived != 2 {
t.Fatalf("incorrect number of rename+delete events received after 500 ms (%d vs %d)", dReceived, 1)
}
- // Try closing the fsnotify instance\r
+ // Try closing the fsnotify instance
t.Log("calling Close()")
watcher.Close()
t.Log("waiting for the event channel to become closed...")
}
func TestFsnotifyDirOnly(t *testing.T) {
- // Create an fsnotify watcher instance and initialize it\r
+ // Create an fsnotify watcher instance and initialize it
watcher, err := NewWatcher()
if err != nil {
t.Fatalf("NewWatcher() failed: %s", err)
const testDir string = "_test"
- // Create directory to watch\r
+ // Create directory to watch
if err := os.Mkdir(testDir, 0777); err != nil {
t.Fatalf("Failed to create test directory: %s", err)
}
defer os.RemoveAll(testDir)
- // Create a file before watching directory\r
- // This should NOT add any events to the fsnotify event queue\r
+ // Create a file before watching directory
+ // This should NOT add any events to the fsnotify event queue
const testFileAlreadyExists string = "_test/TestFsnotifyEventsExisting.testfile"
{
var f *os.File
f.Close()
}
- // Add a watch for testDir\r
+ // Add a watch for testDir
err = watcher.Watch(testDir)
if err != nil {
t.Fatalf("Watcher.Watch() failed: %s", err)
}
- // Receive errors on the error channel on a separate goroutine\r
+ // Receive errors on the error channel on a separate goroutine
go func() {
for err := range watcher.Error {
t.Fatalf("error received: %s", err)
const testFile string = "_test/TestFsnotifyDirOnly.testfile"
- // Receive events on the event channel on a separate goroutine\r
+ // Receive events on the event channel on a separate goroutine
eventstream := watcher.Event
var createReceived, modifyReceived, deleteReceived counter
done := make(chan bool)
go func() {
for event := range eventstream {
- // Only count relevant events\r
+ // Only count relevant events
if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) || event.Name == filepath.Clean(testFileAlreadyExists) {
t.Logf("event received: %s", event)
if event.IsDelete() {
done <- true
}()
- // Create a file\r
- // This should add at least one event to the fsnotify event queue\r
+ // Create a file
+ // This should add at least one event to the fsnotify event queue
var f *os.File
f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
f.Sync()
f.Close()
- time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete\r
+ time.Sleep(50 * time.Millisecond) // give system time to sync write change before delete
os.Remove(testFile)
os.Remove(testFileAlreadyExists)
- // We expect this event to be received almost immediately, but let's wait 500 ms to be sure\r
+ // We expect this event to be received almost immediately, but let's wait 500 ms to be sure
time.Sleep(500 * time.Millisecond)
cReceived := createReceived.value()
if cReceived != 1 {
t.Fatalf("incorrect number of delete events received after 500 ms (%d vs %d)", dReceived, 2)
}
- // Try closing the fsnotify instance\r
+ // Try closing the fsnotify instance
t.Log("calling Close()")
watcher.Close()
t.Log("waiting for the event channel to become closed...")
}
func TestFsnotifyDeleteWatchedDir(t *testing.T) {
- // Create an fsnotify watcher instance and initialize it\r
+ // Create an fsnotify watcher instance and initialize it
watcher, err := NewWatcher()
if err != nil {
t.Fatalf("NewWatcher() failed: %s", err)
const testDir string = "_test"
- // Create directory to watch\r
+ // Create directory to watch
if err := os.Mkdir(testDir, 0777); err != nil {
t.Fatalf("Failed to create test directory: %s", err)
}
- // Create a file before watching directory\r
+ // Create a file before watching directory
const testFileAlreadyExists string = "_test/TestFsnotifyEventsExisting.testfile"
{
var f *os.File
f.Close()
}
- // Add a watch for testDir\r
+ // Add a watch for testDir
err = watcher.Watch(testDir)
if err != nil {
t.Fatalf("Watcher.Watch() failed: %s", err)
}
- // Add a watch for testFile\r
+ // Add a watch for testFile
err = watcher.Watch(testFileAlreadyExists)
if err != nil {
t.Fatalf("Watcher.Watch() failed: %s", err)
}
- // Receive errors on the error channel on a separate goroutine\r
+ // Receive errors on the error channel on a separate goroutine
go func() {
for err := range watcher.Error {
t.Fatalf("error received: %s", err)
}
}()
- // Receive events on the event channel on a separate goroutine\r
+ // Receive events on the event channel on a separate goroutine
eventstream := watcher.Event
var deleteReceived counter
go func() {
for event := range eventstream {
- // Only count relevant events\r
+ // Only count relevant events
if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFileAlreadyExists) {
t.Logf("event received: %s", event)
if event.IsDelete() {
os.RemoveAll(testDir)
- // We expect this event to be received almost immediately, but let's wait 500 ms to be sure\r
+ // We expect this event to be received almost immediately, but let's wait 500 ms to be sure
time.Sleep(500 * time.Millisecond)
dReceived := deleteReceived.value()
if dReceived < 2 {
}
func TestFsnotifySubDir(t *testing.T) {
- // Create an fsnotify watcher instance and initialize it\r
+ t.Skip("fails on OS X at least")
+
+ // Create an fsnotify watcher instance and initialize it
watcher, err := NewWatcher()
if err != nil {
t.Fatalf("NewWatcher() failed: %s", err)
const testSubDir string = "_test/sub"
const testSubDirFile string = "_test/sub/TestFsnotifyFile1.testfile"
- // Create directory to watch\r
+ // Create directory to watch
if err := os.Mkdir(testDir, 0777); err != nil {
t.Fatalf("Failed to create test directory: %s", err)
}
defer os.RemoveAll(testDir)
- // Receive errors on the error channel on a separate goroutine\r
+ // Receive errors on the error channel on a separate goroutine
go func() {
for err := range watcher.Error {
t.Fatalf("error received: %s", err)
}
}()
- // Receive events on the event channel on a separate goroutine\r
+ // Receive events on the event channel on a separate goroutine
eventstream := watcher.Event
var createReceived, deleteReceived counter
done := make(chan bool)
go func() {
for event := range eventstream {
- // Only count relevant events\r
+ // Only count relevant events
if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testSubDir) || event.Name == filepath.Clean(testFile1) {
t.Logf("event received: %s", event)
if event.IsCreate() {
done <- true
}()
- // Add a watch for testDir\r
+ // Add a watch for testDir
err = watcher.Watch(testDir)
if err != nil {
t.Fatalf("Watcher.Watch() failed: %s", err)
}
- // Create sub-directory\r
+ // Create sub-directory
if err := os.Mkdir(testSubDir, 0777); err != nil {
t.Fatalf("Failed to create test sub-directory: %s", err)
}
- // Create a file\r
+ // Create a file
var f *os.File
f, err = os.OpenFile(testFile1, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
f.Sync()
f.Close()
- // Create a file (Should not see this! we are not watching subdir)\r
+ // Create a file (Should not see this! we are not watching subdir)
var fs *os.File
fs, err = os.OpenFile(testSubDirFile, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
fs.Sync()
fs.Close()
- // Make sure receive deletes for both file and sub-directory\r
+ // Make sure receive deletes for both file and sub-directory
os.RemoveAll(testSubDir)
os.Remove(testFile1)
- // We expect this event to be received almost immediately, but let's wait 500 ms to be sure\r
+ // We expect this event to be received almost immediately, but let's wait 500 ms to be sure
time.Sleep(500 * time.Millisecond)
cReceived := createReceived.value()
if cReceived != 2 {
t.Fatalf("incorrect number of delete events received after 500 ms (%d vs %d)", dReceived, 2)
}
- // Try closing the fsnotify instance\r
+ // Try closing the fsnotify instance
t.Log("calling Close()")
watcher.Close()
t.Log("waiting for the event channel to become closed...")
}
func TestFsnotifyRename(t *testing.T) {
- // Create an fsnotify watcher instance and initialize it\r
+ // Create an fsnotify watcher instance and initialize it
watcher, err := NewWatcher()
if err != nil {
t.Fatalf("NewWatcher() failed: %s", err)
const testDir string = "_test"
- // Create directory to watch\r
+ // Create directory to watch
if err := os.Mkdir(testDir, 0777); err != nil {
t.Fatalf("Failed to create test directory: %s", err)
}
defer os.RemoveAll(testDir)
- // Add a watch for testDir\r
+ // Add a watch for testDir
err = watcher.Watch(testDir)
if err != nil {
t.Fatalf("Watcher.Watch() failed: %s", err)
}
- // Receive errors on the error channel on a separate goroutine\r
+ // Receive errors on the error channel on a separate goroutine
go func() {
for err := range watcher.Error {
t.Fatalf("error received: %s", err)
const testFile string = "_test/TestFsnotifyEvents.testfile"
const testFileRenamed string = "_test/TestFsnotifyEvents.testfileRenamed"
- // Receive events on the event channel on a separate goroutine\r
+ // Receive events on the event channel on a separate goroutine
eventstream := watcher.Event
var renameReceived counter
done := make(chan bool)
go func() {
for event := range eventstream {
- // Only count relevant events\r
+ // Only count relevant events
if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) || event.Name == filepath.Clean(testFileRenamed) {
if event.IsRename() {
renameReceived.increment()
done <- true
}()
- // Create a file\r
- // This should add at least one event to the fsnotify event queue\r
+ // Create a file
+ // This should add at least one event to the fsnotify event queue
var f *os.File
f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
f.Sync()
f.Close()
- // Add a watch for testFile\r
+ // Add a watch for testFile
err = watcher.Watch(testFile)
if err != nil {
t.Fatalf("Watcher.Watch() failed: %s", err)
t.Fatalf("rename failed: %s", err)
}
- // We expect this event to be received almost immediately, but let's wait 500 ms to be sure\r
+ // We expect this event to be received almost immediately, but let's wait 500 ms to be sure
time.Sleep(500 * time.Millisecond)
if renameReceived.value() == 0 {
t.Fatal("fsnotify rename events have not been received after 500 ms")
}
- // Try closing the fsnotify instance\r
+ // Try closing the fsnotify instance
t.Log("calling Close()")
watcher.Close()
t.Log("waiting for the event channel to become closed...")
}
func TestFsnotifyRenameToCreate(t *testing.T) {
- // Create an fsnotify watcher instance and initialize it\r
+ // Create an fsnotify watcher instance and initialize it
watcher, err := NewWatcher()
if err != nil {
t.Fatalf("NewWatcher() failed: %s", err)
const testDir string = "_test"
const testDirFrom string = "_testfrom"
- // Create directory to watch\r
+ // Create directory to watch
if err := os.Mkdir(testDir, 0777); err != nil {
t.Fatalf("Failed to create test directory: %s", err)
}
defer os.RemoveAll(testDir)
- // Create directory to get file\r
+ // Create directory to get file
if err := os.Mkdir(testDirFrom, 0777); err != nil {
t.Fatalf("Failed to create test directory: %s", err)
}
defer os.RemoveAll(testDirFrom)
- // Add a watch for testDir\r
+ // Add a watch for testDir
err = watcher.Watch(testDir)
if err != nil {
t.Fatalf("Watcher.Watch() failed: %s", err)
}
- // Receive errors on the error channel on a separate goroutine\r
+ // Receive errors on the error channel on a separate goroutine
go func() {
for err := range watcher.Error {
t.Fatalf("error received: %s", err)
const testFile string = "_testfrom/TestFsnotifyEvents.testfile"
const testFileRenamed string = "_test/TestFsnotifyEvents.testfileRenamed"
- // Receive events on the event channel on a separate goroutine\r
+ // Receive events on the event channel on a separate goroutine
eventstream := watcher.Event
var createReceived counter
done := make(chan bool)
go func() {
for event := range eventstream {
- // Only count relevant events\r
+ // Only count relevant events
if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) || event.Name == filepath.Clean(testFileRenamed) {
if event.IsCreate() {
createReceived.increment()
done <- true
}()
- // Create a file\r
- // This should add at least one event to the fsnotify event queue\r
+ // Create a file
+ // This should add at least one event to the fsnotify event queue
var f *os.File
f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
t.Fatalf("rename failed: %s", err)
}
- // We expect this event to be received almost immediately, but let's wait 500 ms to be sure\r
+ // We expect this event to be received almost immediately, but let's wait 500 ms to be sure
time.Sleep(500 * time.Millisecond)
if createReceived.value() == 0 {
t.Fatal("fsnotify create events have not been received after 500 ms")
}
- // Try closing the fsnotify instance\r
+ // Try closing the fsnotify instance
t.Log("calling Close()")
watcher.Close()
t.Log("waiting for the event channel to become closed...")
}
func TestFsnotifyRenameToOverwrite(t *testing.T) {
- // Create an fsnotify watcher instance and initialize it\r
+ // Create an fsnotify watcher instance and initialize it
watcher, err := NewWatcher()
if err != nil {
t.Fatalf("NewWatcher() failed: %s", err)
const testFile string = "_testfrom/TestFsnotifyEvents.testfile"
const testFileRenamed string = "_test/TestFsnotifyEvents.testfileRenamed"
- // Create directory to watch\r
+ // Create directory to watch
if err := os.Mkdir(testDir, 0777); err != nil {
t.Fatalf("Failed to create test directory: %s", err)
}
defer os.RemoveAll(testDir)
- // Create directory to get file\r
+ // Create directory to get file
if err := os.Mkdir(testDirFrom, 0777); err != nil {
t.Fatalf("Failed to create test directory: %s", err)
}
defer os.RemoveAll(testDirFrom)
- // Create a file\r
+ // Create a file
var fr *os.File
fr, err = os.OpenFile(testFileRenamed, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
fr.Sync()
fr.Close()
- // Add a watch for testDir\r
+ // Add a watch for testDir
err = watcher.Watch(testDir)
if err != nil {
t.Fatalf("Watcher.Watch() failed: %s", err)
}
- // Receive errors on the error channel on a separate goroutine\r
+ // Receive errors on the error channel on a separate goroutine
go func() {
for err := range watcher.Error {
t.Fatalf("error received: %s", err)
}
}()
- // Receive events on the event channel on a separate goroutine\r
+ // Receive events on the event channel on a separate goroutine
eventstream := watcher.Event
var eventReceived counter
done := make(chan bool)
go func() {
for event := range eventstream {
- // Only count relevant events\r
+ // Only count relevant events
if event.Name == filepath.Clean(testFileRenamed) {
eventReceived.increment()
t.Logf("event received: %s", event)
done <- true
}()
- // Create a file\r
- // This should add at least one event to the fsnotify event queue\r
+ // Create a file
+ // This should add at least one event to the fsnotify event queue
var f *os.File
f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
t.Fatalf("rename failed: %s", err)
}
- // We expect this event to be received almost immediately, but let's wait 500 ms to be sure\r
+ // We expect this event to be received almost immediately, but let's wait 500 ms to be sure
time.Sleep(500 * time.Millisecond)
if eventReceived.value() == 0 {
t.Fatal("fsnotify events have not been received after 500 ms")
}
- // Try closing the fsnotify instance\r
+ // Try closing the fsnotify instance
t.Log("calling Close()")
watcher.Close()
t.Log("waiting for the event channel to become closed...")
}
func TestFsnotifyAttrib(t *testing.T) {
- // Create an fsnotify watcher instance and initialize it\r
+ // Create an fsnotify watcher instance and initialize it
watcher, err := NewWatcher()
if err != nil {
t.Fatalf("NewWatcher() failed: %s", err)
const testDir string = "_test"
- // Create directory to watch\r
+ // Create directory to watch
if err := os.Mkdir(testDir, 0777); err != nil {
t.Fatalf("Failed to create test directory: %s", err)
}
defer os.RemoveAll(testDir)
- // Receive errors on the error channel on a separate goroutine\r
+ // Receive errors on the error channel on a separate goroutine
go func() {
for err := range watcher.Error {
t.Fatalf("error received: %s", err)
const testFile string = "_test/TestFsnotifyAttrib.testfile"
- // Receive events on the event channel on a separate goroutine\r
+ // Receive events on the event channel on a separate goroutine
eventstream := watcher.Event
var attribReceived counter
done := make(chan bool)
go func() {
for event := range eventstream {
- // Only count relevant events\r
+ // Only count relevant events
if event.Name == filepath.Clean(testDir) || event.Name == filepath.Clean(testFile) {
if event.IsModify() {
attribReceived.increment()
done <- true
}()
- // Create a file\r
- // This should add at least one event to the fsnotify event queue\r
+ // Create a file
+ // This should add at least one event to the fsnotify event queue
var f *os.File
f, err = os.OpenFile(testFile, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
f.Sync()
f.Close()
- // Add a watch for testFile\r
+ // Add a watch for testFile
err = watcher.Watch(testFile)
if err != nil {
t.Fatalf("Watcher.Watch() failed: %s", err)
t.Fatalf("chmod failed: %s", err)
}
- // We expect this event to be received almost immediately, but let's wait 500 ms to be sure\r
+ // We expect this event to be received almost immediately, but let's wait 500 ms to be sure
time.Sleep(500 * time.Millisecond)
if attribReceived.value() == 0 {
t.Fatal("fsnotify attribute events have not received after 500 ms")
}
- // Try closing the fsnotify instance\r
+ // Try closing the fsnotify instance
t.Log("calling Close()")
watcher.Close()
t.Log("waiting for the event channel to become closed...")
atomic.StoreInt32(&done, 1)
}()
- time.Sleep(50e6) // 50 ms\r
+ time.Sleep(50e6) // 50 ms
if atomic.LoadInt32(&done) == 0 {
t.Fatal("double Close() test failed: second Close() call didn't return")
}
projects / fsnotify.git / commitdiff