public void RaisedUnhandledException(ITestSettings settings)
{
this.TestPurpose("This test checks to see if unhandled exception can work during debugging");
this.WriteSettings(settings);
this.Comment("Set initial debuggee for application");
IDebuggee debuggee = OpenDebuggee(this, settings, DebuggeeMonikers.Exception.Default);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Launch the application");
runner.Launch(settings.DebuggerSettings, debuggee, "-CallRaisedUnhandledException");
this.Comment("Start debugging to hit the exception and verify it should stop at correct source file and line");
runner.Expects.StoppedEvent(StoppedReason.Exception, srcClassName, 8).AfterConfigurationDone();
this.Comment("Verify the callstack, variables and evaluation ");
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
this.Comment("Get current frame object");
IFrameInspector currentFrame = threadInspector.Stack.First();
this.Comment("Verify current frame when stop at the exception");
threadInspector.AssertStackFrameNames(true, "myException::RaisedUnhandledException.*");
this.Comment("Verify the variables after stop at the exception");
Assert.Subset(new HashSet <string>()
{
"result", "temp", "this", "myvar"
}, currentFrame.Variables.ToKeySet());
currentFrame.AssertVariables("result", "10", "temp", "0", "myvar", "200");
// TODO: LLDB was affected by bug #240441, I wil update this once this bug get fixed
if (settings.DebuggerSettings.DebuggerType != SupportedDebugger.Lldb)
{
this.Comment("Evaluate an expression and verify the results after stop at the exception");
string varEvalResult = currentFrame.Evaluate("result = result + 1");
this.WriteLine("Expected: 11, Actual: {0}", varEvalResult);
Assert.Equal("11", varEvalResult);
}
// TODO: Mingw32 was affected by bug #242924, I wil update this once this bug get fixed
if (!(settings.DebuggerSettings.DebuggerType == SupportedDebugger.Gdb_MinGW && settings.DebuggerSettings.DebuggeeArchitecture == SupportedArchitecture.x86))
{
this.Comment("Evaluate a function and verify the the results after stop at exception");
string funEvalResult = currentFrame.Evaluate("EvalFunc(100,100)");
this.WriteLine("Expected: 200, Actual: {0}", funEvalResult);
Assert.Equal("200", funEvalResult);
}
}
this.Comment("Stop debugging");
runner.DisconnectAndVerify();
}
}
public void LocalsBasic(ITestSettings settings)
{
this.TestPurpose("Check primitives displying in locals.");
this.WriteSettings(settings);
IDebuggee debuggee = SinkHelper.Open(this, settings.CompilerSettings, DebuggeeMonikers.KitchenSink.Expression);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Configure launch.");
runner.Launch(settings.DebuggerSettings, debuggee, "-fExpression");
this.Comment("Set a line breakpoints so that we can stop.");
runner.SetBreakpoints(debuggee.Breakpoints(SinkHelper.Expression, 31));
this.Comment("To start debugging and break");
runner.Expects.StoppedEvent(StoppedReason.Breakpoint).AfterConfigurationDone();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
IFrameInspector currentFrame = threadInspector.Stack.First();
this.Comment("To verify locals variables on current frame.");
Assert.Subset(new HashSet <string>()
{
"mybool", "mychar", "myint", "mywchar", "myfloat", "mydouble", "this"
}, currentFrame.Variables.ToKeySet());
currentFrame.AssertVariables(
"mybool", "true",
"myint", "100");
currentFrame.GetVariable("mychar").AssertValueAsChar('A');
currentFrame.GetVariable("mywchar").AssertValueAsWChar('z');
currentFrame.GetVariable("myfloat").AssertValueAsFloat(299);
currentFrame.GetVariable("mydouble").AssertValueAsDouble(321);
}
this.Comment("Run to completion");
runner.Expects.TerminatedEvent().AfterContinue();
runner.DisconnectAndVerify();
}
}
/// <summary>
/// Run core dump basic debugging scenarios
/// </summary>
void RunCoreDumpBasic(ITestSettings settings, int debuggeeMoniker)
{
this.Comment("Set initial debuggee for application");
IDebuggee debuggee = OpenDebuggee(this, settings, debuggeeMoniker);
this.Comment("Launch the application to hit an exception and generate core dump");
string coreDumpPath = GenerateCoreDump(settings, debuggeeMoniker, debuggee);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Configure the core dump before start debugging");
runner.LaunchCoreDump(settings.DebuggerSettings, debuggee, coreDumpPath);
this.Comment("Start debugging to hit the exception and verify it should stop at correct source file and line");
runner.Expects.StoppedEvent(StoppedReason.Exception, srcClassName, 8).AfterConfigurationDone();
this.Comment("Verify the callstack and variables");
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
this.Comment("Get current frame object");
IFrameInspector currentFrame = threadInspector.Stack.First();
this.WriteLine("current frame: {0}", currentFrame);
this.Comment("Verify current frame when stop at the exception");
threadInspector.AssertStackFrameNames(true, "myException::RaisedUnhandledException.*");
this.Comment("Verify the variables after stop at the exception");
Assert.Subset(new HashSet <string>()
{
"result", "temp", "this", "myvar"
}, currentFrame.Variables.ToKeySet());
currentFrame.AssertVariables("result", "10", "temp", "0", "myvar", "200");
}
this.Comment("Stop core dump debugging");
runner.DisconnectAndVerify();
}
}
public void ConditionalBreakpoints(ITestSettings settings)
{
this.TestPurpose("Tests that conditional breakpoints work");
this.WriteSettings(settings);
IDebuggee debuggee = SinkHelper.Open(this, settings.CompilerSettings, DebuggeeMonikers.KitchenSink.Breakpoint);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Configure launch");
runner.Launch(settings.DebuggerSettings, debuggee, "-fCalling");
this.Comment("Set a conditional line breakpoint");
SourceBreakpoints callingBreakpoints = new SourceBreakpoints(debuggee, SinkHelper.Calling);
callingBreakpoints.Add(17, "i == 5");
runner.SetBreakpoints(callingBreakpoints);
// The schema also supports conditions on function breakpoints, but MIEngine or GDB doesn't seem
// to support that. Plus, there's no way to do it through the VSCode UI anyway.
this.Comment("Run to breakpoint");
runner.Expects.HitBreakpointEvent(SinkHelper.Calling, 17)
.AfterConfigurationDone();
this.Comment("Verify breakpoint condition is met");
using (IThreadInspector inspector = runner.GetThreadInspector())
{
IFrameInspector mainFrame = inspector.Stack.First();
mainFrame.AssertVariables("i", "5");
}
this.Comment("Run to completion");
runner.Expects.ExitedEvent()
.TerminatedEvent()
.AfterContinue();
runner.DisconnectAndVerify();
}
}
public void RaisedReThrowException(ITestSettings settings)
{
this.TestPurpose("This test checks to see if re-throw exception can work during debugging.");
this.WriteSettings(settings);
this.Comment("Set initial debuggee for application");
IDebuggee debuggee = OpenDebuggee(this, settings, DebuggeeMonikers.Exception.Default);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Launch the application");
runner.Launch(settings.DebuggerSettings, debuggee, "-CallRaisedReThrowException");
this.Comment("Set line breakpoints to the lines with entry of try block and catch block");
SourceBreakpoints bps = debuggee.Breakpoints(srcClassName, 73, 79, 86);
runner.SetBreakpoints(bps);
this.Comment("Start debugging and hit the breakpoint in the try block");
runner.Expects.HitBreakpointEvent(srcClassName, 73).AfterConfigurationDone();
this.Comment("Continue executing and hit the breakpoint in the frist catch block");
runner.Expects.HitBreakpointEvent(srcClassName, 79).AfterContinue();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
this.Comment("Get current frame object");
IFrameInspector currentFrame = threadInspector.Stack.First();
this.Comment("Verify current frame when stop at the first catch block");
threadInspector.AssertStackFrameNames(true, "myException::RaisedReThrowException.*");
this.Comment("Verify the variables of 'errorCode' in the first catch block");
currentFrame.AssertVariables("errorCode", "200");
this.Comment("Verify step in can work in the first catch block");
runner.ExpectStepAndStepToTarget(srcClassName, startLine: 41, targetLine: 42).AfterStepIn();
this.Comment("Verify current frame after step in another function");
threadInspector.AssertStackFrameNames(true, "myException::EvalFunc.*");
this.Comment("Verify step out can work in the first catch block");
runner.Expects.HitStepEvent(srcClassName, 79).AfterStepOut();
}
this.Comment("Continue to hit the re-throw exception in the first catch block");
runner.Expects.HitBreakpointEvent(srcClassName, 86).AfterContinue();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
this.Comment("Get current frame object");
IFrameInspector currentFrame = threadInspector.Stack.First();
this.Comment("Verify current frame when stop at the second catch block");
threadInspector.AssertStackFrameNames(true, "myException::RaisedReThrowException.*");
this.Comment("Verify the variables in the second catch block");
Assert.Subset(new HashSet <string>()
{
"var", "this", "errorCode", "ex2"
}, currentFrame.Variables.ToKeySet());
currentFrame.AssertVariables("var", "400", "errorCode", "400");
this.Comment("Verify the exception information in the second catch block");
IVariableInspector ex2Var = currentFrame.Variables["ex2"];
Assert.Contains("code", ex2Var.Variables.Keys);
this.WriteLine("Expected: 400, Actual: {0}", ex2Var.Variables["code"].Value);
Assert.Equal("400", ex2Var.Variables["code"].Value);
this.Comment("Evaluate a function and verify the the results at the second catch block ");
// TODO: Mingw32 was affected by bug #242924, I wil update this once this bug get fixed
bool evalNotSupportedInCatch =
(settings.DebuggerSettings.DebuggerType == SupportedDebugger.Gdb_MinGW && settings.DebuggerSettings.DebuggeeArchitecture == SupportedArchitecture.x86) ||
(settings.DebuggerSettings.DebuggerType == SupportedDebugger.VsDbg && settings.DebuggerSettings.DebuggeeArchitecture == SupportedArchitecture.x64);
if (!evalNotSupportedInCatch)
{
string funEvalResult = currentFrame.Evaluate("EvalFunc(20,20)");
this.WriteLine("Expected: 40, Actual: {0}", funEvalResult);
Assert.Equal("40", funEvalResult);
}
}
this.Comment("Verify can step out from a catch block");
runner.ExpectStopAndStepToTarget(StoppedReason.Step, srcAppName, startLine: 61, targetLine: 64).AfterStepOut();
this.Comment("Continue to run at the end of the application");
runner.Expects.TerminatedEvent().AfterContinue();
runner.DisconnectAndVerify();
}
}
public void RaisedHandledException(ITestSettings settings)
{
this.TestPurpose("This test checks to see if user handled exception can work during debugging");
this.WriteSettings(settings);
this.Comment("Set initial debuggee for application");
IDebuggee debuggee = OpenDebuggee(this, settings, DebuggeeMonikers.Exception.Default);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Launch the application");
runner.Launch(settings.DebuggerSettings, debuggee, "-CallRaisedHandledException");
this.Comment("Set line breakpoints to the lines with entry of try block and catch block");
SourceBreakpoints bps = debuggee.Breakpoints(srcClassName, 20, 33);
runner.SetBreakpoints(bps);
this.Comment("Start debugging and hit the breakpoint in the try block");
runner.Expects.HitBreakpointEvent(srcClassName, 20).AfterConfigurationDone();
this.Comment("Step over in the try block");
runner.Expects.HitStepEvent(srcClassName, 21).AfterStepOver();
this.Comment("Continue to raise the exception and hit the breakpoint set in the catch block");
runner.Expects.HitBreakpointEvent(srcClassName, 33).AfterContinue();
this.Comment("Verify can step over in the catch block");
runner.Expects.HitStepEvent(srcClassName, 34).AfterStepOver();
this.Comment("Verify the callstack, variables and evaluation ");
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
this.Comment("Get current frame object");
IFrameInspector currentFrame = threadInspector.Stack.First();
this.Comment("Verify current frame when stop at the catch block");
threadInspector.AssertStackFrameNames(true, "myException::RaisedHandledException.*");
this.Comment("Verify the variables in the catch block");
Assert.Subset(new HashSet <string>()
{
"result", "global", "this", "a", "errorCode", "ex"
}, currentFrame.Variables.ToKeySet());
currentFrame.AssertVariables("result", "201", "global", "101", "a", "100");
this.Comment("Verify the exception information in the catch block");
IVariableInspector exVar = currentFrame.Variables["ex"];
Assert.Contains("code", exVar.Variables.Keys);
this.WriteLine("Expected: 101, Actual: {0}", exVar.Variables["code"].Value);
Assert.Equal("101", exVar.Variables["code"].Value);
// TODO: LLDB was affected by bug #240441, I wil update this once this bug get fixed
if (settings.DebuggerSettings.DebuggerType != SupportedDebugger.Lldb)
{
this.Comment("Evaluate an expression and verify the results");
string varEvalResult = currentFrame.Evaluate("result=result + 1");
this.WriteLine("Expected: 202, Actual: {0}", varEvalResult);
Assert.Equal("202", varEvalResult);
}
this.Comment("Evaluate a function and verify the the results");
// TODO: Mingw32 was affected by bug #242924, I wil update this once this bug get fixed
bool evalNotSupportedInCatch =
(settings.DebuggerSettings.DebuggerType == SupportedDebugger.Gdb_MinGW && settings.DebuggerSettings.DebuggeeArchitecture == SupportedArchitecture.x86) ||
(settings.DebuggerSettings.DebuggerType == SupportedDebugger.VsDbg && settings.DebuggerSettings.DebuggeeArchitecture == SupportedArchitecture.x64);
if (!evalNotSupportedInCatch)
{
string funEvalResult = currentFrame.Evaluate("RecursiveFunc(50)");
this.WriteLine("Expected: 1, Actual: {0}", funEvalResult);
Assert.Equal("1", funEvalResult);
}
}
this.Comment("Verify can step over after evaluation in the catch block");
runner.Expects.HitStepEvent(srcClassName, 35).AfterStepOver();
this.Comment("Continue to run at the end of the application");
runner.Expects.TerminatedEvent().AfterContinue();
runner.DisconnectAndVerify();
}
}
public void TestFolderol(ITestSettings settings)
{
this.TestPurpose("This test checks a bunch of commands and events.");
this.WriteSettings(settings);
IDebuggee debuggee = Debuggee.Open(this, settings.CompilerSettings, HelloName, DebuggeeMonikers.HelloWorld.Sample);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Launch the debuggee");
runner.Launch(settings.DebuggerSettings, debuggee);
StoppedEvent stopAtBreak = new StoppedEvent(StoppedReason.Breakpoint);
// VsDbg does not fire Breakpoint Change events when breakpoints are set.
// Instead it sends a new breakpoint event when it is bound (after configuration done).
bool bindsLate = (settings.DebuggerSettings.DebuggerType == SupportedDebugger.VsDbg);
this.Comment("Set a breakpoint on line 8, but expect it to resolve to line 9.");
runner.Expects.ConditionalEvent(!bindsLate, x => x.BreakpointChangedEvent(BreakpointReason.Changed, 9))
.AfterSetBreakpoints(debuggee.Breakpoints(HelloSourceName, 8));
this.Comment("Start debuggging until breakpoint is hit.");
runner.Expects.ConditionalEvent(bindsLate, x => x.BreakpointChangedEvent(BreakpointReason.Changed, 9))
.Event(stopAtBreak)
.AfterConfigurationDone();
Assert.Equal(HelloSourceName, stopAtBreak.ActualEventInfo.Filename);
Assert.Equal(9, stopAtBreak.ActualEventInfo.Line);
Assert.Equal(StoppedReason.Breakpoint, stopAtBreak.ActualEventInfo.Reason);
this.Comment("Step forward twice until we have initialized variables");
runner.Expects.StoppedEvent(StoppedReason.Step, HelloSourceName, 10)
.AfterStepOver();
runner.Expects.StoppedEvent(StoppedReason.Step, HelloSourceName, 11)
.AfterStepIn();
this.Comment("Inspect the stack and try evaluation.");
using (IThreadInspector inspector = runner.GetThreadInspector())
{
this.Comment("Get the stack trace");
IFrameInspector mainFrame = inspector.Stack.First();
inspector.AssertStackFrameNames(true, "main.*");
this.WriteLine("Main frame: {0}", mainFrame);
this.Comment("Get variables");
Assert.Subset(new HashSet <string>()
{
"x", "y", "argc", "argv"
}, mainFrame.Variables.ToKeySet());
mainFrame.AssertVariables(
"x", "6",
"argc", "1");
IVariableInspector argv = mainFrame.Variables["argv"];
Assert.Matches(HexNumberPattern, argv.Value);
this.Comment("Expand a variable (argv has *argv under it)");
string variableName = "*argv";
if (settings.DebuggerSettings.DebuggerType == SupportedDebugger.VsDbg)
{
variableName = String.Empty;
}
Assert.Contains(variableName, argv.Variables.Keys);
Assert.Matches(HexNumberPattern, argv.Variables[variableName].Value);
this.Comment("Evaluate with side effect");
string result = mainFrame.Evaluate("x = x + 1");
Assert.Equal("7", result);
}
this.Comment("Step to force stack info to refresh");
runner.Expects.StoppedEvent(StoppedReason.Step).AfterStepOver();
using (IThreadInspector inspector = runner.GetThreadInspector())
{
this.Comment("Evaluation has side effect, make sure it propagates");
Assert.Equal("7", inspector.Stack.First().Variables["x"].Value);
}
runner.Expects.ExitedEvent(0).TerminatedEvent().AfterContinue();
runner.DisconnectAndVerify();
}
}
