void IInstanceData.Init(IDumpContext dumpContext, object obj, int id)
{
seenInstances = new HashSet <int>();
this.obj = obj;
this.id = id;
var type = obj.GetType();
var typeDataFactory = dumpContext.TypeDataFactory;
typeData = typeDataFactory.Create(type);
typeSize = typeData.Size;
if (typeData.IsPureValueType)
{
fields = emptyFields;
return;
}
var fieldDataFactory = dumpContext.FieldDataFactory;
var instanceFields = typeData.InstanceFields;
fields = new List <IFieldData>(instanceFields.Count);
foreach (var fieldInfo in instanceFields)
{
var fieldData = fieldDataFactory.Create(fieldInfo, obj);
fields.Add(fieldData);
}
}
public override bool Serialize(XElement node, object obj, ITypeData expectedType)
{
if (obj is ITestStepParent step && activeElements.Contains(node) == false)
{
activeElements.Add(node);
try
{
var inputs = InputOutputRelation.GetRelations(step).Where(x => x.InputObject == step).ToArray();
if (inputs.Length == 0)
{
return(false);
}
var items = inputs.Select(x => new InputOutputMember
{
Id = (x.OutputObject as ITestStep)?.Id ?? Guid.Empty, Member = x.OutputMember.Name, TargetMember = x.InputMember.Name
}).ToArray();
var subnode = new XElement(stepInputsName);
Serializer.Serialize(subnode, items, TypeData.GetTypeData(items));
var ok = Serializer.Serialize(node, obj, expectedType);
if (ok)
{
node.Add(subnode);
}
return(ok);
}
finally
{
activeElements.Remove(node);
}
}
return(false);
}
/// <summary> Creates an Enabled from a string. </summary>
public object FromString(string stringdata, ITypeData _type, object contextObject, CultureInfo culture)
{
Type type = (_type as TypeData)?.Type;
if (type == null)
{
return(null);
}
if (type.DescendsTo(typeof(IEnabledValue)) == false)
{
return(null);
}
stringdata = stringdata.Trim();
var disabled = "(disabled)";
IEnabledValue enabled = (IEnabledValue)Activator.CreateInstance(type);
var elemType = GetEnabledElementType(type);
if (stringdata.StartsWith(disabled))
{
if (StringConvertProvider.TryFromString(stringdata.Substring(disabled.Length).Trim(), TypeData.FromType(elemType), null, out object obj, culture))
{
enabled.Value = obj;
}
else
{
return(null);
}
enabled.IsEnabled = false;
}
void updatePropertyFromName()
{
if (string.IsNullOrEmpty(propertyName))
{
return;
}
else
{
string[] parts = propertyName.Split('|');
if (parts.Length == 1)
{
if (Step != null)
{
ITypeData stepType = TypeData.GetTypeData(Step);
Property = stepType.GetMember(parts[0]);
}
else
{
Property = null;
}
}
else
{
var typename = parts[0];
ITypeData stepType = TypeData.GetTypeData(typename);
Property = stepType.GetMember(parts[1]);
}
}
if (Property != null)
{
propertyName = null;
}
}
/// <summary> Serialization implementation. </summary>
public override bool Serialize(XElement elem, object obj, ITypeData expectedType)
{
if (false == obj is ITestStep)
{
return(false);
}
var objp = Serializer.SerializerStack.OfType <ObjectSerializer>().FirstOrDefault();
if (objp != null && objp.Object != null)
{
if (objp.CurrentMember.TypeDescriptor.DescendsTo(typeof(ITestStep)))
{
elem.Attributes("type")?.Remove();
elem.Value = ((ITestStep)obj).Id.ToString();
return(true);
}
if (objp.CurrentMember.TypeDescriptor is TypeData tp)
{
// serialize references in list<ITestStep>, only when they are declared by a test step and not a TestStepList.
if ((tp.ElementType?.DescendsTo(typeof(ITestStep)) ?? false) && objp.CurrentMember.DeclaringType.DescendsTo(typeof(ITestStep)))
{
if (tp != TypeData.FromType(typeof(TestStepList)))
{
elem.Attributes("type")?.Remove();
elem.Value = ((ITestStep)obj).Id.ToString();
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// Turn stringdata back to an object of type 'type', if an IStringConvertProvider plugin supports the string/type. returns true if the parsing was successful.
/// </summary>
/// <param name="stringdata"></param>
/// <param name="type"></param>
/// <param name="contextObject"></param>
/// <param name="result">The result of the operation.</param>
/// <param name="culture"></param>
/// <returns></returns>
public static bool TryFromString(string stringdata, ITypeData type, object contextObject, out object result, CultureInfo culture = null)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
result = null;
if (stringdata == null)
{
return(false);
}
culture = culture ?? CultureInfo.InvariantCulture;
foreach (var provider in Providers)
{
try
{
var value = provider.FromString(stringdata, type, contextObject, culture);
if (value != null)
{
result = value;
return(true);
}
}
catch
{
} // ignore errors. Assume unsupported value.
}
return(false);
}
/// <summary> Deserialization implementation for SecureString. </summary>
/// <param name="node"></param>
/// <param name="targetType"></param>
/// <param name="setResult"></param>
/// <returns></returns>
public override bool Deserialize(XElement node, ITypeData targetType, Action <object> setResult)
{
if (targetType.IsA(typeof(System.Security.SecureString)) == false)
{
return(false);
}
string valueString = node.Value;
var result = new System.Security.SecureString();
setResult(result);
try
{
string encryptedString = CryptographyHelper.Decrypt(valueString, password);
foreach (var c in encryptedString)
{
result.AppendChar(c);
}
return(true);
}
catch
{
return(true);
}
}
/// <summary> Deserialization implementation. </summary>
public override bool Deserialize(XElement elem, ITypeData t, Action <object> setResult)
{
if (t.IsA(typeof(TestStepList)) == false)
{
return(false);
}
var steps = new TestStepList();
foreach (var subnode in elem.Elements())
{
ITestStep result = null;
try
{
if (!Serializer.Deserialize(subnode, x => result = (ITestStep)x))
{
Log.Warning(subnode, "Unable to deserialize step.");
continue; // skip to next step.
}
}
catch (Exception ex)
{
Log.Error(ex);
continue;
}
if (result != null)
{
steps.Add(result);
}
}
setResult(steps);
return(true);
}
/// <summary> Tries to deserialize a MacroString. This is just a simple string value XML element, but it tries to find the step context for the MacroString.</summary>
public override bool Deserialize(XElement node, ITypeData t, Action <object> setter)
{
if (t.IsA(typeof(MacroString)) == false)
{
return(false);
}
string text = node.Value;
var obj = Serializer.SerializerStack.OfType <ObjectSerializer>().FirstOrDefault();
if (obj != null)
{
setter(new MacroString(obj.Object as ITestStep)
{
Text = text
});
}
else
{
setter(new MacroString {
Text = text
});
}
return(true);
}
/// <summary>
/// Stores an object as a result. These results will be propagated to the ResultStore after the TestStep completes.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="result">The result whose properties should be stored.</param>
public void Publish <T>(T result)
{
if (result == null)
{
throw new ArgumentNullException("result");
}
ITypeData runtimeType = TypeData.GetTypeData(result);
if (ResultFunc == null)
{
lock (resultFuncLock)
ResultFunc = new Dictionary <ITypeData, Func <object, ResultTable> >();
}
if (!ResultFunc.ContainsKey(runtimeType))
{
var Typename = runtimeType.GetDisplayAttribute().GetFullName();
var Props = runtimeType.GetMembers().Where(x => x.Readable && x.TypeDescriptor.DescendsTo(typeof(IConvertible))).ToArray();
var PropNames = Props.Select(p => p.GetDisplayAttribute().GetFullName()).ToArray();
ResultFunc[runtimeType] = (v) =>
{
var cols = new ResultColumn[Props.Length];
for (int i = 0; i < Props.Length; i++)
{
cols[i] = new ResultColumn(PropNames[i], GetArray(Props[i].TypeDescriptor.AsTypeData().Type, Props[i].GetValue(v)));
}
return(new ResultTable(Typename, cols));
};
}
var res = ResultFunc[runtimeType](result);
DoStore(res);
}
public void Ignored_WhenInternalSetter_DefaultsToTrue()
{
SerializerSettings context = new SerializerSettings();
ITypeData handler = context.Types[typeof(NonWritableProperty)];
Assert.IsTrue(handler.FindProperty("InternalInt").Ignored);
}
public void IgnoreProperty_WhenFieldDoesntExist_ThrowsError()
{
SerializerSettings context = new SerializerSettings();
ITypeData handler = context.Type <SimpleObject>();
handler.IgnoreProperty("Foo");
}
private static void ParseCommand(ITypeData type, string[] group, CliActionTree command)
{
if (command.SubCommands == null)
{
command.SubCommands = new List <CliActionTree>();
}
// If group is not empty. Find command with first group name
if (group.Length > 0)
{
var existingCommand = command.SubCommands.FirstOrDefault(c => c.Name == group[0]);
if (existingCommand == null)
{
existingCommand = new CliActionTree(command, group[0]);
command.SubCommands.Add(existingCommand);
}
ParseCommand(type, group.Skip(1).ToArray(), existingCommand);
}
else
{
command.SubCommands.Add(new CliActionTree(command, type.GetDisplayAttribute().Name)
{
Type = type, SubCommands = new List <CliActionTree>()
});
command.SubCommands.Sort((x, y) => string.Compare(x.Name, y.Name));
}
}
/// <summary> Serialization implementation. </summary>
public override bool Serialize(XElement elem, object sourceObj, ITypeData expectedType)
{
if (sourceObj is IEnumerable == false || sourceObj is string)
{
return(false);
}
IEnumerable sourceEnumerable = (IEnumerable)sourceObj;
Type type = sourceObj.GetType();
Type genericTypeArg = type.GetEnumerableElementType();
if (genericTypeArg.IsNumeric())
{
var parser = new NumberFormatter(CultureInfo.InvariantCulture)
{
UseRanges = false
};
elem.Value = parser.FormatRange(sourceEnumerable);
return(true);
}
object prevObj = this.Object;
try
{
this.Object = sourceObj;
bool isComponentSettings = sourceObj is ComponentSettings;
foreach (object obj in sourceEnumerable)
{
var step = new XElement(Element);
if (obj != null)
{
type = obj.GetType();
step.Name = TapSerializer.TypeToXmlString(type);
if (isComponentSettings)
{
ComponentSettingsSerializing.Add(obj);
}
try
{
Serializer.Serialize(step, obj, expectedType: TypeData.FromType(genericTypeArg));
}
finally
{
if (isComponentSettings)
{
ComponentSettingsSerializing.Remove(obj);
}
}
}
elem.Add(step);
}
}
finally
{
this.Object = prevObj;
}
return(true);
}
public object CastConstantValue(ITypeData type, string valueStr)
{
Type dataType = _typeDataMapping[ModuleUtils.GetTypeFullName(type)];
// 值或简单类型或使用Json到类或struct的转换
return(_context.Convertor.CastConstantValue(dataType, valueStr));
}
/// <summary>
/// Merges in the properties from the base class to the property list
/// </summary>
/// <param name="properties">property list to merge into</param>
protected virtual void MergeBaseProperties(IList <IPropertyData> properties)
{
if (this.ForType.BaseType == typeof(object) || this.ForType.BaseType == null)
{
return;
}
ITypeData baseTypeData = this.Settings.Types[this.ForType.BaseType];
List <IPropertyData> baseProps = new List <IPropertyData>(baseTypeData.AllProperties);
foreach (IPropertyData baseProp in baseProps)
{
bool found = false;
foreach (IPropertyData localProp in properties)
{
if (localProp.Name == baseProp.Name)
{
found = true;
break;
}
}
if (!found)
{
properties.Add(baseProp);
}
}
}
/// <summary>
/// Turn stringdata back to an object of type 'type', if an IStringConvertProvider plugin supports the string/type.
/// </summary>
/// <param name="stringdata"></param>
/// <param name="type"></param>
/// <param name="contextObject"></param>
/// <param name="culture">If null, invariant culture is used.</param>
/// <returns></returns>
public static object FromString(string stringdata, ITypeData type, object contextObject, CultureInfo culture = null)
{
if (stringdata == null)
{
return(null);
}
if (type == null)
{
throw new ArgumentNullException("type");
}
culture = culture ?? CultureInfo.InvariantCulture;
foreach (var provider in Providers)
{
try
{
var value = provider.FromString(stringdata, type, contextObject, culture);
if (value != null)
{
return(value);
}
}
catch
{
} // ignore errors. Assume unsupported value.
}
throw new FormatException(string.Format("Unable to parse '{0}' as a {1}.", stringdata, type));
}
private static void InitializeArgumentType(ISequenceManager sequenceManager,
DescriptionDataTable descriptionCollection, IArgumentDescription argumentDescription)
{
ArgumentDescription argDescription = (ArgumentDescription)argumentDescription;
// 如果类型描述类为空且TypeData非空，则说明该argDescription已经被修改过，无需再执行处理
if (argDescription.TypeDescription == null)
{
if (null == argDescription.Type)
{
I18N i18N = I18N.GetInstance(Constants.I18nName);
throw new TestflowRuntimeException(ModuleErrorCode.TypeCannotLoad,
i18N.GetFStr("InvalidArgType", argDescription.Name));
}
return;
}
string fullName = GetFullName(argDescription.TypeDescription);
if (descriptionCollection.ContainsType(fullName))
{
argDescription.Type = descriptionCollection.GetTypeData(fullName);
}
else
{
ITypeData typeData = sequenceManager.CreateTypeData(argDescription.TypeDescription);
descriptionCollection.AddTypeData(fullName, typeData);
argDescription.Type = typeData;
}
argDescription.TypeDescription = null;
}
public MacroTypeVariables(IDataEngine engine, IWalkerTypeResult result, string output,
AttributeParser[] attributes, ITypeData reftype) : base(result, output, attributes)
{
Engine = engine;
TYPE = TypeData.Factory(engine, result.TypeDeclarationSyntax);
REFTYPE = reftype;
}
public ClrmdType(ClrHeap heap, ClrType?baseType, ClrModule?module, ITypeData data)
{
if (data is null)
{
throw new ArgumentNullException(nameof(data));
}
Helpers = data.Helpers;
MethodTable = data.MethodTable;
Heap = heap;
BaseType = baseType;
Module = module;
MetadataToken = data.Token;
Shared = data.IsShared;
StaticSize = data.BaseSize;
ContainsPointers = data.ContainsPointers;
IsShared = data.IsShared;
// If there are no methods, preempt the expensive work to create methods
if (data.MethodCount == 0)
{
_methods = Array.Empty <ClrMethod>();
}
DebugOnlyLoadLazyValues();
}
/// <summary> Deserialization implementation. </summary>
public override bool Deserialize(XElement elem, ITypeData t, Action <object> setter)
{
if (t.DescendsTo(typeof(IDynamicStep)) == false)
{
return(false);
}
try
{
IDynamicStep step = (IDynamicStep)t.CreateInstance(Array.Empty <object>());
Serializer.Register(step);
TryDeserializeObject(elem, TypeData.GetTypeData(step), setter, step, logWarnings: false);
ITestStep genStep = step.GetStep();
bool res = true;
if (elem.IsEmpty == false)
{
res = TryDeserializeObject(elem, TypeData.GetTypeData(genStep), setter, genStep, logWarnings: false);
}
else
{
setter(genStep);
}
Serializer.GetSerializer <TestStepSerializer>().FixupStep(genStep, true);
return(res);
}
catch (Exception e)
{
Log.Error("Unable to deserialize step of type {0}. Error was: {1}", t, e.Message);
Log.Debug(e);
return(true);
}
}
/// <summary>
/// Called as part for the deserialization chain. Returns false if it cannot serialize the XML element.
/// </summary>
public override bool Deserialize(XElement node, ITypeData t, Action <object> setter)
{
if (t.IsA(typeof(PackageDependency)))
{
string name = null;
string version = null;
foreach (XAttribute attr in node.Attributes())
{
switch (attr.Name.LocalName)
{
case "Version":
version = attr.Value;
break;
case "Package": // TAP 8.0 support
case "Name":
name = attr.Value;
break;
default:
Debug.Assert(false);
break;
}
}
setter.Invoke(new PackageDependency(name, ConvertVersion(version), version));
return(true);
}
return(false);
}
/// <summary>
/// Called as part for the serialization chain. Returns false if it cannot serialize the XML element.
/// </summary>
public override bool Serialize(XElement node, object obj, ITypeData expectedType)
{
if (expectedType.IsA(typeof(PackageDependency)) == false)
{
return(false);
}
node.Name = "Package";
node.Name = "PackageDependency"; // TODO: remove when server is updated (this is only here for support of the TAP 8.x Repository server that does not yet have a parser that can handle the new name)
node.SetAttributeValue("type", null);
foreach (var prop in expectedType.GetMembers())
{
object val = prop.GetValue(obj);
string name = prop.Name;
if (val == null)
{
continue;
}
if (name == "Name")
{
name = "Package"; // TODO: remove when server is updated (this is only here for support of the TAP 8.x Repository server that does not yet have a parser that can handle the new name)
}
node.SetAttributeValue(name, val);
}
return(true);
}
public void WhenDefaultValuesSetOnContext_PropertyInheritsFromContextIfNotSetOnType()
{
ISerializerSettings config = new SerializerSettings();
ITypeData typeData = config.Types[typeof(SimpleObject)];
typeData.DefaultValueSetting = DefaultValueOption.SuppressDefaultValues;
config.DefaultValues[typeof(string)] = "FromType";
typeData.DefaultValues[typeof(int)] = 22;
IPropertyData stringProperty = config.Types[typeof(SimpleObject)].FindProperty("StringValue");
Assert.IsFalse(stringProperty.ShouldWriteValue(config, "FromType"));
Assert.IsTrue(stringProperty.ShouldWriteValue(config, ""));
IPropertyData intProperty = config.Types[typeof(SimpleObject)].FindProperty("IntValue");
Assert.IsFalse(intProperty.ShouldWriteValue(config, 22));
Assert.IsTrue(intProperty.ShouldWriteValue(config, 0));
IPropertyData shortProperty = config.Types[typeof(SimpleObject)].FindProperty("ShortValue");
shortProperty.DefaultValue = (short)9;
Assert.IsFalse(shortProperty.ShouldWriteValue(config, (short)9));
Assert.IsTrue(shortProperty.ShouldWriteValue(config, 0));
}
public IClassInterfaceDescription GetClassDescriptionByType(ITypeData typeData, out IAssemblyInfo assemblyInfo)
{
string assemblyName = typeData.AssemblyName;
ComInterfaceDescription interfaceDescription = _descriptionData.GetComDescription(assemblyName);
IClassInterfaceDescription classDescription = null;
// 如果该类型描述已存在则直接返回
if (interfaceDescription != null &&
null != (classDescription = interfaceDescription.Classes.FirstOrDefault(item => item.ClassType.Equals(typeData))))
{
assemblyInfo = interfaceDescription.Assembly;
return(classDescription);
}
string path, version;
classDescription = _loaderManager.GetClassDescription(typeData, _descriptionData, out path, out version);
assemblyInfo = GetAssemblyInfo(assemblyName);
TestflowRunner testflowRunner;
if (null == assemblyInfo && null != (testflowRunner = TestflowRunner.GetInstance()))
{
assemblyInfo = testflowRunner.SequenceManager.CreateAssemblyInfo();
assemblyInfo.Path = path;
assemblyInfo.Version = version;
assemblyInfo.AssemblyName = assemblyName;
assemblyInfo.Available = true;
_descriptionData.Add(assemblyInfo);
}
return(classDescription);
}
private IJsonTypeConverter GetConverter(object value)
{
ITypeData handler = Settings.Types[value.GetType()];
IJsonTypeConverter converter = (handler.HasConverter ? handler.TypeConverter : (IJsonTypeConverter)value);
return(converter);
}
private void SetVariableAndArgumentType(string paramValue, ITypeData type, VariableTreeTable variableTree,
ISequenceFlowContainer parent)
{
IVariable variable;
IArgument argument;
string variableName = ModuleUtils.GetVarNameByParamValue(paramValue);
if (null != (variable = variableTree.GetVariable(variableName)))
{
if (!ModuleUtils.IsPropertyParam(paramValue))
{
variable.Type = type;
}
}
else if (null != (argument = variableTree.GetArgument(variableName)))
{
if (!ModuleUtils.IsPropertyParam(paramValue))
{
argument.Type = type;
}
}
else
{
ThrowIfVariableNotFound(variableName, parent);
}
}
static string getAssemblyName(ITypeData _x)
{
var asm = _x.AsTypeData()?.Type?.Assembly;
if (asm == null)
{
Log.Warning("Unable to find source of type {0}. No package dependency will be recorded for this type in the xml file.", _x.Name);
return(null);
}
// dynamic or assemblies loaded from bytes cannot be located.
if (asm.IsDynamic || string.IsNullOrWhiteSpace(asm.Location))
{
return(null);
}
try
{
return(Path.GetFileName(asm.Location.Replace("\\", "/")));
}
catch
{
return(null);
}
}
public void IgnoredBaseProperty_SharedByChildren()
{
SerializerSettings context = new SerializerSettings();
ITypeData child = context.Types[typeof(ChildClass)];
ITypeData baseClass = context.Types[typeof(BaseClass)];
Assert.AreSame(baseClass.FindProperty("IgnoredProperty"), child.FindProperty("IgnoredProperty"), "child IgnoredProperty");
}
public void OverridenBaseProperty_NotSharedByChildren()
{
SerializerSettings context = new SerializerSettings();
ITypeData child = context.Types[typeof(ChildClass)];
ITypeData baseClass = context.Types[typeof(BaseClass)];
Assert.AreNotSame(baseClass.FindProperty("OverriddenProperty"), child.FindProperty("OverriddenProperty"), "child OverriddenProperty");
}
