예제 #1
0
        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();
            }
        }
예제 #2
0
        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();
            }
        }
예제 #3
0
        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();
            }
        }
예제 #4
0
        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();
            }
        }
예제 #5
0
        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();
            }
        }
예제 #6
0
        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.");
                }
        }
예제 #7
0
        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();
            }
        }
예제 #8
0
        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();
            }
        }
예제 #9
0
        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();
            }
        }
예제 #10
0
        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();
            }
        }
예제 #11
0
        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();
            }
        }
예제 #12
0
        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();
                }
            }
        }
예제 #13
0
        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();
            }
        }
예제 #14
0
        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();
            }
        }
예제 #15
0
        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();
            }
        }
예제 #16
0
        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();
            }
        }
예제 #17
0
        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();
            }
        }
예제 #18
0
        public void EvaluateOnFrames(ITestSettings settings)
        {
            this.TestPurpose("To check evalution on different frame with different variable types.");
            this.WriteSettings(settings);

            this.Comment("Open the debugge with a initialization.");
            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, 19));

                this.Comment("To start debugging and break");
                runner.Expects.StoppedEvent(StoppedReason.Breakpoint).AfterConfigurationDone();

                using (IThreadInspector threadInspector = runner.GetThreadInspector())
                {
                    IFrameInspector currentFrame;

                    this.Comment("To evaluate on the first frame.");
                    currentFrame = threadInspector.Stack.First();
                    currentFrame.AssertVariables("isCalled", "true");
                    Assert.Equal("true", currentFrame.Evaluate("isCalled||false", EvaluateContext.Watch));
                    currentFrame.AssertEvaluateAsDouble("d", EvaluateContext.Watch, 10.1);

                    this.Comment("Switch to next frame then evaluate on that frame.");
                    currentFrame = threadInspector.Stack.ElementAt(1);
                    currentFrame.GetVariable("_f").AssertValueAsFloat(1);
                    currentFrame.AssertEvaluateAsFloat("_f", EvaluateContext.Watch, 1);

                    this.Comment("To evaluate string and vector type on it, the try to enable pretty printing to evaluate again.");
                    currentFrame = threadInspector.Stack.ElementAt(2);
                    currentFrame.GetVariable("vec").AssertValueAsVector(5);
                    currentFrame.AssertEvaluateAsVector("vec", EvaluateContext.Watch, 5);

                    this.Comment("To evaluate some special values on the fourth frame.");
                    currentFrame = threadInspector.Stack.ElementAt(3);
                    currentFrame.AssertEvaluateAsDouble("mydouble=1.0", EvaluateContext.Watch, 1);
                    currentFrame.GetVariable("mynull").AssertValueAsChar('\0');

                    this.Comment("To evaluate class on stack on the fifth frame.");
                    currentFrame = threadInspector.Stack.ElementAt(4);
                    IVariableInspector varInspector;
                    varInspector = currentFrame.GetVariable("student");
                    Assert.Equal("10", varInspector.GetVariable("age").Value);
                    Assert.Equal("19", currentFrame.Evaluate("student.age=19", EvaluateContext.Watch));

                    this.Comment("To evaluate array on the sixth frame.");
                    currentFrame = threadInspector.Stack.ElementAt(5);
                    Assert.Equal("10", currentFrame.Evaluate("*(pArr+1)=10", EvaluateContext.Watch));
                    Assert.Equal("100", currentFrame.Evaluate("arr[0]=100", EvaluateContext.Watch));
                }


                this.Comment("Continue to run to exist.");
                runner.Expects.TerminatedEvent().AfterContinue();

                runner.DisconnectAndVerify();
            }
        }
