public static string GetRuntimeVariableString(WatchDataObject watchDataObj, ISequenceFlowContainer sequenceData)
{
const char delim = '.';
string[] watchElem = watchDataObj.WatchData.Split(delim);
string variableName = watchElem[0];
int sequenceIndex = watchDataObj.Sequence;
IVariable variable = null;
if (sequenceData is ITestProject)
{
ITestProject testProject = sequenceData as ITestProject;
if (watchDataObj.Session == CommonConst.TestGroupSession)
{
variable = GetVariableByNameAndSequence(testProject, sequenceIndex, variableName);
}
else
{
variable = GetVariableByNameAndSequence(testProject.SequenceGroups[watchDataObj.Session],
sequenceIndex, variableName);
}
}
else if (sequenceData is ISequenceGroup)
{
ISequenceGroup sequenceGroup = sequenceData as ISequenceGroup;
variable = GetVariableByNameAndSequence(sequenceGroup, sequenceIndex, variableName);
}
if (null == variable)
{
return(null);
}
watchElem[0] = CoreUtils.GetRuntimeVariableName(watchDataObj.Session, variable);
return(string.Join(delim.ToString(), watchElem));
}
private static ISequence GetSequence(ISequenceGroup sequenceGroup, int index)
{
ISequence sequence;
switch (index)
{
case CommonConst.SetupIndex:
sequence = sequenceGroup.SetUp;
break;
case CommonConst.TeardownIndex:
sequence = sequenceGroup.TearDown;
break;
default:
if (sequenceGroup.Sequences.Count <= index || index < 0)
{
I18N i18N = I18N.GetInstance(UtilityConstants.UtilsName);
throw new TestflowDataException(ModuleErrorCode.SequenceDataError,
i18N.GetStr("CannotFindSequence"));
}
sequence = sequenceGroup.Sequences[index];
break;
}
return(sequence);
}
private IList <ITypeData> GetCallBackRelatedType(ISequenceGroup sequenceGroup)
{
HashSet <ITypeData> typeDatas = new HashSet <ITypeData>();
AddCallBackRelatedType(sequenceGroup, typeDatas);
return(typeDatas.ToArray());
}
public void Initialize(ISequenceFlowContainer sequenceData)
{
if (sequenceData is ITestProject)
{
ITestProject testProject = (ITestProject)sequenceData;
IList <ITypeData> callBackRelatedType = GetCallBackRelatedType(testProject);
IList <IAssemblyInfo>[] assemblyInfoCollections = new IList <IAssemblyInfo> [testProject.SequenceGroups.Count + 1];
IList <IAssemblyInfo> callBackRelatedAssembly = GetCallBackRelatedAssembly(callBackRelatedType, assemblyInfoCollections);
//AssemblyInvoker加载程序集和类型
_typeInvoker = new AssemblyInvoker(_globalInfo, callBackRelatedAssembly, callBackRelatedType);
_typeInvoker.LoadAssemblyAndType();
foreach (ISequenceGroup sequenceGroup in testProject.SequenceGroups)
{
SequenceGroupFindCallBack(sequenceGroup);
}
}
else
{
ISequenceGroup sequenceGroup = (ISequenceGroup)sequenceData;
IList <ITypeData> callBackRelatedType = GetCallBackRelatedType(sequenceGroup);
IList <IAssemblyInfo> callBackRelatedAssembly = GetCallBackRelatedAssembly(callBackRelatedType,
sequenceGroup.Assemblies);
//AssemblyInvoker加载程序集和类型
_typeInvoker = new AssemblyInvoker(_globalInfo, callBackRelatedAssembly, callBackRelatedType);
_typeInvoker.LoadAssemblyAndType();
SequenceGroupFindCallBack(sequenceGroup);
}
}
public void LoadParameter(ISequenceGroup sequenceGroup, bool forceLoad, params string[] param)
{
SequenceGroup sequenceGroupObj = sequenceGroup as SequenceGroup;
sequenceGroupObj.RefreshSignature();
SequenceDeserializer.LoadParameter(sequenceGroupObj, param[0], forceLoad);
}
public static IVariable GetVariable(ISequenceGroup sequenceGroup, string runtimeVariable)
{
string[] variableElement = runtimeVariable.Split(VarNameDelim.ToCharArray());
IVariableCollection varCollection = null;
if (2 == variableElement.Length)
{
varCollection = sequenceGroup.Variables;
}
else if (3 == variableElement.Length)
{
int sequenceIndex = int.Parse(variableElement[1]);
if (sequenceIndex == CommonConst.SetupIndex)
{
varCollection = sequenceGroup.SetUp.Variables;
}
else if (sequenceIndex == CommonConst.TeardownIndex)
{
varCollection = sequenceGroup.TearDown.Variables;
}
else
{
varCollection = sequenceGroup.Sequences[sequenceIndex].Variables;
}
}
return(varCollection.FirstOrDefault(item => item.Name.Equals(variableElement[variableElement.Length - 1])));
}
public IDesignTimeSession RemoveSequenceGroup(string name, string description)
{
ISequenceGroup sequenceGroup = TestProject.SequenceGroups.FirstOrDefault(item => item.Name.Equals(name) && item.Description.Equals(description));
//可能传入null，没关系，同样报错
return(RemoveSequenceGroup(sequenceGroup));
}
public void ValidateSequenceData(ISequenceGroup sequenceGroup, ITestProject parent = null)
{
ModuleUtils.ValidateParent(sequenceGroup, parent);
_typeMaintainer.VerifyVariableTypes(sequenceGroup);
_typeMaintainer.RefreshUsedAssemblyAndType(sequenceGroup);
((SequenceGroup)sequenceGroup).RefreshSignature();
}
private static bool HasVariableInSequence(ISequenceFlowContainer sequenceData, string variable)
{
if (null == sequenceData)
{
return(false);
}
if (sequenceData is ISequence)
{
ISequence sequence = sequenceData as ISequence;
// 如果存在则返回true
if (sequence.Variables.Any(item => item.Name.Equals(variable)))
{
return(true);
}
// 不存在时向上级查找
return(HasVariableInSequence(sequence.Parent, variable));
}
else if (sequenceData is ISequenceGroup)
{
ISequenceGroup sequenceGroup = sequenceData as ISequenceGroup;
return(sequenceGroup.Variables.Any(item => item.Name.Equals(variable)));
}
else if (sequenceData is ITestProject)
{
ITestProject testProject = sequenceData as ITestProject;
return(testProject.Variables.Any(item => item.Name.Equals(variable)));
}
return(false);
}
public VariableMapper(SlaveContext context)
{
ISequenceFlowContainer sequenceData = context.Sequence;
this._variables = new Dictionary <string, object>(512);
this._keyVariables = new HashSet <string>();
this._syncVariables = new HashSet <string>();
this._context = context;
_fullTraceVariables = new List <string>(Constants.DefaultRuntimeSize);
if (context.SequenceType == RunnerType.TestProject)
{
ITestProject testProject = (ITestProject)sequenceData;
AddVariables(testProject.Variables, false);
AddVariables(testProject.SetUp.Variables, false);
AddVariables(testProject.TearDown.Variables, false);
}
else
{
bool addSessionVarToSyncSet = ExecutionModel.ParallelExecution == context.ExecutionModel;
ISequenceGroup sequenceGroup = (ISequenceGroup)sequenceData;
AddVariables(sequenceGroup.Variables, addSessionVarToSyncSet);
AddVariables(sequenceGroup.SetUp.Variables, false);
AddVariables(sequenceGroup.TearDown.Variables, false);
foreach (ISequence sequence in sequenceGroup.Sequences)
{
AddVariables(sequence.Variables, false);
}
}
this._keyVarLock = new SpinLock(false);
this._syncVarLock = new ReaderWriterLockSlim();
}
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);
}
/// <summary>
/// 初始化变量和参数的类型数据
/// </summary>
public bool VerifyVariableType(ISequenceFlowContainer flowContainer, IVariable variable, TypeDataCollection typeDatas)
{
if (flowContainer is ITestProject)
{
ITestProject testProject = flowContainer as ITestProject;
return(VerifyVariableInSequence(testProject.SetUp, variable, typeDatas) ||
VerifyVariableInSequence(testProject.TearDown, variable, typeDatas));
}
else if (flowContainer is ISequenceGroup)
{
ISequenceGroup sequenceGroup = flowContainer as ISequenceGroup;
if (VerifyVariableInSequence(sequenceGroup.SetUp, variable, typeDatas) ||
VerifyVariableInSequence(sequenceGroup.TearDown, variable, typeDatas))
{
return(true);
}
return(sequenceGroup.Sequences.Any(sequence => VerifyVariableInSequence(sequence, variable, typeDatas)));
}
else if (flowContainer is ISequence)
{
return(VerifyVariableInSequence(flowContainer as ISequence, variable, typeDatas));
}
else if (flowContainer is ISequenceStep)
{
return(VerifyVariableInSequenceStep(flowContainer as ISequenceStep, variable, typeDatas));
}
return(false);
}
public SessionTaskEntity(SlaveContext context)
{
this._context = context;
ISequenceFlowContainer sequenceData = _context.Sequence;
switch (context.SequenceType)
{
case RunnerType.TestProject:
ITestProject testProject = (ITestProject)sequenceData;
_setUp = new SequenceTaskEntity(testProject.SetUp, _context);
_tearDown = new SequenceTaskEntity(testProject.TearDown, _context);
_sequenceEntities = new List <SequenceTaskEntity>(1);
break;
case RunnerType.SequenceGroup:
ISequenceGroup sequenceGroup = (ISequenceGroup)sequenceData;
_setUp = new SequenceTaskEntity(sequenceGroup.SetUp, _context);
_tearDown = new SequenceTaskEntity(sequenceGroup.TearDown, _context);
_sequenceEntities = new List <SequenceTaskEntity>(sequenceGroup.Sequences.Count);
foreach (ISequence sequence in sequenceGroup.Sequences)
{
_sequenceEntities.Add(new SequenceTaskEntity(sequence, _context));
}
break;
default:
throw new InvalidOperationException();
}
}
private static void InitSequenceGroupLocations(TestProject testProject, string testProjectPath)
{
testProject.SequenceGroupLocations.Clear();
ISequenceGroupCollection sequenceGroups = testProject.SequenceGroups;
for (int i = 0; i < sequenceGroups.Count; i++)
{
ISequenceGroup sequenceGroup = sequenceGroups[i];
string sequenceGroupPath = ModuleUtils.GetAbsolutePath(sequenceGroup.Info.SequenceGroupFile,
testProjectPath);
string parameterPath = ModuleUtils.GetAbsolutePath(sequenceGroup.Info.SequenceParamFile,
testProjectPath);
if (!ModuleUtils.IsValidFilePath(sequenceGroupPath))
{
sequenceGroupPath = ModuleUtils.GetSequenceGroupPath(testProjectPath, i);
parameterPath = ModuleUtils.GetParameterFilePath(sequenceGroupPath);
sequenceGroup.Info.SequenceGroupFile = ModuleUtils.GetRelativePath(sequenceGroupPath, testProjectPath);
sequenceGroup.Info.SequenceParamFile = ModuleUtils.GetRelativePath(parameterPath, sequenceGroupPath);
}
else if (!ModuleUtils.IsValidFilePath(sequenceGroup.Info.SequenceParamFile))
{
parameterPath = ModuleUtils.GetParameterFilePath(sequenceGroupPath);
sequenceGroup.Info.SequenceParamFile = ModuleUtils.GetRelativePath(parameterPath, sequenceGroupPath);
}
SequenceGroupLocationInfo locationInfo = new SequenceGroupLocationInfo()
{
Name = sequenceGroup.Name,
SequenceFilePath = sequenceGroup.Info.SequenceGroupFile,
ParameterFilePath = sequenceGroup.Info.SequenceParamFile
};
testProject.SequenceGroupLocations.Add(locationInfo);
}
}
public void Initialize(ISequenceFlowContainer flowContainer)
{
ISequenceGroup sequenceGroup = flowContainer as ISequenceGroup;
this.Info.Hash = sequenceGroup.Info.Hash;
this.Info.Modified = true;
this.Info.ModifiedTime = DateTime.Now;
this.Info.Path = sequenceGroup.Info.SequenceParamFile;
this.Info.Version = sequenceGroup.Info.Version;
this.VariableValues = new VariableInitValueCollection();
foreach (IVariable variable in sequenceGroup.Variables)
{
VariableInitValue variableInitValue = new VariableInitValue()
{
Name = variable.Name
};
variableInitValue.Initialize(variable);
this.VariableValues.Add(variableInitValue);
}
this.SetUpParameters = new SequenceParameter();
this.SetUpParameters.Initialize(sequenceGroup.SetUp);
this.SequenceParameters = new SequenceParameterCollection();
foreach (ISequence sequence in sequenceGroup.Sequences)
{
SequenceParameter parameter = new SequenceParameter();
parameter.Initialize(sequence);
SequenceParameters.Add(parameter);
}
this.TearDownParameters = new SequenceParameter();
this.TearDownParameters.Initialize(sequenceGroup.TearDown);
}
public ITestProject GetCallBackTestProjectData2()
{
ITestProject testProject = _sequenceManager.CreateTestProject();
//testProject.SetUp.Steps.Add(CreateStaticWaitStep());
//testProject.TearDown.Steps.Add(CreateStaticWaitStep());
_sequenceManager.ValidateSequenceData(testProject);
ISequenceGroup sequenceGroup = _sequenceManager.CreateSequenceGroup();
sequenceGroup.ExecutionModel = ExecutionModel.SequentialExecution;
sequenceGroup.Description = "SequenceGroup Description";
ISequence sequence1 = _sequenceManager.CreateSequence();
sequence1.Behavior = RunBehavior.Normal;
sequence1.Description = "Sequence Description";
sequence1.Steps.Add(CreateCallBackStep(100, 200));
sequenceGroup.Sequences.Add(sequence1);
_sequenceManager.ValidateSequenceData(sequenceGroup, testProject);
testProject.SequenceGroups.Add(sequenceGroup);
return(testProject);
}
internal static IVariable FindVariableInSequenceGroup(string varName, ISequenceGroup sequenceGroup)
{
foreach (IVariable variable in sequenceGroup.Variables)
{
if (variable.Name.Equals(varName))
{
return(variable);
}
}
foreach (IVariable variable in sequenceGroup.SetUp.Variables)
{
if (variable.Name.Equals(varName))
{
return(variable);
}
}
foreach (IVariable variable in sequenceGroup.TearDown.Variables)
{
if (variable.Name.Equals(varName))
{
return(variable);
}
}
foreach (ISequence sequence in sequenceGroup.Sequences)
{
foreach (IVariable variable in sequence.Variables)
{
if (variable.Name.Equals(varName))
{
return(variable);
}
}
}
return(null);
}
public static int GetSessionId(ITestProject testProject, ISequenceGroup sequenceGroup)
{
if (null == testProject)
{
return(0);
}
return(testProject.SequenceGroups.IndexOf(sequenceGroup));
}
private void AddCallBackRelatedType(ISequenceGroup sequenceGroup, HashSet <ITypeData> typeDatas)
{
AddCallBackRelatedType(sequenceGroup.SetUp, typeDatas);
foreach (ISequence sequence in sequenceGroup.Sequences)
{
AddCallBackRelatedType(sequence, typeDatas);
}
AddCallBackRelatedType(sequenceGroup.TearDown, typeDatas);
}
private void SequenceGroupFindCallBack(ISequenceGroup sequenceGroup)
{
StepCollectionFindCallBack(sequenceGroup.SetUp.Steps);
StepCollectionFindCallBack(sequenceGroup.TearDown.Steps);
foreach (ISequence sequence in sequenceGroup.Sequences)
{
StepCollectionFindCallBack(sequence.Steps);
}
}
public void SequenceGroupDeserialize()
{
ISequenceGroup sequenceGroup = _sequenceManager.LoadSequenceGroup(SerializationTarget.File, SequenceGroupPath);
Assert.AreEqual(sequenceGroup.Sequences[0].Steps[0].Function.ClassType, sequenceGroup.TypeDatas[0]);
Assert.AreEqual(sequenceGroup.Sequences[0].Steps[0].Function.ReturnType.Type, sequenceGroup.TypeDatas[2]);
Assert.AreEqual(sequenceGroup.Sequences[0].Steps[0].Function.ParameterType[0].Type, sequenceGroup.TypeDatas[2]);
Assert.AreEqual(sequenceGroup.Sequences[0].Steps[0].Function.ParameterType[1].Type, sequenceGroup.TypeDatas[2]);
}
public void Add(ISequenceGroup item)
{
if (_innerCollection.Contains(item))
{
return;
}
ModuleUtils.SetElementName(item, this);
this._innerCollection.Add(item);
}
public IDesignTimeSession AddSequenceGroup(string name, string description)
{
//添加到TestProject
ISequenceGroup sequenceGroup = _sequenceManager.CreateSequenceGroup();
sequenceGroup.Name = name;
sequenceGroup.Description = description;
return(AddSequenceGroup(sequenceGroup));
}
public ITestProject Load(string name, string description, ISequenceGroup sequenceGroup)
{
TestProject = _sequenceManager.CreateTestProject();
TestProject.Name = name;
TestProject.Description = description;
sequenceGroup.Parent = TestProject;
AddSequenceGroup(sequenceGroup);
return(TestProject);
}
public void Insert(int index, ISequenceGroup item)
{
if (_innerCollection.Contains(item))
{
return;
}
ModuleUtils.SetElementName(item, this);
_innerCollection.Insert(index, item);
}
public void SequenceTest()
{
TestflowRunner runnerInstance = TestflowRunner.GetInstance();
ISequenceManager sequenceManager = runnerInstance.SequenceManager;
ISequenceGroup sequenceGroup = sequenceManager.LoadSequenceGroup(SerializationTarget.File,
@"C:\Users\jingtao\Desktop\sequence.tfseq");
runnerInstance.EngineController.SetSequenceData(sequenceGroup);
runnerInstance.EngineController.Start();
}
public static void ValidateParent(ISequenceGroup seuquenceGroup, ISequenceFlowContainer parent)
{
seuquenceGroup.Parent = parent;
ValidateParent(seuquenceGroup.Variables, seuquenceGroup);
ValidateParent(seuquenceGroup.SetUp, seuquenceGroup);
foreach (ISequence sequence in seuquenceGroup.Sequences)
{
ValidateParent(sequence, seuquenceGroup);
}
ValidateParent(seuquenceGroup.TearDown, seuquenceGroup);
}
private static void ValidateTypeDatas(ISequenceGroup sequenceGroup)
{
ValidateTypeDatas(sequenceGroup.Arguments, sequenceGroup.TypeDatas);
ValidateTypeDatas(sequenceGroup.Variables, sequenceGroup.TypeDatas);
ValidateTypeDatas(sequenceGroup.SetUp, sequenceGroup.TypeDatas);
foreach (ISequence sequence in sequenceGroup.Sequences)
{
ValidateTypeDatas(sequence, sequenceGroup.TypeDatas);
}
ValidateTypeDatas(sequenceGroup.TearDown, sequenceGroup.TypeDatas);
}
public DesignTimeContext(ISequenceGroup sequenceGroup)
{
//被DesignTimeService加减component
Components = new Dictionary <string, IComInterfaceDescription>(Constants.DefaultCompCollectionSize);
this.SequenceGroup = sequenceGroup;
this.TestProject = (ITestProject)sequenceGroup.Parent;
this.Name = sequenceGroup.Name + " Context";
//todo _interfaceManager.GetComponenetInterfaces => foreach(){addDictioneary}
}
/// <summary>
/// 校验Sequence模块的参数配置正确性
/// </summary>
/// <param name="sequenceGroup">待校验的序列组</param>
/// <param name="sequence">待校验的序列</param>
/// <returns>检查过程中出现的告警信息</returns>
public IList <IWarningInfo> CheckParameters(ISequenceGroup sequenceGroup, ISequence sequence, bool overwriteType)
{
IList <IWarningInfo> warnList = CheckSteps(sequence.Steps, overwriteType, new ISequenceFlowContainer[] { sequence, sequenceGroup });
foreach (IWarningInfo warnInfo in warnList)
{
warnInfo.Sequence = sequence;
warnInfo.SequenceGroup = sequenceGroup;
}
return(warnList);
}
