public void EvaluateInvalidExpression(ITestSettings settings)
{
this.TestPurpose("To test invalid expression evaluation return apropriate errors.");
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 breakpoint so that we can stop at a line.");
runner.SetBreakpoints(debuggee.Breakpoints(SinkHelper.Expression, 31));
this.Comment("To start debugging and hit breakpoint.");
runner.Expects.HitBreakpointEvent().AfterConfigurationDone();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
IFrameInspector currentFrame = threadInspector.Stack.First();
this.Comment("To evaluate some invalid expression on curren stack frame.");
currentFrame.AssertEvaluateAsError("notExistVar", EvaluateContext.Watch);
}
this.Comment("Continue to run to exist.");
runner.Expects.TerminatedEvent().AfterContinue();
runner.DisconnectAndVerify();
}
}
public void BreakpointSettingsVerification(ITestSettings settings)
{
this.TestPurpose("Tests supported breakpoint settings");
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);
Assert.True(runner.InitializeResponse.body.supportsConditionalBreakpoints.HasValue &&
runner.InitializeResponse.body.supportsConditionalBreakpoints.Value == true, "Conditional breakpoints should be supported");
Assert.True(runner.InitializeResponse.body.supportsFunctionBreakpoints.HasValue &&
runner.InitializeResponse.body.supportsFunctionBreakpoints.Value == true, "Function breakpoints should be supported");
this.Comment("Run to completion");
runner.Expects.ExitedEvent()
.TerminatedEvent()
.AfterConfigurationDone();
runner.DisconnectAndVerify();
}
}
public static void Launch(this IDebuggerRunner runner, IDebuggerSettings settings, bool stopAtEntry, string program, params string[] args)
{
runner.RunCommand(new LaunchCommand(settings, program, false, args)
{
StopAtEntry = stopAtEntry
});
}
public void CallStackBasic(ITestSettings settings)
{
this.TestPurpose("To check all frames of callstack on a thead and evaluation on each frame.");
this.WriteSettings(settings);
IDebuggee debuggee = SinkHelper.Open(this, settings.CompilerSettings, DebuggeeMonikers.KitchenSink.Expression);
this.Comment("Here are stack frames in a list we expect the actual to match with this.");
StackFrame[] expectedstackFrames = ExpressionTests.GenerateFramesList(settings.DebuggerSettings);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Configure launch.");
runner.Launch(settings.DebuggerSettings, debuggee, "-fExpression");
this.Comment("Set a breakpoint so that we can stop after starting debugging.");
runner.SetBreakpoints(debuggee.Breakpoints(SinkHelper.Expression, 19));
this.Comment("To start debugging and break");
runner.Expects.StoppedEvent(StoppedReason.Breakpoint, SinkHelper.Expression, 19).AfterConfigurationDone();
this.Comment("To step in several times into the innermost layer of a recursive call.");
runner.ExpectStepAndStepToTarget(SinkHelper.Expression, 9, 10).AfterStepIn();
runner.Expects.HitStepEvent(SinkHelper.Expression, 12).AfterStepIn();
runner.ExpectStepAndStepToTarget(SinkHelper.Expression, 9, 10).AfterStepIn();
runner.Expects.HitStepEvent(SinkHelper.Expression, 12).AfterStepIn();
runner.ExpectStepAndStepToTarget(SinkHelper.Expression, 9, 10).AfterStepIn();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
IEnumerable <IFrameInspector> stackOfCurrentThread = threadInspector.Stack;
this.Comment("To verify the count of stack frames count.");
Assert.True(stackOfCurrentThread.Count() >= 13, "Expected the stack frame count to be at least 13 deep");
this.Comment("To verify each frame, include frame name, line number and source name.");
int index = 0;
foreach (IFrameInspector frame in stackOfCurrentThread)
{
if (index >= 13)
{
break;
}
StackFrame expectedstackFrame = expectedstackFrames[index];
this.Comment("Comparing Names. Expecected: {0}, Actual: {1}", expectedstackFrame.Name, frame.Name);
Assert.Contains(expectedstackFrame.Name, frame.Name, StringComparison.Ordinal);
this.Comment("Comparing line number. Expecected: {0}, Actual: {1}", expectedstackFrame.Line, frame.Line);
Assert.Equal(expectedstackFrame.Line, frame.Line);
this.Comment("Comparing Source Name. Expecected: {0}, Actual: {1}", expectedstackFrame.SourceName, frame.SourceName);
Assert.Equal(expectedstackFrame.SourceName, frame.SourceName);
index++;
}
}
this.Comment("Continue to run to exist.");
runner.Expects.TerminatedEvent().AfterContinue();
runner.DisconnectAndVerify();
}
}
public VariableInspector(IDebuggerRunner runner, int parentVariablesReference, string name, string value, int?variablesReference)
{
Parameter.ThrowIfNull(runner, nameof(runner));
this.DebuggerRunner = runner;
this.parentVariablesReference = parentVariablesReference;
this.name = name;
this.value = value;
this.variablesReference = variablesReference;
}
public void TestOptimizedBpsAndSource(ITestSettings settings)
{
this.TestPurpose("Tests basic operation of bps and source information for optimized app");
this.WriteSettings(settings);
IDebuggee debuggee = Debuggee.Open(this, settings.CompilerSettings, Name, DebuggeeMonikers.Optimization.OptimizationWithSymbols);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Configure launch");
runner.Launch(settings.DebuggerSettings, debuggee);
SourceBreakpoints mainBreakpoints = debuggee.Breakpoints(SourceName, 68);
SourceBreakpoints userDefinedClassBreakpoints = debuggee.Breakpoints(UserDefinedClassName, 8, 15, 54);
this.Comment("Set initial breakpoints");
runner.SetBreakpoints(mainBreakpoints);
runner.SetBreakpoints(userDefinedClassBreakpoints);
this.Comment("Launch and run until 1st bp");
runner.Expects.HitBreakpointEvent(UserDefinedClassName, 8)
.AfterConfigurationDone();
this.Comment("run until 2nd bp");
runner.Expects.HitBreakpointEvent(UserDefinedClassName, 54)
.AfterContinue();
this.Comment("run until 3rd bp");
runner.Expects.HitBreakpointEvent(SourceName, 68)
.AfterContinue();
//Todo: this has different behavior on Mac(:16), Other Platforms(15) I have logged bug#247891 to track
this.Comment("run until 4th bp");
runner.ExpectBreakpointAndStepToTarget(UserDefinedClassName, 15, 16).AfterContinue();
this.Comment("continue to next bp");
runner.Expects.HitBreakpointEvent(UserDefinedClassName, 54)
.AfterContinue();
this.Comment("Check the current callstack frame");
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
this.Comment("Get current frame object");
IFrameInspector currentFrame = threadInspector.Stack.First();
this.Comment("Verify current frame");
threadInspector.AssertStackFrameNames(true, "Foo::Sum");
}
this.Comment("step out to main entry");
runner.Expects.HitStepEvent(SourceName, 69)
.AfterStepOut();
runner.Expects.ExitedEvent(0).TerminatedEvent().AfterContinue();
runner.DisconnectAndVerify();
}
}
/// <summary>
/// Adds an expected stop event within a range of line numbers. If the stop does not occur on <paramref name="targetLine"/>, then perform a step over
/// and verify that the debuggee breaks at the <paramref name="targetLine"/>.
/// </summary>
/// <param name="startLine">The first line number onto which it is acceptable that the stop occurs.</param>
/// <param name="targetLine">The line number which is the desired stopping line.</param>
public static IRunBuilder ExpectStopAndStepToTarget(this IDebuggerRunner runner, StoppedReason reason, string fileName, int startLine, int targetLine)
{
return(runner.Expects.HitStopEventWithinRange(reason, fileName, startLine, targetLine, (e) =>
{
if (e.ActualEvent.body.line != targetLine)
{
runner.Expects.HitStepEvent(fileName, targetLine).AfterStepOver();
}
}));
}
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 FrameInspector(IDebuggerRunner runner, string name, int id, string sourceName, string sourcePath, int?sourceReference, int?line, int?column)
{
Parameter.ThrowIfNull(runner, nameof(runner));
this.DebuggerRunner = runner;
this.name = name;
this.id = id;
this.sourceName = sourceName;
this.sourcePath = sourcePath;
this.sourceReference = sourceReference;
this.line = line;
this.column = column;
}
public void RunModeBreakpoints(ITestSettings settings)
{
this.TestPurpose("Tests setting breakpoints while in run mode");
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, "-fNonTerminating");
runner.ConfigurationDone();
// Wait a second to ensure the debuggee has entered run mode, then try to set a breakpoint
Thread.Sleep(TimeSpan.FromSeconds(1));
this.Comment("Set a function breakpoint while in run mode");
FunctionBreakpoints functionBreakpoints = new FunctionBreakpoints("NonTerminating::DoSleep");
runner.ExpectBreakpointAndStepToTarget(SinkHelper.NonTerminating, startLine: 37, targetLine: 38)
.AfterSetFunctionBreakpoints(functionBreakpoints);
this.Comment("Remove function breakpoint");
functionBreakpoints.Remove("NonTerminating::DoSleep");
runner.SetFunctionBreakpoints(functionBreakpoints);
this.Comment("Continue, set a line breakpoint while in run mode");
runner.Continue();
// Wait a second to ensure the debuggee has entered run mode, then try to set a breakpoint
Thread.Sleep(TimeSpan.FromSeconds(1));
runner.Expects.HitBreakpointEvent(SinkHelper.NonTerminating, 28)
.AfterSetBreakpoints(debuggee.Breakpoints(SinkHelper.NonTerminating, 28));
this.Comment("Escape loop");
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
IFrameInspector firstFrame = threadInspector.Stack.First();
this.WriteLine(firstFrame.ToString());
firstFrame.GetVariable("this", "shouldExit").Value = "1";
}
this.Comment("Continue until end");
runner.Expects.ExitedEvent()
.TerminatedEvent()
.AfterContinue();
runner.DisconnectAndVerify();
}
}
public void ExecutionStepBasic(ITestSettings settings)
{
this.TestPurpose("Verify basic step in/over/out should work during debugging");
this.WriteSettings(settings);
this.Comment("Open the kitchen sink debuggee for execution tests.");
IDebuggee debuggee = SinkHelper.Open(this, settings.CompilerSettings, DebuggeeMonikers.KitchenSink.Execution);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Configure launch");
runner.Launch(settings.DebuggerSettings, debuggee, "-fCalling");
this.Comment("Set initial source breakpoints");
SourceBreakpoints bps = debuggee.Breakpoints(SinkHelper.Main, 21, 33);
runner.SetBreakpoints(bps);
this.Comment("Launch and run until hit the first entry");
runner.Expects.HitBreakpointEvent(SinkHelper.Main, 21).AfterConfigurationDone();
this.Comment("Step over the function");
runner.Expects.HitStepEvent(SinkHelper.Main, 23).AfterStepOver();
this.Comment("Continue to hit the second entry");
runner.Expects.HitBreakpointEvent(SinkHelper.Main, 33).AfterContinue();
this.Comment("Step in the function");
runner.ExpectStepAndStepToTarget(SinkHelper.Feature, startLine: 19, targetLine: 20).AfterStepIn();
this.Comment("Step over the function");
runner.Expects.HitStepEvent(SinkHelper.Feature, 21).AfterStepOver();
runner.Expects.HitStepEvent(SinkHelper.Feature, 22).AfterStepOver();
this.Comment("Step in the function");
runner.ExpectStepAndStepToTarget(SinkHelper.Calling, startLine: 47, targetLine: 48).AfterStepIn();
this.Comment("Step out the function");
runner.ExpectStepAndStepToTarget(SinkHelper.Feature, startLine: 22, targetLine: 23).AfterStepOut();
this.Comment("Continue running at the end of application");
runner.Expects.ExitedEvent()
.TerminatedEvent()
.AfterContinue();
this.Comment("Verify debugger and debuggee closed");
runner.DisconnectAndVerify();
}
}
public void TestArguments(ITestSettings settings)
{
this.TestPurpose("This test checks to see if arguments are passed to the debugee.");
this.WriteSettings(settings);
IDebuggee debuggee = Debuggee.Open(this, settings.CompilerSettings, HelloName, DebuggeeMonikers.HelloWorld.Sample);
this.Comment("Run the debuggee, check argument count");
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
runner.Launch(settings.DebuggerSettings, debuggee, "Param 1", "Param 2");
int args = 2;
runner.Expects.ExitedEvent(exitCode: args).TerminatedEvent().AfterConfigurationDone();
runner.DisconnectAndVerify();
}
}
public void LaunchNonExistentDebuggee(ITestSettings settings)
{
this.TestPurpose("This test checks to see the debugger handles trying to start when there is no debuggee.");
this.WriteSettings(settings);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
LaunchCommand launch = new LaunchCommand(settings.DebuggerSettings, "foofoo");
launch.ExpectsSuccess = false;
runner.RunCommand(launch);
Assert.Matches(".*does not exist.*", launch.Message);
runner.DisconnectAndVerify();
}
}
public void TestSharedLibWithoutSymbol(ITestSettings settings)
{
this.TestPurpose("Tests basic bps and source information for shared library without symbols");
this.WriteSettings(settings);
IDebuggee debuggee = Debuggee.Open(this, settings.CompilerSettings, Name, DebuggeeMonikers.Optimization.OptimizationWithoutSymbols);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Configure launch");
runner.Launch(settings.DebuggerSettings, debuggee);
SourceBreakpoints mainBreakpoints = debuggee.Breakpoints(SourceName, 87, 91);
this.Comment("Set initial breakpoints");
runner.SetBreakpoints(mainBreakpoints);
this.Comment("Launch and run until 1st bp");
runner.Expects.HitBreakpointEvent(SourceName, 87)
.AfterConfigurationDone();
this.Comment("Step into the library source");
runner.Expects.HitStepEvent(SourceName, 89)
.AfterStepIn();
this.Comment("Check the stack for debugging shared library without symbols");
using (IThreadInspector inspector = runner.GetThreadInspector())
{
IFrameInspector currentFrame = inspector.Stack.First();
inspector.AssertStackFrameNames(true, "main");
this.Comment("run to continue to 2nd bp");
runner.Expects.HitBreakpointEvent(SourceName, 91)
.AfterContinue();
this.Comment("Check the stack for debugging shared library without symbols");
currentFrame = inspector.Stack.First();
inspector.AssertStackFrameNames(true, "main");
this.Comment("Check the local variables in main function");
IVariableInspector age = currentFrame.Variables["age"];
Assert.Matches("31", age.Value);
}
runner.DisconnectAndVerify();
}
}
public void AttachAsyncBreak(ITestSettings settings)
{
this.TestPurpose("Verifies attach and that breakpoints can be set from break mode.");
this.WriteSettings(settings);
IDebuggee debuggee = SinkHelper.Open(this, settings.CompilerSettings, DebuggeeMonikers.KitchenSink.Attach);
Process debuggeeProcess = debuggee.Launch("-fNonTerminating", "-fCalling");
using (ProcessHelper.ProcessCleanup(this, debuggeeProcess))
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Attach to debuggee");
runner.Attach(settings.DebuggerSettings, debuggeeProcess);
runner.ConfigurationDone();
this.Comment("Attempt to break all");
StoppedEvent breakAllEvent = new StoppedEvent(StoppedReason.Pause);
runner.Expects.Event(breakAllEvent)
.AfterAsyncBreak();
this.WriteLine("Break all stopped on:");
this.WriteLine(breakAllEvent.ActualEvent.ToString());
this.Comment("Set breakpoint while breaking code.");
runner.SetBreakpoints(debuggee.Breakpoints(SinkHelper.NonTerminating, 28));
this.Comment("Start running after the async break (since we have no idea where we are) and then hit the breakpoint");
runner.Expects.HitBreakpointEvent(SinkHelper.NonTerminating, 28)
.AfterContinue();
this.Comment("Evaluate the shouldExit member to true to stop the infinite loop.");
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
IFrameInspector firstFrame = threadInspector.Stack.First();
this.WriteLine(firstFrame.ToString());
firstFrame.GetVariable("shouldExitLocal").Value = "true";
}
this.Comment("Continue until debuggee exists");
runner.Expects.ExitedEvent(exitCode: 0).TerminatedEvent().AfterContinue();
this.Comment("Verify debugger and debuggee closed");
runner.DisconnectAndVerify();
Assert.True(debuggeeProcess.HasExited, "Debuggee still running.");
}
}
private void TestEnvironmentVariable(ITestSettings settings, string variableName, string variableValue, bool newTerminal)
{
this.WriteSettings(settings);
IDebuggee debuggee = SinkHelper.Open(this, settings.CompilerSettings, DebuggeeMonikers.KitchenSink.Environment);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Configure launch");
LaunchCommand launch = new LaunchCommand(settings.DebuggerSettings, debuggee.OutputPath, false, "-fEnvironment")
{
StopAtEntry = false
};
if (variableValue != null)
{
launch.Args.environment = new EnvironmentEntry[] {
new EnvironmentEntry {
Name = variableName, Value = variableValue
}
};
}
launch.Args.externalConsole = newTerminal;
runner.RunCommand(launch);
this.Comment("Set breakpoint");
runner.SetBreakpoints(debuggee.Breakpoints(SinkHelper.Environment, 14));
runner.Expects.StoppedEvent(StoppedReason.Breakpoint).AfterConfigurationDone();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
IFrameInspector currentFrame = threadInspector.Stack.First();
this.Comment("Verify locals variables on current frame.");
currentFrame.AssertEvaluateAsString("varValue1", EvaluateContext.Watch, variableValue);
}
this.Comment("Continue until end");
runner.Expects.ExitedEvent()
.TerminatedEvent()
.AfterContinue();
runner.DisconnectAndVerify();
}
}
public void ThreadingBreakpoint(ITestSettings settings)
{
this.TestPurpose("Test breakpoint on multiple threads.");
this.WriteSettings(settings);
IDebuggee debuggee = SinkHelper.Open(this, settings.CompilerSettings, DebuggeeMonikers.KitchenSink.Threading);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Launching debuggee. Set breakpoint in worker thread code.");
runner.Launch(settings.DebuggerSettings, true, debuggee, "-fThreading");
runner.SetBreakpoints(debuggee.Breakpoints(SinkHelper.Threading, 16));
// Turned on stop at entry, so should stop before anything is executed.
// On Concord, this is a reason of "entry" versus "step" when it is hit.
if (settings.DebuggerSettings.DebuggerType == SupportedDebugger.VsDbg)
{
runner.Expects.HitEntryEvent().AfterConfigurationDone();
}
else
{
runner.Expects.HitStepEvent()
.AfterConfigurationDone();
}
// Since there are 4 worker threads, expect to hit the
// breakpoint 4 times, once on each thread.
for (int i = 1; i <= 4; i++)
{
StoppedEvent breakpointEvent = new StoppedEvent(StoppedReason.Breakpoint, SinkHelper.Threading, 16);
this.Comment("Run until breakpoint #{0}.", i);
runner.Expects.Event(breakpointEvent).AfterContinue();
this.WriteLine("Stopped on thread: {0}", breakpointEvent.ThreadId);
this.WriteLine("Ensure stopped thread exists in ThreadList");
IEnumerable <IThreadInfo> threadInfo = runner.GetThreads();
Assert.True(threadInfo.Any(thread => thread.Id == breakpointEvent.ThreadId), string.Format(CultureInfo.CurrentCulture, "ThreadId {0} should exist in ThreadList", breakpointEvent.ThreadId));
}
this.Comment("Run to end.");
runner.Expects.TerminatedEvent().AfterContinue();
runner.DisconnectAndVerify();
}
}
public void TestOptimizedLocals(ITestSettings settings)
{
this.TestPurpose("Tests basic local expression which is not been optimized");
this.WriteSettings(settings);
IDebuggee debuggee = Debuggee.Open(this, settings.CompilerSettings, Name, DebuggeeMonikers.Optimization.OptimizationWithSymbols);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Configure launch");
runner.Launch(settings.DebuggerSettings, debuggee);
SourceBreakpoints userDefinedClassBreakpoints = debuggee.Breakpoints(UserDefinedClassName, 54);
this.Comment("Set initial breakpoints");
runner.SetBreakpoints(userDefinedClassBreakpoints);
this.Comment("Launch and run until 1st bp");
runner.Expects.HitBreakpointEvent(UserDefinedClassName, 54)
.AfterConfigurationDone();
this.Comment("Check the un-optimized values");
using (IThreadInspector inspector = runner.GetThreadInspector())
{
IFrameInspector currentFrame = inspector.Stack.First();
IVariableInspector sum = currentFrame.Variables["sum"];
IVariableInspector first = currentFrame.Variables["first"];
this.Comment("Check the local variables in sub function");
Assert.Matches("^0", sum.Value);
Assert.Matches("^1", first.Value);
this.Comment("Step out");
runner.Expects.HitStepEvent(SourceName, 66)
.AfterStepOut();
this.Comment("Evaluate the expression:");
currentFrame = inspector.Stack.First();
inspector.AssertStackFrameNames(true, "main");
}
runner.DisconnectAndVerify();
}
}
public void WatchBasic(ITestSettings settings)
{
this.TestPurpose("Evaluate some expressions in watch.");
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 evaluate variables and functions in watch.");
string evalMyInt = currentFrame.Evaluate("myint-=100", EvaluateContext.Watch);
currentFrame.AssertEvaluateAsChar("mychar", EvaluateContext.Watch, 'A');
string evalMyBool = currentFrame.Evaluate("mybool", EvaluateContext.Watch);
currentFrame.AssertEvaluateAsWChar("mywchar", EvaluateContext.Watch, 'z');
currentFrame.AssertEvaluateAsDouble("mydouble", EvaluateContext.Watch, 321);
currentFrame.AssertEvaluateAsFloat("myfloat", EvaluateContext.Watch, 299);
string evalFuncMaxInt = currentFrame.Evaluate("Test::max(myint,1)", EvaluateContext.Watch);
currentFrame.AssertEvaluateAsDouble("Test::max(mydouble,0.0)-321.0", EvaluateContext.Watch, 0);
Assert.Equal("0", evalMyInt);
Assert.Equal("true", evalMyBool);
Assert.Equal("1", evalFuncMaxInt);
}
this.Comment("Run to completion");
runner.Expects.TerminatedEvent().AfterContinue();
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();
}
}
public void BreakpointBinding(ITestSettings settings)
{
this.TestPurpose("Tests that breakpoints are bound to the correct locations");
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);
SourceBreakpoints callingBreakpoints = debuggee.Breakpoints(SinkHelper.Calling, 11);
FunctionBreakpoints functionBreakpoints = new FunctionBreakpoints("Calling::CoreRun");
// 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 at a location that has no executable code, expect it to be moved to the next line");
runner.Expects.ConditionalEvent(!bindsLate, x => x.BreakpointChangedEvent(BreakpointReason.Changed, 12))
.AfterSetBreakpoints(callingBreakpoints);
this.Comment("Set a function breakpoint in a class member, expect it to be placed at the opening bracket");
runner.Expects.ConditionalEvent(!bindsLate, x => x.FunctionBreakpointChangedEvent(BreakpointReason.Changed, startLine: 47, endLine: 48))
.AfterSetFunctionBreakpoints(functionBreakpoints);
this.Comment("Set a function breakpoint in a non-member, expect it to be placed on the first line of code");
functionBreakpoints.Add("a()");
runner.Expects.ConditionalEvent(!bindsLate, x => x.FunctionBreakpointChangedEvent(BreakpointReason.Changed, startLine: 42, endLine: 43))
.AfterSetFunctionBreakpoints(functionBreakpoints);
runner.Expects.ConditionalEvent(bindsLate, x => x.BreakpointChangedEvent(BreakpointReason.Changed, 12)
.FunctionBreakpointChangedEvent(BreakpointReason.Changed, startLine: 47, endLine: 48)
.FunctionBreakpointChangedEvent(BreakpointReason.Changed, startLine: 42, endLine: 43))
.ExitedEvent()
.TerminatedEvent()
.AfterConfigurationDone();
runner.DisconnectAndVerify();
}
}
public void Detach(ITestSettings settings)
{
this.TestPurpose("Verify debugger can detach and reattach to a debuggee.");
this.WriteSettings(settings);
this.Comment("Starting debuggee");
IDebuggee debuggee = SinkHelper.Open(this, settings.CompilerSettings, DebuggeeMonikers.KitchenSink.Attach);
Process debuggeeProcess = debuggee.Launch("-fNonTerminating", "-fCalling");
using (ProcessHelper.ProcessCleanup(this, debuggeeProcess))
{
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Attaching first time");
runner.Attach(settings.DebuggerSettings, debuggeeProcess);
runner.ConfigurationDone();
this.Comment("Attempt to break all");
StoppedEvent breakAllEvent = new StoppedEvent(StoppedReason.Pause);
runner.Expects.Event(breakAllEvent)
.AfterAsyncBreak();
this.WriteLine("Break all stopped on:");
this.WriteLine(breakAllEvent.ActualEvent.ToString());
this.Comment("Detach then verify debugger closed");
runner.DisconnectAndVerify();
}
Assert.False(debuggeeProcess.HasExited, "Debuggee should still be running.");
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Attaching second time");
runner.Attach(settings.DebuggerSettings, debuggeeProcess);
runner.ConfigurationDone();
this.Comment("Detach then verify debugger closed");
runner.DisconnectAndVerify();
}
}
}
public void Run(IDebuggerRunner runner, params IEvent[] expectedEvents)
{
Parameter.ThrowIfNull(runner, nameof(runner));
if (runner.ErrorEncountered)
{
runner.WriteLine("Previous error. Skipping command '{0}'.", this.Name);
return;
}
try
{
this.Run(runner.DarRunner, runner, expectedEvents);
}
catch (Exception)
{
runner.ErrorEncountered = true;
throw;
}
}
public void AssignInvalidExpressionToVariable(ITestSettings settings)
{
this.TestPurpose("Assign an invalid expression to a variable.");
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 breakpoint so that we can stop at a line.");
runner.SetBreakpoints(debuggee.Breakpoints(SinkHelper.Expression, 31));
this.Comment("Start debugging and hit breakpoint.");
runner.Expects.StoppedEvent(StoppedReason.Breakpoint).AfterConfigurationDone();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
IFrameInspector currentFrame = threadInspector.Stack.First();
this.Comment("Assign an invalid expression to a variable.");
currentFrame.GetVariable("myint").SetVariableValueExpectFailure("39+nonexistingint");
}
// Start another inspector to refresh values
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
IFrameInspector currentFrame = threadInspector.Stack.First();
this.Comment("Check the value of the variable hasn't been updated.");
Assert.Equal("100", currentFrame.GetVariable("myint").Value);
}
this.Comment("Continue to run to exist.");
runner.Expects.TerminatedEvent().AfterContinue();
runner.DisconnectAndVerify();
}
}
public void FunctionBreakpointsBasic(ITestSettings settings)
{
this.TestPurpose("Tests basic operation of function breakpoints");
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 initial function breakpoints");
FunctionBreakpoints functionBreakpoints = new FunctionBreakpoints("Arguments::CoreRun", "Calling::CoreRun", "a()");
runner.SetFunctionBreakpoints(functionBreakpoints);
this.Comment("Launch and run until first initial breakpoint");
runner.ExpectBreakpointAndStepToTarget(SinkHelper.Arguments, startLine: 9, targetLine: 10)
.AfterConfigurationDone();
this.Comment("Continue until second initial breakpoint");
runner.ExpectBreakpointAndStepToTarget(SinkHelper.Calling, startLine: 47, targetLine: 48)
.AfterContinue();
this.Comment("Remove and replace third initial function breakpoint while in break mode");
functionBreakpoints.Remove("a()");
functionBreakpoints.Add("b()");
runner.SetFunctionBreakpoints(functionBreakpoints);
this.Comment("Continue until newly-added function breakpoint");
runner.ExpectBreakpointAndStepToTarget(SinkHelper.Calling, startLine: 37, targetLine: 38)
.AfterContinue();
this.Comment("Continue until end");
runner.Expects.ExitedEvent()
.TerminatedEvent()
.AfterContinue();
runner.DisconnectAndVerify();
}
}
public void ExecutionAsyncBreak(ITestSettings settings)
{
this.TestPurpose("Verify break all should work run function");
this.WriteSettings(settings);
this.Comment("Open the kitchen sink debuggee for execution tests.");
IDebuggee debuggee = SinkHelper.Open(this, settings.CompilerSettings, DebuggeeMonikers.KitchenSink.Execution);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Configure launch");
runner.Launch(settings.DebuggerSettings, debuggee, "-fNonTerminating", "-fCalling");
this.Comment("Try to break all");
StoppedEvent breakAllEvent = new StoppedEvent(StoppedReason.Pause);
runner.Expects.Event(breakAllEvent).AfterAsyncBreak();
this.WriteLine("Break all stopped on:");
this.WriteLine(breakAllEvent.ActualEvent.ToString());
this.Comment("Set a breakpoint while breaking code");
runner.SetBreakpoints(debuggee.Breakpoints(SinkHelper.NonTerminating, 28));
this.Comment("Start running after the async break and then hit the breakpoint");
runner.Expects.HitBreakpointEvent(SinkHelper.NonTerminating, 28).AfterContinue();
this.Comment("Evaluate the shouldExit member to true to stop the infinite loop.");
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
IFrameInspector firstFrame = threadInspector.Stack.First();
this.WriteLine(firstFrame.ToString());
firstFrame.GetVariable("shouldExit").Value = "true";
}
this.Comment("Continue running at the end of application");
runner.Expects.ExitedEvent().TerminatedEvent().AfterContinue();
this.Comment("Verify debugger and debuggee closed");
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 DuplicateBreakpoints(ITestSettings settings)
{
this.TestPurpose("Tests that duplicate breakpoints are only hit once");
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");
// These two breakpoints should resolve to the same line - setting two breakpoints on the same
// line directly will throw an exception.
SourceBreakpoints callingBreakpoints = debuggee.Breakpoints(SinkHelper.Calling, 11, 12);
this.Comment("Set two line breakpoints that resolve to the same source location");
runner.SetBreakpoints(callingBreakpoints);
this.Comment("Set duplicate function breakpoints");
FunctionBreakpoints functionBreakpoints = new FunctionBreakpoints("Arguments::CoreRun", "Arguments::CoreRun");
runner.SetFunctionBreakpoints(functionBreakpoints);
this.Comment("Run to first breakpoint");
runner.ExpectBreakpointAndStepToTarget(SinkHelper.Arguments, startLine: 9, targetLine: 10)
.AfterConfigurationDone();
this.Comment("Run to second breakpoint");
runner.Expects.HitBreakpointEvent(SinkHelper.Calling, 12)
.AfterContinue();
this.Comment("Run to completion");
runner.Expects.ExitedEvent()
.TerminatedEvent()
.AfterContinue();
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 RunBuilder(IDebuggerRunner runner)
{
this.Runner = runner;
this.expectedEvents = new List <IEvent>(1);
this.postSatisfyActions = new Stack <Action>();
}
