public bool HandleStatusMessage(StatusMessage message)
        {
            this.State       = message.State;
            this.Performance = message.Performance;
            IRuntimeStatusInfo runtimeStatusInfo;

            switch (message.Name)
            {
            case MessageNames.StartStatusName:
                this.StartTime = message.Time;
                RefreshTime(message);

                UpdateSessionResultData(string.Empty);

                SetTestResultStatistics(message.WatchData);
                _testResults.Performance = ModuleUtils.GetPerformanceResult(_stateManageContext.DatabaseProxy,
                                                                            RuntimeHash, Session);
                _stateManageContext.EventDispatcher.RaiseEvent(Constants.SessionStart,
                                                               Session, _testResults);
                // 写入性能记录条目
                WritePerformanceStatus();
                for (int i = 0; i < message.Stacks.Count; i++)
                {
                    if (message.SequenceStates[i] == RuntimeState.Running)
                    {
                        _sequenceHandles[message.Stacks[i].Session].HandleStatusMessage(message, i);
                    }
                }
                break;

            case MessageNames.ReportStatusName:
                RefreshTime(message);

                for (int i = 0; i < message.Stacks.Count; i++)
                {
                    RuntimeState sequenceState = message.SequenceStates[i];
                    if (sequenceState == RuntimeState.Running || RuntimeState.Blocked == sequenceState ||
                        RuntimeState.DebugBlocked == sequenceState)
                    {
                        _sequenceHandles[message.Stacks[i].Session].HandleStatusMessage(message, i);
                    }
                }

                runtimeStatusInfo = CreateRuntimeStatusInfo(message);
                _stateManageContext.EventDispatcher.RaiseEvent(Constants.StatusReceived,
                                                               Session, runtimeStatusInfo);

                // 写入性能记录条目
                WritePerformanceStatus();
                break;

            case MessageNames.ResultStatusName:
                this.EndTime = message.Time;
                RefreshTime(message);

                SetTestResultStatistics(message.WatchData);
                _testResults.Performance = ModuleUtils.GetPerformanceResult(_stateManageContext.DatabaseProxy,
                                                                            RuntimeHash, Session);
                _stateManageContext.EventDispatcher.RaiseEvent(Constants.SessionOver,
                                                               Session, _testResults);

                UpdateSessionResultData(string.Empty);
                // 写入性能记录条目
                WritePerformanceStatus();
                break;

            case MessageNames.ErrorStatusName:
                this.EndTime = message.Time;
                RefreshTime(message);

                foreach (SequenceStateHandle sequenceStateHandle in _sequenceHandles.Values)
                {
                    RuntimeState runtimeState = sequenceStateHandle.State;
                    if (runtimeState == RuntimeState.Running || runtimeState == RuntimeState.Blocked ||
                        runtimeState == RuntimeState.DebugBlocked)
                    {
                        sequenceStateHandle.HandleStatusMessage(message, CommonConst.BroadcastSession);
                    }
                }

                UpdateSessionResultData(message.ExceptionInfo.ToString());

                SetTestResultStatistics(message.WatchData);
                _testResults.Performance = ModuleUtils.GetPerformanceResult(_stateManageContext.DatabaseProxy,
                                                                            RuntimeHash, Session);
                _stateManageContext.EventDispatcher.RaiseEvent(Constants.SessionOver,
                                                               Session, _testResults);
                // 写入性能记录条目
                WritePerformanceStatus();
                break;

            case MessageNames.HearBeatStatusName:
                RefreshTime(message);

                for (int i = 0; i < message.Stacks.Count; i++)
                {
                    if (message.SequenceStates[i] == RuntimeState.Running)
                    {
                        _sequenceHandles[message.Stacks[i].Session].HandleStatusMessage(message, i);
                    }
                }

                runtimeStatusInfo = CreateRuntimeStatusInfo(message);
                _stateManageContext.EventDispatcher.RaiseEvent(Constants.StatusReceived,
                                                               Session, runtimeStatusInfo);
                break;

            default:
                throw new InvalidProgramException();
                break;
            }

            FlipHeatBeatIndex();
            return(true);
        }