public TypeConvertor(SlaveContext context)
{
_context = context;
string numericFormat = context.GetPropertyString("NumericFormat");
_convertors = new Dictionary <string, ValueConvertorBase>(20)
{
{ typeof(decimal).Name, new DecimalConvertor(numericFormat) },
{ typeof(double).Name, new DoubleConvertor(numericFormat) },
{ typeof(float).Name, new FloatConvertor(numericFormat) },
{ typeof(long).Name, new LongConvertor() },
{ typeof(ulong).Name, new ULongConvertor() },
{ typeof(int).Name, new IntConvertor() },
{ typeof(uint).Name, new UIntConvertor() },
{ typeof(short).Name, new ShortConvertor() },
{ typeof(ushort).Name, new UShortConvertor() },
{ typeof(char).Name, new CharConvertor() },
{ typeof(byte).Name, new ByteConvertor() },
{ typeof(bool).Name, new BoolConvertor() },
{ typeof(string).Name, new StringConvertor() },
{ typeof(DateTime).Name, new DateTimeConvertor() }
};
_strConvertor = _convertors[typeof(string).Name];
_nonValueConvertor = new NonValueTypeConvertor(_context);
}
public AssemblyInvoker(SlaveContext context, IAssemblyInfoCollection assemblyInfo, ITypeDataCollection typeDatas)
{
this._assembliesMapping = new Dictionary <string, Assembly>(assemblyInfo.Count);
this._typeDataMapping = new Dictionary <string, Type>(typeDatas.Count);
this._assemblyInfos = assemblyInfo;
this._typeDatas = typeDatas;
this._context = context;
this._dotNetLibDir = context.GetProperty <string>("DotNetLibDir");
this._platformLibDir = context.GetProperty <string>("PlatformLibDir");
this._instanceLibDir = context.GetProperty <string>("InstanceLibDir").Split(';');
_valueTypeConvertors = new Dictionary <string, Func <string, object> >(20)
{
{ typeof(double).Name, valueStr => double.Parse(valueStr) },
{ typeof(float).Name, valueStr => float.Parse(valueStr) },
{ typeof(long).Name, valueStr => long.Parse(valueStr) },
{ typeof(ulong).Name, valueStr => ulong.Parse(valueStr) },
{ typeof(int).Name, valueStr => int.Parse(valueStr) },
{ typeof(uint).Name, valueStr => uint.Parse(valueStr) },
{ typeof(short).Name, valueStr => short.Parse(valueStr) },
{ typeof(ushort).Name, valueStr => ushort.Parse(valueStr) },
{ typeof(char).Name, valueStr => char.Parse(valueStr) },
{ typeof(byte).Name, valueStr => byte.Parse(valueStr) },
{ typeof(bool).Name, valueStr => bool.Parse(valueStr) },
{ typeof(decimal).Name, valueStr => decimal.Parse(valueStr) },
{ typeof(sbyte).Name, valueStr => sbyte.Parse(valueStr) },
{ typeof(DateTime).Name, valueStr => DateTime.Parse(valueStr) },
};
}
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();
}
}
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);
}
public SequenceTaskEntity(ISequence sequence, SlaveContext context)
{
this._sequence = sequence;
this._context = context;
this.State = RuntimeState.Idle;
this.RootCoroutineId = -1;
}
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 DebugManager(SlaveContext context)
{
_context = context;
_watchDatas = new DebugWatchData();
_breakPoints = new Dictionary <string, StepTaskEntityBase>(Constants.DefaultRuntimeSize);
_hitBreakPoints = new Dictionary <int, StepTaskEntityBase>(20);
_hitBreakPointsLock = new ReaderWriterLockSlim();
}
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 NonValueTypeConvertor(SlaveContext context)
{
this._context = context;
_settings = new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Include,
DateFormatHandling = DateFormatHandling.IsoDateFormat,
DateFormatString = CommonConst.GlobalTimeFormat,
DateParseHandling = DateParseHandling.None
};
_arrayRegex = new Regex(ArrayDataRegex);
_classRegex = new Regex(ClassDataRegex);
}
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 FunctionActuator(ISequenceStep step, SlaveContext context, int sequenceIndex) : base(step, context, sequenceIndex)
{
int session = context.SessionId;
this.Method = null;
this.Params = new object[step.Function.Parameters?.Count ?? 0];
this.Constructor = null;
this.FunctionType = step.Function.Type;
if (CoreUtils.IsValidVaraible(step.Function.Instance))
{
string variableName = ModuleUtils.GetVariableNameFromParamValue(step.Function.Instance);
this.InstanceVar = ModuleUtils.GetVariableFullName(variableName, step, session);
}
if (CoreUtils.IsValidVaraible(step.Function.Return))
{
string variableName = ModuleUtils.GetVariableNameFromParamValue(step.Function.Return);
this.ReturnVar = ModuleUtils.GetVariableFullName(variableName, step, session);
}
}
public static ActuatorBase GetActuator(ISequenceStep stepData, SlaveContext context, int sequenceIndex)
{
if (stepData?.Function == null)
{
return(new EmptyActuator(context, stepData, sequenceIndex));
}
switch (stepData.Function.Type)
{
case FunctionType.Constructor:
case FunctionType.StructConstructor:
case FunctionType.InstanceFunction:
case FunctionType.StaticFunction:
return(new FunctionActuator(stepData, context, sequenceIndex));
break;
case FunctionType.Assertion:
return(new AssertActuator(stepData, context, sequenceIndex));
break;
case FunctionType.CallBack:
return(new CallBackActuator(stepData, context, sequenceIndex));
break;
case FunctionType.StaticPropertySetter:
case FunctionType.InstancePropertySetter:
return(new PropertySetterActuator(stepData, context, sequenceIndex));
case FunctionType.StaticFieldSetter:
case FunctionType.InstanceFieldSetter:
return(new FieldSetterActuator(stepData, context, sequenceIndex));
break;
default:
throw new InvalidOperationException();
break;
}
}
public MultiThreadStepEntity(ISequenceStep step, SlaveContext context, int sequenceIndex) : base(step, context, sequenceIndex)
{
}
public BatchBlockStepEntity(ISequenceStep step, SlaveContext context, int sequenceIndex) : base(step, context, sequenceIndex)
{
}
public ConditionStatementStepEntity(ISequenceStep step, SlaveContext context, int sequenceIndex) : base(step, context, sequenceIndex)
{
}
public AssertActuator(ISequenceStep stepData, SlaveContext context, int sequenceIndex) : base(stepData, context, sequenceIndex)
{
}
public ParallelTestRunner(SlaveContext context) : base(context)
{
}
public static StepTaskEntityBase GetEmptyStepModel(SlaveContext context, int sequenceIndex)
{
return(new EmptyStepEntity(context, sequenceIndex, null));
}
public FieldSetterActuator(ISequenceStep step, SlaveContext context, int sequenceIndex) : base(step, context, sequenceIndex)
{
_fields = new List <FieldInfo>(step.Function.Parameters.Count);
_params = new List <object>(step.Function.Parameters.Count);
}
public PropertySetterActuator(ISequenceStep step, SlaveContext context, int sequenceIndex) : base(step, context, sequenceIndex)
{
_properties = new List <PropertyInfo>(step.Function.Parameters.Count);
_params = new List <object>(step.Function.Parameters.Count);
}
public ConditionLoopStepEntity(ISequenceStep step, SlaveContext context, int sequenceIndex) : base(step, context, sequenceIndex)
{
this._loopVariable = null;
}
public RunSingleSequenceFlowTask(int sequenceIndex, SlaveContext context) : base(context)
{
_sequenceIndex = sequenceIndex;
}
public HomeController(SlaveContext slaveContext, IHostingEnvironment env)
{
_slaveContext = slaveContext;
}
public CtrlStartProcessFlowTask(SlaveContext context) : base(context)
{
}
public CallBackActuator(ISequenceStep step, SlaveContext context, int sequenceIndex) : base(step, context, sequenceIndex)
{
this.Params = new object[Function.Parameters?.Count ?? 0];
}
public EmptyActuator(SlaveContext context, ISequenceStep step, int sequenceIndex) : base(step, context, sequenceIndex)
{
}
public SlaveController(SlaveContext slaveContext)
{
this._transceiver = slaveContext.MessageTransceiver;
this._slaveContext = slaveContext;
}
public ExecutionStepEntity(ISequenceStep step, SlaveContext context, int sequenceIndex) : base(step, context, sequenceIndex)
{
}
public TestRunnerBase(SlaveContext context)
{
_context = context;
_controller = context.Controller;
}
