public void RegisterTask_AsynchronousCompletion_SwallowsExceptionsThrownByEndDelegate() { // Arrange SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext(); AsyncManager asyncManager = new AsyncManager(syncContext); bool endDelegateWasCalled = false; ManualResetEvent waitHandle = new ManualResetEvent(false /* initialState */); Func<AsyncCallback, IAsyncResult> beginDelegate = callback => { MockAsyncResult asyncResult = new MockAsyncResult(false /* completedSynchronously */); ThreadPool.QueueUserWorkItem(_ => { callback(asyncResult); waitHandle.Set(); }); return asyncResult; }; Action<IAsyncResult> endDelegate = delegate { endDelegateWasCalled = true; throw new Exception("This is a sample exception."); }; // Act asyncManager.RegisterTask(beginDelegate, endDelegate); waitHandle.WaitOne(); // Assert Assert.True(endDelegateWasCalled); Assert.Equal(0, asyncManager.OutstandingOperations.Count); }
public void RegisterTask_ResetsOutstandingOperationCountIfBeginMethodThrows() { // Arrange SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext(); AsyncManager asyncManager = new AsyncManager(syncContext); Func <AsyncCallback, IAsyncResult> beginDelegate = cb => { throw new InvalidOperationException("BeginDelegate throws."); }; Action <IAsyncResult> endDelegate = ar => { Assert.True(false, "This should never be called."); }; // Act & assert Assert.Throws <InvalidOperationException>( delegate { asyncManager.RegisterTask(beginDelegate, endDelegate); }, "BeginDelegate throws." ); Assert.Equal(0, asyncManager.OutstandingOperations.Count); }
public void RegisterTask_SynchronousCompletion() { // Arrange SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext(); AsyncManager asyncManager = new AsyncManager(syncContext); bool endDelegateWasCalled = false; Func <AsyncCallback, IAsyncResult> beginDelegate = callback => { Assert.Equal(1, asyncManager.OutstandingOperations.Count); MockAsyncResult asyncResult = new MockAsyncResult( true /* completedSynchronously */ ); callback(asyncResult); return(asyncResult); }; Action <IAsyncResult> endDelegate = delegate { endDelegateWasCalled = true; }; // Act asyncManager.RegisterTask(beginDelegate, endDelegate); // Assert Assert.True(endDelegateWasCalled); Assert.False(syncContext.SendWasCalled); Assert.Equal(0, asyncManager.OutstandingOperations.Count); }
public void RegisterTask_AsynchronousCompletion() { // Arrange SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext(); AsyncManager asyncManager = new AsyncManager(syncContext); bool endDelegateWasCalled = false; ManualResetEvent waitHandle = new ManualResetEvent(false /* initialState */); Func <AsyncCallback, IAsyncResult> beginDelegate = callback => { Assert.AreEqual(1, asyncManager.OutstandingOperations.Count, "Counter was not incremented properly."); MockAsyncResult asyncResult = new MockAsyncResult(false /* completedSynchronously */); ThreadPool.QueueUserWorkItem(_ => { Assert.AreEqual(1, asyncManager.OutstandingOperations.Count, "Counter shouldn't have been decremented yet."); callback(asyncResult); waitHandle.Set(); }); return(asyncResult); }; Action <IAsyncResult> endDelegate = delegate { endDelegateWasCalled = true; }; // Act asyncManager.RegisterTask(beginDelegate, endDelegate); waitHandle.WaitOne(); // Assert Assert.IsTrue(endDelegateWasCalled); Assert.IsTrue(syncContext.SendWasCalled, "Asynchronous call to End() should have been routed through SynchronizationContext.Send()"); Assert.AreEqual(0, asyncManager.OutstandingOperations.Count, "Counter was not decremented properly."); }
public void RegisterTask_AsynchronousCompletion_SwallowsExceptionsThrownByEndDelegate() { // Arrange SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext(); AsyncManager asyncManager = new AsyncManager(syncContext); bool endDelegateWasCalled = false; using (ManualResetEvent waitHandle = new ManualResetEvent(false /* initialState */)) { Func <AsyncCallback, IAsyncResult> beginDelegate = callback => { MockAsyncResult asyncResult = new MockAsyncResult(false /* completedSynchronously */); ThreadPool.QueueUserWorkItem(_ => { callback(asyncResult); waitHandle.Set(); }); return(asyncResult); }; Action <IAsyncResult> endDelegate = delegate { endDelegateWasCalled = true; throw new Exception("This is a sample exception."); }; // Act asyncManager.RegisterTask(beginDelegate, endDelegate); waitHandle.WaitOne(); // Assert Assert.True(endDelegateWasCalled); Assert.Equal(0, asyncManager.OutstandingOperations.Count); } }
public void RegisterTask_AsynchronousCompletion() { // Arrange SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext(); AsyncManager asyncManager = new AsyncManager(syncContext); bool endDelegateWasCalled = false; ManualResetEvent waitHandle = new ManualResetEvent(false /* initialState */); Func<AsyncCallback, IAsyncResult> beginDelegate = callback => { Assert.AreEqual(1, asyncManager.OutstandingOperations.Count, "Counter was not incremented properly."); MockAsyncResult asyncResult = new MockAsyncResult(false /* completedSynchronously */); ThreadPool.QueueUserWorkItem(_ => { Assert.AreEqual(1, asyncManager.OutstandingOperations.Count, "Counter shouldn't have been decremented yet."); callback(asyncResult); waitHandle.Set(); }); return asyncResult; }; Action<IAsyncResult> endDelegate = delegate { endDelegateWasCalled = true; }; // Act asyncManager.RegisterTask(beginDelegate, endDelegate); waitHandle.WaitOne(); // Assert Assert.IsTrue(endDelegateWasCalled); Assert.IsTrue(syncContext.SendWasCalled, "Asynchronous call to End() should have been routed through SynchronizationContext.Send()"); Assert.AreEqual(0, asyncManager.OutstandingOperations.Count, "Counter was not decremented properly."); }
public static bool TrySetCanceledAsync <T>(this TaskCompletionSource <T> tcs) { #if NET45 return(SimpleSynchronizationContext.Enqueue(() => tcs.TrySetCanceled())); #else return(tcs.TrySetCanceled()); #endif }
public static bool TrySetResultAsync <T>(this TaskCompletionSource <T> tcs, T result) { #if NET45 return(SimpleSynchronizationContext.Enqueue(() => tcs.TrySetResult(result))); #else return(tcs.TrySetResult(result)); #endif }
public static bool TrySetExceptionAsync <T>(this TaskCompletionSource <T> tcs, Exception ex) { #if NET45 return(SimpleSynchronizationContext.Enqueue(() => tcs.TrySetException(ex))); #else return(tcs.TrySetException(ex)); #endif }
public void RegisterTask_ResetsOutstandingOperationCountIfBeginMethodThrows() { // Arrange SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext(); AsyncManager asyncManager = new AsyncManager(syncContext); Func<AsyncCallback, IAsyncResult> beginDelegate = cb => { throw new InvalidOperationException("BeginDelegate throws."); }; Action<IAsyncResult> endDelegate = ar => { Assert.True(false, "This should never be called."); }; // Act & assert Assert.Throws<InvalidOperationException>( delegate { asyncManager.RegisterTask(beginDelegate, endDelegate); }, "BeginDelegate throws."); Assert.Equal(0, asyncManager.OutstandingOperations.Count); }
public void RegisterTask_SynchronousCompletion() { // Arrange SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext(); AsyncManager asyncManager = new AsyncManager(syncContext); bool endDelegateWasCalled = false; Func <AsyncCallback, IAsyncResult> beginDelegate = callback => { Assert.AreEqual(1, asyncManager.OutstandingOperations.Count, "Counter was not incremented properly."); MockAsyncResult asyncResult = new MockAsyncResult(true /* completedSynchronously */); callback(asyncResult); return(asyncResult); }; Action <IAsyncResult> endDelegate = delegate { endDelegateWasCalled = true; }; // Act asyncManager.RegisterTask(beginDelegate, endDelegate); // Assert Assert.IsTrue(endDelegateWasCalled); Assert.IsFalse(syncContext.SendWasCalled, "Synchronous call to End() should not have been routed through SynchronizationContext.Send()"); Assert.AreEqual(0, asyncManager.OutstandingOperations.Count, "Counter was not decremented properly."); }
public static void RunSynchronizationContextTaskSchedulerTests() { // Remember the current SynchronizationContext, so that we can restore it SynchronizationContext previousSC = SynchronizationContext.Current; // Now make up a "real" SynchronizationContext and install it SimpleSynchronizationContext newSC = new SimpleSynchronizationContext(); SetSynchronizationContext(newSC); // Create a scheduler based on the current SC TaskScheduler scTS = TaskScheduler.FromCurrentSynchronizationContext(); // // Launch a Task on scTS, make sure that it is processed in the expected fashion // bool sideEffect = false; Task task = Task.Factory.StartNew(() => { sideEffect = true; }, CancellationToken.None, TaskCreationOptions.None, scTS); Exception ex = null; try { task.Wait(); } catch (Exception e) { ex = e; } Assert.True(task.IsCompleted, "Expected task to have completed"); Assert.True(ex == null, "Did not expect exception on Wait"); Assert.True(sideEffect, "Task appears not to have run"); Assert.True(newSC.PostCount == 1, "Expected exactly one post to underlying SynchronizationContext"); // // Run a Task synchronously on scTS, make sure that it completes // sideEffect = false; Task syncTask = new Task(() => { sideEffect = true; }); ex = null; try { syncTask.RunSynchronously(scTS); } catch (Exception e) { ex = e; } Assert.True(task.IsCompleted, "Expected task to have completed"); Assert.True(ex == null, "Did not expect exception on RunSynchronously"); Assert.True(sideEffect, "Task appears not to have run"); Assert.True(newSC.PostCount == 1, "Did not expect a new Post to underlying SynchronizationContext"); // // Miscellaneous things to test // Assert.True(scTS.MaximumConcurrencyLevel == 1, "Expected scTS.MaximumConcurrencyLevel to be 1"); // restore original SC SetSynchronizationContext(previousSC); }
public void RegisterTask_SynchronousCompletion() { // Arrange SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext(); AsyncManager asyncManager = new AsyncManager(syncContext); bool endDelegateWasCalled = false; Func<AsyncCallback, IAsyncResult> beginDelegate = callback => { Assert.Equal(1, asyncManager.OutstandingOperations.Count); MockAsyncResult asyncResult = new MockAsyncResult(true /* completedSynchronously */); callback(asyncResult); return asyncResult; }; Action<IAsyncResult> endDelegate = delegate { endDelegateWasCalled = true; }; // Act asyncManager.RegisterTask(beginDelegate, endDelegate); // Assert Assert.True(endDelegateWasCalled); Assert.False(syncContext.SendWasCalled); Assert.Equal(0, asyncManager.OutstandingOperations.Count); }
public void RegisterTask_SynchronousCompletion() { // Arrange SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext(); AsyncManager asyncManager = new AsyncManager(syncContext); bool endDelegateWasCalled = false; Func<AsyncCallback, IAsyncResult> beginDelegate = callback => { Assert.AreEqual(1, asyncManager.OutstandingOperations.Count, "Counter was not incremented properly."); MockAsyncResult asyncResult = new MockAsyncResult(true /* completedSynchronously */); callback(asyncResult); return asyncResult; }; Action<IAsyncResult> endDelegate = delegate { endDelegateWasCalled = true; }; // Act asyncManager.RegisterTask(beginDelegate, endDelegate); // Assert Assert.IsTrue(endDelegateWasCalled); Assert.IsFalse(syncContext.SendWasCalled, "Synchronous call to End() should not have been routed through SynchronizationContext.Send()"); Assert.AreEqual(0, asyncManager.OutstandingOperations.Count, "Counter was not decremented properly."); }
public static void RunSynchronizationContextTaskSchedulerTests() { // Remember the current SynchronizationContext, so that we can restore it SynchronizationContext previousSC = SynchronizationContext.Current; // Now make up a "real" SynchronizationContext abd install it SimpleSynchronizationContext newSC = new SimpleSynchronizationContext(); SetSynchronizationContext(newSC); // Create a scheduler based on the current SC TaskScheduler scTS = TaskScheduler.FromCurrentSynchronizationContext(); // // Launch a Task on scTS, make sure that it is processed in the expected fashion // bool sideEffect = false; Task task = Task.Factory.StartNew(() => { sideEffect = true; }, CancellationToken.None, TaskCreationOptions.None, scTS); Exception ex = null; try { task.Wait(); } catch (Exception e) { ex = e; } Assert.True(task.IsCompleted, "Expected task to have completed"); Assert.True(ex == null, "Did not expect exception on Wait"); Assert.True(sideEffect, "Task appears not to have run"); Assert.True(newSC.PostCount == 1, "Expected exactly one post to underlying SynchronizationContext"); // // Run a Task synchronously on scTS, make sure that it completes // sideEffect = false; Task syncTask = new Task(() => { sideEffect = true; }); ex = null; try { syncTask.RunSynchronously(scTS); } catch (Exception e) { ex = e; } Assert.True(task.IsCompleted, "Expected task to have completed"); Assert.True(ex == null, "Did not expect exception on RunSynchronously"); Assert.True(sideEffect, "Task appears not to have run"); Assert.True(newSC.PostCount == 1, "Did not expect a new Post to underlying SynchronizationContext"); // // Miscellaneous things to test // Assert.True(scTS.MaximumConcurrencyLevel == 1, "Expected scTS.MaximumConcurrencyLevel to be 1"); // restore original SC SetSynchronizationContext(previousSC); }