public static void AsyncMethodBuilderCreate_SetExceptionTest2()
{
// Test captured sync context with exceptional completion
SynchronizationContext previousContext = SynchronizationContext.Current;
var trackedContext = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(trackedContext);
// Completing in opposite order as created
var avmb1 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Should have been one active builder (SetException, opposite order).");
var avmb2 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 2, "RunAsyncMethodBuilderTests > FAILED: Should have been two active builders (SetException, opposite order).");
avmb2.SetException(new InvalidOperationException("uh oh 1"));
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have decremented count (SetException, opposite order).");
avmb1.SetException(new InvalidCastException("uh oh 2"));
Assert.True(trackedContext.TrackedCount == 0, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have returned count to 0 (SetException, opposite order).");
Assert.True(
trackedContext.PostExceptions.Count == 2 &&
trackedContext.PostExceptions[0] is InvalidOperationException &&
trackedContext.PostExceptions[1] is InvalidCastException,
" > FAILED: Expected two exceptions of the right types.");
// Completing in same order as created
var avmb3 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Should have been one active builder (SetException, same order).");
var avmb4 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 2, "RunAsyncMethodBuilderTests > FAILED: Should have been two active builders (SetException, same order).");
avmb3.SetException(new InvalidOperationException("uh oh 3"));
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have decremented count (SetException, same order).");
avmb4.SetException(new InvalidCastException("uh oh 4"));
Assert.True(trackedContext.TrackedCount == 0, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have returned count to 0 (SetException, same order).");
Assert.True(
trackedContext.PostExceptions.Count == 4 &&
trackedContext.PostExceptions[2] is InvalidOperationException &&
trackedContext.PostExceptions[3] is InvalidCastException,
"RunAsyncMethodBuilderTests > FAILED: Expected two more exceptions of the right types.");
SynchronizationContext.SetSynchronizationContext(previousContext);
}
public static void AsyncMethodBuilderCreate_SetExceptionTest2()
{
// Test captured sync context with exceptional completion
SynchronizationContext previousContext = SynchronizationContext.Current;
try
{
var trackedContext = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(trackedContext);
// Completing in opposite order as created
var avmb1 = AsyncVoidMethodBuilder.Create();
Assert.Equal(1, trackedContext.TrackedCount);
var avmb2 = AsyncVoidMethodBuilder.Create();
Assert.Equal(2, trackedContext.TrackedCount);
avmb2.SetException(new InvalidOperationException("uh oh 1"));
Assert.Equal(1, trackedContext.TrackedCount);
avmb1.SetException(new InvalidCastException("uh oh 2"));
Assert.Equal(0, trackedContext.TrackedCount);
Assert.Equal(2, trackedContext.PostExceptions.Count);
Assert.IsType <InvalidOperationException>(trackedContext.PostExceptions[0]);
Assert.IsType <InvalidCastException>(trackedContext.PostExceptions[1]);
// Completing in same order as created
var avmb3 = AsyncVoidMethodBuilder.Create();
Assert.Equal(1, trackedContext.TrackedCount);
var avmb4 = AsyncVoidMethodBuilder.Create();
Assert.Equal(2, trackedContext.TrackedCount);
avmb3.SetException(new InvalidOperationException("uh oh 3"));
Assert.Equal(1, trackedContext.TrackedCount);
avmb4.SetException(new InvalidCastException("uh oh 4"));
Assert.Equal(0, trackedContext.TrackedCount);
Assert.Equal(4, trackedContext.PostExceptions.Count);
Assert.IsType <InvalidOperationException>(trackedContext.PostExceptions[2]);
Assert.IsType <InvalidCastException>(trackedContext.PostExceptions[3]);
}
finally
{
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
public static void TrackedSyncContext_ValidateException()
{
SynchronizationContext previousContext = SynchronizationContext.Current;
try
{
var tosc = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(tosc);
var avmb = AsyncVoidMethodBuilder.Create();
try { throw new InvalidOperationException(); }
catch (Exception exc) { avmb.SetException(exc); }
Assert.NotEmpty(tosc.PostExceptions);
ValidateException(tosc.PostExceptions[0]);
}
finally
{
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
public static void TaskMethodBuilder_DoesNotTouchSyncContext()
{
// Verify that AsyncTaskMethodBuilder is not touching sync context
SynchronizationContext previousContext = SynchronizationContext.Current;
try
{
var trackedContext = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(trackedContext);
var atmb = AsyncTaskMethodBuilder.Create();
Assert.Equal(0, trackedContext.TrackedCount);
atmb.SetResult();
Assert.Equal(0, trackedContext.TrackedCount);
}
finally
{
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
public static void RunAsyncAdditionalBehaviorsTests_NegativeCases()
{
// Test ExceptionDispatchInfo usage
//if (Thread.CurrentThread.CurrentCulture.ThreeLetterWindowsLanguageName == "ENU") // only on ENU because of string comparisons
//{
{
var tcs = new TaskCompletionSource <int>();
try { throw new InvalidOperationException(); }
catch (Exception e) { tcs.SetException(e); }
Assert.True(ValidateFaultedTask(tcs.Task), " > FAILURE. Task's stack trace is incorrect");
}
{
var atmb = AsyncTaskMethodBuilder.Create();
try { throw new InvalidOperationException(); }
catch (Exception e) { atmb.SetException(e); }
Assert.True(ValidateFaultedTask(atmb.Task), " > FAILURE. Task's stack trace is incorrect");
}
{
var atmbtr = AsyncTaskMethodBuilder <object> .Create();
try { throw new InvalidOperationException(); }
catch (Exception e) { atmbtr.SetException(e); }
Assert.True(ValidateFaultedTask(atmbtr.Task), " > FAILURE. Task's stack trace is incorrect");
}
{
SynchronizationContext previousContext = SynchronizationContext.Current;
var tosc = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(tosc);
var avmb = AsyncVoidMethodBuilder.Create();
try { throw new InvalidOperationException(); }
catch (Exception exc) { avmb.SetException(exc); }
Assert.True(
tosc.PostExceptions.Count > 0 && ValidateException(tosc.PostExceptions[0]),
" > FAILURE. AVMB task should have posted exceptions to the sync context");
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
public static void VoidMethodBuilder_TrackedContext()
{
SynchronizationContext previousContext = SynchronizationContext.Current;
try
{
var trackedContext = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(trackedContext);
// TrackedCount should increase as Create() is called, and decrease as SetResult() is called.
// Completing in opposite order as created.
var avmb1 = AsyncVoidMethodBuilder.Create();
Assert.Equal(1, trackedContext.TrackedCount);
var avmb2 = AsyncVoidMethodBuilder.Create();
Assert.Equal(2, trackedContext.TrackedCount);
avmb2.SetResult();
Assert.Equal(1, trackedContext.TrackedCount);
avmb1.SetResult();
Assert.Equal(0, trackedContext.TrackedCount);
// Completing in same order as created
avmb1 = AsyncVoidMethodBuilder.Create();
Assert.Equal(1, trackedContext.TrackedCount);
avmb2 = AsyncVoidMethodBuilder.Create();
Assert.Equal(2, trackedContext.TrackedCount);
avmb1.SetResult();
Assert.Equal(1, trackedContext.TrackedCount);
avmb2.SetResult();
Assert.Equal(0, trackedContext.TrackedCount);
}
finally
{
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
public static void RunAsyncMethodBuilderTests()
{
// AsyncVoidMethodBuilder
{
// Test captured sync context with successful completion (SetResult)
{
SynchronizationContext previousContext = SynchronizationContext.Current;
var trackedContext = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(trackedContext);
// Completing in opposite order as created
var avmb1 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Should have been one active builder (SetResult, opposite order).");
var avmb2 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 2, "RunAsyncMethodBuilderTests > FAILED: Should have been two active builders (SetResult, opposite order).");
avmb2.SetResult();
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have decremented count (SetResult, opposite order).");
avmb1.SetResult();
Assert.True(trackedContext.TrackedCount == 0, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have returned count to 0 (SetResult, opposite order).");
// Completing in same order as created
avmb1 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Should have been one active builder (SetResult, same order).");
avmb2 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 2, "RunAsyncMethodBuilderTests > FAILED: Should have been two active builders (SetResult, same order).");
avmb1.SetResult();
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have decremented count (SetResult, same order).");
avmb2.SetResult();
Assert.True(trackedContext.TrackedCount == 0, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have returned count to 0 (SetResult, same order).");
SynchronizationContext.SetSynchronizationContext(previousContext);
}
// Test not having a sync context with successful completion (SetResult)
{
SynchronizationContext previousContext = SynchronizationContext.Current;
try
{
// Make sure not having a sync context doesn't cause us to blow up
SynchronizationContext.SetSynchronizationContext(null);
var avmb = AsyncVoidMethodBuilder.Create();
avmb.SetResult();
}
catch (Exception)
{
Assert.True(false, string.Format("RunAsyncMethodBuilderTests > FAILURE. Sync context caused us to blow up with Create/SetResult"));
}
finally
{
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
}
// AsyncTaskMethodBuilder
{
// Creating a task builder, building it, completing it successfully
{
var atmb = AsyncTaskMethodBuilder.Create();
var t = atmb.Task;
Assert.True(t.Status == TaskStatus.WaitingForActivation, " > FAILURE. Builder should still be active (ATMB, build then set");
atmb.SetResult();
Assert.True(t.Status == TaskStatus.RanToCompletion, "Task status should equal RanToCompletion");
}
// Verify that AsyncTaskMethodBuilder is not touching sync context
{
SynchronizationContext previousContext = SynchronizationContext.Current;
var trackedContext = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(trackedContext);
var atmb = AsyncTaskMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 0, " > FAILURE. Builder should not interact with the sync context (before ATMB set)");
atmb.SetResult();
Assert.True(trackedContext.TrackedCount == 0, " > FAILURE. Builder should not interact with the sync context (after ATMB set)");
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
// AsyncTaskMethodBuilder<T>
{
// Creating a task builder, building it, completing it successfully
{
var atmb = AsyncTaskMethodBuilder <int> .Create();
var t = atmb.Task;
Assert.True(t.Status == TaskStatus.WaitingForActivation, " > FAILURE. Builder should still be active (ATMBT, build then set)");
atmb.SetResult(43);
Assert.True(t.Status == TaskStatus.RanToCompletion, " > FAILURE. Builder should have successfully completed (ATMBT, build then set)");
Assert.True(t.Result == 43, " > FAILURE. Builder should completed with the set result (ATMBT, build then set)");
}
// Verify that AsyncTaskMethodBuilder<T> is not touching sync context
{
SynchronizationContext previousContext = SynchronizationContext.Current;
var trackedContext = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(trackedContext);
var atmb = AsyncTaskMethodBuilder <string> .Create();
Assert.True(trackedContext.TrackedCount == 0, " > FAILURE. Builder should not interact with the sync context (before ATMBT set)");
atmb.SetResult("async");
Assert.True(trackedContext.TrackedCount == 0, " > FAILURE. Builder should not interact with the sync context (after ATMBT set)");
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
}
public static void RunAsyncAdditionalBehaviorsTests_NegativeCases()
{
// Test ExceptionDispatchInfo usage
//if (Thread.CurrentThread.CurrentCulture.ThreeLetterWindowsLanguageName == "ENU") // only on ENU because of string comparisons
//{
{
var tcs = new TaskCompletionSource<int>();
try { throw new InvalidOperationException(); }
catch (Exception e) { tcs.SetException(e); }
Assert.True(ValidateFaultedTask(tcs.Task), " > FAILURE. Task's stack trace is incorrect");
}
{
var atmb = AsyncTaskMethodBuilder.Create();
try { throw new InvalidOperationException(); }
catch (Exception e) { atmb.SetException(e); }
Assert.True(ValidateFaultedTask(atmb.Task), " > FAILURE. Task's stack trace is incorrect");
}
{
var atmbtr = AsyncTaskMethodBuilder<object>.Create();
try { throw new InvalidOperationException(); }
catch (Exception e) { atmbtr.SetException(e); }
Assert.True(ValidateFaultedTask(atmbtr.Task), " > FAILURE. Task's stack trace is incorrect");
}
{
SynchronizationContext previousContext = SynchronizationContext.Current;
var tosc = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(tosc);
var avmb = AsyncVoidMethodBuilder.Create();
try { throw new InvalidOperationException(); }
catch (Exception exc) { avmb.SetException(exc); }
Assert.True(
tosc.PostExceptions.Count > 0 && ValidateException(tosc.PostExceptions[0]),
" > FAILURE. AVMB task should have posted exceptions to the sync context");
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
public static void AsyncMethodBuilderCreate_SetExceptionTest2()
{
// Test captured sync context with exceptional completion
SynchronizationContext previousContext = SynchronizationContext.Current;
var trackedContext = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(trackedContext);
// Completing in opposite order as created
var avmb1 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Should have been one active builder (SetException, opposite order).");
var avmb2 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 2, "RunAsyncMethodBuilderTests > FAILED: Should have been two active builders (SetException, opposite order).");
avmb2.SetException(new InvalidOperationException("uh oh 1"));
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have decremented count (SetException, opposite order).");
avmb1.SetException(new InvalidCastException("uh oh 2"));
Assert.True(trackedContext.TrackedCount == 0, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have returned count to 0 (SetException, opposite order).");
Assert.True(
trackedContext.PostExceptions.Count == 2 &&
trackedContext.PostExceptions[0] is InvalidOperationException &&
trackedContext.PostExceptions[1] is InvalidCastException,
" > FAILED: Expected two exceptions of the right types.");
// Completing in same order as created
var avmb3 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Should have been one active builder (SetException, same order).");
var avmb4 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 2, "RunAsyncMethodBuilderTests > FAILED: Should have been two active builders (SetException, same order).");
avmb3.SetException(new InvalidOperationException("uh oh 3"));
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have decremented count (SetException, same order).");
avmb4.SetException(new InvalidCastException("uh oh 4"));
Assert.True(trackedContext.TrackedCount == 0, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have returned count to 0 (SetException, same order).");
Assert.True(
trackedContext.PostExceptions.Count == 4 &&
trackedContext.PostExceptions[2] is InvalidOperationException &&
trackedContext.PostExceptions[3] is InvalidCastException,
"RunAsyncMethodBuilderTests > FAILED: Expected two more exceptions of the right types.");
SynchronizationContext.SetSynchronizationContext(previousContext);
}
public static void RunAsyncMethodBuilderTests()
{
// AsyncVoidMethodBuilder
{
// Test captured sync context with successful completion (SetResult)
{
SynchronizationContext previousContext = SynchronizationContext.Current;
var trackedContext = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(trackedContext);
// Completing in opposite order as created
var avmb1 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Should have been one active builder (SetResult, opposite order).");
var avmb2 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 2, "RunAsyncMethodBuilderTests > FAILED: Should have been two active builders (SetResult, opposite order).");
avmb2.SetResult();
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have decremented count (SetResult, opposite order).");
avmb1.SetResult();
Assert.True(trackedContext.TrackedCount == 0, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have returned count to 0 (SetResult, opposite order).");
// Completing in same order as created
avmb1 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Should have been one active builder (SetResult, same order).");
avmb2 = AsyncVoidMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 2, "RunAsyncMethodBuilderTests > FAILED: Should have been two active builders (SetResult, same order).");
avmb1.SetResult();
Assert.True(trackedContext.TrackedCount == 1, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have decremented count (SetResult, same order).");
avmb2.SetResult();
Assert.True(trackedContext.TrackedCount == 0, "RunAsyncMethodBuilderTests > FAILED: Completed builder should have returned count to 0 (SetResult, same order).");
SynchronizationContext.SetSynchronizationContext(previousContext);
}
// Test not having a sync context with successful completion (SetResult)
{
SynchronizationContext previousContext = SynchronizationContext.Current;
try
{
// Make sure not having a sync context doesn't cause us to blow up
SynchronizationContext.SetSynchronizationContext(null);
var avmb = AsyncVoidMethodBuilder.Create();
avmb.SetResult();
}
catch (Exception)
{
Assert.True(false, string.Format("RunAsyncMethodBuilderTests > FAILURE. Sync context caused us to blow up with Create/SetResult"));
}
finally
{
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
}
// AsyncTaskMethodBuilder
{
// Creating a task builder, building it, completing it successfully
{
var atmb = AsyncTaskMethodBuilder.Create();
var t = atmb.Task;
Assert.True(t.Status == TaskStatus.WaitingForActivation, " > FAILURE. Builder should still be active (ATMB, build then set");
atmb.SetResult();
Assert.True(t.Status == TaskStatus.RanToCompletion, "Task status should equal RanToCompletion");
}
// Verify that AsyncTaskMethodBuilder is not touching sync context
{
SynchronizationContext previousContext = SynchronizationContext.Current;
var trackedContext = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(trackedContext);
var atmb = AsyncTaskMethodBuilder.Create();
Assert.True(trackedContext.TrackedCount == 0, " > FAILURE. Builder should not interact with the sync context (before ATMB set)");
atmb.SetResult();
Assert.True(trackedContext.TrackedCount == 0, " > FAILURE. Builder should not interact with the sync context (after ATMB set)");
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
// AsyncTaskMethodBuilder<T>
{
// Creating a task builder, building it, completing it successfully
{
var atmb = AsyncTaskMethodBuilder<int>.Create();
var t = atmb.Task;
Assert.True(t.Status == TaskStatus.WaitingForActivation, " > FAILURE. Builder should still be active (ATMBT, build then set)");
atmb.SetResult(43);
Assert.True(t.Status == TaskStatus.RanToCompletion, " > FAILURE. Builder should have successfully completed (ATMBT, build then set)");
Assert.True(t.Result == 43, " > FAILURE. Builder should completed with the set result (ATMBT, build then set)");
}
// Verify that AsyncTaskMethodBuilder<T> is not touching sync context
{
SynchronizationContext previousContext = SynchronizationContext.Current;
var trackedContext = new TrackOperationsSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(trackedContext);
var atmb = AsyncTaskMethodBuilder<string>.Create();
Assert.True(trackedContext.TrackedCount == 0, " > FAILURE. Builder should not interact with the sync context (before ATMBT set)");
atmb.SetResult("async");
Assert.True(trackedContext.TrackedCount == 0, " > FAILURE. Builder should not interact with the sync context (after ATMBT set)");
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
}
