private void AbortEventProcess(EventInfoBase eventInfo)
{
AbortEventInfo abortEventInfo = (AbortEventInfo)eventInfo;
if (abortEventInfo.IsRequest)
{
_globalInfo.StateMachine.State = RuntimeState.AbortRequested;
_sessionStateHandles[eventInfo.Session].AbortEventProcess(abortEventInfo);
}
else
{
_sessionStateHandles[abortEventInfo.Session].AbortEventProcess(abortEventInfo);
// 如果都已经Abort结束，则执行结束操作
if (_sessionStateHandles.Values.All(item => ModuleUtils.IsOver(item.State)))
{
_globalInfo.StateMachine.State = RuntimeState.Abort;
SetTestInstanceEndTime(eventInfo.TimeStamp);
_stateManageContext.DatabaseProxy.UpdateData(_stateManageContext.TestInstance);
_stateManageContext.EventDispatcher.RaiseEvent(Constants.TestInstanceOver, eventInfo.Session,
_stateManageContext.TestResults);
}
}
}
private void RefreshCommonStatus(EventInfoBase eventInfo, RuntimeState newState, StepResult stepResult)
{
// 如果阻塞开始时间无效并且最新状态是非阻塞状态，则继续执行
if (_blockedStart == DateTime.MaxValue && (newState != RuntimeState.Blocked && newState != RuntimeState.DebugBlocked))
{
// ignore
}
// 如果阻塞开始时间有效，并且目前的状态为非阻塞状态，则更新阻塞时间并清空阻塞开始时间
else if (_blockedStart != DateTime.MaxValue && (newState != RuntimeState.Blocked && newState != RuntimeState.DebugBlocked))
{
this.BlockedTime += eventInfo.TimeStamp - _blockedStart;
this._blockedStart = DateTime.MaxValue;
}
// 如果阻塞开始事件无效，并且目前状态为阻塞状态，则更新阻塞开始时间
else if (_blockedStart == DateTime.MaxValue && (newState == RuntimeState.Blocked || newState == RuntimeState.DebugBlocked))
{
this._blockedStart = eventInfo.TimeStamp;
}
this.ElapsedTime = eventInfo.TimeStamp - this.StartTime - this.BlockedTime;
this.CurrentTime = eventInfo.TimeStamp;
this.State = newState;
if (newState == RuntimeState.Abort || newState == RuntimeState.Error || newState == RuntimeState.Failed || newState == RuntimeState.Success)
{
this.EndTime = eventInfo.TimeStamp;
}
this.StepResult = stepResult;
}
protected EventBase(EventInfoBase eventInfo, IDictionary <string, IValue> nmap, IDictionary <string, IUpdateable> umap)
{
info = eventInfo;
statements = new List <Statement>(eventInfo.Statements.Count);
foreach (EventInfoBase.StatementInfo statementInfo in eventInfo.Statements)
{
statements.Add(new Statement(statementInfo, umap, nmap));
}
}
private void ExceptionEventProcess(EventInfoBase eventInfo)
{
_globalInfo.StateMachine.State = RuntimeState.Error;
SetTestInstanceEndTime(eventInfo.TimeStamp);
_stateManageContext.DatabaseProxy.UpdateData(_stateManageContext.TestInstance);
_stateManageContext.EventDispatcher.RaiseEvent(Constants.TestInstanceOver, eventInfo.Session,
_stateManageContext.TestResults);
}
private void RefreshTime(EventInfoBase eventInfo)
{
this.CurrentTime = eventInfo.TimeStamp;
if (this.StartTime != DateTime.MaxValue)
{
this.ElapsedTime = eventInfo.TimeStamp - this.StartTime;
}
if (this.State > RuntimeState.AbortRequested)
{
this.EndTime = eventInfo.TimeStamp;
}
}
// 完成的功能：执行结束后构造TestInstanceData并持久化，转发测试消息和事件到下级
#region 事件和消息处理
private void TestGenEventProcess(EventInfoBase eventInfo)
{
TestGenEventInfo testGenEventInfo = (TestGenEventInfo)eventInfo;
switch (testGenEventInfo.GenState)
{
case TestGenState.StartGeneration:
if (RuntimeState.Idle == _globalInfo.StateMachine.State)
{
_globalInfo.StateMachine.State = RuntimeState.TestGen;
_stateManageContext.TestInstance.StartGenTime = eventInfo.TimeStamp;
_stateManageContext.DatabaseProxy.WriteData(_stateManageContext.TestInstance);
_stateManageContext.EventDispatcher.RaiseEvent(Constants.TestGenerationStart, eventInfo.Session,
_stateManageContext.TestGenerationInfo);
}
_sessionStateHandles[eventInfo.Session].TestGenEventProcess(testGenEventInfo);
break;
case TestGenState.GenerationOver:
_sessionStateHandles[testGenEventInfo.Session].TestGenEventProcess(testGenEventInfo);
if (_sessionStateHandles.Values.All(item => item.State == RuntimeState.StartIdle))
{
_globalInfo.StateMachine.State = RuntimeState.StartIdle;
_stateManageContext.TestInstance.EndGenTime = testGenEventInfo.TimeStamp;
_stateManageContext.DatabaseProxy.UpdateData(_stateManageContext.TestInstance);
_stateManageContext.EventDispatcher.RaiseEvent(Constants.TestGenerationEnd, testGenEventInfo.Session,
_stateManageContext.TestGenerationInfo);
}
break;
case TestGenState.Error:
_sessionStateHandles[eventInfo.Session].TestGenEventProcess(testGenEventInfo);
_globalInfo.StateMachine.State = RuntimeState.Error;
SetTestInstanceEndTime(testGenEventInfo.TimeStamp);
_stateManageContext.DatabaseProxy.UpdateData(_stateManageContext.TestInstance);
_stateManageContext.EventDispatcher.RaiseEvent(Constants.TestGenerationEnd, testGenEventInfo.Session,
_stateManageContext.TestGenerationInfo);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private void ProcessInternalMessage(object state)
{
LocalEventQueue <EventInfoBase> internalEventQueue = _globalInfo.EventQueue;
try
{
while (!_cancellation.IsCancellationRequested)
{
EventInfoBase eventInfo = internalEventQueue.WaitUntilMessageCome();
if (null == eventInfo)
{
return;
}
_eventProcessActions[eventInfo.GetType().Name].Invoke(eventInfo);
}
// 处理完堆积的内部消息，然后停止
while (internalEventQueue.Count > 0)
{
EventInfoBase eventInfo = internalEventQueue.Dequeue();
_eventProcessActions[eventInfo.GetType().Name].Invoke(eventInfo);
}
}
catch (TestflowException ex)
{
_globalInfo.LogService.Print(LogLevel.Fatal, CommonConst.PlatformLogSession, ex);
_globalInfo.StateMachine.State = RuntimeState.Error;
throw;
}
catch (ThreadAbortException)
{
_globalInfo.LogService.Print(LogLevel.Warn, CommonConst.PlatformLogSession,
$"thread {Thread.CurrentThread.Name} is stopped abnormally");
}
catch (Exception ex)
{
_globalInfo.EventQueue.Enqueue(new ExceptionEventInfo(ex));
_globalInfo.LogService.Print(LogLevel.Fatal, CommonConst.PlatformLogSession, ex, "Engine collapsed by fatal error.");
_globalInfo.StateMachine.State = RuntimeState.Collapsed;
}
}
/// <summary>
/// 是否为根序列的事件
/// </summary>
private bool IsRootEvent(EventInfoBase eventInfo)
{
return((eventInfo.Session == CommonConst.TestGroupSession) || 1 == _sessionStateHandles.Count || eventInfo.Session == CommonConst.PlatformLogSession);
}
private void SyncEventProcess(EventInfoBase eventInfo)
{
SyncEventInfo syncEvent = (SyncEventInfo)eventInfo;
_sessionStateHandles[syncEvent.Session].SyncEventProcess(syncEvent);
}
private void DebugEventProcess(EventInfoBase eventInfo)
{
DebugEventInfo debugEvent = (DebugEventInfo)eventInfo;
_sessionStateHandles[debugEvent.Session].DebugEventProcess(debugEvent);
}
private void OnGUI()
{
if (this._encounterInfo != null)
{
this._eventTypeIndex = EditorGUILayout.Popup(this._eventTypeIndex, this._componentTypeNames);
if (EditorWindowBase.GetButton("Add Event", 80, Color.green))
{
if (this._eventTypeIndex < 0)
{
return;
}
EventInfoBase eventInfoBase = CreateInstance(this._componentTypeNames[this._eventTypeIndex]) as EventInfoBase;
if (eventInfoBase != null)
{
this._encounterInfo.Events.Add(eventInfoBase);
}
else
{
throw new ArgumentException("component is NULL.");
}
}
this._scrollPos = EditorGUILayout.BeginScrollView(this._scrollPos);
GUILayout.Space(10);
if (this._encounterInfo.Events.Count > 0)
{
int indexToDelete = -1;
for (int i = 0; i < this._encounterInfo.Events.Count; i++)
{
var @event = this._encounterInfo.Events[i];
if (@event != null)
{
EditorGUILayout.BeginVertical(GUI.skin.box);
Editor.CreateEditor(this._encounterInfo.Events[i]).OnInspectorGUI();
if (EditorWindowBase.GetButton("-", 20, Color.red))
{
indexToDelete = i;
}
EditorGUILayout.EndVertical();
if (indexToDelete > -1)
{
bool result = EditorUtility.DisplayDialog("Delete", "Delete Event",
"OK", "Cancel");
if (result)
{
this._encounterInfo.Events.Remove(this._encounterInfo.Events[indexToDelete]);
DestroyImmediate(this._encounterInfo.Events[indexToDelete], true);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
this.Repaint();
}
}
}
}
EditorGUILayout.EndScrollView();
}
}
