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>
/// Creates a SourceBreakpoints object that can be used to keep
/// track of all the breakpoints in a file.
/// </summary>
public static SourceBreakpoints Breakpoints(this IDebuggee debuggee, string sourceRelativePath, params int[] lineNumbers)
{
SourceBreakpoints breakpoints = new SourceBreakpoints(debuggee, sourceRelativePath);
foreach (int lineNumber in lineNumbers)
{
breakpoints.Add(lineNumber);
}
return(breakpoints);
}
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 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 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 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 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 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 CoreDumpVerifyActions(ITestSettings settings)
{
this.TestPurpose("This test checks to see the behavior when do actions during core dump debugging.");
this.WriteSettings(settings);
this.Comment("Compile the application");
CompileApp(this, settings, DebuggeeMonikers.CoreDump.Action);
this.Comment("Set initial debuggee for application");
IDebuggee debuggee = OpenDebuggee(this, settings, DebuggeeMonikers.CoreDump.Action);
this.Comment("Launch the application to hit an exception and generate core dump");
string coreDumpPath = GenerateCoreDump(settings, DebuggeeMonikers.CoreDump.Action, 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 error message for relevant actions during core dump debugging");
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("Try to evaluate a expression and verify the results");
string varEvalResult = currentFrame.Evaluate("result + 1");
Assert.Equal("11", varEvalResult);
this.Comment("Try to evaluate a function and verify the error message");
EvaluateResponseValue evalResponse = runner.RunCommand(new EvaluateCommand("EvalFunc(100, 100)", currentFrame.Id));
// TODO: From VSCode IDE with the latest cpptools, the error message after evaluate function is "not availabe", but evalResponse.message is null, is it expected ?
// Currently just simply verify the result is empty as a workaround, need to revisit this once get more information from logged bug #242418
this.Comment(string.Format(CultureInfo.InvariantCulture, "Actual evaluated result: {0}", evalResponse.body.result));
Assert.True(evalResponse.body.result.Equals(string.Empty));
this.Comment(string.Format(CultureInfo.InvariantCulture, "Actual evaluated respone message: {0}", evalResponse.message));
//Assert.True(evalResponse.message.Contains(evalError));
}
this.Comment("Try to step in and verify the error message");
StepInCommand stepInCommand = new StepInCommand(runner.DarRunner.CurrentThreadId);
runner.RunCommandExpectFailure(stepInCommand);
this.WriteLine(string.Format(CultureInfo.InvariantCulture, "Actual respone message: {0}", stepInCommand.Message));
Assert.Contains(stepInCommand.Message, string.Format(CultureInfo.InvariantCulture, stepError, "step in"));
this.Comment("Try to step over and verify the error message");
StepOverCommand stepOverCommand = new StepOverCommand(runner.DarRunner.CurrentThreadId);
runner.RunCommandExpectFailure(stepOverCommand);
this.WriteLine(string.Format(CultureInfo.InvariantCulture, "Actual respone message: {0}", stepOverCommand.Message));
Assert.Contains(stepOverCommand.Message, string.Format(CultureInfo.InvariantCulture, stepError, "step next"));
this.Comment("Try to step out and verify the error message");
StepOutCommand stepOutCommand = new StepOutCommand(runner.DarRunner.CurrentThreadId);
runner.RunCommandExpectFailure(stepOutCommand);
this.WriteLine(string.Format(CultureInfo.InvariantCulture, "Actual respone message: {0}", stepOutCommand.Message));
Assert.Contains(stepOutCommand.Message, string.Format(CultureInfo.InvariantCulture, stepError, "step out"));
this.Comment("Try to continue and verify the error message");
ContinueCommand continueCommand = new ContinueCommand(runner.DarRunner.CurrentThreadId);
runner.RunCommandExpectFailure(continueCommand);
this.WriteLine(string.Format(CultureInfo.InvariantCulture, "Actual respone message: {0}", continueCommand.Message));
Assert.Contains(continueCommand.Message, string.Format(CultureInfo.InvariantCulture, stepError, "continue"));
this.Comment("Try to set a breakpoint and verify the error message");
SourceBreakpoints bp = debuggee.Breakpoints(srcAppName, 16);
SetBreakpointsResponseValue setBpResponse = runner.SetBreakpoints(bp);
Assert.False(setBpResponse.body.breakpoints[0].verified);
this.WriteLine(string.Format(CultureInfo.InvariantCulture, "Actual respone message: {0}", setBpResponse.body.breakpoints[0].message));
Assert.Contains(setBpResponse.body.breakpoints[0].message, bpError);
this.Comment("Stop core dump debugging");
runner.DisconnectAndVerify();
}
}
public static SetBreakpointsResponseValue SetBreakpoints(this IDebuggerRunner runner, SourceBreakpoints sourceBreakpoints)
{
return(runner.RunCommand(new SetBreakpointsCommand(sourceBreakpoints)));
}
public void TestOptimizedSharedLib(ITestSettings settings)
{
this.TestPurpose("Tests basic bps and source information for shared library");
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, 87, 89);
SourceBreakpoints libBreakpoints = debuggee.Breakpoints(SrcLibName, 9, 12);
this.Comment("Set initial breakpoints");
runner.SetBreakpoints(mainBreakpoints);
runner.SetBreakpoints(libBreakpoints);
this.Comment("Launch and run until 1st bp");
runner.Expects.HitBreakpointEvent(SourceName, 87)
.AfterConfigurationDone();
//Todo: this has different behavior on Mac, I have logged bug#247895 to track
//Del said that Different compilers generate symbols differently.
//Our tests have to be resilient to this fact. The location of the step is reasonable,
//so this is by design.
this.Comment("enter into the library source");
runner.ExpectBreakpointAndStepToTarget(SrcLibName, 8, 9).AfterContinue();
this.Comment("Step over");
runner.Expects.HitStepEvent(SrcLibName, 10).AfterStepOver();
this.Comment("Check the un-optimized values in shared library");
using (IThreadInspector inspector = runner.GetThreadInspector())
{
IFrameInspector currentFrame = inspector.Stack.First();
IVariableInspector age = currentFrame.Variables["age"];
this.Comment("Check the local variable in sub function");
Assert.Matches("31", age.Value);
this.Comment("run to continue");
if (settings.DebuggerSettings.DebuggerType == SupportedDebugger.Lldb)
{
runner.Expects.HitBreakpointEvent(SourceName, 89)
.AfterContinue();
this.Comment("Verify current frame for main func");
inspector.AssertStackFrameNames(true, "main");
}
else
{
runner.Expects.HitBreakpointEvent(SrcLibName, 12)
.AfterContinue();
this.Comment("Verify current frame for library func");
inspector.AssertStackFrameNames(true, "myClass::DisplayAge");
this.Comment("Step out to main entry");
runner.Expects.HitBreakpointEvent(SourceName, 89).AfterContinue();
this.Comment("Verify current frame for main entry");
inspector.AssertStackFrameNames(true, "main");
}
this.Comment("Evaluate the expression:");
//skip the Mac's verification as bug#247893
currentFrame = inspector.Stack.First();
string strAge = currentFrame.Evaluate("myclass->DisplayAge(30)");
if (settings.DebuggerSettings.DebuggerType == SupportedDebugger.Gdb_MinGW ||
settings.DebuggerSettings.DebuggerType == SupportedDebugger.Gdb_Cygwin)
{
Assert.Equal("Cannot evaluate function -- may be inlined", strAge);
}
}
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 MapSpecificFile(ITestSettings settings)
{
this.TestPurpose("Validate Specific File Mapping.");
this.WriteSettings(settings);
IDebuggee debuggee = SourceMappingHelper.Open(this, settings.CompilerSettings, DebuggeeMonikers.SourceMapping.Default);
// VsDbg is case insensitive on Windows so sometimes stackframe file names might all be lowercase
StringComparison comparison = settings.DebuggerSettings.DebuggerType == SupportedDebugger.VsDbg ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Configure");
LaunchCommand launch = new LaunchCommand(settings.DebuggerSettings, debuggee.OutputPath, false);
launch.Args.externalConsole = false;
this.Comment("Setting up Source File Mappings");
Dictionary <string, string> sourceMappings = new Dictionary <string, string>();
string pathRoot = Path.GetPathRoot(debuggee.SourceRoot);
string sourceFileMapping = Path.Combine(pathRoot, Path.GetRandomFileName(), SourceMappingHelper.Writer);
string compileFileMapping = Path.Combine(debuggee.SourceRoot, SourceMappingHelper.WriterFolder, SourceMappingHelper.Writer);
if (PlatformUtilities.IsWindows)
{
// Move file to the location
Directory.CreateDirectory(Path.GetDirectoryName(sourceFileMapping));
File.Copy(compileFileMapping, sourceFileMapping, true);
}
// Drive letter should be lowercase
sourceMappings.Add(compileFileMapping, sourceFileMapping);
launch.Args.sourceFileMap = sourceMappings;
try
{
runner.RunCommand(launch);
this.Comment("Set Breakpoint");
SourceBreakpoints writerBreakpoints = debuggee.Breakpoints(SourceMappingHelper.Writer, 9);
runner.SetBreakpoints(writerBreakpoints);
runner.Expects.StoppedEvent(StoppedReason.Breakpoint).AfterConfigurationDone();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
IEnumerator <IFrameInspector> frameEnumerator = threadInspector.Stack.GetEnumerator();
// Move to first stack item
Assert.True(frameEnumerator.MoveNext());
this.Comment("Verify path is changed for writer.cpp frame");
ValidateMappingToFrame(SourceMappingHelper.Writer, EnsureDriveLetterLowercase(sourceFileMapping), frameEnumerator.Current, comparison);
// Move to second stack item
Assert.True(frameEnumerator.MoveNext());
this.Comment("Verify path is not changed for main.cpp frame.");
ValidateMappingToFrame(SourceMappingHelper.Main, EnsureDriveLetterLowercase(Path.Combine(debuggee.SourceRoot, SourceMappingHelper.Main)), frameEnumerator.Current, comparison);
writerBreakpoints.Remove(9);
runner.SetBreakpoints(writerBreakpoints);
this.Comment("Continue to end");
runner.Expects.TerminatedEvent().AfterContinue();
runner.DisconnectAndVerify();
}
}
finally
{
if (PlatformUtilities.IsWindows)
{
// Cleanup the directory
if (Directory.Exists(Path.GetDirectoryName(sourceFileMapping)))
{
Directory.Delete(Path.GetDirectoryName(sourceFileMapping), true);
}
}
}
}
}
public void LineBreakpointsBasic(ITestSettings settings)
{
this.TestPurpose("Tests basic operation of line 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");
// These keep track of all the breakpoints in a source file
SourceBreakpoints argumentsBreakpoints = debuggee.Breakpoints(SinkHelper.Arguments, 23);
SourceBreakpoints mainBreakpoints = debuggee.Breakpoints(SinkHelper.Main, 33);
SourceBreakpoints callingBreakpoints = debuggee.Breakpoints(SinkHelper.Calling, 48);
// A bug in clang causes several breakpoint hits in a constructor
// See: https://llvm.org/bugs/show_bug.cgi?id=30620
if (settings.CompilerSettings.CompilerType != SupportedCompiler.ClangPlusPlus)
{
callingBreakpoints.Add(6);
}
this.Comment("Set initial breakpoints");
runner.SetBreakpoints(argumentsBreakpoints);
runner.SetBreakpoints(mainBreakpoints);
runner.SetBreakpoints(callingBreakpoints);
this.Comment("Launch and run until first breakpoint");
runner.Expects.HitBreakpointEvent(SinkHelper.Arguments, 23)
.AfterConfigurationDone();
// A bug in clang causes several breakpoint hits in a constructor
// See: https://llvm.org/bugs/show_bug.cgi?id=30620
if (settings.CompilerSettings.CompilerType != SupportedCompiler.ClangPlusPlus)
{
this.Comment("Continue until second initial breakpoint");
runner.Expects.HitBreakpointEvent(SinkHelper.Calling, 6).AfterContinue();
}
this.Comment("Disable third initial breakpoint");
mainBreakpoints.Remove(33);
runner.SetBreakpoints(mainBreakpoints);
this.Comment("Continue, hit fourth initial breakpoint");
runner.Expects.HitBreakpointEvent(SinkHelper.Calling, 48).AfterContinue();
this.Comment("Set a breakpoint while in break mode");
callingBreakpoints.Add(52);
runner.SetBreakpoints(callingBreakpoints);
this.Comment("Continue until newly-added breakpoint");
runner.Expects.HitBreakpointEvent(SinkHelper.Calling, 52)
.AfterContinue();
this.Comment("Continue until end");
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 MapDirectory(ITestSettings settings)
{
this.TestPurpose("Validate Source Mapping.");
this.WriteSettings(settings);
IDebuggee debuggee = SourceMappingHelper.Open(this, settings.CompilerSettings, DebuggeeMonikers.SourceMapping.Default);
// VsDbg is case insensitive on Windows so sometimes stackframe file names might all be lowercase
StringComparison comparison = settings.DebuggerSettings.DebuggerType == SupportedDebugger.VsDbg ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Configure");
LaunchCommand launch = new LaunchCommand(settings.DebuggerSettings, debuggee.OutputPath, false, "-fCalling");
launch.Args.externalConsole = false;
this.Comment("Setting up Source File Mappings");
Dictionary <string, string> sourceMappings = new Dictionary <string, string>();
string pathRoot = Path.GetPathRoot(debuggee.SourceRoot);
string mgrDirectoryMapping = Path.Combine(debuggee.SourceRoot, SourceMappingHelper.Manager, Path.GetRandomFileName());
string writerDirectoryMapping = Path.Combine(pathRoot, Path.GetRandomFileName(), Path.GetRandomFileName());
string rootDirectoryMapping = Path.Combine(pathRoot, Path.GetRandomFileName());
sourceMappings.Add(Path.Combine(debuggee.SourceRoot, SourceMappingHelper.WriterFolder), writerDirectoryMapping);
sourceMappings.Add(Path.Combine(debuggee.SourceRoot, SourceMappingHelper.ManagerFolder), mgrDirectoryMapping);
sourceMappings.Add(debuggee.SourceRoot, rootDirectoryMapping);
launch.Args.sourceFileMap = sourceMappings;
try
{
if (PlatformUtilities.IsWindows)
{
// Create all the directories but only some of the files will exist on disk.
foreach (var dir in sourceMappings.Values)
{
Directory.CreateDirectory(dir);
}
File.Copy(Path.Combine(debuggee.SourceRoot, SourceMappingHelper.WriterFolder, SourceMappingHelper.Writer), Path.Combine(writerDirectoryMapping, SourceMappingHelper.Writer), true);
File.Copy(Path.Combine(debuggee.SourceRoot, SourceMappingHelper.Main), Path.Combine(rootDirectoryMapping, SourceMappingHelper.Main), true);
}
runner.RunCommand(launch);
this.Comment("Set Breakpoint");
SourceBreakpoints writerBreakpoints = debuggee.Breakpoints(SourceMappingHelper.Writer, 9);
SourceBreakpoints managerBreakpoints = debuggee.Breakpoints(SourceMappingHelper.Manager, 8);
runner.SetBreakpoints(writerBreakpoints);
runner.SetBreakpoints(managerBreakpoints);
runner.Expects.StoppedEvent(StoppedReason.Breakpoint).AfterConfigurationDone();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
IEnumerator <IFrameInspector> frameEnumerator = threadInspector.Stack.GetEnumerator();
// Move to first stack item
Assert.True(frameEnumerator.MoveNext());
this.Comment(string.Format(CultureInfo.InvariantCulture, "Verify source path for {0}.", SourceMappingHelper.Writer));
// Since file is there, lowercase the drive letter
ValidateMappingToFrame(SourceMappingHelper.Writer, EnsureDriveLetterLowercase(Path.Combine(writerDirectoryMapping, SourceMappingHelper.Writer)), frameEnumerator.Current, comparison);
// Move to second stack item
Assert.True(frameEnumerator.MoveNext());
this.Comment(string.Format(CultureInfo.InvariantCulture, "Verify source path for {0}.", SourceMappingHelper.Main));
// Since file is there, lowercase the drive letter
ValidateMappingToFrame(SourceMappingHelper.Main, EnsureDriveLetterLowercase(Path.Combine(rootDirectoryMapping, SourceMappingHelper.Main)), frameEnumerator.Current, comparison);
}
runner.Expects.StoppedEvent(StoppedReason.Breakpoint).AfterContinue();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
IEnumerator <IFrameInspector> frameEnumerator = threadInspector.Stack.GetEnumerator();
// Move to first stack item
Assert.True(frameEnumerator.MoveNext());
this.Comment(string.Format(CultureInfo.InvariantCulture, "Verify source path for {0}.", SourceMappingHelper.Manager));
// Since file is not there, keep what was passed in
ValidateMappingToFrame(SourceMappingHelper.Manager, EnsureDriveLetterLowercase(Path.Combine(mgrDirectoryMapping, SourceMappingHelper.Manager)), frameEnumerator.Current, comparison);
// Move to second stack item
Assert.True(frameEnumerator.MoveNext());
this.Comment(string.Format(CultureInfo.InvariantCulture, "Verify source path for {0}.", SourceMappingHelper.Main));
// Since file is there, lowercase the drive letter
ValidateMappingToFrame(SourceMappingHelper.Main, EnsureDriveLetterLowercase(Path.Combine(rootDirectoryMapping, SourceMappingHelper.Main)), frameEnumerator.Current, comparison);
}
writerBreakpoints.Remove(9);
managerBreakpoints.Remove(8);
runner.SetBreakpoints(writerBreakpoints);
runner.SetBreakpoints(managerBreakpoints);
this.Comment("Continue to end");
runner.Expects.TerminatedEvent().AfterContinue();
runner.DisconnectAndVerify();
}
finally
{
if (PlatformUtilities.IsWindows)
{
foreach (var dir in sourceMappings.Values)
{
if (Directory.Exists(dir))
{
Directory.Delete(dir, recursive: true);
}
}
}
}
}
}
public void ExecutionStepRecursiveCall(ITestSettings settings)
{
this.TestPurpose("Verify steps should work when debugging recursive call");
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 function breakpoints");
FunctionBreakpoints funcBp = new FunctionBreakpoints("Calling::CoreRun()");
runner.SetFunctionBreakpoints(funcBp);
this.Comment("Launch and run until hit function breakpoint in the entry of calling");
runner.ExpectBreakpointAndStepToTarget(SinkHelper.Calling, startLine: 47, targetLine: 48).AfterConfigurationDone();
this.Comment("Step over to go to the entry of recursive call");
runner.Expects.HitStepEvent(SinkHelper.Calling, 49).AfterStepOver();
this.Comment("Step in the recursive call");
runner.ExpectStepAndStepToTarget(SinkHelper.Calling, startLine: 25, targetLine: 26).AfterStepIn();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
this.Comment("Set count = 2");
IFrameInspector currentFrame = threadInspector.Stack.First();
currentFrame.GetVariable("count").Value = "2";
this.Comment("Verify there is only one 'recursiveCall' frames");
threadInspector.AssertStackFrameNames(true, "recursiveCall.*", "Calling::CoreRun.*", "Feature::Run.*", "main.*");
}
this.Comment("Step over and then step in the recursive call once again");
runner.Expects.HitStepEvent(SinkHelper.Calling, 29).AfterStepOver();
runner.ExpectStepAndStepToTarget(SinkHelper.Calling, startLine: 25, targetLine: 26).AfterStepIn();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
this.Comment("Verify there are two 'recursiveCall' frames");
threadInspector.AssertStackFrameNames(true, "recursiveCall.*", "recursiveCall.*", "Calling::CoreRun.*", "Feature::Run.*", "main.*");
this.Comment("Set a source breakpoint in recursive call");
SourceBreakpoints srcBp = debuggee.Breakpoints(SinkHelper.Calling, 26);
runner.SetBreakpoints(srcBp);
}
this.Comment("Step over the recursive call and hit the source breakpoint");
runner.Expects.HitStepEvent(SinkHelper.Calling, 29).AfterStepOver();
runner.Expects.HitBreakpointEvent(SinkHelper.Calling, 26).AfterStepOver();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
this.Comment("Verify there are three 'recursiveCall' frames");
threadInspector.AssertStackFrameNames(true, "recursiveCall.*", "recursiveCall.*", "recursiveCall.*", "Calling::CoreRun.*", "Feature::Run.*", "main.*");
}
this.Comment("Try to step out twice from recursive call");
runner.ExpectStepAndStepToTarget(SinkHelper.Calling, 29, 30).AfterStepOut();
runner.ExpectStepAndStepToTarget(SinkHelper.Calling, 29, 30).AfterStepOut();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
this.Comment("Verify 'recursiveCall' return back only one frame");
threadInspector.AssertStackFrameNames(true, "recursiveCall.*", "Calling::CoreRun.*", "Feature::Run.*", "main.*");
}
this.Comment("Step over from recursive call");
runner.ExpectStepAndStepToTarget(SinkHelper.Calling, 49, 50).AfterStepOver();
using (IThreadInspector threadInspector = runner.GetThreadInspector())
{
this.Comment("Verify there is not 'recursiveCall' frame");
threadInspector.AssertStackFrameNames(true, "Calling::CoreRun.*", "Feature::Run.*", "main.*");
}
this.Comment("Verify stop debugging");
runner.DisconnectAndVerify();
}
}
public static void AfterSetBreakpoints(this IRunBuilder runBuilder, SourceBreakpoints sourceBreakpoints)
{
runBuilder.AfterCommand(new SetBreakpointsCommand(sourceBreakpoints));
}
/// <summary>
/// Testing the common targeted scenarios
/// </summary>
private void RunTargetedScenarios(ITestSettings settings, string outputName, int debuggeeMoniker)
{
this.Comment("Set initial debuggee");
IDebuggee debuggee = Debuggee.Open(this, settings.CompilerSettings, debuggeeName, debuggeeMoniker, outAppName);
using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
{
this.Comment("Configure launch");
runner.Launch(settings.DebuggerSettings, debuggee);
this.Comment("Set initial function breakpoints");
FunctionBreakpoints functionBreakpoints = new FunctionBreakpoints("main", "myClass::DisplayName", "myClass::DisplayAge");
runner.SetFunctionBreakpoints(functionBreakpoints);
this.Comment("Set line breakpoints to the lines with entry of shared library");
SourceBreakpoints bps = debuggee.Breakpoints(srcAppName, 71, 77);
runner.SetBreakpoints(bps);
this.Comment("Launch and run until first breakpoint in the entry of main");
runner.ExpectBreakpointAndStepToTarget(srcAppName, startLine: 62, targetLine: 63)
.AfterConfigurationDone();
this.Comment("Continue to go to the line which is the first entry of shared library");
runner.Expects.HitBreakpointEvent(srcAppName, 71)
.AfterContinue();
this.Comment("Step into the function in shared library");
runner.Expects.HitStepEvent(srcLibName, 23)
.AfterStepIn();
this.Comment("Step out to go back to the entry in main function");
runner.Expects.HitStepEvent(srcAppName, 71)
.AfterStepOut();
this.Comment("Step over to go to the line which is the second entry of shared library");
runner.Expects.HitStepEvent(srcAppName, 73).AfterStepOver();
this.Comment("Step over a function which have a breakpoint set in shared library");
runner.ExpectBreakpointAndStepToTarget(srcLibName, startLine: 8, targetLine: 9).AfterStepOver();
this.Comment("Step over a line in function which is inside shared library");
runner.Expects.HitStepEvent(srcLibName, 10).AfterStepOver();
this.Comment("Step out to go back to the entry in main function");
runner.ExpectStepAndStepToTarget(srcAppName, startLine: 73, targetLine: 75).AfterStepOut();
this.Comment("Continue to hit breakpoint in function which is inside shared library");
runner.ExpectBreakpointAndStepToTarget(srcLibName, startLine: 15, targetLine: 16)
.AfterContinue();
this.Comment("Continue to hit breakpoint which set in the last entry of shared library");
runner.Expects.HitBreakpointEvent(srcAppName, 77).AfterContinue();
this.Comment("Step over a function which don't have breakpoint set in shared library");
runner.Expects.HitStepEvent(srcAppName, 79)
.AfterStepOver();
this.Comment("Continue to run till at the end of the application");
runner.Expects.TerminatedEvent().AfterContinue();
runner.DisconnectAndVerify();
}
}
