FIX: FsEventWatcher crashes when dealing with empty path (#718)

Co-authored-by: Yuki Okushi <[email protected]>

Author: riberk

CHANGELOG.md

@@ -3,6 +3,12 @@
 
 - CHANGE: raise MSRV to 1.82 **breaking**
 
+## notify (unreleased)
+- FIX: Fix the bug that `FsEventWatcher` crashes when dealing with empty path [#718]
+
+[#718]: https://github.com/notify-rs/notify/pull/718
+
+
 ## notify 8.2.0 (2025-08-03)
 - FEATURE: notify user if inotify's `max_user_watches` has been reached [#698]
 - FIX: `INotifyWatcher` ignore events with unknown watch descriptors (instead of `EventMask::Q_OVERFLOW`) [#700]

notify/src/fsevent.rs

@@ -353,7 +353,9 @@ impl FsEventWatcher {
             let mut err: cf::CFErrorRef = ptr::null_mut();
             let cf_path = cf::str_path_to_cfstring_ref(str_path, &mut err);
             if cf_path.is_null() {
-                cf::CFRelease(err as cf::CFRef);
+                if !err.is_null() {
+                    cf::CFRelease(err as cf::CFRef);
+                }
                 return Err(Error::watch_not_found().add_path(path.into()));
             }
 
@@ -614,38 +616,74 @@ impl Drop for FsEventWatcher {
     }
 }
 
-#[test]
-fn test_fsevent_watcher_drop() {
+#[cfg(test)]
+mod tests {
+    use crate::ErrorKind;
+
     use super::*;
-    use std::time::Duration;
 
-    let dir = tempfile::tempdir().unwrap();
+    #[test]
+    fn test_fsevent_watcher_drop() {
+        use super::*;
+        use std::time::Duration;
+
+        let dir = tempfile::tempdir().unwrap();
 
-    let (tx, rx) = std::sync::mpsc::channel();
+        let (tx, rx) = std::sync::mpsc::channel();
 
-    {
-        let mut watcher = FsEventWatcher::new(tx, Default::default()).unwrap();
-        watcher.watch(dir.path(), RecursiveMode::Recursive).unwrap();
-        thread::sleep(Duration::from_millis(2000));
-        println!("is running -> {}", watcher.is_running());
+        {
+            let mut watcher = FsEventWatcher::new(tx, Default::default()).unwrap();
+            watcher.watch(dir.path(), RecursiveMode::Recursive).unwrap();
+            thread::sleep(Duration::from_millis(2000));
+            println!("is running -> {}", watcher.is_running());
+
+            thread::sleep(Duration::from_millis(1000));
+            watcher.unwatch(dir.path()).unwrap();
+            println!("is running -> {}", watcher.is_running());
+        }
 
         thread::sleep(Duration::from_millis(1000));
-        watcher.unwatch(dir.path()).unwrap();
-        println!("is running -> {}", watcher.is_running());
-    }
 
-    thread::sleep(Duration::from_millis(1000));
+        for res in rx {
+            let e = res.unwrap();
+            println!("debug => {:?} {:?}", e.kind, e.paths);
+        }
 
-    for res in rx {
-        let e = res.unwrap();
-        println!("debug => {:?} {:?}", e.kind, e.paths);
+        println!("in test: {} works", file!());
     }
 
-    println!("in test: {} works", file!());
-}
+    #[test]
+    fn test_steam_context_info_send_and_sync() {
+        fn check_send<T: Send + Sync>() {}
+        check_send::<StreamContextInfo>();
+    }
 
-#[test]
-fn test_steam_context_info_send_and_sync() {
-    fn check_send<T: Send + Sync>() {}
-    check_send::<StreamContextInfo>();
+    #[test]
+    fn does_not_crash_with_empty_path() {
+        let mut watcher = FsEventWatcher::new(|_| {}, Default::default()).unwrap();
+
+        let watch_result = watcher.watch(Path::new(""), RecursiveMode::Recursive);
+        assert!(
+            matches!(
+                watch_result,
+                Err(Error {
+                    kind: ErrorKind::PathNotFound,
+                    paths: _
+                })
+            ),
+            "actual: {watch_result:#?}"
+        );
+
+        let unwatch_result = watcher.unwatch(Path::new(""));
+        assert!(
+            matches!(
+                unwatch_result,
+                Err(Error {
+                    kind: ErrorKind::WatchNotFound,
+                    paths: _
+                })
+            ),
+            "actual: {unwatch_result:#?}"
+        );
+    }
 }