public void HandleResultWhenNormal(ExitReason expected) { var ei = ExitInfo.Normal(expected); ExitReason?actual = null; Exception error = null; ei.HandleResult( onNormal: r => actual = r, onError: ex => error = ex);; Assert.AreEqual(expected, actual); Assert.IsNull(error); }
public void IfErrorWhenNormal() { var ei = ExitInfo.Normal(ExitReason.Unknown); var isCalled = false; Action <Exception> a = ex => { isCalled = true; }; ei.IfError(a); Assert.IsFalse(isCalled); }
public int Detach() { DetachRequested = true; if (!_lldbProcess.Detach()) { DetachRequested = false; return(VSConstants.E_FAIL); } // Send the ProgramDestroyEvent immediately, so that Visual Studio can't cause a // deadlock by waiting for the event while preventing us from accessing the main thread. // TODO: Block and wait for LldbEventHandler to send the event _debugEngineHandler.Abort(this, ExitInfo.Normal(ExitReason.DebuggerDetached)); return(VSConstants.S_OK); }
public void AbortSendsProgramDestroyEvent(ExitReason exitReason) { ProgramDestroyEvent destroyEvent = null; debugEngineHandler.SendEvent( Arg.Do <DebugEvent>(e => destroyEvent = e as ProgramDestroyEvent), Arg.Any <IGgpDebugProgram>(), Arg.Any <IDebugThread2>()) .Returns(VSConstants.S_OK); debugEngineHandler.Abort(program, ExitInfo.Normal(exitReason)); debugEngineHandler.Received(1).SendEvent( Arg.Is <DebugEvent>(e => e is ProgramDestroyEvent), program, (IDebugThread2)null); destroyEvent.ExitInfo.HandleResult( r => Assert.That(r, Is.EqualTo(exitReason)), ex => Assert.Fail("Unexpected error: " + ex.ToString())); }
public int Terminate() { TerminationRequested = true; //TODO: remove the legacy launch flow. if (!_lldbProcess.Kill()) { // Visual Studio waits for the ProgramDestroyEvent regardless of whether // Terminate() succeeds, so we send the event on failure as well as on success. _debugEngineHandler.Abort( this, ExitInfo.Error(new TerminateProcessException(ErrorStrings.FailedToStopGame))); return(VSConstants.E_FAIL); } // Send the ProgramDestroyEvent immediately, so that Visual Studio can't cause a // deadlock by waiting for the event while preventing us from accessing the main thread. // TODO: Block and wait for LldbEventHandler to send the event _debugEngineHandler.Abort(this, ExitInfo.Normal(ExitReason.DebuggerTerminated)); return(VSConstants.S_OK); }
// Called when we receive a state changed LLDB event. void OnStateChangedEvent(SbEvent sbEvent) { if (sbEvent == null) { return; } var type = sbEvent.GetStateType(); Debug.WriteLine("Received LLDB event: " + Enum.GetName(type.GetType(), type)); switch (type) { case StateType.STOPPED: if (sbEvent.GetProcessRestarted()) { break; } var currentThread = _lldbProcess.GetSelectedThread(); var currentStopReason = StopReason.INVALID; if (currentThread != null) { currentStopReason = currentThread.GetStopReason(); } // When stopping pick the most relevant thread based on the stop reason. if (currentThread == null || currentStopReason == StopReason.INVALID || currentStopReason == StopReason.NONE) { int numThreads = _lldbProcess.GetNumThreads(); RemoteThread planThread = null; RemoteThread otherThread = null; for (int i = 0; i < numThreads; ++i) { RemoteThread thread = _lldbProcess.GetThreadAtIndex(i); switch (thread.GetStopReason()) { case StopReason.INVALID: // fall-through case StopReason.NONE: break; case StopReason.SIGNAL: if (otherThread == null) { var signalNumber = thread.GetStopReasonDataAtIndex(0); var unixSignals = _lldbProcess.GetUnixSignals(); if (unixSignals != null && unixSignals.GetShouldStop((int)signalNumber)) { otherThread = thread; } } break; case StopReason.TRACE: // fall-through case StopReason.BREAKPOINT: // fall-through case StopReason.WATCHPOINT: // fall-through case StopReason.EXCEPTION: // fall-through case StopReason.EXEC: // fall-through case StopReason.EXITING: // fall-through case StopReason.INSTRUMENTATION: if (otherThread == null) { otherThread = thread; } break; case StopReason.PLAN_COMPLETE: if (planThread == null) { planThread = thread; } break; } } if (planThread != null) { currentThread = planThread; } else if (otherThread != null) { currentThread = otherThread; } else if (currentThread == null) { currentThread = _lldbProcess.GetThreadAtIndex(0); } if (currentThread == null) { Trace.WriteLine("Error: Cannot handle event. No thread found."); return; } _lldbProcess.SetSelectedThreadById(currentThread.GetThreadId()); currentStopReason = currentThread.GetStopReason(); } // Log specific information about the stop event. string message = "Received stop event. Reason: " + currentStopReason; var stopReasonDataCount = currentThread.GetStopReasonDataCount(); if (stopReasonDataCount > 0) { message += " Data:"; for (uint i = 0; i < stopReasonDataCount; i++) { message += " " + currentThread.GetStopReasonDataAtIndex(i); } } Trace.WriteLine(message); _taskContext.Factory.Run(async() => { // We run the event resolution on the main thread to make sure // we do not race with concurrent modifications in the breakpoint // manager class (we could just have hit breakpoint that is being // added by the main thread!). await _taskContext.Factory.SwitchToMainThreadAsync(); DebugEvent eventToSend = null; switch (currentStopReason) { case StopReason.BREAKPOINT: eventToSend = HandleBreakpointStop(currentThread); break; case StopReason.WATCHPOINT: eventToSend = HandleWatchpointStop(currentThread); break; case StopReason.SIGNAL: eventToSend = HandleSignalStop(currentThread); break; case StopReason.PLAN_COMPLETE: eventToSend = new StepCompleteEvent(); break; default: break; } if (eventToSend == null) { eventToSend = new BreakEvent(); } _debugEngineHandler.SendEvent(eventToSend,_program,currentThread); }); break; case StateType.EXITED: { // There are two ways to exit a debug session without an error: // - We call program.Terminate, which causes LLDB to send this event. // - Program exits by itself, resulting in this event. // We distinguish these events by checking if we called Terminate. ExitReason exitReason = _program.TerminationRequested ? ExitReason.DebuggerTerminated : ExitReason.ProcessExited; _debugEngineHandler.Abort(_program,ExitInfo.Normal(exitReason)); } break; case StateType.DETACHED: { // Normally the only way to detach the process is by program.Detach. // However, this check was retained to mirror the EXITED case and to // record unexpected instances of detaching through some other path. ExitReason exitReason = _program.DetachRequested ? ExitReason.DebuggerDetached : ExitReason.ProcessDetached; _debugEngineHandler.Abort(_program,ExitInfo.Normal(exitReason)); } break; } }