예제 #19
0
        public void DataTipBasic(ITestSettings settings)
        {
            this.TestPurpose("To test evaluation in datatip.");
            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("To set a breakpoint so that we can stop at somewhere for evaluation.");
                runner.SetBreakpoints(debuggee.Breakpoints(SinkHelper.Expression, 19));

                this.Comment("To start debugging and break");
                runner.Expects.StoppedEvent(StoppedReason.Breakpoint).AfterConfigurationDone();

                using (IThreadInspector threadInspector = runner.GetThreadInspector())
                {
                    IFrameInspector currentFrame;

                    this.Comment("To evaluate in datatip on the first frame.");
                    currentFrame = threadInspector.Stack.First();
                    Assert.Equal("true", currentFrame.Evaluate("isCalled", EvaluateContext.DataTip));
                    currentFrame.AssertEvaluateAsDouble("d", EvaluateContext.DataTip, 10.1);

                    // We only verify the major contents in datatip
                    Assert.Contains(@"accumulate(int)", currentFrame.Evaluate("accumulate", EvaluateContext.DataTip), StringComparison.Ordinal);

                    this.Comment("To evaluate in datatip on the fourth frame.");
                    currentFrame = threadInspector.Stack.ElementAt(3);
                    currentFrame.AssertEvaluateAsDouble("mydouble", EvaluateContext.DataTip, double.PositiveInfinity);
                    currentFrame.AssertEvaluateAsChar("mynull", EvaluateContext.DataTip, '\0');

                    this.Comment("To evaluate in datatip on the fifth frame.");
                    currentFrame = threadInspector.Stack.ElementAt(4);
                    currentFrame.AssertEvaluateAsObject("student", EvaluateContext.DataTip, "name", @"""John""", "age", "10");
                    Assert.Matches(@"0x[0-9A-Fa-f]+", currentFrame.Evaluate("pStu", EvaluateContext.DataTip));

                    this.Comment("To evaluate in datatip on the sixth frame.");
                    currentFrame = threadInspector.Stack.ElementAt(5);
                    currentFrame.AssertEvaluateAsIntArray("arr", EvaluateContext.DataTip, 0, 1, 2, 3, 4);
                    Assert.Matches(@"0x[0-9A-Fa-f]+", currentFrame.Evaluate("pArr", EvaluateContext.DataTip));

                    this.Comment("To evaluate in datatip on the seventh frame.");
                    currentFrame = threadInspector.Stack.ElementAt(6);
                    Assert.Equal("true", currentFrame.Evaluate("mybool", EvaluateContext.DataTip));
                    Assert.Equal("100", currentFrame.Evaluate("myint", EvaluateContext.DataTip));
                    currentFrame.AssertEvaluateAsFloat("myfloat", EvaluateContext.DataTip, 299);
                    currentFrame.AssertEvaluateAsDouble("mydouble", EvaluateContext.DataTip, 321);
                    currentFrame.AssertEvaluateAsChar("mychar", EvaluateContext.DataTip, 'A');
                    currentFrame.AssertEvaluateAsWChar("mywchar", EvaluateContext.DataTip, 'z');
                }

                this.Comment("Continue to run to exist.");
                runner.Expects.TerminatedEvent().AfterContinue();

                runner.DisconnectAndVerify();
            }
        }
예제 #20
0
        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();
            }
        }
예제 #21
0
        public void ThreadingBasic(ITestSettings settings)
        {
            this.TestPurpose("Test basic multithreading scenario.");
            this.WriteSettings(settings);

            IDebuggee debuggee = SinkHelper.Open(this, settings.CompilerSettings, DebuggeeMonikers.KitchenSink.Threading);

            using (IDebuggerRunner runner = CreateDebugAdapterRunner(settings))
            {
                this.Comment("Launching debuggee. Run until multiple threads are running.");
                runner.Launch(settings.DebuggerSettings, debuggee, "-fThreading");
                runner.SetBreakpoints(debuggee.Breakpoints(SinkHelper.Threading, 37));

                runner.Expects.HitBreakpointEvent()
                .AfterConfigurationDone();

                IEnumerable <IThreadInfo> threads    = runner.GetThreads();
                List <string>             loopCounts = new List <string>();

                this.Comment("Inspect threads and find 'loopCount' variable on each worker thread.");
                this.WriteLine("Threads:");
                foreach (var threadInfo in threads)
                {
                    IThreadInspector threadInspector = threadInfo.GetThreadInspector();

                    // Don't look at main thread, just workers
                    if (threadInspector.ThreadId == runner.StoppedThreadId)
                    {
                        continue;
                    }

                    this.Comment("Thread '{0}', Id: {1}".FormatInvariantWithArgs(threadInfo.Name, threadInspector.ThreadId));
                    IFrameInspector threadLoopFrame = threadInspector.Stack.FirstOrDefault(s => s.Name.Contains("ThreadLoop"));

                    // Fail the test if the ThreadLoop frame could not be found
                    if (threadLoopFrame == null)
                    {
                        this.WriteLine("This thread's stack did not contain a frame with 'ThreadLoop'");
                        this.WriteLine("Stack Trace:");
                        foreach (var frame in threadInspector.Stack)
                        {
                            this.WriteLine(frame.Name);
                        }
                        continue;
                    }

                    string variables = threadLoopFrame.Variables.ToReadableString();
                    this.WriteLine("Variables in 'ThreadLoop' frame:");
                    this.WriteLine(variables);

                    // Put the different loopCounts in a list, so they can be verified order agnostic
                    string loopCountValue = threadLoopFrame.GetVariable("loopCount").Value;
                    this.WriteLine("loopCount = {0}", loopCountValue);
                    loopCounts.Add(loopCountValue);
                }

                //Verify all the worker threads were observed
                Assert.True(loopCounts.Contains("0"), "Could not find thread with loop count 0");
                Assert.True(loopCounts.Contains("1"), "Could not find thread with loop count 1");
                Assert.True(loopCounts.Contains("2"), "Could not find thread with loop count 2");
                Assert.True(loopCounts.Contains("3"), "Could not find thread with loop count 3");
                Assert.True(4 == loopCounts.Count, "Expected to find 4 threads, but found " + loopCounts.Count.ToString(CultureInfo.InvariantCulture));

                this.Comment("Run to end.");
                runner.Expects.TerminatedEvent().AfterContinue();

                runner.DisconnectAndVerify();
            }
        }
예제 #22
0
        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();
            }
        }