private void HandleBreakPoint(BreakpointEvent bpEvent) { MonoPendingBreakpoint bp = _pendingBreakpoints.FirstOrDefault(x => x.LastRequest == bpEvent.Request); StackFrame[] frames = bpEvent.Thread.GetFrames(); _engine.Events.BreakpointHit(bp, _mainThread); }
private bool HandleBreakPoint(BreakpointEvent ev) { DebugHelper.TraceEnteringMethod(); if (_isStepping) { return(true); } bool resume = false; AD7PendingBreakpoint bp; lock (_pendingBreakpoints) bp = _pendingBreakpoints.FirstOrDefault(x => x.LastRequest == ev.Request); if (bp == null) { return(true); } Mono.Debugger.Soft.StackFrame[] frames = ev.Thread.GetFrames(); _engine.Callback.BreakpointHit(bp, GetThread(ev)); return(resume); }
public void HandleEventInvalidBoundBreakpoint() { // Return null and false for all bound breakpoints on the pending breakpoint. _mockPendingBreakpoint1.GetBoundBreakpointById(Arg.Any <int>(), out IBoundBreakpoint _) .ReturnsForAnyArgs(x => { x[1] = null; return(false); }); // We want to inspect the BreakpointEvent further, so capture it when OnSendEvent is // called. BreakpointEvent resultEvent = null; _mockDebugEngineHandler.SendEvent( Arg.Do(delegate(DebugEvent x) { resultEvent = (BreakpointEvent)x; }), _mockProgram, _mockRemoteThread); _mockDebugEngineHandler.SendEvent(Arg.Is <DebugEvent>(x => x is BreakpointEvent), _mockProgram, _mockRemoteThread); RaiseSingleStateChanged(); AssertBreakpointEvent(resultEvent, new List <IDebugBoundBreakpoint2> { _mockBoundBreakpoint1 }); }
public virtual void OnBreakpoint(IEnumDebugBoundBreakpoints2 boundBreakpoints) { Logger.Debug(string.Empty); var eventObject = new BreakpointEvent(boundBreakpoints); OnDebugEvent(eventObject, InterfaceGuids.IDebugBreakpointEvent2Guid); }
public void HandleEventWatchpointWorkerThread() { MockThread(_mockRemoteThread, StopReason.NONE, new List <ulong>()); var mockWorkerThread = Substitute.For <RemoteThread>(); const ulong mockWorkerThreadId = 2; mockWorkerThread.GetThreadId().Returns(mockWorkerThreadId); MockThread(mockWorkerThread, StopReason.WATCHPOINT, _watchpointStopData); MockProcess(new List <RemoteThread> { _mockRemoteThread, mockWorkerThread }); MockBreakpointManagerForWatchpoint(); BreakpointEvent resultEvent = null; _mockDebugEngineHandler.SendEvent( Arg.Do(delegate(DebugEvent x) { resultEvent = (BreakpointEvent)x; }), _mockProgram, mockWorkerThread); RaiseSingleStateChanged(); _mockDebugEngineHandler.Received(1).SendEvent( Arg.Is <DebugEvent>(x => x is BreakpointEvent), _mockProgram, mockWorkerThread); AssertBreakpointEvent(resultEvent, new List <IDebugBoundBreakpoint2> { _mockWatchpoint }); _mockSbProcess.Received(1).SetSelectedThreadById(mockWorkerThreadId); }
public void HandleEventBreakpointWorkerThread() { const ulong mockWorkerThreadId = 2; MockThread(_mockRemoteThread, StopReason.NONE, new List <ulong>()); var mockWorkerThread = Substitute.For <RemoteThread>(); mockWorkerThread.GetThreadId().Returns(mockWorkerThreadId); MockThread(mockWorkerThread, StopReason.BREAKPOINT, new List <ulong> { 1u, 2u }); MockProcess(new List <RemoteThread> { _mockRemoteThread, mockWorkerThread }); // We want to inspect the BreakpointEvent further, so capture it when OnSendEvent is // called. BreakpointEvent resultEvent = null; _mockDebugEngineHandler.SendEvent( Arg.Do(delegate(DebugEvent x) { resultEvent = (BreakpointEvent)x; }), _mockProgram, mockWorkerThread); RaiseSingleStateChanged(); _mockSbProcess.Received(1).SetSelectedThreadById(mockWorkerThreadId); _mockDebugEngineHandler.Received(1).SendEvent( Arg.Is <DebugEvent>(x => x is BreakpointEvent), _mockProgram, mockWorkerThread); AssertBreakpointEvent(resultEvent, new List <IDebugBoundBreakpoint2> { _mockBoundBreakpoint2 }); }
/// <summary> /// Handles event message. /// </summary> /// <param name="message">Message.</param> private void HandleEventMessage(JObject message) { var eventType = (string)message["event"]; switch (eventType) { case "afterCompile": EventHandler <CompileScriptEventArgs> compileScriptHandler = CompileScriptEvent; if (compileScriptHandler != null) { var compileScriptEvent = new CompileScriptEvent(message); compileScriptHandler(this, new CompileScriptEventArgs(compileScriptEvent)); } break; case "break": EventHandler <BreakpointEventArgs> breakpointHandler = BreakpointEvent; if (breakpointHandler != null) { var breakpointEvent = new BreakpointEvent(message); breakpointHandler(this, new BreakpointEventArgs(breakpointEvent)); } break; case "exception": EventHandler <ExceptionEventArgs> exceptionHandler = ExceptionEvent; if (exceptionHandler != null) { var exceptionEvent = new ExceptionEvent(message); exceptionHandler(this, new ExceptionEventArgs(exceptionEvent)); } break; case "beforeCompile": case "breakForCommand": case "newFunction": case "scriptCollected": case "compileError": break; default: Debug.Fail(string.Format(CultureInfo.CurrentCulture, "Unrecognized type '{0}' in event message: {1}", eventType, message)); break; } }
public void CreateBreakpointEvent() { // Arrange JObject message = JObject.Parse(Resources.NodeBreakpointResponse); // Act var breakpointEvent = new BreakpointEvent(message); // Assert Assert.IsNotNull(breakpointEvent.Breakpoints); Assert.AreEqual(1, breakpointEvent.Breakpoints.Count); Assert.AreEqual(2, breakpointEvent.Breakpoints[0]); Assert.AreEqual(1, breakpointEvent.Line); Assert.AreEqual(0, breakpointEvent.Column); Assert.IsNotNull(breakpointEvent.Module); Assert.AreEqual("server.js", breakpointEvent.Module.Name); Assert.AreEqual(false, breakpointEvent.Running); }
public void HandleEventBreakpoint() { // We want to inspect the BreakpointEvent further, so capture it when OnSendEvent is // called. BreakpointEvent resultEvent = null; _mockDebugEngineHandler.SendEvent( Arg.Do(delegate(DebugEvent x) { resultEvent = (BreakpointEvent)x; }), _mockProgram, _mockRemoteThread); RaiseSingleStateChanged(); _mockDebugEngineHandler.Received(1).SendEvent( Arg.Is <DebugEvent>(x => x is BreakpointEvent), _mockProgram, _mockRemoteThread); AssertBreakpointEvent(resultEvent, new List <IDebugBoundBreakpoint2> { _mockBoundBreakpoint2, _mockBoundBreakpoint3, _mockBoundBreakpoint1 }); }
void AssertBreakpointEvent(BreakpointEvent breakpointEvent, List <IDebugBoundBreakpoint2> expectedBoundBreakpoints) { int numberBreakpoints = expectedBoundBreakpoints.Count; Assert.AreNotEqual(null, breakpointEvent); breakpointEvent.EnumBreakpoints(out IEnumDebugBoundBreakpoints2 enumBoundBreakpoints); enumBoundBreakpoints.GetCount(out uint count); Assert.AreEqual(numberBreakpoints, count); var boundBreakpoints = new IDebugBoundBreakpoint2[numberBreakpoints]; uint numberReturned = 0; enumBoundBreakpoints.Next((uint)numberBreakpoints, boundBreakpoints, ref numberReturned); Assert.AreEqual(numberBreakpoints, numberReturned); var difference = expectedBoundBreakpoints.Except(boundBreakpoints).ToList(); Assert.IsEmpty(difference); }
public void HandleEventInvalidPendingBreakpoint() { // Return null and false for one of the pending breakpoints. _mockBreakpointManager .GetPendingBreakpointById(Arg.Any <int>(), out IPendingBreakpoint _) .ReturnsForAnyArgs(x => { int id = (int)x[0]; switch (id) { case 1: x[1] = _mockPendingBreakpoint1; return(true); default: x[1] = null; return(false); } }); // We want to inspect the BreakpointEvent further, so capture it when OnSendEvent is // called. BreakpointEvent resultEvent = null; _mockDebugEngineHandler.SendEvent( Arg.Do(delegate(DebugEvent x) { resultEvent = (BreakpointEvent)x; }), _mockProgram, _mockRemoteThread); RaiseSingleStateChanged(); _mockDebugEngineHandler.Received(1).SendEvent( Arg.Is <DebugEvent>(x => x is BreakpointEvent), _mockProgram, _mockRemoteThread); AssertBreakpointEvent( resultEvent, new List <IDebugBoundBreakpoint2> { _mockBoundBreakpoint2, _mockBoundBreakpoint3 }); }
/// <summary> /// <para>The event indicates that some information about a breakpoint has changed.</para> /// </summary> /// <param name="reason"> /// <para>The reason for the event.</para> /// <para>Values: 'changed', 'new', 'removed', etc.</para> /// </param> /// <param name="breakpoint"> /// <para>The 'id' attribute is used to find the target breakpoint and the other attributes are used as the new values.</para> /// </param> public static void SendBreakpointEvent(this ProtocolServer server, EventReason reason, Breakpoint breakpoint) { BreakpointEvent breakpointEvent = new BreakpointEvent(new BreakpointEvent.BreakpointEventBody(reason, breakpoint)); server.SendMessage(breakpointEvent); }
public BreakpointEventArgs(BreakpointEvent breakpointEvent) { BreakpointEvent = breakpointEvent; }
void HandleEvent(Event e, bool dequeuing) { if (dequeuing && exited) { return; } bool resume = true; ObjectMirror exception = null; TargetEventType etype = TargetEventType.TargetStopped; #if DEBUG_EVENT_QUEUEING if (!(e is TypeLoadEvent)) { Console.WriteLine("pp event: " + e); } #endif OnHandleEvent(e); if (e is AssemblyLoadEvent) { AssemblyLoadEvent ae = (AssemblyLoadEvent)e; bool isExternal = !UpdateAssemblyFilters(ae.Assembly) && userAssemblyNames != null; string flagExt = isExternal? " [External]" : ""; OnDebuggerOutput(false, string.Format("Loaded assembly: {0}{1}\n", ae.Assembly.Location, flagExt)); } if (e is AssemblyUnloadEvent) { AssemblyUnloadEvent aue = (AssemblyUnloadEvent)e; // Mark affected breakpoints as pending again List <KeyValuePair <EventRequest, BreakInfo> > affectedBreakpoints = new List <KeyValuePair <EventRequest, BreakInfo> > ( breakpoints.Where(x => (x.Value.Location.Method.DeclaringType.Assembly.Location.Equals(aue.Assembly.Location, StringComparison.OrdinalIgnoreCase))) ); foreach (KeyValuePair <EventRequest, BreakInfo> breakpoint in affectedBreakpoints) { OnDebuggerOutput(false, string.Format("Re-pending breakpoint at {0}:{1}\n", Path.GetFileName(breakpoint.Value.Location.SourceFile), breakpoint.Value.Location.LineNumber)); breakpoints.Remove(breakpoint.Key); pending_bes.Add(breakpoint.Value.BreakEvent); } // Remove affected types from the loaded types list List <string> affectedTypes = new List <string>(); foreach (var pair in types) { try { if (!pair.Value.Assembly.Location.Equals(aue.Assembly.Location, StringComparison.OrdinalIgnoreCase)) { continue; } } catch { } affectedTypes.Add(pair.Key); } foreach (string typename in affectedTypes) { types.Remove(typename); } foreach (var pair in source_to_type) { pair.Value.RemoveAll(delegate(TypeMirror mirror){ try { return(mirror.Assembly.Location.Equals(aue.Assembly.Location, StringComparison.OrdinalIgnoreCase)); } catch { } return(true); }); } OnDebuggerOutput(false, string.Format("Unloaded assembly: {0}\n", aue.Assembly.Location)); } if (e is VMStartEvent) { //HACK: 2.6.1 VM doesn't emit type load event, so work around it var t = vm.RootDomain.Corlib.GetType("System.Exception", false, false); if (t != null) { ResolveBreakpoints(t); } OnVMStartEvent((VMStartEvent)e); } if (e is TypeLoadEvent) { var t = ((TypeLoadEvent)e).Type; string typeName = t.FullName; // if (types.ContainsKey(typeName)) { // if (typeName != "System.Exception") // LoggingService.LogError("Type '" + typeName + "' loaded more than once", null); // } ResolveBreakpoints(t); } if (e is BreakpointEvent) { BreakpointEvent be = (BreakpointEvent)e; if (!HandleBreakpoint(e.Thread, be.Request)) { etype = TargetEventType.TargetHitBreakpoint; resume = false; } } if (e is ExceptionEvent) { etype = TargetEventType.ExceptionThrown; var ev = (ExceptionEvent)e; exception = ev.Exception; if (ev.Request != unhandledExceptionRequest || exception.Type.FullName != "System.Threading.ThreadAbortException") { resume = false; } } if (e is StepEvent) { etype = TargetEventType.TargetStopped; resume = false; } if (e is ThreadStartEvent) { ThreadStartEvent ts = (ThreadStartEvent)e; OnDebuggerOutput(false, string.Format("Thread started: {0}\n", ts.Thread.Name)); } if (resume) { vm.Resume(); } else { if (currentStepRequest != null) { currentStepRequest.Enabled = false; currentStepRequest = null; } current_thread = recent_thread = e.Thread; TargetEventArgs args = new TargetEventArgs(etype); args.Process = OnGetProcesses() [0]; args.Thread = GetThread(args.Process, current_thread); args.Backtrace = GetThreadBacktrace(current_thread); if (exception != null) { activeExceptionsByThread [current_thread.Id] = exception; } OnTargetEvent(args); } }
/// <summary> /// Send the given event to VS. /// </summary> internal void Send(DebugThread thread, BreakpointEvent @event) { eventCallback.Send(thread, @event); }