static void OnEventReceived(object sender, EventReceivedEventArgs e)
{
if (e.Resource != null)
{
System.Console.WriteLine("Received Event {0}", (e.Resource as Event).Links.Self.Href);
}
}
private void EventHandlingThread()
{
Debug.WriteLine("EventHandlingThread Started");
_listeningReadyEvent.Wait();
while (true)
{
bool paused;
lock (_isListeningLock) {
if (!_isListening)
{
break;
}
paused = _isPaused;
}
EventReceivedEventArgs eventReceived = null;
if (!paused && _eventsPending.TryDequeue(out eventReceived))
{
try {
HandleEvent(eventReceived);
} catch (Exception e) when(!e.IsCriticalException())
{
Debug.Fail(string.Format("Error while handling debugger event '{0}'.\n{1}", eventReceived.Name, e));
}
}
else
{
_eventsPendingWakeUp.WaitOne();
}
}
Debug.WriteLine("EventHandlingThread Ended");
}
public void JoinGameWithLobby()
{
string roomName = CreateRandomRoomName();
TestClient client = this.InitClient();
OperationRequest request = new OperationRequest((short)OperationCodes.Join);
request.Params.Add((short)ParameterKeys.GameId, roomName);
request.Params.Add((short)LiteLobby.Operations.LobbyParameterKeys.LobbyId, "Mainlobby");
client.SendOperationRequest(request, 0, true);
OperationResponse response = client.WaitForOperationResponse(this.WaitTime);
EventReceivedEventArgs eventArgs = client.WaitForEvent(this.WaitTime);
// check operation params
CheckDefaultOperationParams(response, OperationCodes.Join);
CheckParam(response, ParameterKeys.ActorNr, 1);
// check event params
CheckDefaultEventParams(eventArgs, OperationCodes.Join, 1);
CheckEventParamExists(eventArgs, ParameterKeys.Actors);
// cleanup
client.Close();
client.Dispose();
}
private void OnEventReceived(object sender, EventReceivedEventArgs e)
{
Entity entity = engine.GetEntity(e.SourceGuid);
if (entity != null)
{
}
}
private static void WriteEventReceived(EventReceivedEventArgs e)
{
if (e == null)
{
throw new ArgumentNullException(nameof(e));
}
WriteEventMessage(e.ApplicationName, e.EventId, e.Param, e.RaiserId, e.Sent, null, e.ServerName, null, null);
}
private void _connection_EventReceived(object sender, EventReceivedEventArgs e)
{
// Process events in a separate thread from the one that is processing messages
// so that event handling code that needs access to the UI thread don't end up racing with other
// code on the UI thread which may be waiting for a response to a request.
_debugLog.WriteLine("PythonProcess enqueuing event: " + e.Name);
_eventsPending.Enqueue(e);
_eventsPendingWakeUp.Set();
}
private void ConnectionReceivedEvent(object sender, EventReceivedEventArgs e) {
switch (e.Name) {
case TP.ResultEvent.Name:
var result = (TP.ResultEvent)e.Event;
TestOutcome outcome = TestOutcome.None;
switch (result.outcome) {
case "passed": outcome = TestOutcome.Passed; break;
case "failed": outcome = TestOutcome.Failed; break;
case "skipped": outcome = TestOutcome.Skipped; break;
}
RecordEnd(
_frameworkHandle,
_curTestResult,
_stdOut.ToString(),
_stdErr.ToString(),
outcome,
result
);
_stdOut.Clear();
_stdErr.Clear();
break;
case TP.StartEvent.Name:
var start = (TP.StartEvent)e.Event;
// Create the TestResult object right away, so that
// StartTime is initialized correctly.
_curTestResult = null;
foreach (var test in GetTestCases()) {
if (test.Key == start.test) {
_curTestResult = new TestResult(test.Value);
break;
}
}
if (_curTestResult != null) {
_frameworkHandle.RecordStart(_curTestResult.TestCase);
} else {
Warning(Strings.Test_UnexpectedResult.FormatUI(start.classname, start.method));
}
break;
case TP.StdErrEvent.Name:
var err = (TP.StdErrEvent)e.Event;
_stdErr.Append(err.content);
break;
case TP.StdOutEvent.Name:
var outp = (TP.StdOutEvent)e.Event;
_stdOut.Append(outp.content);
break;
case TP.DoneEvent.Name:
_done.Set();
break;
}
}
protected static void CheckJoinEvent(EventReceivedEventArgs eventArgs, int actorNumber, Hashtable expectedActorProperties)
{
CheckDefaultEventParams(eventArgs, OperationCodes.Join, actorNumber);
CheckEventParamExists(eventArgs, ParameterKeys.Actors);
if (expectedActorProperties != null)
{
CheckEventParamExists(eventArgs, ParameterKeys.ActorProperties);
CheckEventParam(eventArgs, ParameterKeys.ActorProperties, expectedActorProperties);
}
}
private void EventReceivedHandler(object sender, EventReceivedEventArgs args)
{
CefEvent cefEvent = args.CefEvent;
if (!_cefInstances.ContainsKey(cefEvent.InstanceID))
{
return;
}
_cefInstances[cefEvent.InstanceID].ReceiveEvent(cefEvent);
}
private static void Client_EventReceived(object sender, EventReceivedEventArgs e)
{
Console.WriteLine("Event: " + e.EventType);
if (e.Body is BreakpointEvent be)
{
Console.WriteLine(be.Reason);
Breakpoint breakpoint = be.Breakpoint;
Console.WriteLine("id: " + breakpoint.Id + " message: " + breakpoint.Message + " line: " + breakpoint.Line + " verified: " + breakpoint.Verified);
}
else if (e.Body is OutputEvent oe)
{
Console.WriteLine("Debugee: " + oe.Output.Trim());
}
}
private static void EventReceivedHandler(object sender, EventReceivedEventArgs args)
{
CefEvent cefEvent = args.CefEvent;
if (cefEvent is CefCreateInstanceEvent)
{
CefCreateInstanceEvent createEvent = (CefCreateInstanceEvent)cefEvent;
InstanceManager.CreateInstance(createEvent.InstanceID);
CefInstance cefInstance = InstanceManager.GetInstance(createEvent.InstanceID);
cefInstance.Width = createEvent.Width;
cefInstance.Height = createEvent.Height;
cefInstance.Url = createEvent.Url;
cefInstance.Start();
return;
}
InstanceManager.GetInstance(cefEvent.InstanceID).ReceiveEvent(cefEvent);
}
protected static void CheckJoinEvent(EventReceivedEventArgs eventArgs, int actorNumber)
{
CheckJoinEvent(eventArgs, actorNumber, null);
}
protected static void CheckEventParamExists(EventReceivedEventArgs eventArgs, object key)
{
Assert.Contains(key, eventArgs.EventData.Keys, "Parameter '{0}' is missing in event.", key);
}
protected static void CheckEventParamExists(EventReceivedEventArgs eventArgs, ParameterKeys paramKey)
{
Assert.Contains((short)paramKey, eventArgs.EventData.Keys, "Parameter '{0}' is missing in event.", paramKey);
}
protected static void CheckJoinEvent(EventReceivedEventArgs eventArgs, int actorNumber)
{
CheckJoinEvent(eventArgs, actorNumber, null);
}
private void EventReceived(object sender, EventReceivedEventArgs e)
{
_eventsReceived.TryAdd(e);
}
void OnEventReceived(EventReceivedEventArgs e) => EventReceived?.Invoke(this, e);
protected static void CheckEventParam(EventReceivedEventArgs eventArgs, ParameterKeys paramKey, object expectedValue)
{
CheckEventParamExists(eventArgs, paramKey);
Assert.AreEqual(expectedValue, eventArgs.EventData[(short)paramKey], "Event param '{0}' has unexpected value", paramKey);
}
protected static void CheckDefaultEventParams(EventReceivedEventArgs eventArgs, EventCodes eventCode, int actorNumber)
{
CheckEventParam(eventArgs, ParameterKeys.Code, (byte)eventCode);
CheckEventParam(eventArgs, ParameterKeys.ActorNr, actorNumber);
}
protected static void CheckEventParam(EventReceivedEventArgs eventArgs, ParameterKeys paramKey, object expectedValue)
{
CheckEventParamExists(eventArgs, paramKey);
Assert.AreEqual(expectedValue, eventArgs.EventData[(short)paramKey], "Event param '{0}' has unexpected value", paramKey);
}
private void ConectionReceivedEvent(object sender, EventReceivedEventArgs e)
{
switch (e.Name)
{
case TP.ResultEvent.Name:
var result = (TP.ResultEvent)e.Event;
TestOutcome outcome = TestOutcome.None;
switch (result.outcome)
{
case "passed": outcome = TestOutcome.Passed; break;
case "failed": outcome = TestOutcome.Failed; break;
case "skipped": outcome = TestOutcome.Skipped; break;
}
var testResult = new TestResult(_curTest);
RecordEnd(
_frameworkHandle,
_curTest,
testResult,
_stdOut.ToString(),
_stdErr.ToString(),
outcome,
result
);
_stdOut.Clear();
_stdErr.Clear();
break;
case TP.StartEvent.Name:
var start = (TP.StartEvent)e.Event;
_curTest = null;
foreach (var test in _tests)
{
string testFile, testClass, testMethod;
TestDiscoverer.ParseFullyQualifiedTestName(
test.FullyQualifiedName,
out testFile,
out testClass,
out testMethod
);
string testFilePath = CommonUtils.GetAbsoluteFilePath(_settings.ProjectHome, test.CodeFilePath);
var modulePath = ModulePath.FromFullPath(testFilePath);
if (start.test == modulePath.ModuleName + "." + testClass + "." + testMethod)
{
_curTest = test;
break;
}
}
if (_curTest != null)
{
_frameworkHandle.RecordStart(_curTest);
}
else
{
Warning(
string.Format(
"Unexpected test result: {0} {1} {2}",
start.classname,
start.method
)
);
}
break;
case TP.StdErrEvent.Name:
var err = (TP.StdErrEvent)e.Event;
_stdErr.Append(err.content);
break;
case TP.StdOutEvent.Name:
var outp = (TP.StdOutEvent)e.Event;
_stdOut.Append(outp.content);
break;
case TP.DoneEvent.Name:
_done.Set();
break;
}
}
protected static void CheckEventParamExists(EventReceivedEventArgs eventArgs, ParameterKeys paramKey)
{
Assert.Contains((short)paramKey, eventArgs.EventData.Keys, "Parameter '{0}' is missing in event.", paramKey);
}
void EventReceivedCallback(object sender, EventReceivedEventArgs e)
{
switch (e.Event.MessageType)
{
case MessageType.UserControlMessage:
var m = (UserControlMessage)e.Event;
if (m.EventType == UserControlMessageType.PingRequest)
{
Console.WriteLine("Client Ping Request");
WriteProtocolControlMessage(new UserControlMessage(UserControlMessageType.PingResponse, m.Values));
}
else if (m.EventType == UserControlMessageType.SetBufferLength)
{
Console.WriteLine("Set Buffer Length");
// TODO
}
else if (m.EventType == UserControlMessageType.PingResponse)
{
Console.WriteLine("Ping Response");
var message = m as UserControlMessage;
_callbackManager.SetResult(message.Values[0], null);
}
break;
case MessageType.DataAmf3:
#if DEBUG
System.Diagnostics.Debugger.Break();
#endif
break;
case MessageType.CommandAmf3:
case MessageType.DataAmf0:
case MessageType.CommandAmf0:
var command = (Command)e.Event;
var call = command.MethodCall;
var param = call.Parameters.Length == 1 ? call.Parameters[0] : call.Parameters;
switch (call.Name)
{
case "connect":
StreamID = _server.RequestStreamId();
HandleConnectInvokeAsync(command);
HasConnected = true;
break;
case "_result":
var ack = param as AcknowledgeMessage;
_callbackManager.SetResult(command.InvokeId, ack != null ? ack.Body : param);
break;
case "_error":
var error = param as ErrorMessage;
_callbackManager.SetException(command.InvokeId, error != null ? new InvocationException(error) : new InvocationException());
break;
case "receiveAudio":
// TODO
break;
case "releaseStream":
Console.WriteLine("ReleaseStream");
// TODO
break;
case "publish":
HandlePublish(command);
break;
case "unpublish":
HandleUnpublish(command);
break;
case "FCpublish":
case "FCPublish":
// TODO
break;
case "FCUnpublish":
case "FCunPublish":
HandleUnpublish(command);
break;
case "createStream":
SetResultValInvoke(StreamID, command.InvokeId);
break;
case "play":
HandlePlay(command);
break;
case "deleteStream":
Console.WriteLine("deleteStream");
// TODO
break;
case "@setDataFrame":
SetDataFrame(command);
break;
case "getStreamLength":
// TODO
break;
default:
#if DEBUG
System.Diagnostics.Debug.Print($"unknown rtmp command: {call.Name}");
System.Diagnostics.Debugger.Break();
#endif
break;
}
break;
case MessageType.WindowAcknowledgementSize:
var msg = (WindowAcknowledgementSize)e.Event;
break;
case MessageType.Video:
var video_data = e.Event as VideoData;
if (is_not_set_video_config && video_data.Data.Length >= 2 && video_data.Data[1] == 0)
{
is_not_set_video_config = false;
AvCConfigureRecord = video_data;
}
ChannelDataReceived?.Invoke(this, new ChannelDataReceivedEventArgs(ChannelType.Video, e.Event));
break;
case MessageType.Audio:
var audio_data = e.Event as AudioData;
if (is_not_set_auido_config && audio_data.Data.Length >= 2 && audio_data.Data[1] == 0)
{
is_not_set_auido_config = false;
AACConfigureRecord = audio_data;
}
ChannelDataReceived?.Invoke(this, new ChannelDataReceivedEventArgs(ChannelType.Audio, e.Event));
break;
case MessageType.Acknowledgement:
break;
default:
Console.WriteLine(string.Format("Unknown message type {0}", e.Event.MessageType));
break;
}
}
protected static void CheckEventParam(EventReceivedEventArgs eventArgs, object key, object expectedValue)
{
CheckEventParamExists(eventArgs, key);
Assert.AreEqual(expectedValue, eventArgs.EventData[key], "Event param '{0}' has unexpected value", key);
}
protected static void CheckJoinEvent(EventReceivedEventArgs eventArgs, int actorNumber, Hashtable expectedActorProperties)
{
CheckDefaultEventParams(eventArgs, OperationCodes.Join, actorNumber);
CheckEventParamExists(eventArgs, ParameterKeys.Actors);
if (expectedActorProperties != null)
{
CheckEventParamExists(eventArgs, ParameterKeys.ActorProperties);
CheckEventParam(eventArgs, ParameterKeys.ActorProperties, expectedActorProperties);
}
}
protected static void CheckDefaultEventParams(EventReceivedEventArgs eventArgs, EventCodes eventCode, int actorNumber)
{
CheckEventParam(eventArgs, ParameterKeys.Code, (byte)eventCode);
CheckEventParam(eventArgs, ParameterKeys.ActorNr, actorNumber);
}
private void ClientEventReceived(object sender, EventReceivedEventArgs e)
{
state.EventCalled(e.Msg);
}
protected static void CheckEventParam(EventReceivedEventArgs eventArgs, object key, object expectedValue)
{
CheckEventParamExists(eventArgs, key);
Assert.AreEqual(expectedValue, eventArgs.EventData[key], "Event param '{0}' has unexpected value", key);
}
protected void HandleEvent(object sender, EventReceivedEventArgs obj)
{
Task.Run(() => {
switch (obj.EventType)
{
case "initialized":
//OnStarted();
break;
case "stopped":
TargetEventArgs args;
var body = (StoppedEvent)obj.Body;
switch (body.Reason)
{
case StoppedEvent.ReasonValue.Breakpoint:
var stackFrame = this.GetThreadBacktrace(body.ThreadId ?? -1).GetFrame(0);
args = new TargetEventArgs(TargetEventType.TargetHitBreakpoint);
var bp = breakpoints.Select(b => b.Key).OfType <Mono.Debugging.Client.Breakpoint> ().FirstOrDefault(b => b.FileName == stackFrame.SourceLocation.FileName && b.Line == stackFrame.SourceLocation.Line);
if (bp == null)
{
//None of breakpoints is matching, this is probably Debugger.Break();
args = new TargetEventArgs(TargetEventType.TargetStopped);
}
else
{
args.BreakEvent = bp;
}
break;
case StoppedEvent.ReasonValue.Step:
case StoppedEvent.ReasonValue.Pause:
args = new TargetEventArgs(TargetEventType.TargetStopped);
break;
case StoppedEvent.ReasonValue.Exception:
args = new TargetEventArgs(TargetEventType.ExceptionThrown);
break;
default:
throw new NotImplementedException(body.Reason.ToString());
}
currentThreadId = body.ThreadId ?? -1;
//TODO: what happens if thread is not specified?
args.Process = GetProcesses() [0];
args.Thread = args.Process.GetThreads().Single(t => t.Id == currentThreadId);
args.Backtrace = args.Thread.Backtrace;
OnTargetEvent(args);
break;
case "terminated":
OnTargetEvent(new TargetEventArgs(TargetEventType.TargetExited));
break;
case "exited":
OnTargetEvent(new TargetEventArgs(TargetEventType.TargetExited)
{
ExitCode = ((ExitedEvent)obj.Body).ExitCode
});
break;
case "output":
var outputBody = (OutputEvent)obj.Body;
switch (outputBody.Category)
{
case OutputEvent.CategoryValue.Stdout:
OnTargetOutput(false, outputBody.Output);
break;
case OutputEvent.CategoryValue.Console:
OnDebuggerOutput(false, outputBody.Output);
break;
case OutputEvent.CategoryValue.Stderr:
OnTargetOutput(true, outputBody.Output);
break;
}
break;
}
});
}
private void HandleEvent(EventReceivedEventArgs e)
{
_debugLog.WriteLine(string.Format("PythonProcess handling event: {0}", e.Event.name));
lock (_eventHandlingLock) {
Debug.Assert(e.Event.name == LDP.LocalConnectedEvent.Name || e.Event.name == LDP.RemoteConnectedEvent.Name || _isAuthenticated);
switch (e.Event.name)
{
case LDP.AsyncBreakEvent.Name:
LegacyAsyncBreak?.Invoke(this, (LDP.AsyncBreakEvent)e.Event);
break;
case LDP.BreakpointFailedEvent.Name:
LegacyBreakpointFailed?.Invoke(this, (LDP.BreakpointFailedEvent)e.Event);
break;
case LDP.BreakpointHitEvent.Name:
LegacyBreakpointHit?.Invoke(this, (LDP.BreakpointHitEvent)e.Event);
break;
case LDP.BreakpointSetEvent.Name:
LegacyBreakpointSet?.Invoke(this, (LDP.BreakpointSetEvent)e.Event);
break;
case LDP.DebuggerOutputEvent.Name:
LegacyDebuggerOutput?.Invoke(this, (LDP.DebuggerOutputEvent)e.Event);
break;
case LDP.DetachEvent.Name:
LegacyDetach?.Invoke(this, (LDP.DetachEvent)e.Event);
break;
case LDP.EnumChildrenEvent.Name:
LegacyEnumChildren?.Invoke(this, (LDP.EnumChildrenEvent)e.Event);
break;
case LDP.ExceptionEvent.Name:
LegacyException?.Invoke(this, (LDP.ExceptionEvent)e.Event);
break;
case LDP.ExecutionExceptionEvent.Name:
LegacyExecutionException?.Invoke(this, (LDP.ExecutionExceptionEvent)e.Event);
break;
case LDP.ExecutionResultEvent.Name:
LegacyExecutionResult?.Invoke(this, (LDP.ExecutionResultEvent)e.Event);
break;
case LDP.LastEvent.Name:
LegacyLast?.Invoke(this, (LDP.LastEvent)e.Event);
break;
case LDP.LocalConnectedEvent.Name:
LegacyLocalConnected?.Invoke(this, (LDP.LocalConnectedEvent)e.Event);
break;
case LDP.ModuleLoadEvent.Name:
LegacyModuleLoad?.Invoke(this, (LDP.ModuleLoadEvent)e.Event);
break;
case LDP.ProcessLoadEvent.Name:
LegacyProcessLoad?.Invoke(this, (LDP.ProcessLoadEvent)e.Event);
break;
case LDP.RemoteConnectedEvent.Name:
LegacyRemoteConnected?.Invoke(this, (LDP.RemoteConnectedEvent)e.Event);
break;
case LDP.ModulesChangedEvent.Name:
LegacyModulesChanged?.Invoke(this, (LDP.ModulesChangedEvent)e.Event);
break;
case LDP.RequestHandlersEvent.Name:
LegacyRequestHandlers?.Invoke(this, (LDP.RequestHandlersEvent)e.Event);
break;
case LDP.StepDoneEvent.Name:
LegacyStepDone?.Invoke(this, (LDP.StepDoneEvent)e.Event);
break;
case LDP.ThreadCreateEvent.Name:
LegacyThreadCreate?.Invoke(this, (LDP.ThreadCreateEvent)e.Event);
break;
case LDP.ThreadFrameListEvent.Name:
LegacyThreadFrameList?.Invoke(this, (LDP.ThreadFrameListEvent)e.Event);
break;
case LDP.ThreadExitEvent.Name:
LegacyThreadExit?.Invoke(this, (LDP.ThreadExitEvent)e.Event);
break;
default:
Debug.Fail("Unknown event: {0}".FormatUI(e.Event.name));
break;
}
}
}
private void ConectionReceivedEvent(object sender, EventReceivedEventArgs e) {
switch (e.Event.name) {
case AP.ModulesChangedEvent.Name: OnModulesChanged(this, EventArgs.Empty); break;
case AP.OptionsChangedEvent.Name: SetOptions((AP.OptionsChangedEvent)e.Event); break;
case AP.SetCommentTaskTokens.Name: _commentPriorityMap = ((AP.SetCommentTaskTokens)e.Event).tokens; break;
case AP.ExtensionAddedEvent.Name: AddExtension((AP.ExtensionAddedEvent)e.Event); break;
}
}
protected void HandleEvent(object sender, EventReceivedEventArgs obj)
{
Task.Run(() => {
switch (obj.EventType)
{
case "initialized":
//OnStarted();
break;
case "stopped":
TargetEventArgs args;
var body = (StoppedEvent)obj.Body;
switch (body.Reason)
{
case StoppedEvent.ReasonValue.Breakpoint:
var stackFrame = (VsCodeStackFrame)this.GetThreadBacktrace(body.ThreadId ?? -1).GetFrame(0);
args = new TargetEventArgs(TargetEventType.TargetHitBreakpoint);
var bp = breakpoints.Select(b => b.Key).OfType <Mono.Debugging.Client.Breakpoint> ().FirstOrDefault(b => b.FileName == stackFrame.SourceLocation.FileName && b.Line == stackFrame.SourceLocation.Line);
if (bp == null)
{
bp = breakpoints.Select(b => b.Key).OfType <Mono.Debugging.Client.Breakpoint> ().FirstOrDefault(b => Path.GetFileName(b.FileName) == Path.GetFileName(stackFrame.SourceLocation.FileName) && b.Line == stackFrame.SourceLocation.Line);
}
if (bp == null)
{
//None of breakpoints is matching, this is probably Debugger.Break();
args = new TargetEventArgs(TargetEventType.TargetStopped);
}
else
{
args.BreakEvent = bp;
if (breakpoints.TryGetValue(bp, out var binfo))
{
if ((bp.HitAction & HitAction.PrintExpression) != HitAction.None)
{
string exp = EvaluateTrace(stackFrame.frameId, bp.TraceExpression);
binfo.UpdateLastTraceValue(exp);
OnContinue();
return;
}
}
}
break;
case StoppedEvent.ReasonValue.Step:
case StoppedEvent.ReasonValue.Pause:
args = new TargetEventArgs(TargetEventType.TargetStopped);
break;
case StoppedEvent.ReasonValue.Exception:
stackFrame = null;
var backtrace = GetThreadBacktrace(body.ThreadId ?? -1);
if (Options.ProjectAssembliesOnly)
{
// We can't evaluate expressions in external code frames, the debugger will hang
for (int i = 0; i < backtrace.FrameCount; i++)
{
var frame = stackFrame = (VsCodeStackFrame)backtrace.GetFrame(i);
if (!frame.IsExternalCode)
{
stackFrame = frame;
break;
}
}
if (stackFrame == null)
{
OnContinue();
return;
}
}
else
{
// It's OK to evaluate expressions in external code
stackFrame = (VsCodeStackFrame)backtrace.GetFrame(0);
}
if (!breakpoints.Select(b => b.Key).OfType <Catchpoint> ().Any(c => ShouldStopOnExceptionCatchpoint(c, stackFrame.frameId)))
{
OnContinue();
return;
}
args = new TargetEventArgs(TargetEventType.ExceptionThrown);
break;
default:
throw new NotImplementedException(body.Reason.ToString());
}
currentThreadId = body.ThreadId ?? -1;
//TODO: what happens if thread is not specified?
args.Process = GetProcesses() [0];
args.Thread = args.Process.GetThreads().Single(t => t.Id == currentThreadId);
args.Backtrace = args.Thread.Backtrace;
OnTargetEvent(args);
break;
case "terminated":
OnTargetEvent(new TargetEventArgs(TargetEventType.TargetExited));
break;
case "exited":
OnTargetEvent(new TargetEventArgs(TargetEventType.TargetExited)
{
ExitCode = ((ExitedEvent)obj.Body).ExitCode
});
break;
case "process":
var processEvent = (ProcessEvent)obj.Body;
processInfo.Add(new ProcessInfo(processEvent.SystemProcessId ?? 1, processEvent.Name));
OnStarted();
break;
case "output":
var outputBody = (OutputEvent)obj.Body;
switch (outputBody.Category)
{
case OutputEvent.CategoryValue.Stdout:
OnTargetOutput(false, outputBody.Output);
break;
case OutputEvent.CategoryValue.Console:
OnDebuggerOutput(false, outputBody.Output);
break;
case OutputEvent.CategoryValue.Stderr:
OnTargetOutput(true, outputBody.Output);
break;
}
break;
case "module":
var moduleEvent = (ModuleEvent)obj.Body;
if (moduleEvent.Reason == ModuleEvent.ReasonValue.New)
{
OnAssemblyLoaded(moduleEvent.Module.Path);
}
break;
}
});
}
protected static void CheckEventParamExists(EventReceivedEventArgs eventArgs, object key)
{
Assert.Contains(key, eventArgs.EventData.Keys, "Parameter '{0}' is missing in event.", key);
}
