using LabViewHelper;
|
using NationalInstruments.LabVIEW.Interop;
|
using OpenTap;
|
using OpenTap.Addin.Annotation;
|
using OpenTap.Addin.Util;
|
using System;
|
using System.Collections.Generic;
|
using System.Collections.ObjectModel;
|
using System.Linq;
|
using System.Reflection;
|
using System.Xml.Serialization;
|
using UtilLib;
|
using ViHelper;
|
|
namespace AddInPlugin.Super
|
{
|
public enum JudgeType
|
{
|
Number = 0,
|
String = 1,
|
Bool = 2
|
}
|
|
[Display("Adapter")]
|
public enum AdapterType
|
{
|
None = 0,
|
[Display(".Net")]
|
CShape = 1,
|
LabView = 2,
|
Lvlibp = 3,
|
}
|
|
[Display("ComparisonType")]
|
public enum ComparisonType
|
{
|
[Display("x == Low")]
|
EQ = 0,
|
[Display("x != Low")]
|
NE = 1,
|
[Display("x > Low")]
|
GT = 2,
|
[Display("x < Low")]
|
LT = 3,
|
[Display("x >= Low")]
|
GE = 4,
|
[Display("x <= Low")]
|
LE = 5,
|
|
[Display("Low < x < High")]
|
GTLT = 6,
|
|
[Display("Low <= x <= High")]
|
GELE = 7,
|
|
[Display("Low <= x < High")]
|
GELT = 8,
|
|
[Display("Low < x <= High")]
|
GTLE = 9,
|
|
[Display("x < Low OR x > High")]
|
LTGT = 10,
|
|
[Display("x <= Low OR x >= High")]
|
LEGE = 11,
|
|
[Display("x <= Low OR x > High")]
|
LEGT = 12,
|
|
[Display("x < Low OR x >= High")]
|
LTGE = 13,
|
}
|
|
|
public class JudgeTest : VariableTestStep
|
{
|
private Exception loadException;
|
|
[XmlIgnore]
|
public Exception LoadException
|
{
|
get => loadException;
|
set
|
{
|
Set(ref loadException, value);
|
}
|
}
|
|
private AdapterType adapter = AdapterType.None;
|
[Display("适配器")]
|
public AdapterType Adapter
|
{
|
get => adapter;
|
set
|
{
|
Set(ref adapter, value);
|
}
|
}
|
|
public JudgeTest() : base()
|
{
|
DllLocation = new LocationString();
|
LvlibpLocation = new LocationString();
|
}
|
|
protected override void OnRootChanged(TestPlan old, TestPlan plan)
|
{
|
if (old == plan) return;
|
try
|
{
|
if (Adapter == AdapterType.CShape)
|
{
|
if (!string.IsNullOrEmpty(DllPath))
|
{
|
DllLocation.AbsoluteLocation = DllPath;
|
DllPath = null;
|
}
|
DllLocation.Refresh(Root.Path);
|
LoadDll(true);
|
}
|
else if (Adapter == AdapterType.Lvlibp)
|
{
|
if (!string.IsNullOrEmpty(LvlibpPath))
|
{
|
LvlibpLocation.AbsoluteLocation = LvlibpPath;
|
LvlibpPath = null;
|
}
|
LvlibpLocation.Refresh(Root.Path);
|
LoadLvlibp(true);
|
}
|
}
|
catch (Exception ex)
|
{
|
Log.Error($"{Name}: JudgeTest load dll error. {0}", ex);
|
}
|
}
|
|
private void Location_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
|
{
|
if (sender == DllLocation)
|
{
|
LoadDll(false);
|
}
|
else if (sender == LvlibpLocation)
|
{
|
LoadLvlibp(false);
|
}
|
}
|
|
private void ConcatVariable(MethodVariable mv, MethodVariable[] source)
|
{
|
MethodVariables.Add(mv);
|
var preview = source?.FirstOrDefault(v => v.Name == mv.Name && !string.IsNullOrEmpty(v.ValueStr));
|
if (preview != null)
|
{
|
mv.ValueStr = preview.ValueStr;
|
}
|
}
|
|
#region .Net相关
|
|
private Assembly assembly;
|
|
private Type targetType;
|
|
private Dictionary<string, MethodBase> methodCache = new Dictionary<string, MethodBase>();
|
|
[XmlIgnore]
|
private object instance;
|
|
private string dllPath;
|
[Obsolete]
|
public string DllPath
|
{
|
get => dllPath;
|
set
|
{
|
Set(ref dllPath, value);
|
}
|
}
|
|
private LocationString dllLocation;
|
[Display("DLL路径", Order: 0.0, Description: "Dll绝对路径.")]
|
[DependOn("Adapter", AdapterType.CShape)]
|
[FilePath(FilePathAttribute.BehaviorChoice.Open, fileExtension: "Dll|*.dll")]
|
public LocationString DllLocation
|
{
|
get => dllLocation;
|
set
|
{
|
if (value != dllLocation)
|
{
|
value.PropertyChanged += Location_PropertyChanged;
|
}
|
Set(ref dllLocation, value);
|
}
|
}
|
|
private ObservableCollection<string> types;
|
[XmlIgnore]
|
public ObservableCollection<string> Types
|
{
|
get => types;
|
set
|
{
|
types = value;
|
OnPropertyChanged(nameof(Types));
|
}
|
}
|
|
private ObservableCollection<string> methods;
|
[XmlIgnore]
|
public ObservableCollection<string> Methods
|
{
|
get => methods;
|
set
|
{
|
methods = value;
|
OnPropertyChanged(nameof(Methods));
|
}
|
}
|
|
private string className;
|
[DependOn("Adapter", AdapterType.CShape)]
|
[Display("类名", Order: 0.0, Description: "类名.")]
|
[DynamicSelect("Types")]
|
public string ClassName
|
{
|
get => className;
|
set
|
{
|
if (className != value)
|
{
|
className = value;
|
if (!string.IsNullOrEmpty(value))
|
{
|
LoadTypes();
|
}
|
OnPropertyChanged(nameof(ClassName));
|
}
|
}
|
}
|
|
private string methodName;
|
[DependOn("Adapter", AdapterType.CShape)]
|
[Display("方法", Order: 0.0, Description: "方法名.")]
|
[DynamicSelect("Methods")]
|
public string MethodName
|
{
|
get => methodName;
|
set
|
{
|
if (methodName != value)
|
{
|
methodName = value;
|
OnPropertyChanged(nameof(MethodName));
|
if (!string.IsNullOrEmpty(value))
|
{
|
RefreshVariables();
|
}
|
}
|
}
|
}
|
|
private void LoadDll(bool loadAll)
|
{
|
try
|
{
|
if (!DllLocation.GetLocation(Root.Path, out string path))
|
{
|
throw new Exception("Dll Exception");
|
}
|
assembly = DllLoader.Instance.LoadAssembly(path, out var types);
|
Types = types;
|
if (loadAll)
|
{
|
LoadTypes();
|
RefreshVariables();
|
}
|
LoadException = null;
|
}
|
catch (Exception ex)
|
{
|
LoadException = ex;
|
Log.Error($"{Name}: JudgeTest load dll error. {0}", ex);
|
}
|
}
|
|
public void LoadTypes()
|
{
|
methodCache.Clear();
|
try
|
{
|
targetType = assembly?.GetType(ClassName);
|
if (targetType != null)
|
{
|
var creators = targetType?.GetConstructors();
|
if (creators != null)
|
{
|
for (int i = 0; i < creators.Length; i++)
|
{
|
var creator = creators[i];
|
var ps = creator.GetParameters();
|
var displayName = $"{targetType.Name} ({string.Join(", ", ps.Select(p => $"{p.ParameterType.ToString()} {p.Name}").ToArray())})";
|
methodCache[displayName] = creator;
|
}
|
}
|
|
var methods = MethodInfoHelper.GetPublicMethodNames(targetType);
|
if (methods != null)
|
{
|
for (int i = 0; i < methods.Count; i++)
|
{
|
var method = methods[i];
|
var ps = method.GetParameters();
|
var displayName = $"{method.Name} ({string.Join(", ", ps.Select(p => $"{p.ParameterType.ToString()} {p.Name}").ToArray())})";
|
methodCache[displayName] = method;
|
}
|
}
|
}
|
Methods = new ObservableCollection<string>(methodCache.Keys.ToArray());
|
}
|
catch (Exception ex)
|
{
|
Log.Error("DotNetStep LoadTypes error. {0}", ex);
|
}
|
}
|
|
public void RefreshVariables()
|
{
|
if (MethodVariables == null)
|
{
|
MethodVariables = new ObservableCollection<MethodVariable>();
|
}
|
var last = MethodVariables.ToArray();
|
MethodVariables.Clear();
|
try
|
{
|
if (!methodCache.ContainsKey(MethodName))
|
{
|
return;
|
}
|
var method = methodCache[MethodName];
|
var ps = method.GetParameters();
|
var IsStatic = method.IsStatic;
|
var IsConstructorMethod = method.IsConstructor;
|
|
if (IsConstructorMethod)
|
{
|
var newOne = new MethodVariable
|
{
|
Name = "(return)",
|
Type = targetType,
|
TypeName = targetType?.ToString(),
|
Direction = VariableDirection.Out,
|
};
|
ConcatVariable(newOne, last);
|
}
|
else if (!IsStatic)
|
{
|
var mi = (MethodInfo)method;
|
var newOne = new MethodVariable
|
{
|
Name = "(instance)",
|
Type = targetType,
|
TypeName = targetType?.ToString(),
|
Direction = VariableDirection.In,
|
};
|
ConcatVariable(newOne, last);
|
|
newOne = new MethodVariable
|
{
|
Name = "(return)",
|
Type = mi.ReturnType,
|
TypeName = mi.ReturnType?.ToString(),
|
Direction = VariableDirection.Out,
|
};
|
ConcatVariable(newOne, last);
|
}
|
else
|
{
|
var mi = (MethodInfo)method;
|
var newOne = new MethodVariable
|
{
|
Name = "(return)",
|
Type = mi.ReturnType,
|
TypeName = mi.ReturnType?.ToString(),
|
Direction = VariableDirection.Out,
|
};
|
ConcatVariable(newOne, last);
|
}
|
|
foreach (var p in ps)
|
{
|
var newOne = new MethodVariable
|
{
|
Name = p.Name,
|
Type = p.ParameterType,
|
TypeName = p.ParameterType.ToString(),
|
Direction = p.IsOut ? VariableDirection.Out : VariableDirection.In,
|
};
|
ConcatVariable(newOne, last);
|
}
|
}
|
catch (Exception ex)
|
{
|
Log.Error("DotNetStep LoadVariables error. {0}", ex);
|
}
|
}
|
|
/// <summary>
|
/// 转换参数
|
/// </summary>
|
private void ResolveDotNetVariables()
|
{
|
var method = methodCache[methodName];
|
var IsStatic = method.IsStatic;
|
var IsConstructorMethod = method.IsConstructor;
|
if (IsConstructorMethod)
|
{
|
for (int i = 1; i < MethodVariables.Count; i++)
|
{
|
MethodVariable mv = MethodVariables[i];
|
if (mv.Direction == VariableDirection.In)
|
{
|
mv.Value = PlanRun.Resolve(this, mv.ValueStr, mv.Type);
|
}
|
}
|
}
|
else if (IsStatic)
|
{
|
for (int i = 1; i < MethodVariables.Count; i++)
|
{
|
MethodVariable mv = MethodVariables[i];
|
if (mv.Direction == VariableDirection.In)
|
{
|
mv.Value = PlanRun.Resolve(this, mv.ValueStr, mv.Type);
|
}
|
}
|
}
|
else
|
{
|
for (int i = 1; i < MethodVariables.Count; i++)
|
{
|
var mv = MethodVariables[i];
|
if (mv.Direction == VariableDirection.In)
|
{
|
mv.Value = PlanRun.Resolve(this, mv.ValueStr, mv.Type);
|
}
|
}
|
}
|
}
|
#endregion
|
|
#region LabView相关
|
private string viPath;
|
|
[Display("VI路径", Order: 0.0, Description: "Dll绝对路径.")]
|
[DependOn(nameof(Adapter), AdapterType.LabView)]
|
[FilePath(FilePathAttribute.BehaviorChoice.Open)]
|
public string ViPath
|
{
|
get => viPath;
|
set
|
{
|
if (viPath != value)
|
{
|
viPath = value;
|
OnPropertyChanged(nameof(viPath));
|
LoadVi();
|
}
|
}
|
}
|
|
private void LoadVi()
|
{
|
try
|
{
|
if (string.IsNullOrEmpty(ViPath))
|
{
|
return;
|
}
|
LabViHelper.GetIOType(ViPath, out var inVariables, out var outVariables);
|
|
var last = MethodVariables?.ToArray();
|
MethodVariables.Clear();
|
foreach (var inv in inVariables)
|
{
|
var newOne = new MethodVariable
|
{
|
Name = inv.Name,
|
Type = inv.Type,
|
TypeName = inv.Type.ToString(),
|
Direction = VariableDirection.In,
|
ValueStr = inv.Data.ToString()
|
};
|
ConcatVariable(newOne, last);
|
}
|
|
foreach (var onv in outVariables)
|
{
|
var newOne = new MethodVariable
|
{
|
Name = onv.Name,
|
Type = onv.Type,
|
TypeName = onv.Type.ToString(),
|
Direction = VariableDirection.Out
|
};
|
ConcatVariable(newOne, last);
|
}
|
}
|
catch (Exception ex)
|
{
|
Log.Error("ViStep load vi error. {0}", ex);
|
}
|
}
|
|
/// <summary>
|
/// 转换参数
|
/// </summary>
|
private void ResolveLabViewVariables()
|
{
|
foreach (var m in MethodVariables)
|
{
|
m.Value = PlanRun.Resolve(this, m.ValueStr);
|
}
|
}
|
#endregion
|
|
#region lvlibp相关
|
private string lvlibpPath;
|
[Obsolete]
|
public string LvlibpPath
|
{
|
get => lvlibpPath;
|
set
|
{
|
Set(ref lvlibpPath, value);
|
}
|
}
|
|
private LocationString lvlibpLocation;
|
[Display("路径", Order: 0.0, Description: "lvlibp绝对路径.")]
|
[DependOn(nameof(Adapter), AdapterType.Lvlibp)]
|
[FilePath(FilePathAttribute.BehaviorChoice.Open, fileExtension: "Labview|*.lvlibp")]
|
public LocationString LvlibpLocation
|
{
|
get => lvlibpLocation;
|
set
|
{
|
if (value != lvlibpLocation)
|
{
|
value.PropertyChanged += Location_PropertyChanged;
|
}
|
Set(ref lvlibpLocation, value);
|
}
|
}
|
|
private ObservableCollection<string> nameDatasource;
|
[XmlIgnore]
|
public ObservableCollection<string> NameDatasource
|
{
|
get => nameDatasource;
|
set
|
{
|
Set(ref nameDatasource, value);
|
}
|
}
|
|
private string viName;
|
|
[Display("VI", Order: 0.0, Description: "VI名称.")]
|
[DependOn(nameof(Adapter), AdapterType.Lvlibp)]
|
[DynamicSelect(nameof(NameDatasource))]
|
public string ViName
|
{
|
get => viName;
|
set
|
{
|
Set(ref viName, value);
|
LoadViByName();
|
}
|
}
|
|
private bool showWindow;
|
|
[Display("显示窗口", Order: 0.0)]
|
[DependOn(nameof(Adapter), AdapterType.Lvlibp)]
|
public bool ShowWindow
|
{
|
get => showWindow;
|
set
|
{
|
Set(ref showWindow, value);
|
}
|
}
|
|
private void LoadLvlibp(bool loadAll)
|
{
|
try
|
{
|
if (!LvlibpLocation.GetLocation(Root.Path, out string path))
|
{
|
return;
|
}
|
|
LabViewRunner.GetLibpNames(new LVPath(path), out string[] names, out var outVariables);
|
NameDatasource = new ObservableCollection<string>(names);
|
|
if (loadAll)
|
{
|
LoadVi();
|
}
|
LoadException = null;
|
}
|
catch (Exception ex)
|
{
|
LoadException = ex;
|
//Log.Error("ViStep load vi error. {0}", ex);
|
}
|
}
|
|
private void LoadViByName()
|
{
|
try
|
{
|
if (!LvlibpLocation.GetLocation(Root?.Path, out string path))
|
{
|
return;
|
}
|
LabViHelper.GetIOTypeByLvlibp(path, ViName, out var inVariables, out var outVariables);
|
var last = MethodVariables.ToArray();
|
MethodVariables.Clear();
|
foreach (var inv in inVariables)
|
{
|
var newOne = new MethodVariable
|
{
|
Name = inv.Name,
|
Type = inv.Type,
|
TypeName = inv.Type.ToString(),
|
Direction = VariableDirection.In,
|
ValueStr = inv.Type == typeof(string) ? $"\"{inv.Data?.ToString()}\"" : inv.Data?.ToString()
|
};
|
ConcatVariable(newOne, last);
|
}
|
|
foreach (var onv in outVariables)
|
{
|
var newOne = new MethodVariable
|
{
|
Name = onv.Name,
|
Type = onv.Type,
|
TypeName = onv.Type.ToString(),
|
Direction = VariableDirection.Out
|
};
|
ConcatVariable(newOne, last);
|
}
|
LoadException = null;
|
}
|
catch (Exception ex)
|
{
|
LoadException = ex;
|
}
|
}
|
|
|
#endregion
|
|
[Display("参数", Order: 0.0, Description: "运行参数.")]
|
[BindingList(nameof(MethodVariables))]
|
[DependOn(nameof(Adapter), new object[] { AdapterType.Lvlibp, AdapterType.LabView, AdapterType.CShape }, GroupCheck.OR)]
|
public override ObservableCollection<MethodVariable> MethodVariables
|
{
|
get => methodVariables;
|
set
|
{
|
methodVariables = value;
|
foreach (var mv in value)
|
{
|
mv.Type = System.Type.GetType(mv.TypeName);
|
}
|
OnPropertyChanged(nameof(MethodVariables));
|
OnMethodVariablesChanged(value);
|
}
|
}
|
|
protected JudgeType type = JudgeType.Number;
|
// [Display("校验类型")]
|
public virtual JudgeType Type
|
{
|
get => type;
|
set
|
{
|
Set(ref type, value);
|
}
|
}
|
|
private string compareSource;
|
[Display("数据源")]
|
public string CompareSource
|
{
|
get => compareSource;
|
set
|
{
|
Set(ref compareSource, value);
|
}
|
}
|
|
private ComparisonType comparsion = ComparisonType.EQ;
|
[Display("比较方法")]
|
[DependOn("Type", JudgeType.Number)]
|
public ComparisonType Comparison
|
{
|
get => comparsion;
|
set
|
{
|
Set(ref comparsion, value);
|
}
|
}
|
|
private string limitDown;
|
[Display("下限 (Low)")]
|
[DependOn("Type", JudgeType.Number)]
|
public string LimitDown
|
{
|
get => limitDown;
|
set
|
{
|
Set(ref limitDown, value);
|
OnPropertyChanged(nameof(TargetValue));
|
}
|
}
|
|
private string limitUp;
|
[Display("上限 (High)")]
|
[DependOn("Type", JudgeType.Number)]
|
public string LimitUp
|
{
|
get => limitUp;
|
set
|
{
|
Set(ref limitUp, value);
|
}
|
}
|
|
[Display("目标值")]
|
[DependOn("Type", JudgeType.String)]
|
public string TargetValue
|
{
|
get => limitDown;
|
set
|
{
|
Set(ref limitDown, value);
|
OnPropertyChanged(nameof(LimitDown));
|
}
|
}
|
|
private bool ignoreCase = false;
|
[Display("忽略大小写")]
|
[DependOn("Type", JudgeType.String)]
|
public bool IgnoreCase
|
{
|
get => ignoreCase;
|
set
|
{
|
Set(ref ignoreCase, value);
|
}
|
}
|
|
private string output = ConstNames.StepResultPassFail;
|
[Display("输出结果")]
|
public string Output
|
{
|
get => output;
|
set
|
{
|
Set(ref output, value);
|
}
|
}
|
|
/// <summary>
|
/// 运行函数
|
/// </summary>
|
private void RunDotNetMethod()
|
{
|
ResolveDotNetVariables();
|
var method = methodCache[methodName];
|
var IsStatic = method.IsStatic;
|
var IsConstructorMethod = method.IsConstructor;
|
if (IsConstructorMethod)
|
{
|
var constructor = (ConstructorInfo)method;
|
var methodParams = new object[MethodVariables.Count - 1];
|
for (int i = 1; i < MethodVariables.Count; i++)
|
{
|
var mv = MethodVariables[i];
|
methodParams[i - 1] = mv.Value;
|
}
|
instance = constructor.Invoke(methodParams);
|
MethodVariables[0].Value = instance;
|
}
|
else if (IsStatic)
|
{
|
var methodParams = new object[MethodVariables.Count - 1];
|
for (int i = 1; i < MethodVariables.Count; i++)
|
{
|
var mv = MethodVariables[i];
|
methodParams[i - 1] = mv.Value;
|
}
|
|
MethodVariables[0].Value = method.Invoke(null, methodParams);
|
for (int i = 0; i < methodParams.Length; i++)
|
{
|
MethodVariables[i + 1].Value = methodParams[i];
|
}
|
}
|
else
|
{
|
var methodParams = new object[MethodVariables.Count - 2];
|
for (int i = 2; i < MethodVariables.Count; i++)
|
{
|
var mv = MethodVariables[i];
|
methodParams[i - 2] = mv.Value;
|
}
|
instance = PlanRun.Resolve(this, MethodVariables[0].ValueStr);
|
MethodVariables[1].Value = method.Invoke(instance, methodParams);
|
for (int i = 0; i < methodParams.Length; i++)
|
{
|
MethodVariables[i + 2].Value = methodParams[i];
|
}
|
}
|
}
|
|
/// <summary>
|
/// 运行函数
|
/// </summary>
|
private void RunLabViewMethod()
|
{
|
ResolveLabViewVariables();
|
|
var ins = MethodVariables.Where(m => m.Direction == VariableDirection.In)
|
.Select(m => new Cluster { name = m.Name, variant__32Data = new LVVariant(m.Value) }).ToArray();
|
|
LabViewRunner.ViRunner(new LVPath(this.ViPath), 0, ins, out var outs);
|
foreach (var ov in outs)
|
{
|
foreach (var m in MethodVariables)
|
{
|
if (ov.name == m.Name)
|
{
|
m.Value = ov.variant__32Data.value;
|
break;
|
}
|
}
|
}
|
}
|
|
private void RunLvlibpMethod()
|
{
|
if (!LvlibpLocation.GetLocation(Root?.Path, out string path))
|
{
|
return;
|
}
|
ResolveLabViewVariables();
|
|
var ins = MethodVariables.Where(m => m.Direction == VariableDirection.In && m.Value != null)
|
.Select(m => new Cluster { name = m.Name, variant__32Data = new LVVariant(m.Value) }).ToArray();
|
|
|
LabViewRunner.RunLibpByName2(new LVPath(path), ViName, 0, ShowWindow, ins, out var outs, out ErrorCluster err);
|
if (err.status)
|
{
|
Verdict = Verdict.Error;
|
return;
|
}
|
|
foreach (var ov in outs)
|
{
|
foreach (var m in MethodVariables)
|
{
|
if (ov.name == m.Name)
|
{
|
m.Value = ov.variant__32Data.value;
|
break;
|
}
|
}
|
}
|
}
|
|
protected override void RunDetail()
|
{
|
try
|
{
|
if (Adapter == AdapterType.CShape)
|
{
|
RunDotNetMethod();
|
UpdateVariableToRuntime();
|
}
|
else if (Adapter == AdapterType.LabView)
|
{
|
RunLabViewMethod();
|
UpdateVariableToRuntime();
|
}
|
else if (Adapter == AdapterType.Lvlibp)
|
{
|
RunLvlibpMethod();
|
UpdateVariableToRuntime();
|
}
|
|
bool res = false;
|
if (Type == JudgeType.Number)
|
{
|
res = DoCompareNumber();
|
Log.Debug($"DoCompareNumber: {res}");
|
}
|
else if (Type == JudgeType.String)
|
{
|
res = DoCompareString();
|
Log.Debug($"DoCompareString: {res}");
|
}
|
else if (Type == JudgeType.Bool)
|
{
|
res = DoCompareBool();
|
Log.Debug($"DoCompareBool: {res}");
|
}
|
UploadResult(res);
|
}
|
catch (Exception ex)
|
{
|
UploadResult(false);
|
Log.Error("JudgeTest Run error. {0}", ex);
|
this.Verdict = Verdict.Error;
|
}
|
}
|
|
private void UploadResult(bool data)
|
{
|
this.Verdict = data ? Verdict.Pass : Verdict.Fail;
|
PlanRun.Update(this, ConstNames.StepResultPassFail, data);
|
PlanRun.Update(this, Output, data);
|
}
|
|
private bool DoCompareNumber()
|
{
|
string express = $"{CompareSource} == {LimitDown}";
|
switch (Comparison)
|
{
|
case ComparisonType.NE:
|
express = $"{CompareSource} != {LimitDown}";
|
break;
|
case ComparisonType.GT:
|
express = $"{CompareSource} > {LimitDown}";
|
break;
|
case ComparisonType.LT:
|
express = $"{CompareSource} < {LimitDown}";
|
break;
|
case ComparisonType.GE:
|
express = $"{CompareSource} >= {LimitDown}";
|
break;
|
case ComparisonType.LE:
|
express = $"{CompareSource} <= {LimitDown}";
|
break;
|
case ComparisonType.GTLT:
|
express = $"{CompareSource} > {LimitDown} && {CompareSource} < {LimitUp}";
|
break;
|
case ComparisonType.GELE:
|
express = $"{CompareSource} >= {LimitDown} && {CompareSource} <= {LimitUp}";
|
break;
|
case ComparisonType.GELT:
|
express = $"{CompareSource} >= {LimitDown} && {CompareSource} < {LimitUp}";
|
break;
|
case ComparisonType.GTLE:
|
express = $"{CompareSource} > {LimitDown} && {CompareSource} <= {LimitUp}";
|
break;
|
case ComparisonType.LTGT:
|
express = $"{CompareSource} > {LimitUp} || {CompareSource} < {LimitDown}";
|
break;
|
case ComparisonType.LEGE:
|
express = $"{CompareSource} >= {LimitUp} || {CompareSource} <= {LimitDown}";
|
break;
|
case ComparisonType.LEGT:
|
express = $"{CompareSource} > {LimitUp} || {CompareSource} <= {LimitDown}";
|
break;
|
case ComparisonType.LTGE:
|
express = $"{CompareSource} >= {LimitUp} || {CompareSource} < {LimitDown}";
|
break;
|
default:
|
break;
|
}
|
return PlanRun.Resolve<bool>(this, express);
|
}
|
|
private bool DoCompareString()
|
{
|
string express = $"CompareString({CompareSource},{TargetValue},{IgnoreCase})";
|
return PlanRun.Resolve<bool>(this, express);
|
}
|
|
private bool DoCompareBool()
|
{
|
if (string.IsNullOrEmpty(CompareSource))
|
{
|
return false;
|
}
|
return PlanRun.Resolve<bool>(this, CompareSource);
|
}
|
}
|
}
|
