public async Task DeleteMonitoredDirectory_StreamsError()
		{
			using (var watcher = new ObservableFileSystemWatcher(c => { c.Path = TempPath; }))
			{
				var firstError = watcher.Errors.FirstAsync().ToTask();
				watcher.Start();

				Directory.Delete(TempPath);

				var error = await firstError;
				Expect(error.GetException().Message, Is.EqualTo("Access is denied"));
			}
		}
		public async Task WriteToFile_StreamsChanged()
		{
			using (var watcher = new ObservableFileSystemWatcher(c => { c.Path = TempPath; }))
			{
				var firstChanged = watcher.Changed.FirstAsync().ToTask();
				watcher.Start();

				File.WriteAllText(Path.Combine(TempPath, "Changed.Txt"), "foo");

				var changed = await firstChanged;
				Expect(changed.ChangeType, Is.EqualTo(WatcherChangeTypes.Changed));
				Expect(changed.Name, Is.EqualTo("Changed.Txt"));
			}
		}
		public async Task DeleteFile_StreamsDeleted()
		{
			using (var watcher = new ObservableFileSystemWatcher(c => { c.Path = TempPath; }))
			{
				var firstDeleted = watcher.Deleted.FirstAsync().ToTask();
				var filePath = Path.Combine(TempPath, "ToDelete.Txt");
				File.WriteAllText(filePath, "foo");
				watcher.Start();

				File.Delete(filePath);

				var deleted = await firstDeleted;
				Expect(deleted.ChangeType, Is.EqualTo(WatcherChangeTypes.Deleted));
				Expect(deleted.Name, Is.EqualTo("ToDelete.Txt"));
			}
		}
        public FileDropWatcher(string path, string filter)
        {
            _Path = path;
            _Filter = filter;
            _Watcher = new ObservableFileSystemWatcher(w =>
            {
                w.Path = path;
                w.Filter = filter;
                // note: filtering on changes can help reduce excessive notifications, make sure to verify any changes with integration tests
                w.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName;
            });

            var renames = _Watcher.Renamed.Select(r => new FileDropped(r));
            var creates = _Watcher.Created.Select(c => new FileDropped(c));
            var changed = _Watcher.Changed.Select(c => new FileDropped(c));

            Dropped = creates
                .Merge(renames)
                .Merge(changed)
                .Merge(_PollResults);
        }
        public FileDropWatcher(string path, string filter)
        {
            _Path    = path;
            _Filter  = filter;
            _Watcher = new ObservableFileSystemWatcher(w =>
            {
                w.Path   = path;
                w.Filter = filter;
                // note: filtering on changes can help reduce excessive notifications, make sure to verify any changes with integration tests
                w.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName;
            });

            var renames = _Watcher.Renamed.Select(r => new FileDropped(r));
            var creates = _Watcher.Created.Select(c => new FileDropped(c));
            var changed = _Watcher.Changed.Select(c => new FileDropped(c));

            Dropped = creates
                      .Merge(renames)
                      .Merge(changed)
                      .Merge(_PollResults);
        }
		public async Task RenameFile_StreamsRenamed()
		{
			using (var watcher = new ObservableFileSystemWatcher(c => { c.Path = TempPath; }))
			{
				var firstRenamed = watcher.Renamed.FirstAsync().ToTask();
				var originalPath = Path.Combine(TempPath, "Changed.Txt");
				File.WriteAllText(originalPath, "foo");
				watcher.Start();

				var renamedPath = Path.Combine(TempPath, "Renamed.Txt");
				File.Move(originalPath, renamedPath);

				var renamed = await firstRenamed;
				Expect(renamed.OldFullPath, Is.EqualTo(originalPath));
				Expect(renamed.FullPath, Is.EqualTo(renamedPath));
			}
		}