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