public void ShouldOnlyRaiseChangedOnceIfSeveralIsPending()
{
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int ChangedRaised = 0;
tested.Changed += (s, e) => ChangedRaised++;
string fileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(fileName))
{
file.WriteLine("somedata");
mockInternal.RaiseChanged(fileName);
mockInternal.RaiseChanged(fileName);
mockInternal.RaiseChanged(fileName);
}
Thread.Sleep(500);
Assert.AreEqual(1, ChangedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void ShouldDelayRaiseRenamedUntilFileIsUnlocked()
{
AutoResetEvent raisedEvent = new AutoResetEvent(false);
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int RenamedRaised = 0;
tested.Renamed += (s, e) =>
{
RenamedRaised++;
raisedEvent.Set();
};
string fileName = Guid.NewGuid().ToString();
string newFileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(newFileName))
{
file.WriteLine("somedata");
mockInternal.RaiseRenamed(fileName, newFileName);
Assert.AreEqual(0, RenamedRaised);
raisedEvent.WaitOne(500);
}
raisedEvent.WaitOne(500);
Assert.AreEqual(1, RenamedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void ShouldRaiseDeletedIfInternalRaisesDeleted()
{
AutoResetEvent raisedEvent = new AutoResetEvent(false);
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int DeletedRaised = 0;
tested.Deleted += (s, e) =>
{
DeletedRaised++;
raisedEvent.Set();
};
string fileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(fileName))
file.WriteLine("somedata");
mockInternal.RaiseDeleted(fileName);
raisedEvent.WaitOne(TimeSpan.FromSeconds(1));
Assert.AreEqual(1, DeletedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void RaiseEventRequiresArgument()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
DoAssert.Throws <ArgumentNullException>(() => tested.RaiseEvent(null));
}
public void ShouldWaitRaisingChangedUntilFileIsUnlocked()
{
AutoResetEvent raisedEvent = new AutoResetEvent(false);
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int ChangedRaised = 0;
tested.Changed += (s, e) =>
{
ChangedRaised++;
raisedEvent.Set();
};
string fileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(fileName))
{
file.WriteLine("somedata");
mockInternal.RaiseChanged(fileName);
raisedEvent.WaitOne(TimeSpan.FromSeconds(1));
Thread.Sleep(500);
Assert.AreEqual(0, ChangedRaised);
}
raisedEvent.WaitOne(TimeSpan.FromSeconds(1));
Assert.AreEqual(1, ChangedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void ConstructorShouldInitLog()
{
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(new Mock <IFileSystemWatcher>().Object))
{
ILogWriter logWriter = tested as ILogWriter;
Assert.IsNotNull(logWriter.Log);
}
}
public void ConstructorShouldInitLog()
{
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(new Mock<IFileSystemWatcher>().Object))
{
ILogWriter logWriter = tested as ILogWriter;
Assert.IsNotNull(logWriter.Log);
}
}
public void RaseEventThrowsArgumentExceptionOnUnknownEvent()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
var evt = new FileSystemEventArgs((WatcherChangeTypes)666, "", "");
DoAssert.Throws<ArgumentException>(() => tested.RaiseEvent(evt));
}
}
public void ShouldUpdatePathOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.Path = "FAKEPATH";
Assert.AreEqual("FAKEPATH", mockWatcher.Path);
}
}
public void RaseEventThrowsArgumentExceptionOnUnknownEvent()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
var evt = new FileSystemEventArgs((WatcherChangeTypes)666, "", "");
DoAssert.Throws <ArgumentException>(() => tested.RaiseEvent(evt));
}
}
public void ShouldUpdateFilterOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.Filter = "FAKEFILTER";
Assert.AreEqual("FAKEFILTER", mockWatcher.Filter);
}
}
public void DisposeShouldRaiseDisposed()
{
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
bool wasDisposed = false;
tested.Disposed += (s, e) => wasDisposed = true;
tested.Dispose();
Assert.IsTrue(wasDisposed);
}
}
public void DisposeShouldDisposeInnerFileSystemWatcher()
{
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
bool wasDisposed = false;
mockInternal.Disposed += (s, e) => wasDisposed = true;
tested.Dispose();
Assert.IsTrue(wasDisposed);
}
}
public void ShouldListenToAllEventsOnInternalWatcher()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
Assert.AreEqual(1, mockWatcher.CreatedListeners().Length);
Assert.AreEqual(1, mockWatcher.ChangedListeners().Length);
Assert.AreEqual(1, mockWatcher.DeletedListeners().Length);
Assert.AreEqual(1, mockWatcher.RenamedListeners().Length);
}
}
public void ShouldUpdateNotifyFilterOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.NotifyFilter = NotifyFilters.DirectoryName;
Assert.AreEqual(NotifyFilters.DirectoryName, mockWatcher.NotifyFilter);
tested.NotifyFilter = NotifyFilters.LastAccess;
Assert.AreEqual(NotifyFilters.LastAccess, mockWatcher.NotifyFilter);
}
}
public void ShouldExposeEnableRaisingEventsFromInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
mockWatcher.EnableRaisingEvents = true;
Assert.AreEqual(true, tested.EnableRaisingEvents);
mockWatcher.EnableRaisingEvents = false;
Assert.AreEqual(false, tested.EnableRaisingEvents);
}
}
public void ShouldUpdateEnableRaisingEventsOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.EnableRaisingEvents = false;
Assert.AreEqual(false, mockWatcher.EnableRaisingEvents);
tested.EnableRaisingEvents = true;
Assert.AreEqual(true, mockWatcher.EnableRaisingEvents);
}
}
public void ShouldUpdateIncludeSubdirectoriesOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.IncludeSubdirectories = false;
Assert.AreEqual(false, mockWatcher.IncludeSubdirectories);
tested.IncludeSubdirectories = true;
Assert.AreEqual(true, mockWatcher.IncludeSubdirectories);
}
}
public void ShouldLogToDebugIfProcessingIsDelayedBecauseOfMissingDeletedEvent()
{
var dir = new System.IO.FileInfo(GetType().Assembly.Location).Directory.FullName;
var fileName = Guid.NewGuid().ToString();
MockLog log;
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(new Mock <IFileSystemWatcher>().Object))
{
log = new MockLog(tested);
tested.QueueEvent(this, new FileSystemEventArgs(WatcherChangeTypes.Created, dir, fileName));
Thread.Sleep(250);
}
Assert.IsTrue(log.Any(x =>
x.Level == MockLog.Level.Debug &&
x.Message.Contains("does not exists, awaiting Deleted event") &&
x.Message.Contains(dir) &&
x.Message.Contains(fileName)));
}
public void ShouldLogQueuedEventsToDebug()
{
var dir = "somedir";
var file = "somefile";
MockLog log;
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(new Mock <IFileSystemWatcher>().Object))
{
log = new MockLog(tested);
tested.QueueEvent(tested, new FileSystemEventArgs(WatcherChangeTypes.Created, dir, file));
}
Assert.IsTrue(
log.Any(x =>
x.Level == MockLog.Level.Debug &&
x.Message.Contains(dir) &&
x.Message.Contains(file) &&
x.Message.Contains(WatcherChangeTypes.Created.ToString())));
}
public void ShouldLogToDebugIfCompactingAwayAllEventsForFile()
{
var dir = "somedir";
var file = "somefile";
MockLog log;
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(new Mock <IFileSystemWatcher>().Object))
{
log = new MockLog(tested);
List <FileSystemEventArgs> events = new List <FileSystemEventArgs>();
events.Add(new FileSystemEventArgs(WatcherChangeTypes.Created, dir, file));
events.Add(new FileSystemEventArgs(WatcherChangeTypes.Deleted, dir, file));
tested.Compact(events);
}
Assert.IsTrue(log.Any(x =>
x.Level == MockLog.Level.Debug &&
x.Message.Contains(dir) &&
x.Message.Contains(file)));
}
public void ShouldNotEmitAnythingIfDeletedWhileStillPendingRaiseCreated()
{
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int CreatedRaised = 0;
int ChangedRaised = 0;
int DeletedRaised = 0;
tested.Created += (s, e) => CreatedRaised++;
tested.Changed += (s, e) => ChangedRaised++;
tested.Deleted += (s, e) => DeletedRaised++;
string fileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(fileName))
{
file.WriteLine("somedata");
mockInternal.RaiseCreated(fileName);
mockInternal.RaiseChanged(fileName);
Thread.Sleep(500);
Assert.AreEqual(0, CreatedRaised);
Assert.AreEqual(0, ChangedRaised);
mockInternal.RaiseDeleted(fileName);
}
Thread.Sleep(500);
Assert.AreEqual(0, CreatedRaised);
Assert.AreEqual(0, ChangedRaised);
Assert.AreEqual(0, DeletedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void ShouldNotRaiseEventsOnNonExistingFileUntilPendingDeleted()
{
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int ChangedRaised = 0;
int DeletedRaised = 0;
tested.Changed += (s, e) => ChangedRaised++;
tested.Deleted += (s, e) => DeletedRaised++;
string fileName = Guid.NewGuid().ToString();
mockInternal.RaiseChanged(fileName);
Thread.Sleep(500);
Assert.AreEqual(0, ChangedRaised);
mockInternal.RaiseDeleted(fileName);
Thread.Sleep(500);
Assert.AreEqual(1, ChangedRaised);
Assert.AreEqual(1, DeletedRaised);
}
}
public void ShouldRaiseDeletedIfInternalRaisesDeleted()
{
AutoResetEvent raisedEvent = new AutoResetEvent(false);
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int DeletedRaised = 0;
tested.Deleted += (s, e) =>
{
DeletedRaised++;
raisedEvent.Set();
};
string fileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(fileName))
file.WriteLine("somedata");
mockInternal.RaiseDeleted(fileName);
raisedEvent.WaitOne(TimeSpan.FromSeconds(1));
Assert.AreEqual(1, DeletedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void ShouldOnlyRaiseChangedOnceIfSeveralIsPending()
{
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int ChangedRaised = 0;
tested.Changed += (s, e) => ChangedRaised++;
string fileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(fileName))
{
file.WriteLine("somedata");
mockInternal.RaiseChanged(fileName);
mockInternal.RaiseChanged(fileName);
mockInternal.RaiseChanged(fileName);
}
Thread.Sleep(500);
Assert.AreEqual(1, ChangedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void ShouldWaitRaisingChangedUntilFileIsUnlocked()
{
AutoResetEvent raisedEvent = new AutoResetEvent(false);
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int ChangedRaised = 0;
tested.Changed += (s, e) =>
{
ChangedRaised++;
raisedEvent.Set();
};
string fileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(fileName))
{
file.WriteLine("somedata");
mockInternal.RaiseChanged(fileName);
raisedEvent.WaitOne(TimeSpan.FromSeconds(1));
Thread.Sleep(500);
Assert.AreEqual(0, ChangedRaised);
}
raisedEvent.WaitOne(TimeSpan.FromSeconds(1));
Assert.AreEqual(1, ChangedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void ShouldUpdateNotifyFilterOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.NotifyFilter = NotifyFilters.DirectoryName;
Assert.AreEqual(NotifyFilters.DirectoryName, mockWatcher.NotifyFilter);
tested.NotifyFilter = NotifyFilters.LastAccess;
Assert.AreEqual(NotifyFilters.LastAccess, mockWatcher.NotifyFilter);
}
}
public void ShouldUpdateFilterOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.Filter = "FAKEFILTER";
Assert.AreEqual("FAKEFILTER", mockWatcher.Filter);
}
}
public void ShouldLogRaisedEventsToDebug()
{
var dir = "somedir";
var file = "somefile";
MockLog log;
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(new Mock<IFileSystemWatcher>().Object))
{
log = new MockLog(tested);
var evt = new FileSystemEventArgs(WatcherChangeTypes.Created, dir, file);
tested.RaiseEvent(evt);
}
Assert.IsTrue(
log.Any(x =>
x.Level == MockLog.Level.Debug &&
x.Message.Contains(dir) &&
x.Message.Contains(file) &&
x.Message.Contains(WatcherChangeTypes.Created.ToString())));
}
public void ShouldListenToAllEventsOnInternalWatcher()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
Assert.AreEqual(1, mockWatcher.CreatedListeners().Length);
Assert.AreEqual(1, mockWatcher.ChangedListeners().Length);
Assert.AreEqual(1, mockWatcher.DeletedListeners().Length);
Assert.AreEqual(1, mockWatcher.RenamedListeners().Length);
}
}
public void ImplementsILogWriter()
{
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(new Mock <IFileSystemWatcher>().Object))
Assert.IsInstanceOfType(tested, typeof(ILogWriter));
}
public void ShouldUpdateEnableRaisingEventsOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.EnableRaisingEvents = false;
Assert.AreEqual(false, mockWatcher.EnableRaisingEvents);
tested.EnableRaisingEvents = true;
Assert.AreEqual(true, mockWatcher.EnableRaisingEvents);
}
}
public void ImplementsILogWriter()
{
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(new Mock<IFileSystemWatcher>().Object))
Assert.IsInstanceOfType(tested, typeof(ILogWriter));
}
public void ShouldLogToDebugIfCompactingAwayAllEventsForFile()
{
var dir = "somedir";
var file = "somefile";
MockLog log;
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(new Mock<IFileSystemWatcher>().Object))
{
log = new MockLog(tested);
List<FileSystemEventArgs> events = new List<FileSystemEventArgs>();
events.Add(new FileSystemEventArgs(WatcherChangeTypes.Created, dir, file));
events.Add(new FileSystemEventArgs(WatcherChangeTypes.Deleted, dir, file));
tested.Compact(events);
}
Assert.IsTrue(log.Any(x =>
x.Level == MockLog.Level.Debug &&
x.Message.Contains(dir) &&
x.Message.Contains(file)));
}
public void ShouldUpdateIncludeSubdirectoriesOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.IncludeSubdirectories = false;
Assert.AreEqual(false, mockWatcher.IncludeSubdirectories);
tested.IncludeSubdirectories = true;
Assert.AreEqual(true, mockWatcher.IncludeSubdirectories);
}
}
public void ShouldLogToDebugIfProcessingIsDelayedBecauseOfMissingDeletedEvent()
{
var dir = new System.IO.FileInfo(GetType().Assembly.Location).Directory.FullName;
var fileName = Guid.NewGuid().ToString();
MockLog log;
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(new Mock<IFileSystemWatcher>().Object))
{
log = new MockLog(tested);
tested.QueueEvent(this, new FileSystemEventArgs(WatcherChangeTypes.Created, dir, fileName));
Thread.Sleep(250);
}
Assert.IsTrue(log.Any(x =>
x.Level == MockLog.Level.Debug &&
x.Message.Contains("does not exists, awaiting Deleted event") &&
x.Message.Contains(dir) &&
x.Message.Contains(fileName)));
}
public void ShouldUpdatePathOnInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
tested.Path = "FAKEPATH";
Assert.AreEqual("FAKEPATH", mockWatcher.Path);
}
}
public void ShouldNotEmitAnythingIfDeletedWhileStillPendingRaiseCreated()
{
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int CreatedRaised = 0;
int ChangedRaised = 0;
int DeletedRaised = 0;
tested.Created += (s, e) => CreatedRaised++;
tested.Changed += (s, e) => ChangedRaised++;
tested.Deleted += (s, e) => DeletedRaised++;
string fileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(fileName))
{
file.WriteLine("somedata");
mockInternal.RaiseCreated(fileName);
mockInternal.RaiseChanged(fileName);
Thread.Sleep(500);
Assert.AreEqual(0, CreatedRaised);
Assert.AreEqual(0, ChangedRaised);
mockInternal.RaiseDeleted(fileName);
}
Thread.Sleep(500);
Assert.AreEqual(0, CreatedRaised);
Assert.AreEqual(0, ChangedRaised);
Assert.AreEqual(0, DeletedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void RaiseEventRequiresArgument()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
DoAssert.Throws<ArgumentNullException>(() => tested.RaiseEvent(null));
}
public void ShouldNotRaiseEventsOnNonExistingFileUntilPendingDeleted()
{
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int ChangedRaised = 0;
int DeletedRaised = 0;
tested.Changed += (s, e) => ChangedRaised++;
tested.Deleted += (s, e) => DeletedRaised++;
string fileName = Guid.NewGuid().ToString();
mockInternal.RaiseChanged(fileName);
Thread.Sleep(500);
Assert.AreEqual(0, ChangedRaised);
mockInternal.RaiseDeleted(fileName);
Thread.Sleep(500);
Assert.AreEqual(1, ChangedRaised);
Assert.AreEqual(1, DeletedRaised);
}
}
public void ShouldDelayRaiseRenamedUntilFileIsUnlocked()
{
AutoResetEvent raisedEvent = new AutoResetEvent(false);
MockFileSystemWatcher mockInternal = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockInternal))
{
int RenamedRaised = 0;
tested.Renamed += (s, e) =>
{
RenamedRaised++;
raisedEvent.Set();
};
string fileName = Guid.NewGuid().ToString();
string newFileName = Guid.NewGuid().ToString();
try
{
using (var file = System.IO.File.CreateText(newFileName))
{
file.WriteLine("somedata");
mockInternal.RaiseRenamed(fileName, newFileName);
Assert.AreEqual(0, RenamedRaised);
raisedEvent.WaitOne(500);
}
raisedEvent.WaitOne(500);
Assert.AreEqual(1, RenamedRaised);
}
finally
{
System.IO.File.Delete(fileName);
}
}
}
public void ShouldExposeEnableRaisingEventsFromInternal()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
mockWatcher.EnableRaisingEvents = true;
Assert.AreEqual(true, tested.EnableRaisingEvents);
mockWatcher.EnableRaisingEvents = false;
Assert.AreEqual(false, tested.EnableRaisingEvents);
}
}
