/// <summary>
/// Handles exception event.
/// </summary>
/// <param name="sender">Sender.</param>
/// <param name="e">Event arguments.</param>
private async void OnExceptionEvent(object sender, ExceptionMessageEventArgs e)
{
IsRunning = e.Message.IsRunning;
IsException = true;
int scriptId = e.Message.ScriptId;
string filename = e.Message.Filename;
string description = e.Message.Description;
AddModuleIfNotExist(scriptId, filename);
// Try to serialize exception
string objectName = string.Format("object{0}", DateTime.UtcNow.Ticks);
IResponseMessage response = await _client.SendMessage("evaluate", new
{
expression = objectName + ".toString()",
additional_context = new[]
{
new { name = objectName, handle = e.Message.ExceptionId }
},
maxStringLength = -1
}, this, null, objectName).ConfigureAwait(false);
var evaluateMessage = response as EvaluateMessage;
if (evaluateMessage != null && evaluateMessage.IsSuccessful)
{
description = evaluateMessage.Result.StringValue;
}
// Fire async breakpoint event
EventHandler <ExceptionRaisedEventArgs> exceptionRaised = ExceptionRaised;
if (exceptionRaised != null)
{
var nodeException = new NodeException(e.Message.TypeName, description);
exceptionRaised(this, new ExceptionRaisedEventArgs(Thread, nodeException, e.Message.IsUnhandled));
}
}
/// <summary>
/// Handles exception event.
/// </summary>
/// <param name="sender">Sender.</param>
/// <param name="e">Event arguments.</param>
private async void OnExceptionEvent(object sender, ExceptionMessageEventArgs e)
{
IsRunning = e.Message.IsRunning;
IsException = true;
int scriptId = e.Message.ScriptId;
string filename = e.Message.Filename;
string description = e.Message.Description;
AddModuleIfNotExist(scriptId, filename);
// Try to serialize exception
string objectName = string.Format("object{0}", DateTime.UtcNow.Ticks);
IResponseMessage response = await _client.SendMessage("evaluate", new
{
expression = objectName + ".toString()",
additional_context = new[]
{
new {name = objectName, handle = e.Message.ExceptionId}
},
maxStringLength = -1
}, this, null, objectName).ConfigureAwait(false);
var evaluateMessage = response as EvaluateMessage;
if (evaluateMessage != null && evaluateMessage.IsSuccessful)
{
description = evaluateMessage.Result.StringValue;
}
// Fire async breakpoint event
EventHandler<ExceptionRaisedEventArgs> exceptionRaised = ExceptionRaised;
if (exceptionRaised != null)
{
var nodeException = new NodeException(e.Message.TypeName, description);
exceptionRaised(this, new ExceptionRaisedEventArgs(Thread, nodeException, e.Message.IsUnhandled));
}
}
internal void TestDebuggerSteps(
NodeDebugger process,
NodeThread thread,
string filename,
IEnumerable <TestStep> steps,
ExceptionHitTreatment?defaultExceptionTreatment = null,
ICollection <KeyValuePair <string, ExceptionHitTreatment> > exceptionTreatments = null,
bool waitForExit = false
)
{
if (!Path.IsPathRooted(filename))
{
filename = DebuggerTestPath + filename;
}
// Since Alpha does not support break on unhandled, and the commonly used Express module has handled SyntaxError exceptions,
// for alpha we have SyntaxErrors set to BreakNever by default. Here we set it to BreakAlways so unit tests can run
// assuming BreakAlways is the default.
// TODO: Remove once exception treatment is updated for just my code support when it is added after Alpha
process.SetExceptionTreatment(null, CollectExceptionTreatments(ExceptionHitTreatment.BreakAlways, "SyntaxError"));
if (defaultExceptionTreatment != null || exceptionTreatments != null)
{
process.SetExceptionTreatment(defaultExceptionTreatment, exceptionTreatments);
}
Dictionary <Breakpoint, NodeBreakpoint> breakpoints = new Dictionary <Breakpoint, NodeBreakpoint>();
AutoResetEvent entryPointHit = new AutoResetEvent(false);
process.EntryPointHit += (sender, e) => {
Console.WriteLine("EntryPointHit");
Assert.AreEqual(e.Thread, thread);
entryPointHit.Set();
};
AutoResetEvent breakpointBound = new AutoResetEvent(false);
process.BreakpointBound += (sender, e) => {
Console.WriteLine("BreakpointBound {0} {1}", e.BreakpointBinding.Position.FileName, e.BreakpointBinding.Position.Line);
breakpointBound.Set();
};
AutoResetEvent breakpointUnbound = new AutoResetEvent(false);
process.BreakpointUnbound += (sender, e) => {
Console.WriteLine("BreakpointUnbound");
breakpointUnbound.Set();
};
AutoResetEvent breakpointBindFailure = new AutoResetEvent(false);
process.BreakpointBindFailure += (sender, e) => {
Console.WriteLine("BreakpointBindFailure");
breakpointBindFailure.Set();
};
AutoResetEvent breakpointHit = new AutoResetEvent(false);
process.BreakpointHit += (sender, e) => {
Console.WriteLine("BreakpointHit {0}", e.BreakpointBinding.Target.Line);
Assert.AreEqual(e.Thread, thread);
Assert.AreEqual(e.BreakpointBinding.Target.Line, thread.Frames.First().Line);
breakpointHit.Set();
};
AutoResetEvent stepComplete = new AutoResetEvent(false);
process.StepComplete += (sender, e) => {
Console.WriteLine("StepComplete");
Assert.AreEqual(e.Thread, thread);
stepComplete.Set();
};
AutoResetEvent exceptionRaised = new AutoResetEvent(false);
NodeException exception = null;
process.ExceptionRaised += (sender, e) => {
Console.WriteLine("ExceptionRaised");
Assert.AreEqual(e.Thread, thread);
exception = e.Exception;
exceptionRaised.Set();
};
AutoResetEvent processExited = new AutoResetEvent(false);
int exitCode = 0;
process.ProcessExited += (sender, e) => {
Console.WriteLine("ProcessExited {0}", e.ExitCode);
exitCode = e.ExitCode;
processExited.Set();
};
Console.WriteLine("-----------------------------------------");
Console.WriteLine("Begin debugger step test");
foreach (var step in steps)
{
Console.WriteLine("Step: {0}", step._action);
Assert.IsFalse(
((step._expectedEntryPointHit != null ? 1 : 0) +
(step._expectedBreakpointHit != null ? 1 : 0) +
(step._expectedStepComplete != null ? 1 : 0) +
(step._expectedExceptionRaised != null ? 1 : 0)) > 1);
bool wait = false;
NodeBreakpoint nodeBreakpoint;
switch (step._action)
{
case TestAction.None:
break;
case TestAction.Wait:
wait = true;
break;
case TestAction.ResumeThread:
thread.Resume();
wait = true;
break;
case TestAction.ResumeProcess:
process.Resume();
wait = true;
break;
case TestAction.StepOver:
thread.StepOver();
wait = true;
break;
case TestAction.StepInto:
thread.StepInto();
wait = true;
break;
case TestAction.StepOut:
thread.StepOut();
wait = true;
break;
case TestAction.AddBreakpoint:
string breakpointFileName = step._targetBreakpointFile;
if (breakpointFileName != null)
{
if (!step._builtin && !Path.IsPathRooted(breakpointFileName))
{
breakpointFileName = DebuggerTestPath + breakpointFileName;
}
}
else
{
breakpointFileName = filename;
}
int breakpointLine = step._targetBreakpoint.Value;
int breakpointColumn = step._targetBreakpointColumn.HasValue ? step._targetBreakpointColumn.Value : 0;
Breakpoint breakpoint = new Breakpoint(breakpointFileName, breakpointLine, breakpointColumn);
Assert.IsFalse(breakpoints.TryGetValue(breakpoint, out nodeBreakpoint));
breakpoints[breakpoint] =
AddBreakPoint(
process,
breakpointFileName,
breakpointLine,
breakpointColumn,
step._enabled ?? true,
step._breakOn ?? new BreakOn(),
step._condition
);
if (step._expectFailure)
{
AssertWaited(breakpointBindFailure);
AssertNotSet(breakpointBound);
breakpointBindFailure.Reset();
}
else
{
AssertWaited(breakpointBound);
AssertNotSet(breakpointBindFailure);
breakpointBound.Reset();
}
break;
case TestAction.RemoveBreakpoint:
breakpointFileName = step._targetBreakpointFile ?? filename;
breakpointLine = step._targetBreakpoint.Value;
breakpointColumn = step._targetBreakpointColumn.HasValue ? step._targetBreakpointColumn.Value : 0;
breakpoint = new Breakpoint(breakpointFileName, breakpointLine, breakpointColumn);
breakpoints[breakpoint].Remove().WaitAndUnwrapExceptions();
breakpoints.Remove(breakpoint);
AssertWaited(breakpointUnbound);
breakpointUnbound.Reset();
break;
case TestAction.UpdateBreakpoint:
breakpointFileName = step._targetBreakpointFile ?? filename;
breakpointLine = step._targetBreakpoint.Value;
breakpointColumn = step._targetBreakpointColumn.HasValue ? step._targetBreakpointColumn.Value : 0;
breakpoint = new Breakpoint(breakpointFileName, breakpointLine, breakpointColumn);
nodeBreakpoint = breakpoints[breakpoint];
foreach (var breakpointBinding in nodeBreakpoint.GetBindings())
{
if (step._hitCount != null)
{
Assert.IsTrue(breakpointBinding.SetHitCountAsync(step._hitCount.Value).WaitAndUnwrapExceptions());
}
if (step._enabled != null)
{
Assert.IsTrue(breakpointBinding.SetEnabledAsync(step._enabled.Value).WaitAndUnwrapExceptions());
}
if (step._breakOn != null)
{
Assert.IsTrue(breakpointBinding.SetBreakOnAsync(step._breakOn.Value).WaitAndUnwrapExceptions());
}
if (step._condition != null)
{
Assert.IsTrue(breakpointBinding.SetConditionAsync(step._condition).WaitAndUnwrapExceptions());
}
}
break;
case TestAction.KillProcess:
process.Terminate();
break;
case TestAction.Detach:
process.Detach();
break;
}
if (wait)
{
if (step._expectedEntryPointHit != null)
{
AssertWaited(entryPointHit);
AssertNotSet(breakpointHit);
AssertNotSet(stepComplete);
AssertNotSet(exceptionRaised);
Assert.IsNull(exception);
entryPointHit.Reset();
}
else if (step._expectedBreakpointHit != null)
{
if (step._expectReBind)
{
AssertWaited(breakpointUnbound);
AssertWaited(breakpointBound);
breakpointUnbound.Reset();
breakpointBound.Reset();
}
AssertWaited(breakpointHit);
AssertNotSet(entryPointHit);
AssertNotSet(stepComplete);
AssertNotSet(exceptionRaised);
Assert.IsNull(exception);
breakpointHit.Reset();
}
else if (step._expectedStepComplete != null)
{
AssertWaited(stepComplete);
AssertNotSet(entryPointHit);
AssertNotSet(breakpointHit);
AssertNotSet(exceptionRaised);
Assert.IsNull(exception);
stepComplete.Reset();
}
else if (step._expectedExceptionRaised != null)
{
AssertWaited(exceptionRaised);
AssertNotSet(entryPointHit);
AssertNotSet(breakpointHit);
AssertNotSet(stepComplete);
exceptionRaised.Reset();
}
else
{
AssertNotSet(entryPointHit);
AssertNotSet(breakpointHit);
AssertNotSet(stepComplete);
AssertNotSet(exceptionRaised);
Assert.IsNull(exception);
}
}
if (step._expectedEntryPointHit != null)
{
Assert.AreEqual(step._expectedEntryPointHit.Value, thread.Frames.First().Line);
}
else if (step._expectedBreakpointHit != null)
{
Assert.AreEqual(step._expectedBreakpointHit.Value, thread.Frames.First().Line);
}
else if (step._expectedStepComplete != null)
{
Assert.AreEqual(step._expectedStepComplete.Value, thread.Frames.First().Line);
}
else if (step._expectedExceptionRaised != null)
{
Assert.AreEqual(step._expectedExceptionRaised.TypeName, exception.TypeName);
Assert.AreEqual(step._expectedExceptionRaised.Description, exception.Description);
if (step._expectedExceptionRaised.LineNo != null)
{
Assert.AreEqual(step._expectedExceptionRaised.LineNo.Value, thread.Frames[0].Line);
}
exception = null;
}
var expectedBreakFile = step._expectedBreakFile;
if (expectedBreakFile != null)
{
if (!step._builtin && !Path.IsPathRooted(expectedBreakFile))
{
expectedBreakFile = DebuggerTestPath + expectedBreakFile;
}
Assert.AreEqual(expectedBreakFile, thread.Frames.First().FileName);
}
var expectedBreakFunction = step._expectedBreakFunction;
if (expectedBreakFunction != null)
{
Assert.AreEqual(expectedBreakFunction, thread.Frames.First().FunctionName);
}
if (step._expectedHitCount != null)
{
string breakpointFileName = step._targetBreakpointFile ?? filename;
if (!step._builtin && !Path.IsPathRooted(breakpointFileName))
{
breakpointFileName = DebuggerTestPath + breakpointFileName;
}
int breakpointLine = step._targetBreakpoint.Value;
int breakpointColumn = step._targetBreakpointColumn.HasValue ? step._targetBreakpointColumn.Value : 0;
var breakpoint = new Breakpoint(breakpointFileName, breakpointLine, breakpointColumn);
nodeBreakpoint = breakpoints[breakpoint];
foreach (var breakpointBinding in nodeBreakpoint.GetBindings())
{
Assert.AreEqual(step._expectedHitCount.Value, breakpointBinding.GetHitCount());
}
}
if (step._validation != null)
{
step._validation(process, thread);
}
if (step._expectedExitCode != null)
{
AssertWaited(processExited);
Assert.AreEqual(step._expectedExitCode.Value, exitCode);
}
}
if (waitForExit)
{
process.WaitForExit(10000);
}
AssertNotSet(entryPointHit);
AssertNotSet(breakpointHit);
AssertNotSet(stepComplete);
AssertNotSet(exceptionRaised);
Assert.IsNull(exception);
}