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);
}
