protected override void InvokeStepSingleTime(bool forceInvoke) { // 重置计时时间 Actuator.ResetTiming(); // 调用前置监听 OnPreListener(); this.Result = StepResult.NotAvailable; this.Result = Actuator.InvokeStep(forceInvoke); // 如果当前step被标记为记录状态,则返回状态信息 if (null != StepData && StepData.RecordStatus) { RecordRuntimeStatus(); } // 调用后置监听 OnPostListener(); if (null != StepData && StepData.HasSubSteps) { StepTaskEntityBase subStepEntity = SubStepRoot; do { if (!forceInvoke && Context.Cancellation.IsCancellationRequested) { this.Result = StepResult.Abort; return; } subStepEntity.Invoke(forceInvoke); } while (null != (subStepEntity = subStepEntity.NextStep)); } }
public StepTaskEntityBase GetStepEntity(ICallStack stack) { // 当前当前StepRoot为null,则说明序列已经执行结束,返回null if (null == _stepEntityRoot) { return(null); } StepTaskEntityBase currentStep = _stepEntityRoot; int currentLevel = 0; int stepId = stack.StepStack[currentLevel]; for (int i = 0; i < stepId; i++) { currentStep = currentStep.NextStep; } currentLevel++; while (currentLevel < stack.StepStack.Count && null != currentStep.SubStepRoot) { currentStep = currentStep.SubStepRoot; stepId = stack.StepStack[currentLevel]; for (int i = 0; i < stepId; i++) { currentStep = currentStep.NextStep; } currentLevel++; } return(currentStep); }
protected override void InvokeStepSingleTime(bool forceInvoke) { // 重置计时 Actuator.ResetTiming(); // 调用前置监听 OnPreListener(); // 开始计时 Actuator.StartTiming(); // 停止计时 Actuator.EndTiming(); // 应为TryFinally块上级为空,默认为pass this.Result = StepResult.Pass; // 调用后置监听 OnPostListener(); StepTaskEntityBase tryBlock = SubStepRoot; StepTaskEntityBase finallyBlock = tryBlock.NextStep; try { tryBlock.Invoke(forceInvoke); } finally { // finally模块是强制调用 finallyBlock.Invoke(true); } if (null != StepData && StepData.RecordStatus) { RecordRuntimeStatus(); } }
private void SetResultState(out StepResult lastStepResult, out StatusReportType finalReportType, out FailedInfo failedInfo) { StepTaskEntityBase lastStep = StepTaskEntityBase.GetCurrentStep(this.Index, RootCoroutineId); lastStepResult = lastStep.Result; failedInfo = null; this.State = ModuleUtils.GetSequenceState(this._stepEntityRoot); switch (this.State) { case RuntimeState.Over: case RuntimeState.Success: finalReportType = StatusReportType.Over; break; case RuntimeState.Failed: finalReportType = StatusReportType.Failed; break; case RuntimeState.Timeout: case RuntimeState.Error: finalReportType = StatusReportType.Error; break; case RuntimeState.Abort: finalReportType = StatusReportType.Error; failedInfo = new FailedInfo("Sequence aborted", FailedType.Abort); _context.LogSession.Print(LogLevel.Warn, Index, $"Sequence {Index} execution aborted"); break; default: finalReportType = StatusReportType.Over; break; } }
public static void AddSequenceEntrance(StepTaskEntityBase stepModel) { if (!CurrentModel.ContainsKey(stepModel.SequenceIndex)) { CurrentModel.Add(stepModel.SequenceIndex, new Dictionary <int, StepTaskEntityBase>(Constants.DefaultRuntimeSize)); } CurrentModel[stepModel.SequenceIndex].Add(stepModel.Coroutine.Id, stepModel); }
public void FillStatusInfo(StatusMessage message, string errorInfo) { // 如果是外部调用且该序列已经执行结束或者message中已经有了当前序列的信息,则说明该序列在前面的消息中已经标记结束,直接返回。 if (message.InterestedSequence.Contains(this.Index) || this.State > RuntimeState.AbortRequested) { return; } message.Stacks.Add(StepTaskEntityBase.GetCurrentStep(Index, RootCoroutineId).GetStack()); message.SequenceStates.Add(this.State); message.Results.Add(StepResult.NotAvailable); }
public void FillStatusInfo(StatusMessage message) { // 如果是外部调用且该序列已经执行结束或者未开始或者message中已经有了当前序列的信息,则说明该序列在前面的消息中已经标记结束,直接返回。 if (message.InterestedSequence.Contains(this.Index) || this.State > RuntimeState.AbortRequested || this.State == RuntimeState.StartIdle) { return; } message.SequenceStates.Add(this.State); StepTaskEntityBase currentStep = StepTaskEntityBase.GetCurrentStep(Index, RootCoroutineId); currentStep.FillStatusInfo(message); }
protected StepTaskEntityBase(ISequenceStep step, SlaveContext context, int sequenceIndex) { this.Context = context; this.StepData = step; this.Result = StepResult.NotAvailable; this.SequenceIndex = sequenceIndex; this.Actuator = ActuatorBase.GetActuator(step, context, sequenceIndex); this.Coroutine = null; // 只有在断言失败和调用异常都配置为终止执行时,该步骤才会被判断为失败后终止 if (null != StepData && StepData.HasSubSteps) { this.SubStepRoot = ModuleUtils.CreateSubStepModelChain(StepData.SubSteps, Context, sequenceIndex); } BreakIfFailed = (null == StepData) || (StepData.AssertFailedAction == FailedAction.Terminate && StepData.InvokeErrorAction == FailedAction.Terminate); }
public virtual void Generate(ref int coroutineId) { this.Coroutine = Context.CoroutineManager.GetCoroutineHandle(coroutineId); Actuator.Generate(coroutineId); // 只有在StepData的LoopCounter不为null,loop最大值大于1,并且Step类型不是ConditionLoop的情况下才会执行LoopCounter this._hasLoopCounter = (StepData?.LoopCounter != null && StepData.LoopCounter.MaxValue > 1 && StepData.StepType != SequenceStepType.ConditionLoop); this._isUnderRetryStep = IsUnderRetryBlock(); if (StepData?.HasSubSteps ?? false) { StepTaskEntityBase subStepEntity = SubStepRoot; do { subStepEntity.Generate(ref coroutineId); } while (null != (subStepEntity = subStepEntity.NextStep)); } InintializeInvokeAction(); }
public void Generate(int startCoroutineId) { this.RootCoroutineId = startCoroutineId; this.State = RuntimeState.TestGen; _stepEntityRoot = ModuleUtils.CreateStepModelChain(_sequence.Steps, _context, _sequence.Index); if (null == _stepEntityRoot) { return; } StepTaskEntityBase stepEntity = _stepEntityRoot; do { stepEntity.Generate(ref startCoroutineId); } while (null != (stepEntity = stepEntity.NextStep)); this.State = RuntimeState.StartIdle; // 添加当前根节点到stepModel管理中 StepTaskEntityBase.AddSequenceEntrance(_stepEntityRoot); }
protected override void InvokeStepSingleTime(bool forceInvoke) { // 重置计时时间 Actuator.ResetTiming(); // 调用前置监听 OnPreListener(); this.Result = StepResult.NotAvailable; this.Result = Actuator.InvokeStep(forceInvoke); // 如果当前step被标记为记录状态,则返回状态信息 if (null != StepData && StepData.RecordStatus) { RecordRuntimeStatus(); } // 调用后置监听 OnPostListener(); object returnValue = Actuator.Return; // 如果执行结果不是bool类型或者为False,或者没有下级节点,则退出当前循环 bool conditionFail = !(returnValue is bool) || !(bool)returnValue; if (conditionFail || null == StepData || !StepData.HasSubSteps) { return; } // 执行下级的所有Step StepTaskEntityBase subStepEntity = SubStepRoot; do { if (!forceInvoke && Context.Cancellation.IsCancellationRequested) { this.Result = StepResult.Abort; return; } subStepEntity.Invoke(forceInvoke); } while (null != (subStepEntity = subStepEntity.NextStep)); }
// protected override void CheckSequenceData() // { // if (null != StepData.Function) // { // Context.LogSession.Print(LogLevel.Error, Context.SessionId, // $"Conditionblock cannot configure function data. Step:{StepData.Name}"); // I18N i18N = I18N.GetInstance(Constants.I18nName); // throw new TestflowDataException(ModuleErrorCode.SequenceDataError, i18N.GetStr("ConditionBlockHasFunc")); // // } // if (null != StepData.SubSteps && // StepData.SubSteps.Any(item => item.StepType != SequenceStepType.ConditionStatement)) // { // Context.LogSession.Print(LogLevel.Error, Context.SessionId, // $"Some steps under condition block is not ConditionStatement type. Step:{GetStack()}"); // I18N i18N = I18N.GetInstance(Constants.I18nName); // throw new TestflowDataException(ModuleErrorCode.SequenceDataError, i18N.GetStr("IllegalStepType")); // } // } protected override void InvokeStepSingleTime(bool forceInvoke) { // 重置计时时间 Actuator.ResetTiming(); // 调用前置监听 OnPreListener(); // 开始计时 Actuator.StartTiming(); // 停止计时 Actuator.EndTiming(); this.Result = StepResult.Pass; // 如果当前step被标记为记录状态,则返回状态信息 if (null != StepData && StepData.RecordStatus) { RecordRuntimeStatus(); } // 调用后置监听 OnPostListener(); if (null != StepData && StepData.HasSubSteps) { StepTaskEntityBase subStepEntity = SubStepRoot; do { subStepEntity.Invoke(forceInvoke); object returnValue = subStepEntity.Return; // 如果ConditionStatement返回值为True则说明该分支已执行完成,则跳过后续的Step if (returnValue is bool && (bool)returnValue) { break; } } while (null != (subStepEntity = subStepEntity.NextStep)); } }
protected override void InvokeStepSingleTime(bool forceInvoke) { int index = 0; while (true) { try { while (true) { // 设置循环变量的值 if (null != _loopVariable) { Context.VariableMapper.SetParamValue(_loopVariable, StepData.LoopCounter.CounterVariable, index++); } // 如果是取消状态并且不是强制执行则返回。因为ConditionLoop内部有循环,所以需要在内部也做判断 if (!forceInvoke && Context.Cancellation.IsCancellationRequested) { BreakAndReportAbortMessage(); } // 重置计时时间 Actuator.ResetTiming(); // 调用前置监听 OnPreListener(); this.Result = StepResult.NotAvailable; this.Result = Actuator.InvokeStep(forceInvoke); // 如果当前step被标记为记录状态,则返回状态信息 if (null != StepData && StepData.RecordStatus) { RecordRuntimeStatus(); } // 调用后置监听 OnPostListener(); // 如果执行结果不是bool类型或者为False,或者没有下级节点,则退出当前循环 object returnValue = Actuator.Return; bool conditionFail = !(returnValue is bool) || !(bool)returnValue; if (conditionFail || null == StepData || !StepData.HasSubSteps) { return; } // 执行所有的下级Step StepTaskEntityBase subStepEntity = SubStepRoot; do { if (!forceInvoke && Context.Cancellation.IsCancellationRequested) { this.Result = StepResult.Abort; return; } subStepEntity.Invoke(forceInvoke); } while (null != (subStepEntity = subStepEntity.NextStep)); } } catch (TestflowLoopBreakException ex) { ex.CalcDown(); // 如果计数大于0,则继续抛出到上层 if (ex.Count > 0) { throw; } // 如果是跳出当前循环,则return if (ex.BreakLoop) { return; } } } }
public void Invoke(bool forceInvoke = false) { FailedInfo failedInfo = null; StepResult lastStepResult = StepResult.NotAvailable; StatusReportType finalReportType = StatusReportType.Failed; try { this.State = RuntimeState.Running; SequenceStatusInfo startStatusInfo = new SequenceStatusInfo(Index, _stepEntityRoot.GetStack(), StatusReportType.Start, RuntimeState.Running, StepResult.NotAvailable) { ExecutionTime = DateTime.Now, ExecutionTicks = -1, CoroutineId = RootCoroutineId }; _context.StatusQueue.Enqueue(startStatusInfo); StepTaskEntityBase stepEntity = _stepEntityRoot; do { stepEntity.Invoke(forceInvoke); } while (null != (stepEntity = stepEntity.NextStep)); SetResultState(out lastStepResult, out finalReportType, out failedInfo); } catch (TaskFailedException ex) { // 停止失败的step的计时 StepTaskEntityBase currentStep = StepTaskEntityBase.GetCurrentStep(Index, RootCoroutineId); currentStep?.EndTiming(); FillFinalExceptionReportInfo(ex, out finalReportType, out lastStepResult, out failedInfo); // 如果抛出TargetInvokcationException到当前位置则说明内部没有发送错误事件 if (null != currentStep && currentStep.Result == StepResult.NotAvailable) { currentStep.SetStatusAndSendErrorEvent(lastStepResult, failedInfo); } } catch (TestflowAssertException ex) { // 停止失败的step的计时 StepTaskEntityBase currentStep = StepTaskEntityBase.GetCurrentStep(Index, RootCoroutineId); currentStep?.EndTiming(); FillFinalExceptionReportInfo(ex, out finalReportType, out lastStepResult, out failedInfo); // 如果抛出TargetInvokcationException到当前位置则说明内部没有发送错误事件 if (null != currentStep && currentStep.Result == StepResult.NotAvailable) { currentStep.SetStatusAndSendErrorEvent(lastStepResult, failedInfo); } } catch (ThreadAbortException ex) { // 停止失败的step的计时 StepTaskEntityBase currentStep = StepTaskEntityBase.GetCurrentStep(Index, RootCoroutineId); currentStep?.EndTiming(); FillFinalExceptionReportInfo(ex, out finalReportType, out lastStepResult, out failedInfo); // Abort异常不会在内部处理,需要在外部强制抛出 currentStep?.SetStatusAndSendErrorEvent(lastStepResult, failedInfo); } catch (TargetInvocationException ex) { // 停止失败的step的计时 StepTaskEntityBase currentStep = StepTaskEntityBase.GetCurrentStep(Index, RootCoroutineId); currentStep?.EndTiming(); FillFinalExceptionReportInfo(ex.InnerException, out finalReportType, out lastStepResult, out failedInfo); // 如果抛出TargetInvokcationException到当前位置则说明内部没有发送错误事件 if (null != currentStep && currentStep.Result == StepResult.NotAvailable) { currentStep.SetStatusAndSendErrorEvent(lastStepResult, failedInfo); } } catch (TestflowLoopBreakException ex) { // 停止失败的step的计时 StepTaskEntityBase currentStep = StepTaskEntityBase.GetCurrentStep(Index, RootCoroutineId); currentStep?.EndTiming(); // 如果包含内部异常,则说明发生了运行时错误,记录错误信息。 if (null != ex.InnerException) { FillFinalExceptionReportInfo(ex.InnerException, out finalReportType, out lastStepResult, out failedInfo); // 如果抛出TargetInvokcationException到当前位置则说明内部没有发送错误事件 if (null != currentStep && currentStep.BreakIfFailed) { currentStep.SetStatusAndSendErrorEvent(lastStepResult, failedInfo); } } // 只是流程控制,记录结果信息后退出 else { SetResultState(out lastStepResult, out finalReportType, out failedInfo); } } catch (Exception ex) { // 停止失败的step的计时 StepTaskEntityBase currentStep = StepTaskEntityBase.GetCurrentStep(Index, RootCoroutineId); currentStep?.EndTiming(); FillFinalExceptionReportInfo(ex, out finalReportType, out lastStepResult, out failedInfo); // 如果抛出Exception到当前位置则说明内部没有发送错误事件 if (null != currentStep && currentStep.BreakIfFailed) { currentStep.SetStatusAndSendErrorEvent(lastStepResult, failedInfo); } } finally { StepTaskEntityBase currentStep = StepTaskEntityBase.GetCurrentStep(Index, RootCoroutineId); // 发送结束事件,包括所有的ReturnData信息 SequenceStatusInfo overStatusInfo = new SequenceStatusInfo(Index, currentStep.GetStack(), finalReportType, this.State, StepResult.Over, failedInfo) { ExecutionTime = DateTime.Now, CoroutineId = RootCoroutineId, ExecutionTicks = 0 }; overStatusInfo.WatchDatas = _context.VariableMapper.GetReturnDataValues(_sequence); this._context.StatusQueue.Enqueue(overStatusInfo); _context.VariableMapper.ClearSequenceVariables(_sequence); this._stepEntityRoot = null; // 将失败步骤职责链以后的step标记为null currentStep.NextStep = null; } }