public void HandleEventSignalWorkerThread()
        {
            MockThread(_mockRemoteThread, StopReason.NONE, new List <ulong>());
            const ulong mockWorkerThreadId = 2;
            const int   signalNumber       = 1;
            var         mockWorkerThread   = Substitute.For <RemoteThread>();

            mockWorkerThread.GetThreadId().Returns(mockWorkerThreadId);
            MockThread(mockWorkerThread, StopReason.SIGNAL,new List <ulong> {
                signalNumber
            });
            var mockUnixSignals = Substitute.For <SbUnixSignals>();

            mockUnixSignals.GetShouldStop(signalNumber).Returns(true);
            _mockSbProcess.GetUnixSignals().Returns(mockUnixSignals);
            MockProcess(new List <RemoteThread> {
                _mockRemoteThread,mockWorkerThread
            });
            ExceptionEvent resultEvent = null;

            _mockDebugEngineHandler.SendEvent(
                Arg.Do(delegate(DebugEvent x) { resultEvent = (ExceptionEvent)x; }), _mockProgram,
                mockWorkerThread);

            RaiseSingleStateChanged();

            _mockDebugEngineHandler.Received(1).SendEvent(
                Arg.Is <DebugEvent>(x => x is ExceptionEvent), _mockProgram, mockWorkerThread);
            _mockSbProcess.Received(1).SetSelectedThreadById(mockWorkerThreadId);
            AssertExceptionEvent(resultEvent, signalNumber);
        }
        private void SetSignals(IEnumerable <Signal> signals)
        {
            var unixSignals = lldbProcess.GetUnixSignals();

            foreach (var signal in signals)
            {
                Trace.WriteLine($"Setting {signal.name} to stop: {signal.stop}");
                unixSignals.SetShouldStop(signal.code, signal.stop);
            }
        }
        // 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;
            }
        }