public void CalculatePiTest()
{
MainViewModel target = new MainViewModel();
MockNotificationVisualizer notifyVisualizer = new MockNotificationVisualizer();
MockMessageVisualizer messageVisualizer = new MockMessageVisualizer {
Response = UICommand.Yes
};
ServiceLocator.Instance.Add(typeof(INotificationVisualizer), notifyVisualizer);
ServiceLocator.Instance.Add(typeof(IMessageVisualizer), messageVisualizer);
SynchronizationContext savedContext = SynchronizationContext.Current;
MockSynchronizationContext mockContext = new MockSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(mockContext);
target.CalculatePi.Execute(null);
Assert.IsTrue(notifyVisualizer.WaitForDispose(TimeSpan.FromSeconds(10), mockContext));
Assert.AreEqual(Math.PI.ToString(), target.PiText);
Assert.IsTrue(notifyVisualizer.LastBeginCall != null);
Assert.IsTrue(notifyVisualizer.LastDisposeCall != null);
Assert.IsTrue(notifyVisualizer.LastDisposeCall > notifyVisualizer.LastBeginCall);
ServiceLocator.Instance.Remove(typeof(INotificationVisualizer));
ServiceLocator.Instance.Remove(typeof(IMessageVisualizer));
SynchronizationContext.SetSynchronizationContext(savedContext);
}
public bool WaitForDispose(TimeSpan waitTime, MockSynchronizationContext context)
{
DateTime start = DateTime.Now;
while (DateTime.Now - start < waitTime)
{
if (_waitEvent.Wait(1))
{
return(true);
}
context.ExecutePostedCallbacks();
}
return(false);
}
public void ResetsPreviousSynchronizationContextWhenTaskCreatorThrows()
{
// Set custom sync-context.
var syncContext = new MockSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(syncContext);
var exHandler = new MockExceptionHandler();
using (var runner = new LocalTaskRunner(exHandler))
{
Assert.Throws <TestException>(() => runner.StartTask(() => throw new TestException()));
}
// Verify that its again active.
Assert.True(SynchronizationContext.Current == syncContext);
}
public void ResetsPreviousSynchronizationContextAfterExecute()
{
// Set custom sync-context.
var syncContext = new MockSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(syncContext);
var exHandler = new MockExceptionHandler();
using (var runner = new LocalTaskRunner(exHandler))
{
runner.Execute();
}
// Verify that its again active.
Assert.True(SynchronizationContext.Current == syncContext);
}
public static IDisposable ExpectSinglePost(Action <Action> testPostedAction)
{
if (testPostedAction is null)
{
throw new ArgumentNullException(nameof(testPostedAction));
}
var context = new MockSynchronizationContext(testPostedAction);
var withTempContext = Utils.WithTemporarySynchronizationContext(context);
return(On.Dispose(() =>
{
withTempContext.Dispose();
if (!context.ReceivedPost)
{
Assert.Fail("Expected a call to SynchronizationContext.Post.");
}
}));
}
public static void DoesNotUseSynchronizationContext(Action action)
{
var context = new MockSynchronizationContext();
SynchronizationContext oldContext = SynchronizationContext.Current;
try
{
SynchronizationContext.SetSynchronizationContext(context);
action();
}
finally
{
SynchronizationContext.SetSynchronizationContext(oldContext);
}
Assert.False(
context.WasCalled,
"Synchronization context was used unexpectedly. Is there a missing .ConfigureAwait(false) somewhere?");
}
public static IDisposable ExpectNoPost()
{
var context = new MockSynchronizationContext(testPostedAction: null);
return(Utils.WithTemporarySynchronizationContext(context));
}
