public Importer(IJokeOracle jokeOracle, IJokeImporter jokeImporter, IJokeImportProgressDialogFactory importDialogFactory, IUserInterfaceThreadSynchronizer uiSynchronizer)
{
this.jokeOracle = jokeOracle;
this.jokeImporter = jokeImporter;
this.importDialogFactory = importDialogFactory;
this.uiSynchronizer = uiSynchronizer;
this.asyncWorker = new AsyncWorker(this.ImportJokesWorker);
}
public void ExecuteFailingOperation()
{
AppDomain.CurrentDomain.UnhandledException += this.UnhandledException;
DoWorkEventHandler worker = delegate
{
throw new InvalidOperationException("test");
};
AsyncWorker testee = new AsyncWorker(worker);
testee.RunWorkerAsync();
Assert.IsTrue(this.caughtExceptionSignal.WaitOne(TimeOut), "no exception caught");
AppDomain.CurrentDomain.UnhandledException -= this.UnhandledException;
}
public void ExecuteOperation()
{
AutoResetEvent go = new AutoResetEvent(false);
AutoResetEvent workerExecuted = new AutoResetEvent(false);
DoWorkEventHandler worker = delegate
{
go.WaitOne();
workerExecuted.Set();
};
AsyncWorker testee = new AsyncWorker(worker);
testee.RunWorkerAsync();
go.Set();
Assert.IsTrue(workerExecuted.WaitOne(TimeOut), "worker did not execute.");
}
public void ExecuteOperation()
{
AutoResetEvent go = new AutoResetEvent(false);
AutoResetEvent workerExecuted = new AutoResetEvent(false);
DoWorkEventHandler worker = delegate
{
go.WaitOne();
workerExecuted.Set();
};
AsyncWorker testee = new AsyncWorker(worker);
testee.RunWorkerAsync();
go.Set();
Assert.IsTrue(workerExecuted.WaitOne(TimeOut), "worker did not execute.");
}
public void ExecuteOperationAndPassArguments()
{
AutoResetEvent go = new AutoResetEvent(false);
AutoResetEvent workerExecuted = new AutoResetEvent(false);
const string Argument = "test";
DoWorkEventHandler worker = delegate(object sender, DoWorkEventArgs e)
{
Assert.AreEqual(Argument, e.Argument, "argument is not passed.");
go.WaitOne();
workerExecuted.Set();
};
AsyncWorker testee = new AsyncWorker(worker);
testee.RunWorkerAsync(Argument);
go.Set();
Assert.IsTrue(workerExecuted.WaitOne(TimeOut), "worker did not execute.");
}
public void CancelOperation()
{
AutoResetEvent workerStarted = new AutoResetEvent(false);
AutoResetEvent workerExecuted = new AutoResetEvent(false);
AutoResetEvent workerCancelled = new AutoResetEvent(false);
AutoResetEvent allowTerminating = new AutoResetEvent(false);
DoWorkEventHandler worker = delegate(object sender, DoWorkEventArgs e)
{
AsyncWorker genericWorker = (AsyncWorker)sender;
genericWorker.WorkerSupportsCancellation = true;
workerStarted.Set();
while (!genericWorker.CancellationPending)
{
Thread.Sleep(1);
}
e.Cancel = true;
workerCancelled.Set();
allowTerminating.WaitOne();
};
RunWorkerCompletedEventHandler completed = delegate(object sender, RunWorkerCompletedEventArgs e)
{
Assert.IsTrue(e.Cancelled, "result does not reflect canceled state.");
workerExecuted.Set();
};
AsyncWorker testee = new AsyncWorker(worker, completed);
testee.RunWorkerAsync();
Assert.IsTrue(workerStarted.WaitOne(TimeOut), "worker did not start.");
testee.CancelAsync();
Assert.IsTrue(workerCancelled.WaitOne(TimeOut), "worker did not cancel.");
allowTerminating.Set();
Assert.IsTrue(workerExecuted.WaitOne(TimeOut), "worker did not execute.");
}
public void ExecuteOperationAndPassArguments()
{
AutoResetEvent go = new AutoResetEvent(false);
AutoResetEvent workerExecuted = new AutoResetEvent(false);
const string Argument = "test";
DoWorkEventHandler worker = delegate(object sender, DoWorkEventArgs e)
{
Assert.AreEqual(Argument, e.Argument, "argument is not passed.");
go.WaitOne();
workerExecuted.Set();
};
AsyncWorker testee = new AsyncWorker(worker);
testee.RunWorkerAsync(Argument);
go.Set();
Assert.IsTrue(workerExecuted.WaitOne(TimeOut), "worker did not execute.");
}
public void Progress()
{
AutoResetEvent workerExecuted = new AutoResetEvent(false);
DoWorkEventHandler worker = delegate(object sender, DoWorkEventArgs e)
{
AsyncWorker genericWorker = (AsyncWorker)sender;
genericWorker.WorkerReportsProgress = true;
for (int i = 0; i <= 100; i += 10)
{
genericWorker.ReportProgress(i, null);
}
};
int count = 0;
ProgressChangedEventHandler progress = (sender, e) =>
{
count++;
if (count == 10)
{
workerExecuted.Set();
}
};
AsyncWorker testee = new AsyncWorker(worker, progress, null);
testee.RunWorkerAsync();
Assert.IsTrue(workerExecuted.WaitOne(TimeOut), "worker did not execute.");
}
public void CancelOperation()
{
AutoResetEvent workerStarted = new AutoResetEvent(false);
AutoResetEvent workerExecuted = new AutoResetEvent(false);
AutoResetEvent workerCancelled = new AutoResetEvent(false);
AutoResetEvent allowTerminating = new AutoResetEvent(false);
DoWorkEventHandler worker = delegate(object sender, DoWorkEventArgs e)
{
AsyncWorker genericWorker = (AsyncWorker)sender;
genericWorker.WorkerSupportsCancellation = true;
workerStarted.Set();
while (!genericWorker.CancellationPending)
{
Thread.Sleep(1);
}
e.Cancel = true;
workerCancelled.Set();
allowTerminating.WaitOne();
};
RunWorkerCompletedEventHandler completed = delegate(object sender, RunWorkerCompletedEventArgs e)
{
Assert.IsTrue(e.Cancelled, "result does not reflect canceled state.");
workerExecuted.Set();
};
AsyncWorker testee = new AsyncWorker(worker, completed);
testee.RunWorkerAsync();
Assert.IsTrue(workerStarted.WaitOne(TimeOut), "worker did not start.");
testee.CancelAsync();
Assert.IsTrue(workerCancelled.WaitOne(TimeOut), "worker did not cancel.");
allowTerminating.Set();
Assert.IsTrue(workerExecuted.WaitOne(TimeOut), "worker did not execute.");
}
public void ExecuteFailingOperationWithCompletedHandler()
{
AppDomain.CurrentDomain.UnhandledException += this.UnhandledException;
AutoResetEvent workerExecuted = new AutoResetEvent(false);
DoWorkEventHandler worker = delegate
{
throw new InvalidOperationException("test");
};
RunWorkerCompletedEventHandler completed = delegate(object sender, RunWorkerCompletedEventArgs e)
{
Assert.IsInstanceOf<InvalidOperationException>(e.Error, "wrong exception");
workerExecuted.Set();
};
AsyncWorker testee = new AsyncWorker(worker, completed);
testee.RunWorkerAsync();
Assert.IsTrue(workerExecuted.WaitOne(TimeOut), "worker did not execute.");
Assert.IsNull(this.caughtException, "no exception should be handled globally.");
AppDomain.CurrentDomain.UnhandledException -= this.UnhandledException;
}
public void ExecuteFailingOperation()
{
AppDomain.CurrentDomain.UnhandledException += this.UnhandledException;
DoWorkEventHandler worker = delegate
{
throw new InvalidOperationException("test");
};
AsyncWorker testee = new AsyncWorker(worker);
testee.RunWorkerAsync();
Assert.IsTrue(this.caughtExceptionSignal.WaitOne(TimeOut), "no exception caught");
AppDomain.CurrentDomain.UnhandledException -= this.UnhandledException;
}
public void ExecuteOperationWithCompletedHandler()
{
AutoResetEvent workerExecuted = new AutoResetEvent(false);
const int Result = 3;
DoWorkEventHandler worker = delegate(object sender, DoWorkEventArgs e)
{
e.Result = Result;
};
RunWorkerCompletedEventHandler completed = delegate(object sender, RunWorkerCompletedEventArgs e)
{
Assert.IsNull(e.Error);
Assert.AreEqual(Result, e.Result);
workerExecuted.Set();
};
AsyncWorker testee = new AsyncWorker(worker, completed);
testee.RunWorkerAsync();
Assert.IsTrue(workerExecuted.WaitOne(TimeOut), "worker did not execute.");
}
