public bool SetDefaultExceptionHitTreatment(ExceptionHitTreatment exceptionTreatment) { if (_defaultExceptionTreatment != exceptionTreatment) { _defaultExceptionTreatment = exceptionTreatment; return true; } return false; }
public bool SetDefaultExceptionHitTreatment(ExceptionHitTreatment exceptionTreatment) { if (this._defaultExceptionTreatment != exceptionTreatment) { this._defaultExceptionTreatment = exceptionTreatment; return(true); } return(false); }
public void GetExceptionHitTreatmentForUnknownError() { // Arrange var exceptionHandler = new ExceptionHandler(); // Act ExceptionHitTreatment result = exceptionHandler.GetExceptionHitTreatment("Error(MY)"); // Assert Assert.AreEqual(ExceptionHitTreatment.BreakNever, result); }
public void GetExceptionHitTreatmentForUnknownErrorAfterChangingDefaults() { // Arrange var exceptionHandler = new ExceptionHandler(); const ExceptionHitTreatment newDefault = ExceptionHitTreatment.BreakAlways; // Act exceptionHandler.SetDefaultExceptionHitTreatment(newDefault); ExceptionHitTreatment result = exceptionHandler.GetExceptionHitTreatment("Error(MY)"); // Assert Assert.AreEqual(newDefault, result); }
public void SetNewExceptionTreatments() { // Arrange var exceptionHandler = new ExceptionHandler(); const string exceptionName = "Error"; const ExceptionHitTreatment newValue = ExceptionHitTreatment.BreakOnUnhandled; ExceptionHitTreatment initial = exceptionHandler.GetExceptionHitTreatment(exceptionName); // Act bool updated = exceptionHandler.SetExceptionTreatments(new Dictionary <string, ExceptionHitTreatment> { { exceptionName, newValue } }); ExceptionHitTreatment changed = exceptionHandler.GetExceptionHitTreatment(exceptionName); // Assert Assert.AreEqual(ExceptionHitTreatment.BreakNever, initial); Assert.IsTrue(updated); Assert.AreEqual(newValue, changed); }
public void ClearExceptionTreatments() { // Arrange var exceptionHandler = new ExceptionHandler(); const string exceptionName = "SyntaxError"; exceptionHandler.SetExceptionTreatments(new Dictionary <string, ExceptionHitTreatment> { { exceptionName, ExceptionHitTreatment.BreakAlways } }); ExceptionHitTreatment initial = exceptionHandler.GetExceptionHitTreatment(exceptionName); // Act bool updated = exceptionHandler.ClearExceptionTreatments(new Dictionary <string, ExceptionHitTreatment> { { exceptionName, ExceptionHitTreatment.BreakOnUnhandled } }); ExceptionHitTreatment changed = exceptionHandler.GetExceptionHitTreatment(exceptionName); // Assert Assert.AreEqual(ExceptionHitTreatment.BreakAlways, initial); Assert.IsTrue(updated); Assert.AreEqual(ExceptionHitTreatment.BreakNever, changed); }
public void ClearExceptionTreatment( ExceptionHitTreatment? defaultExceptionTreatment, ICollection<KeyValuePair<string, ExceptionHitTreatment>> exceptionTreatments ) { DebuggerClient.RunWithRequestExceptionsHandled(async () => { bool updated = false; if (defaultExceptionTreatment.HasValue) { updated |= _exceptionHandler.SetDefaultExceptionHitTreatment(ExceptionHitTreatment.BreakNever); } updated |= _exceptionHandler.ClearExceptionTreatments(exceptionTreatments); if (updated) { var tokenSource = new CancellationTokenSource(_timeout); await SetExceptionBreakAsync(tokenSource.Token).ConfigureAwait(false); } }); }
internal void TestDebuggerSteps( NodeDebugger process, NodeThread thread, string filename, IEnumerable<TestStep> steps, ExceptionHitTreatment? defaultExceptionTreatment = null, ICollection<KeyValuePair<string, ExceptionHitTreatment>> exceptionTreatments = null, bool waitForExit = false ) { if (!Path.IsPathRooted(filename)) { filename = DebuggerTestPath + filename; } // Since Alpha does not support break on unhandled, and the commonly used Express module has handled SyntaxError exceptions, // for alpha we have SyntaxErrors set to BreakNever by default. Here we set it to BreakAlways so unit tests can run // assuming BreakAlways is the default. // TODO: Remove once exception treatment is updated for just my code support when it is added after Alpha process.SetExceptionTreatment(null, CollectExceptionTreatments(ExceptionHitTreatment.BreakAlways, "SyntaxError")); if (defaultExceptionTreatment != null || exceptionTreatments != null) { process.SetExceptionTreatment(defaultExceptionTreatment, exceptionTreatments); } Dictionary<Breakpoint, NodeBreakpoint> breakpoints = new Dictionary<Breakpoint, NodeBreakpoint>(); AutoResetEvent entryPointHit = new AutoResetEvent(false); process.EntryPointHit += (sender, e) => { Console.WriteLine("EntryPointHit"); Assert.AreEqual(e.Thread, thread); entryPointHit.Set(); }; AutoResetEvent breakpointBound = new AutoResetEvent(false); process.BreakpointBound += (sender, e) => { Console.WriteLine("BreakpointBound {0} {1}", e.BreakpointBinding.Position.FileName, e.BreakpointBinding.Position.Line); breakpointBound.Set(); }; AutoResetEvent breakpointUnbound = new AutoResetEvent(false); process.BreakpointUnbound += (sender, e) => { Console.WriteLine("BreakpointUnbound"); breakpointUnbound.Set(); }; AutoResetEvent breakpointBindFailure = new AutoResetEvent(false); process.BreakpointBindFailure += (sender, e) => { Console.WriteLine("BreakpointBindFailure"); breakpointBindFailure.Set(); }; AutoResetEvent breakpointHit = new AutoResetEvent(false); process.BreakpointHit += (sender, e) => { Console.WriteLine("BreakpointHit {0}", e.BreakpointBinding.Target.Line); Assert.AreEqual(e.Thread, thread); Assert.AreEqual(e.BreakpointBinding.Target.Line, thread.Frames.First().Line); breakpointHit.Set(); }; AutoResetEvent stepComplete = new AutoResetEvent(false); process.StepComplete += (sender, e) => { Console.WriteLine("StepComplete"); Assert.AreEqual(e.Thread, thread); stepComplete.Set(); }; AutoResetEvent exceptionRaised = new AutoResetEvent(false); NodeException exception = null; process.ExceptionRaised += (sender, e) => { Console.WriteLine("ExceptionRaised"); Assert.AreEqual(e.Thread, thread); exception = e.Exception; exceptionRaised.Set(); }; AutoResetEvent processExited = new AutoResetEvent(false); int exitCode = 0; process.ProcessExited += (sender, e) => { Console.WriteLine("ProcessExited {0}", e.ExitCode); exitCode = e.ExitCode; processExited.Set(); }; Console.WriteLine("-----------------------------------------"); Console.WriteLine("Begin debugger step test"); foreach (var step in steps) { Console.WriteLine("Step: {0}", step._action); Assert.IsFalse( ((step._expectedEntryPointHit != null ? 1 : 0) + (step._expectedBreakpointHit != null ? 1 : 0) + (step._expectedStepComplete != null ? 1 : 0) + (step._expectedExceptionRaised != null ? 1 : 0)) > 1); bool wait = false; NodeBreakpoint nodeBreakpoint; switch (step._action) { case TestAction.None: break; case TestAction.Wait: wait = true; break; case TestAction.ResumeThread: thread.Resume(); wait = true; break; case TestAction.ResumeProcess: process.Resume(); wait = true; break; case TestAction.StepOver: thread.StepOver(); wait = true; break; case TestAction.StepInto: thread.StepInto(); wait = true; break; case TestAction.StepOut: thread.StepOut(); wait = true; break; case TestAction.AddBreakpoint: string breakpointFileName = step._targetBreakpointFile; if (breakpointFileName != null) { if (!step._builtin && !Path.IsPathRooted(breakpointFileName)) { breakpointFileName = DebuggerTestPath + breakpointFileName; } } else { breakpointFileName = filename; } int breakpointLine = step._targetBreakpoint.Value; int breakpointColumn = step._targetBreakpointColumn.HasValue ? step._targetBreakpointColumn.Value : 0; Breakpoint breakpoint = new Breakpoint(breakpointFileName, breakpointLine, breakpointColumn); Assert.IsFalse(breakpoints.TryGetValue(breakpoint, out nodeBreakpoint)); breakpoints[breakpoint] = AddBreakPoint( process, breakpointFileName, breakpointLine, breakpointColumn, step._enabled ?? true, step._breakOn ?? new BreakOn(), step._condition ); if (step._expectFailure) { AssertWaited(breakpointBindFailure); AssertNotSet(breakpointBound); breakpointBindFailure.Reset(); } else { AssertWaited(breakpointBound); AssertNotSet(breakpointBindFailure); breakpointBound.Reset(); } break; case TestAction.RemoveBreakpoint: breakpointFileName = step._targetBreakpointFile ?? filename; breakpointLine = step._targetBreakpoint.Value; breakpointColumn = step._targetBreakpointColumn.HasValue ? step._targetBreakpointColumn.Value : 0; breakpoint = new Breakpoint(breakpointFileName, breakpointLine, breakpointColumn); breakpoints[breakpoint].Remove().WaitAndUnwrapExceptions(); breakpoints.Remove(breakpoint); AssertWaited(breakpointUnbound); breakpointUnbound.Reset(); break; case TestAction.UpdateBreakpoint: breakpointFileName = step._targetBreakpointFile ?? filename; breakpointLine = step._targetBreakpoint.Value; breakpointColumn = step._targetBreakpointColumn.HasValue ? step._targetBreakpointColumn.Value : 0; breakpoint = new Breakpoint(breakpointFileName, breakpointLine, breakpointColumn); nodeBreakpoint = breakpoints[breakpoint]; foreach (var breakpointBinding in nodeBreakpoint.GetBindings()) { if (step._hitCount != null) { Assert.IsTrue(breakpointBinding.SetHitCountAsync(step._hitCount.Value).WaitAndUnwrapExceptions()); } if (step._enabled != null) { Assert.IsTrue(breakpointBinding.SetEnabledAsync(step._enabled.Value).WaitAndUnwrapExceptions()); } if (step._breakOn != null) { Assert.IsTrue(breakpointBinding.SetBreakOnAsync(step._breakOn.Value).WaitAndUnwrapExceptions()); } if (step._condition != null) { Assert.IsTrue(breakpointBinding.SetConditionAsync(step._condition).WaitAndUnwrapExceptions()); } } break; case TestAction.KillProcess: process.Terminate(); break; case TestAction.Detach: process.Detach(); break; } if (wait) { if (step._expectedEntryPointHit != null) { AssertWaited(entryPointHit); AssertNotSet(breakpointHit); AssertNotSet(stepComplete); AssertNotSet(exceptionRaised); Assert.IsNull(exception); entryPointHit.Reset(); } else if (step._expectedBreakpointHit != null) { if (step._expectReBind) { AssertWaited(breakpointUnbound); AssertWaited(breakpointBound); breakpointUnbound.Reset(); breakpointBound.Reset(); } AssertWaited(breakpointHit); AssertNotSet(entryPointHit); AssertNotSet(stepComplete); AssertNotSet(exceptionRaised); Assert.IsNull(exception); breakpointHit.Reset(); } else if (step._expectedStepComplete != null) { AssertWaited(stepComplete); AssertNotSet(entryPointHit); AssertNotSet(breakpointHit); AssertNotSet(exceptionRaised); Assert.IsNull(exception); stepComplete.Reset(); } else if (step._expectedExceptionRaised != null) { AssertWaited(exceptionRaised); AssertNotSet(entryPointHit); AssertNotSet(breakpointHit); AssertNotSet(stepComplete); exceptionRaised.Reset(); } else { AssertNotSet(entryPointHit); AssertNotSet(breakpointHit); AssertNotSet(stepComplete); AssertNotSet(exceptionRaised); Assert.IsNull(exception); } } if (step._expectedEntryPointHit != null) { Assert.AreEqual(step._expectedEntryPointHit.Value, thread.Frames.First().Line); } else if (step._expectedBreakpointHit != null) { Assert.AreEqual(step._expectedBreakpointHit.Value, thread.Frames.First().Line); } else if (step._expectedStepComplete != null) { Assert.AreEqual(step._expectedStepComplete.Value, thread.Frames.First().Line); } else if (step._expectedExceptionRaised != null) { Assert.AreEqual(step._expectedExceptionRaised.TypeName, exception.TypeName); Assert.AreEqual(step._expectedExceptionRaised.Description, exception.Description); if (step._expectedExceptionRaised.LineNo != null) { Assert.AreEqual(step._expectedExceptionRaised.LineNo.Value, thread.Frames[0].Line); } exception = null; } var expectedBreakFile = step._expectedBreakFile; if (expectedBreakFile != null) { if (!step._builtin && !Path.IsPathRooted(expectedBreakFile)) { expectedBreakFile = DebuggerTestPath + expectedBreakFile; } Assert.AreEqual(expectedBreakFile, thread.Frames.First().FileName); } var expectedBreakFunction = step._expectedBreakFunction; if (expectedBreakFunction != null) { Assert.AreEqual(expectedBreakFunction, thread.Frames.First().FunctionName); } if (step._expectedHitCount != null) { string breakpointFileName = step._targetBreakpointFile ?? filename; if (!step._builtin && !Path.IsPathRooted(breakpointFileName)) { breakpointFileName = DebuggerTestPath + breakpointFileName; } int breakpointLine = step._targetBreakpoint.Value; int breakpointColumn = step._targetBreakpointColumn.HasValue ? step._targetBreakpointColumn.Value : 0; var breakpoint = new Breakpoint(breakpointFileName, breakpointLine, breakpointColumn); nodeBreakpoint = breakpoints[breakpoint]; foreach (var breakpointBinding in nodeBreakpoint.GetBindings()) { Assert.AreEqual(step._expectedHitCount.Value, breakpointBinding.GetHitCount()); } } if (step._validation != null) { step._validation(process, thread); } if (step._expectedExitCode != null) { AssertWaited(processExited); Assert.AreEqual(step._expectedExitCode.Value, exitCode); } } if (waitForExit) { process.WaitForExit(10000); } AssertNotSet(entryPointHit); AssertNotSet(breakpointHit); AssertNotSet(stepComplete); AssertNotSet(exceptionRaised); Assert.IsNull(exception); }
internal void TestDebuggerSteps( string filename, IEnumerable<TestStep> steps, string interpreterOptions = null, Action<NodeDebugger> onProcessCreated = null, ExceptionHitTreatment? defaultExceptionTreatment = null, ICollection<KeyValuePair<string, ExceptionHitTreatment>> exceptionTreatments = null, string scriptArguments = null ) { if (!Path.IsPathRooted(filename)) { filename = DebuggerTestPath + filename; } NodeThread thread = null; using (var process = DebugProcess( filename, onProcessCreated: onProcessCreated, onLoadComplete: (newproc, newthread) => { thread = newthread; }, interpreterOptions: interpreterOptions, arguments: scriptArguments, resumeOnProcessLoad: false )) { TestDebuggerSteps( process, thread, filename, steps, defaultExceptionTreatment, exceptionTreatments, waitForExit: true); } }
internal void TestExceptions( string filename, ExceptionHitTreatment? defaultExceptionTreatment, ICollection<KeyValuePair<string, ExceptionHitTreatment>> exceptionTreatments, int expectedExitCode, params ExceptionInfo[] exceptions ) { var steps = new List<TestStep>(); foreach (var exception in exceptions) { steps.Add(new TestStep(action: TestAction.ResumeProcess, expectedExceptionRaised: exception)); } steps.Add(new TestStep(action: TestAction.ResumeProcess, expectedExitCode: expectedExitCode)); TestDebuggerSteps( filename, steps, defaultExceptionTreatment: defaultExceptionTreatment, exceptionTreatments: exceptionTreatments ); }
internal ICollection<KeyValuePair<string, ExceptionHitTreatment>> CollectExceptionTreatments(ExceptionHitTreatment exceptionTreatment = ExceptionHitTreatment.BreakAlways, params string[] exceptionNames) { return exceptionNames.Select( name => new KeyValuePair<string, ExceptionHitTreatment>(name, exceptionTreatment) ).ToArray(); }
internal ICollection <KeyValuePair <string, ExceptionHitTreatment> > CollectExceptionTreatments(ExceptionHitTreatment exceptionTreatment = ExceptionHitTreatment.BreakAlways, params string[] exceptionNames) { return(exceptionNames.Select( name => new KeyValuePair <string, ExceptionHitTreatment>(name, exceptionTreatment) ).ToArray()); }