private void InitializeSubStep(ISequenceFlowContainer parent)
{
ISequenceStep sequence = parent as ISequenceStep;
this.Parent = parent;
ModuleUtils.SetElementName(this, sequence.SubSteps);
}
//todo I18n
public void RemoveSequenceStep(ISequenceFlowContainer parent, ISequenceStep step)
{
bool removed = false;
if (parent is ISequence)
{
removed = ((ISequence)parent).Steps.Remove(step);
}
else if (parent is ISequenceStep)
{
ISequenceStep parentStep = (ISequenceStep)parent;
if (parentStep.StepType == SequenceStepType.TryFinallyBlock ||
parentStep.StepType == SequenceStepType.SequenceCall)
{
I18N i18N = I18N.GetInstance(Constants.I18nName);
throw new TestflowDataException(ModuleErrorCode.InvalidEditOperation,
i18N.GetStr("InvalidOperation"));
}
removed = (parentStep).SubSteps.Remove(step);
}
else
{
throw new TestflowDataException(ModuleErrorCode.InvalidEditOperation, "Parent needs to be Sequence or SequenceStep");
}
//判断成功remove与否
if (removed)
{
ContextSequenceGroupModify();
}
else
{
throw new TestflowDataException(ModuleErrorCode.TargetNotExist, $"Step {step.Name} could not be found in parent {parent.Name}");
}
}
public ISequenceStep AddSequenceStep(ISequenceFlowContainer parent, IList <ISequenceStep> stepDatas, int index)
{
if (parent is ISequence)
{
for (int n = 0; n < stepDatas.Count; n++)
{
((ISequence)parent).Steps.Insert(n + index, stepDatas[n]);
stepDatas[n].Parent = parent;
}
}
else if (parent is ISequenceStep)
{
for (int n = 0; n < stepDatas.Count; n++)
{
ISequenceStep parentStep = (ISequenceStep)parent;
if (parentStep.StepType == SequenceStepType.TryFinallyBlock ||
parentStep.StepType == SequenceStepType.SequenceCall)
{
I18N i18N = I18N.GetInstance(Constants.I18nName);
throw new TestflowDataException(ModuleErrorCode.InvalidEditOperation,
i18N.GetStr("InvalidOperation"));
}
parentStep.SubSteps.Insert(n + index, stepDatas[n]);
stepDatas[n].Parent = parent;
}
}
else
{
throw new TestflowDataException(ModuleErrorCode.InvalidEditOperation, "Parent needs to be Sequence or SequenceStep");
}
ContextSequenceGroupModify();
return(stepDatas[0]);
}
public static CallStack GetStack(ISequenceStep step)
{
CallStack callStack = new CallStack();
ISequence sequence = null;
ISequenceGroup sequenceGroup = null;
while (null != step)
{
callStack.StepStack.Add(step.Index);
ISequenceFlowContainer parent = step.Parent;
if (parent is ISequence)
{
sequence = parent as ISequence;
}
step = parent as ISequenceStep;
}
if (null == sequence)
{
return(callStack);
}
callStack.Session = sequence.Index;
sequenceGroup = sequence.Parent as ISequenceGroup;
if (!(sequenceGroup?.Parent is ITestProject))
{
return(callStack);
}
ITestProject testProject = (ITestProject)sequenceGroup.Parent;
callStack.SessionIndex = testProject.SequenceGroups.IndexOf(sequenceGroup);
return(callStack);
}
public static StepTaskEntityBase GetStepModel(ISequenceStep stepData, SlaveContext context, int sequenceIndex)
{
// 如果某个Step的Function为null，且不是块步骤类型，则为该Step分配空类型运行实体
if (null == stepData.Function && !_blockStepTypes.Contains(stepData.StepType))
{
return(new EmptyStepEntity(context, sequenceIndex, stepData));
}
StepTaskEntityBase stepEntity;
switch (stepData.StepType)
{
case SequenceStepType.Execution:
stepEntity = new ExecutionStepEntity(stepData, context, sequenceIndex);
break;
case SequenceStepType.ConditionBlock:
stepEntity = new ConditionBlockStepEntity(stepData, context, sequenceIndex);
break;
case SequenceStepType.ConditionStatement:
stepEntity = new ConditionStatementStepEntity(stepData, context, sequenceIndex);
break;
case SequenceStepType.TryFinallyBlock:
stepEntity = new TryFinallyBlockStepEntity(stepData, context, sequenceIndex);
break;
case SequenceStepType.ConditionLoop:
stepEntity = new ConditionLoopStepEntity(stepData, context, sequenceIndex);
break;
case SequenceStepType.SequenceCall:
stepEntity = new SequenceCallStepEntity(stepData, context, sequenceIndex);
break;
case SequenceStepType.Goto:
stepEntity = new GotoStepEntity(stepData, context, sequenceIndex);
break;
case SequenceStepType.MultiThreadBlock:
stepEntity = new MultiThreadStepEntity(stepData, context, sequenceIndex);
break;
case SequenceStepType.TimerBlock:
stepEntity = new TimerBlockStepEntity(stepData, context, sequenceIndex);
break;
case SequenceStepType.BatchBlock:
stepEntity = new BatchBlockStepEntity(stepData, context, sequenceIndex);
break;
default:
context.LogSession.Print(LogLevel.Error, context.SessionId,
$"The step type of <{stepData.Name}> is invalid.");
I18N i18N = I18N.GetInstance(Constants.I18nName);
throw new TestflowDataException(ModuleErrorCode.SequenceDataError,
i18N.GetFStr("UnsupportedStepType", stepData.StepType.ToString()));
}
return(stepEntity);
}
private static void ValidateTypeDatas(ISequenceStep sequenceStep, ITypeDataCollection typeDatas)
{
if (sequenceStep.HasSubSteps)
{
foreach (ISequenceStep subStep in sequenceStep.SubSteps)
{
ValidateTypeDatas(subStep, typeDatas);
}
}
else
{
FunctionData functionData = sequenceStep.Function as FunctionData;
if (null == functionData)
{
return;
}
if (Constants.UnverifiedTypeIndex != functionData.ClassTypeIndex)
{
functionData.ClassType = typeDatas[functionData.ClassTypeIndex];
}
Argument returnType = functionData.ReturnType as Argument;
if (null != returnType && Constants.UnverifiedTypeIndex != returnType.TypeIndex)
{
returnType.Type = typeDatas[returnType.TypeIndex];
}
foreach (IArgument rawArgument in functionData.ParameterType)
{
Argument argument = rawArgument as Argument;
if (Constants.UnverifiedTypeIndex != argument.TypeIndex)
{
argument.Type = typeDatas[argument.TypeIndex];
}
}
}
}
/// <summary>
/// 检查function return
/// 1. 检查是否为null：静态方法可以为null，不然报错
/// 2. 在arr里面寻找对应的variable，调用CheckPropertyType
/// </summary>
/// <param name="function"> function信息 </param>
/// <param name="arr"> 要检查的Sequence/SequenceGroup集合 </param>
/// <returns> warnList (注：虽只会有一条错误信息，但为了上级代码整洁与一致性，返回List)</returns>
public IWarningInfo CheckReturn(ISequenceStep Step, ISequenceFlowContainer[] arr, bool overwriteType)
{
IFunctionData function = Step.Function;
//先判断返回类型是不是void, void则不检查
if (function.ReturnType == null)
{
if (!string.IsNullOrEmpty(function.Return))
{
return(new WarningInfo()
{
//todo I18n
WarnCode = WarnCode.ReturnNotEmpty,
Infomation = $"\"{Step.Name}\" function Return Type is void, but value not empty"
});
}
return(null);
}
//空值也不检查
else if (string.IsNullOrEmpty(function.Return))
{
return(null);
}
return(FindVariablesCheckPropertyType(arr, function.Return, function.ReturnType.Type, overwriteType));
}
public void Initialize(ISequenceFlowContainer parent)
{
ISequenceStep sequenceStep = parent as ISequenceStep;
if (null != sequenceStep.SubSteps && sequenceStep.SubSteps.Count > 0)
{
this.SubStepParameters = new SequenceStepParameterCollection();
foreach (ISequenceStep subStep in sequenceStep.SubSteps)
{
SequenceStepParameter stepParameter = new SequenceStepParameter();
stepParameter.Initialize(subStep);
this.SubStepParameters.Add(stepParameter);
}
}
else
{
this.SubStepParameters = null;
}
IFunctionData functionData = sequenceStep.Function;
if (functionData?.Parameters != null && functionData.Parameters.Count > 0)
{
this.Parameters = functionData.Parameters;
}
else
{
this.Parameters = null;
}
if (null != functionData)
{
this.Return = functionData.Return;
this.Instance = functionData.Instance;
}
}
private ISequenceStep CreateGetFuncStep(string instanceName, string returnName, ISequence parentSequence)
{
if (parentSequence.Variables.All(item => !item.Name.Equals(returnName)))
{
// 添加实例变量
Variable returnVar = new Variable()
{
Description = $"Variable {returnName}",
LogRecordLevel = RecordLevel.FinalResult,
Name = returnName,
OIRecordLevel = RecordLevel.FinalResult,
Parent = parentSequence,
ReportRecordLevel = RecordLevel.FinalResult,
Type = _testClassTypeData,
TypeIndex = 1,
VariableType = VariableType.Class,
};
parentSequence.Variables.Add(returnVar);
}
// 添加实例化类的step
ISequenceStep step = _sequenceManager.CreateSequenceStep();
step.RecordStatus = true;
step.Function = new FunctionData()
{
ClassType = _testClassTypeData,
ClassTypeIndex = 1,
Description = null,
Instance = instanceName,
MethodName = GetValueMethodName,
Return = string.Empty,
ReturnType = null,
Type = FunctionType.InstanceFunction
};
Argument intArgument = new Argument()
{
Modifier = ArgumentModifier.Out,
Name = "waitTime",
Type = _intTypeData,
TypeIndex = 0,
VariableType = VariableType.Value
};
step.Function.ParameterType = new ArgumentCollection();
step.Function.ParameterType.Add(intArgument);
step.Function.Parameters = new ParameterDataCollection();
ParameterData intParameterData = new ParameterData()
{
Index = 0,
ParameterType = ParameterType.Value,
Value = "100",
};
step.Function.Parameters.Add(intParameterData);
return(step);
}
public ISequenceStep AddSequenceStep(ISequenceFlowContainer parent, string name, string description, int index)
{
ISequenceStep sequenceStep = _sequenceManager.CreateSequenceStep(true);
sequenceStep.Name = name;
sequenceStep.Description = description;
return(AddSequenceStep(parent, sequenceStep, index));
}
public IRetryCounter RemoveRetryCounter(ISequenceStep sequenceStep)
{
IRetryCounter retryCounter = sequenceStep.RetryCounter;
sequenceStep.RetryCounter = null;
ContextSequenceGroupModify();
return(retryCounter);
}
public ILoopCounter RemoveLoopCounter(ISequenceStep sequenceStep)
{
ILoopCounter loopCounter = sequenceStep.LoopCounter;
sequenceStep.LoopCounter = null;
ContextSequenceGroupModify();
return(loopCounter);
}
public ILoopCounter AddLoopCounter(ISequenceStep sequenceStep, int maxCount)
{
ILoopCounter loopCounter = _sequenceManager.CreateLoopCounter();
loopCounter.MaxValue = maxCount;
sequenceStep.LoopCounter = loopCounter;
ContextSequenceGroupModify();
return(loopCounter);
}
public IRetryCounter AddRetryCounter(ISequenceStep sequenceStep, int maxCount)
{
IRetryCounter retryCounter = _sequenceManager.CreateRetryCounter();
retryCounter.MaxRetryTimes = maxCount;
sequenceStep.RetryCounter = retryCounter;
ContextSequenceGroupModify();
return(retryCounter);
}
private ISequenceStep CreateCallBackStep(int x, int y)
{
ISequenceStep step = _sequenceManager.CreateSequenceStep();
step.RecordStatus = true;
step.Function = new FunctionData()
{
ClassType = _testCallBackTypeData,
ClassTypeIndex = 6,
Description = null,
Instance = string.Empty,
MethodName = CallBackMethodName,
Return = string.Empty,
Type = FunctionType.CallBack
};
#region 添加参数类型
step.Function.ParameterType = new ArgumentCollection();
Argument intArgument = new Argument()
{
Modifier = ArgumentModifier.None,
Name = "x",
Type = _intTypeData,
TypeIndex = 0
};
step.Function.ParameterType.Add(intArgument);
intArgument = new Argument()
{
Modifier = ArgumentModifier.None,
Name = "y",
Type = _intTypeData,
TypeIndex = 0
};
step.Function.ParameterType.Add(intArgument);
#endregion
#region 添加参数值
step.Function.Parameters = new ParameterDataCollection();
ParameterData intParameterData = new ParameterData()
{
Index = 0,
ParameterType = ParameterType.Value,
Value = x.ToString()
};
step.Function.Parameters.Add(intParameterData);
intParameterData = new ParameterData()
{
Index = 0,
ParameterType = ParameterType.Value,
Value = y.ToString()
};
step.Function.Parameters.Add(intParameterData);
#endregion
return(step);
}
protected ActuatorBase(ISequenceStep step, SlaveContext context, int sequenceIndex)
{
this.Context = context;
this.Function = step?.Function;
this.StepData = step;
this.SequenceIndex = sequenceIndex;
this.Return = null;
this.ExecutionTime = DateTime.MaxValue;
this.ExecutionTicks = -1;
}
public ISequenceStep CreateSequenceStep(bool createSubStepCollection = false)
{
ISequenceStep sequenceStep = SequenceStepCreator.CreateSequenceStep(SequenceStepType.Execution);
if (createSubStepCollection)
{
sequenceStep.SubSteps = new SequenceStepCollection();
}
return(sequenceStep);
}
//to do: check valid steps
public ISequenceStep GetSequenceStep(ICallStack stack)
{
ISequence sequence = Context.SequenceGroup.Sequences[stack.Sequence];
ISequenceStep step = sequence.Steps[stack.StepStack[0]];
for (int n = 1; n < stack.StepStack.Count; n++)
{
step = step.SubSteps[stack.StepStack[n]];
}
return(step);
}
public IList <IWarningInfo> CheckStep(ISequenceStep Step, ISequenceFlowContainer[] arr, bool overwriteType)
{
IList <IWarningInfo> warningList = new List <IWarningInfo>();
IFunctionData function = Step.Function;
#region 空function, 空step
if (function == null)
{
return(warningList);
}
#endregion
IWarningInfo warnInfo = null;
#region Instance
warnInfo = CheckInstance(Step, arr, overwriteType);
if (warnInfo != null)
{
warningList.Add(warnInfo);
}
#endregion
#region Return
warnInfo = CheckReturn(Step, arr, overwriteType);
if (warnInfo != null)
{
warningList.Add(warnInfo);
}
#endregion
#region Parameters
if (function.Parameters == null)
{
}
else
{
for (int n = 0; n < function.Parameters.Count; n++)
{
warnInfo = CheckParameterData(function, n, arr, overwriteType);
if (warnInfo != null)
{
warningList.Add(warnInfo);
}
}
}
#endregion
foreach (IWarningInfo info in warningList)
{
info.SequenceStep = Step;
}
return(warningList);
}
private static void ValidateParent(ISequenceStep step, ISequenceFlowContainer parent)
{
step.Parent = parent;
if (step.HasSubSteps)
{
foreach (ISequenceStep subStep in step.SubSteps)
{
ValidateParent(subStep, step);
}
}
}
public ISequenceStep GetSequenceStep(int sequenceIndex, params int[] stepIndex)
{
ISequenceStepCollection stepCollection = Context.SequenceGroup.Sequences[sequenceIndex].Steps;
ISequenceStep step = stepCollection[stepIndex[0]];
for (int n = 1; n < stepIndex.Length; n++)
{
//todo:need to check hasSubSteps()
//need to check stepIndex valid
step = step.SubSteps[stepIndex[n]];
}
return(step);
}
//todo I18n
internal static IParameterData FindParameterByName(string paramName, ISequenceStep sequenceStep)
{
IArgument argument = sequenceStep.Function.ParameterType.FirstOrDefault(item => item.Name.Equals(paramName));
if (argument == null)
{
throw new TestflowDataException(ModuleErrorCode.TargetNotExist, $"Parameter with {paramName} not found");
}
int index = sequenceStep.Function.ParameterType.IndexOf(argument);
return(sequenceStep.Function.Parameters[index]);
}
private static void VerifyTypeIndexes(ITypeDataCollection typeDatas, ISequenceStep step)
{
if (step.HasSubSteps)
{
foreach (ISequenceStep subStep in step.SubSteps)
{
VerifyTypeIndexes(typeDatas, subStep);
}
}
else
{
VerifyTypeIndexes(typeDatas, step.Function as FunctionData);
}
}
private void AddSequenceStepTypeDatas(HashSet <ITypeData> typeDatas, ISequenceStep step)
{
if (null != step.Function)
{
AddFunctionTypeDatas(typeDatas, step.Function);
}
if (step.HasSubSteps)
{
foreach (ISequenceStep subStep in step.SubSteps)
{
AddSequenceStepTypeDatas(typeDatas, subStep);
}
}
}
private void StepFindCallBack(ISequenceStep step)
{
if (step.Function.Type == FunctionType.CallBack)
{
IFunctionData function = step.Function;
string fullname = function.ClassType.Namespace + "." + function.ClassType.Name + "." + function.MethodName;
_callBackMethods.Add(fullname, _typeInvoker.GetMethod(function));
_callBackFunctions.Add(fullname, function);
}
if (step.HasSubSteps)
{
StepCollectionFindCallBack(step.SubSteps);
}
}
private static void SetParameterToSequenceData(ISequenceStep sequenecStep, ISequenceStepParameter parameter)
{
if (sequenecStep.HasSubSteps)
{
for (int i = 0; i < sequenecStep.SubSteps.Count; i++)
{
SetParameterToSequenceData(sequenecStep.SubSteps[i], parameter.SubStepParameters[i]);
}
}
else if (null != sequenecStep.Function)
{
sequenecStep.Function.Parameters = parameter.Parameters;
sequenecStep.Function.Instance = parameter.Instance;
sequenecStep.Function.Return = parameter.Return;
}
}
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 EmptyStepEntity(SlaveContext context, int sequenceIndex, ISequenceStep stepData) : base(stepData, context, sequenceIndex)
{
// switch (sequenceIndex)
// {
// case CommonConst.SetupIndex:
// _sequenceName = Constants.EmptySetupName;
// break;
// case CommonConst.TeardownIndex:
// _sequenceName = Constants.EmptyTeardownName;
// break;
// default:
// _sequenceName = sequenceIndex.ToString();
// break;
// }
// _sequenceIndex = sequenceIndex;
}
public void SetParameterValue(string parameterName, string value, ParameterType parameterType, int sequenceIndex, params int[] indexes)
{
ISequence sequence = Context.SequenceGroup.Sequences[sequenceIndex];
ISequenceStep step = sequence.Steps[indexes[0]];
if (indexes.Length > 1)
{
int n = 1;
while (n < indexes.Length)
{
step = step.SubSteps[indexes[n]];
n++;
}
}
SetParameterValue(parameterName, value, parameterType, step);
}
private bool VerifyVariableInSequenceStep(ISequenceStep sequenceStep, IVariable variable, TypeDataCollection typeDatas)
{
if ((null != sequenceStep.LoopCounter && variable.Name.Equals(sequenceStep.LoopCounter.CounterVariable)) ||
(null != sequenceStep.RetryCounter) && variable.Name.Equals(sequenceStep.RetryCounter.CounterVariable))
{
Type varType = typeof(int);
ITypeData typeData = typeDatas.GetTypeData(varType.Name);
if (null == typeData)
{
variable.Type = _comInterfaceManager.GetTypeByName(varType.Name, varType.Namespace);
}
return(true);
}
if (null != sequenceStep.Function)
{
IFunctionData functionData = sequenceStep.Function;
if (variable.Name.Equals(functionData.Instance))
{
variable.Type = functionData.ClassType;
return(true);
}
if (variable.Name.Equals(functionData.Return))
{
variable.Type = functionData.ReturnType.Type;
return(true);
}
IParameterData parameter = functionData.Parameters.FirstOrDefault
(item => item.ParameterType == ParameterType.Variable && variable.Name.Equals(item.Value));
if (null != parameter)
{
variable.Type = functionData.ParameterType[parameter.Index].Type;
return(true);
}
}
if (sequenceStep.HasSubSteps)
{
foreach (ISequenceStep subStep in sequenceStep.SubSteps)
{
bool verified = VerifyVariableInSequenceStep(subStep, variable, typeDatas);
if (verified)
{
return(true);
}
}
}
return(false);
}