internal void RealRun() { if (_isPromise) { _promise = new TaskCompletionSource <int>(); } else { _task = new Task(TaskRun, _taskCts.Token); } if (_testAction != TestAction.None) { try { bool executeTask = false; if (_isPromise) { switch (_testAction) { case TestAction.CompletedTask: _promise.SetResult(1); break; case TestAction.FailedTask: _promise.SetException(new StatusTestException()); break; } } else { if (_testAction == TestAction.CancelScheduledTask) { CancelWaitingToRunTaskScheduler scheduler = new CancelWaitingToRunTaskScheduler(); CancellationTokenSource cts = new CancellationTokenSource(); scheduler.Cancellation = cts; // Replace _task with a task that has a cutoms scheduler _task = Task.Factory.StartNew(() => { }, cts.Token, TaskCreationOptions.None, scheduler); try { _task.GetAwaiter().GetResult(); } catch (Exception ex) { if (ex is OperationCanceledException) { Debug.WriteLine("OperationCanceledException Exception was thrown as expected"); } else { Assert.True(false, string.Format("Unexpected exception was thrown: \n{0}", ex.ToString())); } } } else if (_testAction == TestAction.CancelCreatedTask) { _taskCts.Cancel(); } else //When the TestAction is CompletedTask and IsPromise is false, the code will reach this point { executeTask = true; _task.Start(); } } if (_task != null && executeTask) { _mre.Wait(); // // Current Task status is WaitingForChildrenToComplete if Task didn't Cancel/Faulted and Child was created // without Detached options and current status of the child isn't RanToCompletion or Faulted yet // Task.Delay(100).Wait(); if (_createChildTask && _childTask != null && _testAction != TestAction.CancelTask && _testAction != TestAction.CancelTaskAndAcknowledge && _testAction != TestAction.FailedTask && _childCreationOptions == MyTaskCreationOptions.AttachedToParent && _childTask.Status != TaskStatus.RanToCompletion && _childTask.Status != TaskStatus.Faulted) { //we may have reach this point too soon, let's keep spinning until the status changes. while (_task.Status == TaskStatus.Running) { ; } // // If we're still waiting for children our Status should reflect so // if (_task.Status != TaskStatus.WaitingForChildrenToComplete) { Assert.True(false, string.Format("Expecting currrent Task status to be WaitingForChildren but getting {0}", _task.Status.ToString())); } } _task.Wait(); } } catch (AggregateException exp) { if ((_testAction == TestAction.CancelTaskAndAcknowledge || _testAction == TestAction.CancelScheduledTask || _testAction == TestAction.CancelCreatedTask) && exp.Flatten().InnerException.GetType() == typeof(TaskCanceledException)) { Debug.WriteLine("TaskCanceledException Exception was thrown as expected"); } else if ((_testAction == TestAction.FailedTask || _testAction == TestAction.FailedChildTask) && _task.IsFaulted && exp.Flatten().InnerException.GetType() == typeof(StatusTestException)) { Debug.WriteLine("StatusTestException Exception was thrown as expected"); } else { Assert.True(false, string.Format("Unexpected exception was thrown: \n{0}", exp.ToString())); } } try { // // Need to wait for Children task if it was created with Default option (Detached by default), // or current task was either canceled or failed // if (_createChildTask && (_childCreationOptions == MyTaskCreationOptions.None || _testAction == TestAction.CancelTask || _testAction == TestAction.CancelTaskAndAcknowledge || _testAction == TestAction.FailedTask)) { _childTask.Wait(); } } catch (AggregateException exp) { if (((_testAction == TestAction.CancelTask || _testAction == TestAction.CancelTaskAndAcknowledge) && _childCreationOptions == MyTaskCreationOptions.RespectParentCancellation) && exp.Flatten().InnerException.GetType() == typeof(TaskCanceledException)) { Debug.WriteLine("TaskCanceledException Exception was thrown as expected"); } else if (_testAction == TestAction.FailedChildTask && _childTask.IsFaulted && exp.Flatten().InnerException.GetType() == typeof(StatusTestException)) { Debug.WriteLine("StatusTestException Exception was thrown as expected"); } else { Assert.True(false, string.Format("Unexpected exception was thrown: \n{0}", exp.ToString())); } } } // // Verification // if (_finalTaskStatus != null && _finalTaskStatus.Value != _task.Status) { Assert.True(false, string.Format("Expecting Task final Status to be {0}, while getting {1}", _finalTaskStatus.Value, _task.Status)); } if (_finalChildTaskStatus != null && _finalChildTaskStatus.Value != _childTask.Status) { Assert.True(false, string.Format("Expecting Child Task final Status to be {0}, while getting {1}", _finalChildTaskStatus.Value, _childTask.Status)); } if (_finalPromiseStatus != null && _finalPromiseStatus.Value != _promise.Task.Status) { Assert.True(false, string.Format("Expecting Promise Status to be {0}, while getting {1}", _finalPromiseStatus.Value, _promise.Task.Status)); } // // Extra verifications for Cancel Task // if (_task != null && _task.Status == TaskStatus.Canceled && _task.IsCanceled != true) { Assert.True(false, string.Format("Task final Status is Canceled, expecting IsCanceled property to be True as well")); } if (_childTask != null && _childTask.Status == TaskStatus.Canceled && _childTask.IsCanceled != true) { Assert.True(false, string.Format("Child Task final Status is Canceled, expecting IsCanceled property to be True as well")); } // // Extra verification for faulted Promise // if (_isPromise && _testAction == TestAction.FailedTask) { // // If promise with Exception, read the exception so we don't // crash on Finalizer // AggregateException exp = _promise.Task.Exception; if (!_promise.Task.IsFaulted || exp == null) { Assert.True(false, string.Format("No Exception found on promise")); } else if (exp.Flatten().InnerException.GetType() == typeof(StatusTestException)) { Debug.WriteLine("StatusTestException Exception was thrown as expected"); } else { Assert.True(false, string.Format("Exception on promise has mismatched type, expecting StatusTestException, actual: {0}", exp.Flatten().InnerException.GetType())); } } }
internal void RealRun() { if (_isPromise) { _promise = new TaskCompletionSource<int>(); } else { _task = new Task(TaskRun, _taskCts.Token); } if (_testAction != TestAction.None) { try { bool executeTask = false; if (_isPromise) { switch (_testAction) { case TestAction.CompletedTask: _promise.SetResult(1); break; case TestAction.FailedTask: _promise.SetException(new StatusTestException()); break; } } else { if (_testAction == TestAction.CancelScheduledTask) { CancelWaitingToRunTaskScheduler scheduler = new CancelWaitingToRunTaskScheduler(); CancellationTokenSource cts = new CancellationTokenSource(); scheduler.Cancellation = cts; // Replace _task with a task that has a cutoms scheduler _task = Task.Factory.StartNew(() => { }, cts.Token, TaskCreationOptions.None, scheduler); try { _task.GetAwaiter().GetResult(); } catch (Exception ex) { if (ex is OperationCanceledException) Debug.WriteLine("OperationCanceledException Exception was thrown as expected"); else Assert.True(false, string.Format("Unexpected exception was thrown: \n{0}", ex.ToString())); } } else if (_testAction == TestAction.CancelCreatedTask) { _taskCts.Cancel(); } else //When the TestAction is CompletedTask and IsPromise is false, the code will reach this point { executeTask = true; _task.Start(); } } if (_task != null && executeTask) { _mre.Wait(); // // Current Task status is WaitingForChildrenToComplete if Task didn't Cancel/Faulted and Child was created // without Detached options and current status of the child isn't RanToCompletion or Faulted yet // Task.Delay(1).Wait(); if (_createChildTask && _childTask != null && _testAction != TestAction.CancelTask && _testAction != TestAction.CancelTaskAndAcknowledge && _testAction != TestAction.FailedTask && _childCreationOptions == MyTaskCreationOptions.AttachedToParent && _childTask.Status != TaskStatus.RanToCompletion && _childTask.Status != TaskStatus.Faulted) { //we may have reach this point too soon, let's keep spinning until the status changes. while (_task.Status == TaskStatus.Running) ; // // If we're still waiting for children our Status should reflect so // if (_task.Status != TaskStatus.WaitingForChildrenToComplete) { Assert.True(false, string.Format("Expecting currrent Task status to be WaitingForChildren but getting {0}", _task.Status.ToString())); } } _task.Wait(); } } catch (AggregateException exp) { if ((_testAction == TestAction.CancelTaskAndAcknowledge || _testAction == TestAction.CancelScheduledTask || _testAction == TestAction.CancelCreatedTask) && exp.Flatten().InnerException.GetType() == typeof(TaskCanceledException)) { Debug.WriteLine("TaskCanceledException Exception was thrown as expected"); } else if ((_testAction == TestAction.FailedTask || _testAction == TestAction.FailedChildTask) && _task.IsFaulted && exp.Flatten().InnerException.GetType() == typeof(StatusTestException)) { Debug.WriteLine("StatusTestException Exception was thrown as expected"); } else { Assert.True(false, string.Format("Unexpected exception was thrown: \n{0}", exp.ToString())); } } try { // // Need to wait for Children task if it was created with Default option (Detached by default), // or current task was either canceled or failed // if (_createChildTask && (_childCreationOptions == MyTaskCreationOptions.None || _testAction == TestAction.CancelTask || _testAction == TestAction.CancelTaskAndAcknowledge || _testAction == TestAction.FailedTask)) { _childTask.Wait(); } } catch (AggregateException exp) { if (((_testAction == TestAction.CancelTask || _testAction == TestAction.CancelTaskAndAcknowledge) && _childCreationOptions == MyTaskCreationOptions.RespectParentCancellation) && exp.Flatten().InnerException.GetType() == typeof(TaskCanceledException)) { Debug.WriteLine("TaskCanceledException Exception was thrown as expected"); } else if (_testAction == TestAction.FailedChildTask && _childTask.IsFaulted && exp.Flatten().InnerException.GetType() == typeof(StatusTestException)) { Debug.WriteLine("StatusTestException Exception was thrown as expected"); } else { Assert.True(false, string.Format("Unexpected exception was thrown: \n{0}", exp.ToString())); } } } // // Verification // if (_finalTaskStatus != null && _finalTaskStatus.Value != _task.Status) { Assert.True(false, string.Format("Expecting Task final Status to be {0}, while getting {1}", _finalTaskStatus.Value, _task.Status)); } if (_finalChildTaskStatus != null && _finalChildTaskStatus.Value != _childTask.Status) { Assert.True(false, string.Format("Expecting Child Task final Status to be {0}, while getting {1}", _finalChildTaskStatus.Value, _childTask.Status)); } if (_finalPromiseStatus != null && _finalPromiseStatus.Value != _promise.Task.Status) { Assert.True(false, string.Format("Expecting Promise Status to be {0}, while getting {1}", _finalPromiseStatus.Value, _promise.Task.Status)); } // // Extra verifications for Cancel Task // if (_task != null && _task.Status == TaskStatus.Canceled && _task.IsCanceled != true) { Assert.True(false, string.Format("Task final Status is Canceled, expecting IsCanceled property to be True as well")); } if (_childTask != null && _childTask.Status == TaskStatus.Canceled && _childTask.IsCanceled != true) { Assert.True(false, string.Format("Child Task final Status is Canceled, expecting IsCanceled property to be True as well")); } // // Extra verification for faulted Promise // if (_isPromise && _testAction == TestAction.FailedTask) { // // If promise with Exception, read the exception so we don't // crash on Finalizer // AggregateException exp = _promise.Task.Exception; if (!_promise.Task.IsFaulted || exp == null) { Assert.True(false, string.Format("No Exception found on promise")); } else if (exp.Flatten().InnerException.GetType() == typeof(StatusTestException)) { Debug.WriteLine("StatusTestException Exception was thrown as expected"); } else { Assert.True(false, string.Format("Exception on promise has mismatched type, expecting StatusTestException, actual: {0}", exp.Flatten().InnerException.GetType())); } } }