public void Main() { Process process = Start(); Assert.IsTrue(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "main", "X.Main()"); AssertExecute("next -bg"); DebuggerEvent e = AssertEvent(); if (e.Type != DebuggerEventType.TargetEvent) { Assert.Fail("Got unknown event: {0}", e); } TargetEventArgs args = (TargetEventArgs)e.Data2; if (args.Type != TargetEventType.TargetHitBreakpoint) { Assert.Fail("Got unknown event: {0}", args); } Thread child = (Thread)e.Data; AssertFrame(child, "thread main", "X.ThreadMain()"); AssertExecute("kill"); }
private void StartEvent(DebuggerMode mode, string reason, string action = null) { _lastEvent = Create <DebuggerEvent>(); _lastEvent.Mode = mode; _lastEvent.Reason = reason; _lastEvent.Action = action; }
private void FireLastEvent() { if (_lastEvent != null) { FireNow(_lastEvent); _lastEvent = null; } }
public void MapsToDevelopment() { var @event = new DebuggerEvent { Action = "some action", Reason = "some reason", Mode = DebuggerMode.Run }; AssertMapsToActivity(@event, Activity.Development); }
public void ShouldSerializeToString() { var e = new DebuggerEvent { Action = "SomeAction", Mode = DebuggerMode.Design, Reason = "SomeReason" }; const string expected = "{\"$type\":\"KaVE.Commons.Model.Events.VisualStudio.DebuggerEvent, KaVE.Commons\",\"Mode\":0,\"Reason\":\"SomeReason\",\"Action\":\"SomeAction\",\"TriggeredBy\":0}"; JsonAssert.SerializesTo(e, expected); JsonAssert.DeserializesTo(expected, e); }
public void NativeChild() { Interpreter.Options.File = Path.Combine(BuildDirectory, "TestExec.exe"); Interpreter.Options.InferiorArgs = new string [] { Path.Combine(BuildDirectory, "testnativechild") }; AssertExecute("disable " + bpt_child); Interpreter.DebuggerConfiguration.ThreadingModel = ThreadingModel.Single; Process process = Start(); Assert.IsTrue(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "X.Main(string[])", line_main); AssertExecute("continue -wait"); Thread child = AssertProcessCreated(); Thread execd_child = null; bool exited = false; bool execd = false; bool stopped = false; bool thread_created = false; bool thread_exited = false; bool child_exited = false; while (!stopped || !thread_created || !exited || !execd || !child_exited || !thread_exited) { DebuggerEvent e = AssertEvent(); Report.Debug(DebugFlags.NUnit, "EXEC EVENT: {0}", e); if (e.Type == DebuggerEventType.ProcessExited) { if ((Process)e.Data == child.Process) { child_exited = true; continue; } } else if (e.Type == DebuggerEventType.ThreadExited) { if ((Thread)e.Data == execd_child) { thread_exited = true; continue; } } else if (e.Type == DebuggerEventType.ProcessExecd) { if ((Process)e.Data == child.Process) { execd = true; continue; } } else if (e.Type == DebuggerEventType.ThreadCreated) { execd_child = (Thread)e.Data; thread_created = true; continue; } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == thread) && (args.Type == TargetEventType.TargetHitBreakpoint) && ((int)args.Data == bpt_main)) { stopped = true; continue; } else if ((e_thread == execd_child) && (args.Type == TargetEventType.TargetExited)) { exited = true; continue; } } Assert.Fail("Received unexpected event {0}", e); } AssertFrame(thread, "X.Main(string[])", line_main_3); AssertPrint(thread, "process.ExitCode", "(int) 0"); AssertTargetOutput("Hello World!"); AssertExecute("continue"); AssertTargetExited(thread.Process); }
private void ProcessIDEStateEvent(DebuggerEvent @event) { InsertActivity(@event, Activity.Development); }
public void Breakpoint() { Process process = Start(); Assert.IsFalse(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "main", LineMain); AssertExecute("enable " + bpt_child); AssertExecute("enable " + bpt_waitpid); AssertExecute("next -wait"); Thread child = AssertProcessCreated(); bool child_stopped = false; bool stopped = false; while (!stopped || !child_stopped) { DebuggerEvent e = AssertEvent(); if (e.Type != DebuggerEventType.TargetEvent) { Assert.Fail("Received unexpected event {0}", e); } Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == thread) && (args.Type == TargetEventType.TargetStopped)) { stopped = true; continue; } else if ((e_thread == child) && (args.Type == TargetEventType.TargetHitBreakpoint) && ((int)args.Data == bpt_child)) { child_stopped = true; continue; } Assert.Fail("Received unexpected event {0}", e); } AssertFrame(thread, "main", LineMain + 1); AssertFrame(child, "main", LineChild); AssertPrint(thread, "pid", String.Format("(pid_t) {0}", child.PID)); AssertPrint(child, "pid", "(pid_t) 0"); AssertExecute("background -thread " + child.ID); AssertExecute("continue -wait -thread " + thread.ID); bool exited = false; bool child_exited = false; bool thread_exited = false; stopped = false; while (!exited || !child_exited || !thread_exited || !stopped) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.ProcessExited) { if ((Process)e.Data == child.Process) { child_exited = true; continue; } } else if (e.Type == DebuggerEventType.ThreadExited) { if ((Thread)e.Data == child) { thread_exited = true; continue; } } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == thread) && (args.Type == TargetEventType.TargetHitBreakpoint) && ((int)args.Data == bpt_waitpid)) { stopped = true; continue; } else if ((e_thread == child) && (args.Type == TargetEventType.TargetExited)) { exited = true; continue; } } Assert.Fail("Received unexpected event {0}", e); } AssertFrame(thread, "main", LineWaitpid + 1); AssertExecute("continue -wait -thread " + thread.ID); AssertTargetExited(thread.Process); }
void HandleUncaughtException(DebuggerEvent obj) { // FIXME: incomplete, not really reached here. var uce = (ExceptionEventBody) obj.Body; var e = new TargetEventArgs (TargetEventType.ExceptionThrown) { Backtrace = this.ActiveThread.Backtrace, IsStopEvent = true }; this.OnTargetEvent (e); }
public void Main() { Process process = Start(); Assert.IsFalse(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "main", LineMain); AssertExecute("disable " + bpt_child); AssertExecute("disable " + bpt_waitpid); AssertExecute("continue -wait"); Thread child = AssertProcessCreated(); bool exited = false; bool thread_created = false; bool child_exited = false; bool thread_exited = false; bool execd = false; bool stopped = false; Thread execd_child = null; while (!exited || !child_exited || !stopped || !execd || !thread_created || !thread_exited) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.ProcessExited) { if ((Process)e.Data == child.Process) { child_exited = true; continue; } } else if (e.Type == DebuggerEventType.ThreadExited) { if ((Thread)e.Data == execd_child) { thread_exited = true; continue; } } else if (e.Type == DebuggerEventType.ProcessExecd) { if ((Process)e.Data == child.Process) { execd = true; continue; } } else if (e.Type == DebuggerEventType.ThreadCreated) { execd_child = (Thread)e.Data; thread_created = true; continue; } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == thread) && (args.Type == TargetEventType.TargetHitBreakpoint) && ((int)args.Data == bpt_local_waitpid)) { stopped = true; continue; } else if ((e_thread == execd_child) && (args.Type == TargetEventType.TargetExited)) { exited = true; continue; } } Assert.Fail("Received unexpected event {0}", e); } AssertFrame(thread, "main", LineWaitpid + 1); AssertPrint(thread, "pid", String.Format("(pid_t) {0}", child.PID)); AssertExecute("continue"); AssertTargetOutput("Hello World!"); AssertTargetExited(thread.Process); }
protected void OnBreak(DebuggerEvent evt) { if (Break != null) Break (evt); }
public DebuggerEventArgs(DebuggerEvent debuggerEvent) { this.DebuggerEvent = debuggerEvent; }
public void Main() { Process process = Start(); Assert.IsTrue(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertHitBreakpoint(thread, "main", "X.Main()"); AssertExecuteInBackground("print -nested-break x.Test ()"); AssertNestedBreakState(thread, "X.Test()", GetLine("test")); AssertExecute("continue"); DebuggerEvent e = AssertEvent(DebuggerEventType.CommandDone); Assert.AreEqual(e.Data, "(double) 3.14159265358979"); int catchpoint = AssertCatchpoint("MyException"); int unhandled_catch = AssertUnhandledCatchpoint("Exception"); AssertExecute("continue"); AssertHitBreakpoint(thread, "test", "X.Test()"); AssertExecuteInBackground("print -nested-break UnhandledException ()"); AssertNestedBreakState(thread, "X.UnhandledException()", GetLine("unhandled")); AssertPrint(thread, "catch", "(MyUnhandledException) { \"MyUnhandledException: Exception of type 'MyUnhandledException' " + "was thrown.\n at X.UnhandledException () [0x00000] in " + FileName + ":" + GetLine("unhandled") + " \" }"); AssertExecute("continue"); e = AssertEvent(DebuggerEventType.CommandDone); if (!(e.Data is ScriptingException)) { Assert.Fail(String.Format("Got unknown event: {0}", e)); } string message = ((ScriptingException)e.Data).Message; if (!message.StartsWith("Invocation of `UnhandledException ()' raised an exception: MyUnhandledException")) { Assert.Fail(String.Format("Got unknown event: {0}", e)); } AssertExecute("continue"); AssertCaughtException(thread, "X.Exception()", GetLine("first")); AssertExecuteInBackground("print -nested-break OtherException ()"); AssertNestedBreakState(thread, "X.OtherException()", GetLine("second")); AssertExecute("continue"); e = AssertEvent(DebuggerEventType.CommandDone); if (!(e.Data is ScriptingException)) { Assert.Fail(String.Format("Got unknown event: {0}", e)); } message = ((ScriptingException)e.Data).Message; if (!message.StartsWith("Invocation of `OtherException ()' raised an exception: MyException: second")) { Assert.Fail(String.Format("Got unknown event: {0}", e)); } AssertExecute("continue"); AssertCaughtException(thread, "X.HandledException()", GetLine("rethrow")); AssertExecute("continue"); AssertTargetExited(process); }
private bool SignalControlAndWait(DebuggerEvent evt, object args) { CurrentEvent = new Tuple <DebuggerEvent, object>(evt, args); m_awakeControlEvent.Set(); return(m_awakeExecutionEvent.WaitOne()); }
public void Main() { Process process = Start(); Assert.IsTrue(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "X.Main()", LineMain); bpt_loop = AssertBreakpoint(LineLoop); AssertExecute("next"); AssertStopped(thread, "X.Main()", LineMain + 1); AssertExecute("next"); Thread child = AssertThreadCreated(); AssertStopped(thread, "X.Main()", LineMain + 2); Assert.IsTrue(thread.IsStopped); Assert.IsTrue(child.IsStopped); Assert.IsTrue(Interpreter.CurrentThread == thread); AssertExecute("continue"); AssertTargetOutput("Loop: child 0"); AssertHitBreakpoint(child, bpt_loop, "X.LoopDone()", LineLoop); Assert.IsTrue(thread.IsStopped); Assert.IsTrue(child.IsStopped); Assert.IsTrue(Interpreter.CurrentThread == child); AssertPrint(child, "Child.Counter", "(int) 0"); AssertPrint(child, "Counter", "(int) 0"); AssertPrint(child, "Parent.Counter", "(int) 0"); AssertExecute("continue"); AssertTargetOutput("Loop: child 1"); AssertHitBreakpoint(child, bpt_loop, "X.LoopDone()", LineLoop); Assert.IsTrue(thread.IsStopped); Assert.IsTrue(child.IsStopped); Assert.IsTrue(Interpreter.CurrentThread == child); AssertPrint(child, "Child.Counter", "(int) 1"); AssertPrint(child, "Counter", "(int) 1"); AssertPrint(child, "Parent.Counter", "(int) 0"); AssertExecute("continue"); AssertTargetOutput("Loop: main 0"); AssertHitBreakpoint(thread, bpt_loop, "X.LoopDone()", LineLoop); Assert.IsTrue(thread.IsStopped); Assert.IsTrue(child.IsStopped); Assert.IsTrue(Interpreter.CurrentThread == thread); AssertPrint(thread, "Child.Counter", "(int) 2"); AssertPrint(thread, "Counter", "(int) 0"); AssertPrint(thread, "Parent.Counter", "(int) 0"); AssertNoEvent(); AssertExecute("continue -wait -thread " + thread.ID); AssertTargetOutput("Loop: child 2"); bool child_event = false, thread_event = false; while (!child_event || !thread_event) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((args.Type == TargetEventType.TargetHitBreakpoint) && ((int)args.Data == bpt_loop)) { if ((e_thread == thread) && !thread_event) { thread_event = true; continue; } else if ((e_thread == child) && !child_event) { child_event = true; continue; } } } Assert.Fail("Received unexpected event {0}", e); } AssertTargetOutput("Loop: main 1"); AssertNoTargetOutput(); Assert.IsTrue(thread.IsStopped); Assert.IsTrue(child.IsStopped); Assert.IsTrue(Interpreter.CurrentThread == thread); AssertPrint(thread, "Child.Counter", "(int) 2"); AssertPrint(thread, "Parent.Counter", "(int) 1"); AssertFrame(thread, "X.LoopDone()", LineLoop); AssertFrame(child, "X.LoopDone()", LineLoop); AssertExecute("continue -wait -thread " + thread.ID); AssertTargetOutput("Loop: child 3"); child_event = false; thread_event = false; while (!child_event || !thread_event) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((args.Type == TargetEventType.TargetHitBreakpoint) && ((int)args.Data == bpt_loop)) { if ((e_thread == thread) && !thread_event) { thread_event = true; continue; } else if ((e_thread == child) && !child_event) { child_event = true; continue; } } } Assert.Fail("Received unexpected event {0}", e); } AssertTargetOutput("Loop: main 2"); AssertNoTargetOutput(); Assert.IsTrue(thread.IsStopped); Assert.IsTrue(child.IsStopped); Assert.IsTrue(Interpreter.CurrentThread == thread); AssertPrint(thread, "Child.Counter", "(int) 3"); AssertPrint(thread, "Parent.Counter", "(int) 2"); AssertFrame(thread, "X.LoopDone()", LineLoop); AssertFrame(child, "X.LoopDone()", LineLoop); AssertExecute("continue -single -thread " + child.ID); AssertTargetOutput("Loop: child 4"); AssertHitBreakpoint(child, bpt_loop, "X.LoopDone()", LineLoop); Assert.IsTrue(thread.IsStopped); Assert.IsTrue(child.IsStopped); Assert.IsTrue(Interpreter.CurrentThread == child); AssertPrint(child, "Child.Counter", "(int) 4"); AssertPrint(child, "Parent.Counter", "(int) 2"); AssertFrame(child, "X.LoopDone()", LineLoop); AssertFrame(thread, "X.LoopDone()", LineLoop); AssertExecute("continue -thread " + thread.ID); AssertTargetOutput("Loop: child 5"); AssertHitBreakpoint(child, bpt_loop, "X.LoopDone()", LineLoop); Assert.IsTrue(thread.IsStopped); Assert.IsTrue(child.IsStopped); Assert.IsTrue(Interpreter.CurrentThread == child); AssertPrint(child, "Child.Counter", "(int) 5"); AssertPrint(child, "Parent.Counter", "(int) 3"); AssertFrame(child, "X.LoopDone()", LineLoop); Backtrace bt = thread.GetBacktrace(Backtrace.Mode.Managed, -1); Assert.IsTrue(bt.Count == 6); AssertFrame(bt [3], 3, "X.Loop()", LineSleep + 1); AssertExecute("continue -single -thread " + thread.ID); AssertTargetOutput("Loop: main 3"); AssertHitBreakpoint(thread, bpt_loop, "X.LoopDone()", LineLoop); Assert.IsTrue(thread.IsStopped); Assert.IsTrue(child.IsStopped); Assert.IsTrue(Interpreter.CurrentThread == thread); AssertPrint(thread, "Child.Counter", "(int) 5"); AssertPrint(thread, "Parent.Counter", "(int) 3"); Assert.IsTrue(thread.IsStopped); Assert.IsTrue(child.IsStopped); Assert.IsTrue(Interpreter.CurrentThread == thread); AssertExecute("continue -wait -thread " + thread.ID); AssertTargetOutput("Loop: child 6"); child_event = false; thread_event = false; while (!child_event || !thread_event) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((args.Type == TargetEventType.TargetHitBreakpoint) && ((int)args.Data == bpt_loop)) { if ((e_thread == thread) && !thread_event) { thread_event = true; continue; } else if ((e_thread == child) && !child_event) { child_event = true; continue; } } } Assert.Fail("Received unexpected event {0}", e); } AssertTargetOutput("Loop: main 4"); AssertNoTargetOutput(); AssertPrint(thread, "Child.Counter", "(int) 6"); AssertPrint(thread, "Parent.Counter", "(int) 4"); AssertFrame(thread, "X.LoopDone()", LineLoop); AssertFrame(child, "X.LoopDone()", LineLoop); AssertPrint(thread, "Parent.Test ()", "(int) 4"); AssertExecute("kill"); }
public void Main() { Process process = Start(); Assert.IsTrue(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "main", "X.Main(string[])"); AssertExecute("continue"); Thread blocking = AssertThreadCreated(); AssertHitBreakpoint(thread, "thread start1", "X.StartThreads()"); AssertExecute("continue"); Thread sleeping = AssertThreadCreated(); AssertHitBreakpoint(thread, "thread start2", "X.StartThreads()"); AssertExecute("continue"); Thread executing = AssertThreadCreated(); AssertTargetOutput("True"); AssertHitBreakpoint(thread, "thread start3", "X.StartThreads()"); AssertExecute("bg"); int bpt_executing = (int)AssertExecute("break -gui -global " + GetLine("executing")); AssertHitBreakpoint(executing, bpt_executing, "X.ExecutingThread()", GetLine("executing")); Interpreter.CurrentThread = executing; AssertExecute("set loop = false"); AssertPrint(executing, "loop", "(bool) false"); AssertExecute("bg"); int status = 0; while (status != 63) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.ThreadExited) { if (e.Data == blocking) { status |= 1; continue; } else if (e.Data == executing) { status |= 2; continue; } else if (e.Data == sleeping) { status |= 4; continue; } } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if (args.Type == TargetEventType.TargetExited) { if (e_thread == blocking) { status |= 8; continue; } else if (e_thread == executing) { status |= 16; continue; } else if (e_thread == sleeping) { status |= 32; continue; } } } Assert.Fail("Received unexpected event {0}.", e); } AssertTargetOutput("Blocking Done"); AssertTargetExited(process); }
protected void OnUncaughtException(DebuggerEvent evt) { if (UncaughtException != null) UncaughtException (evt); else throw new InvalidOperationException ("V8 debugger returned uncaught exception message", new JavaScriptException (evt.Instance, 0, null)); }
public void ManagedChild() { Interpreter.Options.File = Path.Combine(BuildDirectory, "testnativenoforkexec"); Interpreter.Options.InferiorArgs = new string [] { MonoExecutable, Path.Combine(BuildDirectory, "TestChild.exe") }; Config.ThreadingModel = ThreadingModel.Global; AssertExecute("disable " + bpt_child); AssertExecute("enable " + bpt_managed_child); Process process = Start(); Assert.IsFalse(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "main", LineMain); AssertExecute("continue -wait"); bool thread_created = false; bool reached_main = false; bool execd = false; Thread execd_child = null; while (!execd || !thread_created || !reached_main) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.ProcessExecd) { execd = true; continue; } else if (e.Type == DebuggerEventType.ThreadCreated) { execd_child = (Thread)e.Data; thread_created = true; continue; } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == execd_child) && (args.Type == TargetEventType.TargetStopped)) { AssertFrame(execd_child, "X.Main()", LineManagedMain); reached_main = true; continue; } } Assert.Fail("Received unexpected event {0}", e); } AssertExecute("continue"); AssertHitBreakpoint(execd_child, bpt_managed_child, "X.Main()", LineManagedBpt); AssertExecute("continue"); AssertTargetOutput("Hello World"); AssertTargetExited(thread.Process); }
public void Main() { Interpreter.Options.File = Path.Combine(BuildDirectory, "testnativenoforkexec"); Interpreter.Options.InferiorArgs = new string [] { Path.Combine(BuildDirectory, "testnativechild") }; Process process = Start(); Assert.IsFalse(process.IsManaged); Assert.IsTrue(process.MainThread.IsStopped); Thread thread = process.MainThread; AssertStopped(thread, "main", LineMain); AssertExecute("disable " + bpt_child); AssertExecute("continue"); bool thread_created = false; bool execd = false; bool stopped = false; Thread execd_child = null; while (!execd || !thread_created || !stopped) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.ProcessExecd) { execd = true; continue; } else if (e.Type == DebuggerEventType.ThreadCreated) { execd_child = (Thread)e.Data; thread_created = true; continue; } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == execd_child) && (args.Type == TargetEventType.TargetStopped)) { AssertFrame(execd_child, "main", LineChild); stopped = true; continue; } } Assert.Fail("Received unexpected event {0}", e); } AssertExecute("continue"); bool exited_event = false; bool process_exited = false; bool thread_exited = false; bool exited = false; while (!exited || !exited_event || !thread_exited || !process_exited) { DebuggerEvent e = AssertEvent(); if (e.Type == DebuggerEventType.ThreadExited) { if ((Thread)e.Data == execd_child) { thread_exited = true; continue; } } else if (e.Type == DebuggerEventType.ProcessExited) { process_exited = true; continue; } else if (e.Type == DebuggerEventType.TargetEvent) { Thread e_thread = (Thread)e.Data; TargetEventArgs args = (TargetEventArgs)e.Data2; if ((e_thread == execd_child) && (args.Type == TargetEventType.TargetExited)) { exited_event = true; continue; } } else if (e.Type == DebuggerEventType.TargetExited) { exited = true; continue; } Assert.Fail("Received unexpected event {0}", e); } AssertTargetOutput("Hello World!"); AssertNoTargetOutput(); }
public void onDebuggerEvent(ref Guid riid, object punk) { DebuggerEvent?.Invoke(riid, punk); }
void HandleBreak(DebuggerEvent obj) { // FIXME: incomplete, not really reached here. var jsbe = (BreakEventBody) obj.Body; var e = new TargetEventArgs (TargetEventType.TargetHitBreakpoint) { Backtrace = this.ActiveThread.Backtrace, IsStopEvent = true }; this.OnTargetEvent (e); }