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