public void Test2()
{
var th = new TaskHelper<int>();
var t = th.Task;
Assert.IsNotNull(t);
var e =new InvalidProgramException();
th.RunTask(null, e);
Assert.IsTrue(t.IsFaulted);
Assert.AreEqual(t.Exception.InnerException, e);
}
public void AreEqual(Mock<ISciencePublisher> publisher, Mock<IExperimentSteps<string, string>> steps,
Mock<IExperimentState> state, string name, string ctrlResult, string candResult,
string candName, InvalidProgramException excp, string errMsg)
{
//Setup
AreEqualDelegate<string> areEqual = (ctrl, cand) =>
{
throw excp;
};
bool excpPassed = false;
Action<ErrorEventArgs> onError = (e) =>
{
excpPassed = e.ExperimentError.LastException == excp
&& e.ExperimentError.LastStep == Operations.AreEqual;
e.Publisher.Publish(errMsg, e.State);
};
steps.DefaultValue = DefaultValue.Empty;
steps.SetupAllProperties();
steps.SetupGet(x => x.AreEqual).Returns(areEqual);
steps.Setup(x => x.OnError(It.IsAny<ErrorEventArgs>()))
.Callback(onError);
SetupControlAndCandidate(steps, ctrlResult, candResult, candName);
state.SetupAllProperties();
SetupStateSnapshot(state);
//Exercise
var sut = new Experiment<string, string>(name, publisher.Object, state.Object, steps.Object, true);
var result = sut.Run(); //no exception
//Verify
steps.Verify(x => x.AreEqual, Times.AtLeastOnce);
steps.Verify(x => x.OnError(It.Is<ErrorEventArgs>(
a => a.State.CurrentStep == Operations.OnError && a.ExperimentError.LastException == excp
&& a.ExperimentError.LastStep == Operations.AreEqual)), Times.AtLeastOnce);
//Results correct
publisher.Verify(x => x.Publish(It.Is<IExperimentResult<string>>(
r => !r.Control.ExceptionThrown && r.Control.Value == ctrlResult
&& r.Candidates.All(kvp => kvp.Value.ExceptionThrown
&& kvp.Value.ExperimentError.LastException == excp
&& kvp.Value.ExperimentError.LastStep == Operations.AreEqual))), Times.Once);
//Message published
publisher.Verify(x => x.Publish(errMsg,
It.Is<IExperimentState>(y => y.CurrentStep == Operations.OnError)), Times.AtLeastOnce);
Assert.True(excpPassed);
}
public void Should_execute_all_cleanup_steps_despite_async_exceptions_in_run_and_cleanup_and_complete_with_all_exceptions()
{
CleanupGuard guard = new CleanupGuard();
List<int> steps = new List<int>();
Func<int, Task, Task> doStepAsync = delegate(int i, Task t)
{
steps.Add(i);
return t;
};
TaskCompletionSource<bool> cleanupTcs = new TaskCompletionSource<bool>();
guard.Register(() => doStepAsync(1, Task.FromResult(false)));
guard.Register(() => doStepAsync(2, cleanupTcs.Task));
TaskCompletionSource<bool> runTcs = new TaskCompletionSource<bool>();
Task task = guard.RunAsync(g => runTcs.Task);
Assert.False(task.IsCompleted);
InvalidProgramException expectedRunException = new InvalidProgramException("Expected (run).");
runTcs.SetException(expectedRunException);
InvalidTimeZoneException expectedCleanupException = new InvalidTimeZoneException("Expected (cleanup).");
cleanupTcs.SetException(expectedCleanupException);
Assert.Equal(TaskStatus.Faulted, task.Status);
Assert.NotNull(task.Exception);
AggregateException ae = Assert.IsType<AggregateException>(task.Exception).Flatten();
Assert.Equal(2, ae.InnerExceptions.Count);
Assert.Same(expectedRunException, ae.InnerExceptions[0]);
Assert.Same(expectedCleanupException, ae.InnerExceptions[1]);
Assert.Equal(new int[] { 2, 1 }, steps.ToArray());
}
public void First_exception_fails_operation_without_executing_remaining_calls_for_that_loop()
{
Queue<TaskCompletionSource<bool>> pending = new Queue<TaskCompletionSource<bool>>();
Func<Task> doAsync = delegate
{
TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();
pending.Enqueue(tcs);
return tcs.Task;
};
ParallelOperationManager manager = new ParallelOperationManager(2, doAsync);
Task task = manager.RunAsync(4);
Assert.False(task.IsCompleted);
Assert.Equal(2, pending.Count);
TaskCompletionSource<bool> current = pending.Dequeue();
InvalidProgramException exception = new InvalidProgramException("expected");
current.SetException(exception);
Assert.False(task.IsCompleted);
Assert.Equal(1, pending.Count);
current = pending.Dequeue();
current.SetResult(false);
Assert.False(task.IsCompleted);
Assert.Equal(1, pending.Count);
current = pending.Dequeue();
current.SetResult(false);
Assert.True(task.IsCompleted);
Assert.True(task.IsFaulted);
Assert.NotNull(task.Exception);
AggregateException ae = Assert.IsType<AggregateException>(task.Exception).Flatten();
Assert.Equal(1, ae.InnerExceptions.Count);
Assert.Same(exception, ae.InnerExceptions[0]);
}
private void DispatchAsync(PipeInvocation invocation, MessageDispatch dispatch)
{
var invocationTask = invocation.RunAsync();
invocationTask.ContinueWith(task => dispatch.SetHandled(invocation.Invoker, GetException(task)), TaskContinuationOptions.ExecuteSynchronously);
if (invocationTask.Status != TaskStatus.Created)
return;
if (invocation.Invoker.ShouldCreateStartedTasks)
{
var exception = new InvalidProgramException(string.Format("{0}.Handle({1}) did not start the returned task", invocation.Invoker.MessageHandlerType.Name, invocation.Invoker.MessageType.Name));
dispatch.SetHandled(invocation.Invoker, exception);
return;
}
var taskScheduler = GetTaskScheduler(invocation.Invoker.DispatchQueueName);
invocationTask.Start(taskScheduler);
}
void OnError(string msg, int retval)
{
Console.WriteLine();
Console.WriteLine("Fatal error: {0}", msg);
Console.WriteLine("PC = {0:X8} ", (PC - 1) * 4);
Console.Write("R[0] = {0:X8} ", R[0]);
Console.Write("R[1] = {0:X8} ", R[1]);
Console.Write("R[2] = {0:X8} ", R[2]);
Console.WriteLine("R[3] = {0:X8}", R[3]);
Console.Write("MT = {0:X8} ", R[12]);
Console.Write("SB = {0:X8} ", R[13]);
Console.Write("SP = {0:X8} ", R[14]);
Console.WriteLine("LNK = {0:X8} ", R[15]);
Exception e = new InvalidProgramException(msg);
e.Data[0] = retval;
throw e;
}
public void Candidate(Mock<ISciencePublisher> publisher,
Mock<IExperimentSteps<string, string>> steps, Mock<IExperimentState> state,
string name, string ctrlResult, string candResult, string candName, InvalidProgramException excp,
string errMsg)
{
//Setup
steps.DefaultValue = DefaultValue.Empty;
steps.SetupAllProperties();
bool excpPassed = false;
Action<ErrorEventArgs> onError = (e) =>
{
excpPassed = e.ExperimentError.LastException == excp
&& e.ExperimentError.LastStep == Operations.Candidate;
e.Publisher.Publish(errMsg, e.State);
};
Func<string> candidate = () =>
{
throw excp;
};
SetupControlAndCandidate(steps, ctrlResult, candResult, candName);
steps.Setup(x => x.GetCandidates())
.Returns(new Dictionary<string, Func<string>> { { candName, candidate } });
steps.Setup(x => x.OnError(It.IsAny<ErrorEventArgs>()))
.Callback(onError);
state.SetupAllProperties();
SetupStateSnapshot(state);
//Exercise
var sut = new Experiment<string, string>(name, publisher.Object, state.Object, steps.Object, true);
var result = sut.Run(); //No exceptions should be thrown
//Verify
steps.Verify(x => x.GetCandidates(), Times.AtLeastOnce);
steps.Verify(x => x.OnError(It.Is<ErrorEventArgs>(
a => a.State.CurrentStep == Operations.OnError && a.ExperimentError.LastException == excp
&& a.ExperimentError.LastStep == Operations.Candidate)), Times.AtLeastOnce);
//Results published
publisher.Verify(x => x.Publish(It.Is<IExperimentResult<string>>(
r => r.Candidates.All(kvp => kvp.Key.Equals(candName) && kvp.Value.ExceptionThrown
&& kvp.Value.Name.Equals(candName) && kvp.Value.IsMismatched
&& kvp.Value.ExperimentError.LastException == excp
&& kvp.Value.ExperimentError.LastStep == Operations.Candidate))), Times.Once);
publisher.Verify(x => x.Publish(errMsg,
It.Is<IExperimentState>(y => y.CurrentStep == Operations.OnError)), Times.AtLeastOnce);
Assert.True(excpPassed);
}
public void Control_Exception_Thrown(Mock<ISciencePublisher> publisher,
Mock<IExperimentSteps<string, string>> steps, Mock<IExperimentState> state,
string name, string ctrlResult, string candResult, string candName, InvalidProgramException excp)
{
//Setup
steps.DefaultValue = DefaultValue.Empty;
steps.SetupAllProperties();
Func<string> control = () => { throw excp; };
SetupControlAndCandidate(steps, ctrlResult, candResult, candName);
steps.Setup(x => x.Control)
.Returns(control);
state.SetupAllProperties();
SetupStateSnapshot(state);
//Exercise
var sut = new Experiment<string, string>(name, publisher.Object, state.Object, steps.Object, true);
var thrown = Assert.Throws<InvalidProgramException>(() => sut.Run()); //Exceptions should be thrown
//Verify
steps.Verify(x => x.Control, Times.AtLeastOnce);
steps.Verify(x => x.GetCandidates(), Times.AtLeastOnce); //GetCandidates STILL called
steps.Verify(x => x.OnMismatch(It.Is<MismatchEventArgs<string>>(
r => r.Candidate == candResult && r.ControlException == excp)),
Times.AtLeastOnce);
steps.Verify(x => x.OnError(It.Is<ErrorEventArgs>(a => a.State.CurrentStep == Operations.OnError)),
Times.AtLeastOnce);
//Results published
publisher.Verify(x => x.Publish(It.Is<IExperimentResult<string>>(
r => r.Control.ExceptionThrown && r.Control.ExperimentError.LastException == excp
&& r.Control.ExperimentError.LastStep == Operations.Control
&& r.Candidates.All(kvp => kvp.Value.IsMismatched))),
Times.Once);
Assert.Equal(thrown, excp);
}
public void Control_And_Candidate_Throw_Same_Exception(Mock<ISciencePublisher> publisher,
Mock<IExperimentSteps<string, string>> steps, Mock<IExperimentState> state,
string name, string candName, InvalidProgramException excp)
{
//Setup
steps.DefaultValue = DefaultValue.Empty;
steps.SetupAllProperties();
Func<string> function = () => { throw excp; };
steps.SetupGet(x => x.Control)
.Returns(function);
steps.Setup(x => x.GetCandidates())
.Returns(new Dictionary<string, Func<string>> { { candName, function } });
state.SetupAllProperties();
SetupStateSnapshot(state);
//Exercise
var sut = new Experiment<string, string>(name, publisher.Object, state.Object, steps.Object, true);
var thrown = Assert.Throws<InvalidProgramException>(() => sut.Run()); //Exceptions should be thrown
//Verify
steps.Verify(x => x.Control, Times.AtLeastOnce);
steps.Verify(x => x.GetCandidates(), Times.AtLeastOnce); //GetCandidates STILL called
steps.Verify(x => x.OnMismatch(It.IsAny<MismatchEventArgs<string>>()),
Times.Never); //Same exception, they're not mismatched
steps.Verify(x => x.OnError(It.Is<ErrorEventArgs>(a => a.State.CurrentStep == Operations.OnError)),
Times.AtLeastOnce);
//Results published
publisher.Verify(x => x.Publish(It.Is<IExperimentResult<string>>(
r => r.Control.ExceptionThrown && r.Control.ExperimentError.LastException == excp
&& r.Control.ExperimentError.LastStep == Operations.Control
&& r.Candidates.All(kvp => !kvp.Value.IsMismatched && kvp.Value.ExceptionThrown
&& kvp.Value.ExperimentError.LastException == excp
&& kvp.Value.ExperimentError.LastStep == Operations.Candidate))),
Times.Once);
Assert.Equal(thrown, excp);
}
public void Candidate_Exception_Thrown(Mock<ISciencePublisher> publisher,
Mock<IExperimentSteps<string, string>> steps, Mock<IExperimentState> state,
string name, string ctrlResult, string candResult, string candName, InvalidProgramException excp)
{
//Setup
steps.DefaultValue = DefaultValue.Empty;
steps.SetupAllProperties();
Func<string> candidate = () =>
{
throw excp;
};
SetupControlAndCandidate(steps, ctrlResult, candResult, candName);
steps.Setup(x => x.GetCandidates())
.Returns(new Dictionary<string, Func<string>> { { candName, candidate } });
state.SetupAllProperties();
SetupStateSnapshot(state);
//Exercise
var sut = new Experiment<string, string>(name, publisher.Object, state.Object, steps.Object, true);
var result = sut.Run(); //No exceptions should be thrown
//Verify
steps.Verify(x => x.GetCandidates(), Times.AtLeastOnce); //Setup called
steps.Verify(x => x.OnMismatch(It.Is<MismatchEventArgs<string>>(
a => a.CandidateException == excp && a.Control == ctrlResult)), Times.AtLeastOnce);
steps.Verify(x => x.OnError(It.Is<ErrorEventArgs>(r => r.ExperimentError.LastException == excp
&& r.State.CurrentStep == Operations.OnError
&& r.ExperimentError.LastStep == Operations.Candidate)),
Times.AtLeastOnce);
//Results published
publisher.Verify(x => x.Publish(It.Is<IExperimentResult<string>>(
r => r.Candidates.All(kvp => kvp.Key.Equals(candName) && kvp.Value.ExceptionThrown
&& kvp.Value.Name.Equals(candName) && kvp.Value.IsMismatched
&& kvp.Value.ExperimentError.LastException == excp
&& kvp.Value.ExperimentError.LastStep == Operations.Candidate))), Times.Once);
}
public void OnMismatch_ThrowInternalExceptions_True(Mock<ISciencePublisher> publisher,
Mock<IExperimentSteps<string, string>> steps, Mock<IExperimentState> state, string name,
string ctrlResult, string candResult, string candName, InvalidProgramException excp, string errMsg)
{
//Setup
Action<MismatchEventArgs<string>> onMismatch = (e) =>
{
throw excp;
};
bool excpPassed = false;
Action<ErrorEventArgs> onError = (e) =>
{
excpPassed = e.ExperimentError.LastException == excp
&& e.ExperimentError.LastStep == Operations.OnMismatch;
e.Publisher.Publish(errMsg, e.State);
};
steps.DefaultValue = DefaultValue.Empty;
steps.SetupAllProperties();
steps.SetupGet(x => x.AreEqual).Returns((x, y) => false); //Make sure to cause a mismatch
steps.Setup(x => x.OnMismatch(It.IsAny<MismatchEventArgs<string>>())).Callback(onMismatch);
steps.Setup(x => x.OnError(It.IsAny<ErrorEventArgs>()))
.Callback(onError);
SetupControlAndCandidate(steps, ctrlResult, candResult, candName);
state.SetupAllProperties();
SetupStateSnapshot(state);
//Exercise
var sut = new Experiment<string, string>(name, publisher.Object, state.Object, steps.Object, true);
//Exception thrown because throwOnInternalExceptions = true!
var result = Assert.Throws<StepFailedException>(() => sut.Run());
//Verify
steps.Verify(x => x.OnMismatch(It.IsAny<MismatchEventArgs<string>>()), Times.AtLeastOnce);
steps.Verify(x => x.OnError(It.Is<ErrorEventArgs>(
a => a.State.CurrentStep == Operations.OnError && a.ExperimentError.LastException == excp
&& a.ExperimentError.LastStep == Operations.OnMismatch)), Times.AtLeastOnce);
//Final results NOT published
publisher.Verify(x => x.Publish(It.IsAny<IExperimentResult<string>>()), Times.Never);
//Message published
publisher.Verify(x => x.Publish(errMsg,
It.Is<IExperimentState>(y => y.CurrentStep == Operations.OnError)), Times.AtLeastOnce);
Assert.True(excpPassed);
Assert.Equal(result.InnerException, excp);
}
public void OnError_ThrowInternalExceptions_False(Mock<ISciencePublisher> publisher,
Mock<IExperimentSteps<string, string>> steps, Mock<IExperimentState> state, string name,
string ctrlResult, string candResult, string candName, InvalidProgramException excp,
ApplicationException otherExcp)
{
//Setup
Action<MismatchEventArgs<string>> onMismatch = (e) =>
{
throw otherExcp;
};
Action<ErrorEventArgs> onError = (error) =>
{
throw excp;
};
steps.DefaultValue = DefaultValue.Empty;
steps.SetupAllProperties();
steps.SetupGet(x => x.AreEqual).Returns((x, y) => false); //Make sure to cause a mismatch
steps.Setup(x => x.OnMismatch(It.IsAny<MismatchEventArgs<string>>())).Callback(onMismatch);
steps.Setup(x => x.OnError(It.IsAny<ErrorEventArgs>()))
.Callback(onError);
SetupControlAndCandidate(steps, ctrlResult, candResult, candName);
state.SetupAllProperties();
SetupStateSnapshot(state);
//Exercise
var sut = new Experiment<string, string>(name, publisher.Object, state.Object, steps.Object, false);
var result = sut.Run(); //Exception swallowed because throwOnInternalExceptions = false!
//Verify
steps.Verify(x => x.OnMismatch(It.IsAny<MismatchEventArgs<string>>()), Times.AtLeastOnce);
steps.Verify(x => x.OnError(It.Is<ErrorEventArgs>(
a => a.State.CurrentStep == Operations.OnError && a.ExperimentError.LastException == otherExcp
&& a.ExperimentError.LastStep == Operations.OnMismatch)), Times.AtLeastOnce);
//Final results NOT published
publisher.Verify(x => x.Publish(It.IsAny<IExperimentResult<string>>()), Times.Never);
//Message NOT published
publisher.Verify(x => x.Publish(It.IsAny<string>(),
It.Is<IExperimentState>(y => y.CurrentStep == Operations.OnError)), Times.Never);
Assert.Equal(result, ctrlResult);
}
public void OnError_And_Control_ThrowInternalExceptions_True(Mock<ISciencePublisher> publisher,
Mock<IExperimentSteps<string, string>> steps, Mock<IExperimentState> state, string name,
string ctrlResult, string candResult, string candName, InvalidProgramException onErrorExcp,
ApplicationException ctrlExcp)
{
//Setup
Action<ErrorEventArgs> onError = (error) =>
{
throw onErrorExcp;
};
Func<string> control = () => { throw ctrlExcp; };
steps.DefaultValue = DefaultValue.Empty;
steps.SetupAllProperties();
steps.Setup(x => x.OnError(It.IsAny<ErrorEventArgs>()))
.Callback(onError);
SetupControlAndCandidate(steps, ctrlResult, candResult, candName);
steps.SetupGet(x => x.Control).Returns(control);
state.SetupAllProperties();
SetupStateSnapshot(state);
//Exercise
var sut = new Experiment<string, string>(name, publisher.Object, state.Object, steps.Object, true);
// Exception thrown because throwOnInternalExceptions = true, but its a
// StepFailedException, not an ApplicationException as would be expected
var result = Assert.Throws<StepFailedException>(() => sut.Run());
//Verify
steps.Verify(x => x.OnError(It.Is<ErrorEventArgs>(
a => a.State.CurrentStep == Operations.OnError && a.ExperimentError.LastException == ctrlExcp
&& a.ExperimentError.LastStep == Operations.Control)), Times.AtLeastOnce);
steps.Verify(x => x.GetCandidates(), Times.Never); //Candidates don't run in this case
//Final results NOT published
publisher.Verify(x => x.Publish(It.IsAny<IExperimentResult<string>>()), Times.Never);
//Message NOT published
publisher.Verify(x => x.Publish(It.IsAny<string>(),
It.Is<IExperimentState>(y => y.CurrentStep == Operations.OnError)), Times.Never);
Assert.Equal(result.InnerException, onErrorExcp); // Inner comes from OnError, not Control
}
public void OnError_And_Control_ThrowInternalExceptions_False(Mock<ISciencePublisher> publisher,
Mock<IExperimentSteps<string, string>> steps, Mock<IExperimentState> state, string name,
string ctrlResult, string candResult, string candName, InvalidProgramException onErrorExcp,
ApplicationException ctrlExcp)
{
//Setup
Action<ErrorEventArgs> onError = (error) =>
{
throw onErrorExcp;
};
Func<string> control = () => { throw ctrlExcp; };
steps.DefaultValue = DefaultValue.Empty;
steps.SetupAllProperties();
steps.Setup(x => x.OnError(It.IsAny<ErrorEventArgs>()))
.Callback(onError);
SetupControlAndCandidate(steps, ctrlResult, candResult, candName);
steps.SetupGet(x => x.Control).Returns(control);
state.SetupAllProperties();
SetupStateSnapshot(state);
//Exercise
var sut = new Experiment<string, string>(name, publisher.Object, state.Object, steps.Object, false);
// OnError Exception swallowed because throwOnInternalExceptions = false, but still
// throws the control's Exception
var result = Assert.Throws<ApplicationException>(() => sut.Run());
//Verify
steps.Verify(x => x.OnError(It.Is<ErrorEventArgs>(
a => a.State.CurrentStep == Operations.OnError && a.ExperimentError.LastException == ctrlExcp
&& a.ExperimentError.LastStep == Operations.Control)), Times.AtLeastOnce);
steps.Verify(x => x.GetCandidates(), Times.AtLeastOnce); //Candidates still run in this case
//Final results ARE published, but the Control Observation is not properly filled out
publisher.Verify(x => x.Publish(It.Is<IExperimentResult<string>>(
r => r.Control == null)), Times.AtLeastOnce);
//Error Message NOT published
publisher.Verify(x => x.Publish(It.IsAny<string>(),
It.Is<IExperimentState>(y => y.CurrentStep == Operations.OnError)), Times.Never);
Assert.Equal(result, ctrlExcp); //Still throws the right exception
}