/// <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); }
/// <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> 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); }
public override bool Deserialize(XElement node, ITypeData t, Action <object> setter) { if (t.IsA(typeof(PackageVersion[]))) { var list = new List <PackageVersion>(); foreach (var element in node.Elements()) { list.Add(DeserializePackageVersion(element)); } setter(list.ToArray()); return(true); } if (t.IsA(typeof(PackageVersion))) { setter(DeserializePackageVersion(node)); return(true); } return(false); }
public bool Deserialize(XElement node, ITypeData t, Action <object> setter) { if (t.IsA(typeof(Verdict))) { if (node.Value == legacyNotSetName) { node.SetValue(nameof(Verdict.NotSet)); return(TapSerializer.GetCurrentSerializer().Serialize(node, setter, t)); } } if (node.Name == TestStepName && t.DescendsTo(typeof(DialogStep))) { if (currentBox != null) { return(false); } currentBox = new Box(); var serializer = TapSerializer.GetCurrentSerializer(); return(serializer.Deserialize(node, x => { currentBox.Step = (DialogStep)x; setter(x); }, t)); } else if (currentBox != null && node.Name == legacyDefaultAnswerPropertyName) { if (bool.TryParse(node.Value, out bool defaultAnswer)) { node.Remove(); var serializer = TapSerializer.GetCurrentSerializer(); var thisbox = currentBox; serializer.DeferLoad(() => { if (thisbox.Step == null) { return; } if (defaultAnswer) { thisbox.Step.DefaultAnswer = thisbox.Step.PositiveAnswer; } else { thisbox.Step.DefaultAnswer = thisbox.Step.NegativeAnswer; } }); return(true); } } return(false); }
/// <summary> /// Deserializes a test plan from XML. /// </summary> /// <param name="element"></param> /// <param name="_t"></param> /// <param name="setter"></param> /// <returns></returns> public override bool Deserialize(XElement element, ITypeData _t, Action <object> setter) { if (_t.IsA(typeof(TestPlan)) == false) { return(false); } var prevPlan = Plan; Plan = new TestPlan { Path = Serializer.ReadPath }; try { return(TryDeserializeObject(element, _t, setter, Plan)); } finally { Plan = prevPlan; } }
/// <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 ((node.Name.LocalName == "Package" && t.IsA(typeof(PackageDef))) || (node.Name.LocalName == nameof(PackageIdentifier) && t.IsA(typeof(PackageIdentifier)))) { var pkg = new PackageDef(); foreach (XAttribute attr in node.Attributes()) { switch (attr.Name.LocalName) { case "Version": pkg.RawVersion = attr.Value; if (SemanticVersion.TryParse(attr.Value, out var semver)) { pkg.Version = semver; } break; case "Date": if (DateTime.TryParse(attr.Value, out DateTime date)) { pkg.Date = date; } else { pkg.Date = DateTime.MinValue; } break; case "Architecture": pkg.Architecture = (CpuArchitecture)Enum.Parse(typeof(CpuArchitecture), attr.Value); break; default: var prop = pkg.GetType().GetProperty(attr.Name.LocalName); if (prop != null) { prop.SetValue(pkg, attr.Value); } break; } } foreach (var elm in node.Elements()) { switch (elm.Name.LocalName) { case "Description": pkg.Description = Regex.Match(elm.ToString().Replace("\r", ""), "^<Description.*?>((?:.|\\n)+)</Description>", RegexOptions.Multiline).Groups[1].Value.Trim(); break; case "PackageRepositoryUrl": #pragma warning disable 618 pkg.Location = elm.Value; #pragma warning restore 618 break; default: var prop = pkg.GetType().GetProperty(elm.Name.LocalName); if (prop != null) { Serializer.Deserialize(elm, o => prop.SetValue(pkg, o), prop.PropertyType); } break; } } if (t.IsA(typeof(PackageIdentifier))) { setter.Invoke(new PackageIdentifier(pkg)); } else { setter.Invoke(pkg); } // If the Version XML attribute is missing, default to same behavior as if Version="" was specified. We depend on packages having a version. if (pkg.Version is null && string.IsNullOrEmpty(pkg.RawVersion)) { pkg.RawVersion = ""; if (SemanticVersion.TryParse("0.0.0", out var semver)) { pkg.Version = semver; } } 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(PackageDef)) == false && expectedType.IsA(typeof(PackageIdentifier)) == false) { return(false); } XNamespace ns = "http://opentap.io/schemas/package"; node.Name = ns + (expectedType.IsA(typeof(PackageIdentifier)) ? nameof(PackageIdentifier) : "Package"); node.SetAttributeValue("type", null); foreach (var prop in expectedType.GetMembers()) { object val = prop.GetValue(obj); if (false == val is string && val is IEnumerable && (val as IEnumerable).GetEnumerator().MoveNext() == false) { continue; // don't write empty enumerables } var defaultAttr = prop.GetAttribute <DefaultValueAttribute>(); if (defaultAttr != null && object.Equals(defaultAttr.Value, val)) { continue; } switch (prop.Name) { case "RawVersion": continue; case "Date": if (((DateTime)val) != DateTime.MinValue) { node.SetAttributeValue("Date", ((DateTime)val).ToString(CultureInfo.InvariantCulture)); } break; case "Description": var mngr = new XmlNamespaceManager(new NameTable()); mngr.AddNamespace("", ns.NamespaceName); // or proper URL var parserContext = new XmlParserContext(null, mngr, null, XmlSpace.None, null); var txtReader = new XmlTextReader($"<Description>{val}</Description>", XmlNodeType.Element, parserContext); var ele = XElement.Load(txtReader); node.Add(ele); break; default: var xmlAttr = prop.GetAttributes <XmlAttributeAttribute>().FirstOrDefault(); if (xmlAttr != null) { string name = prop.Name; if (!String.IsNullOrWhiteSpace(xmlAttr.AttributeName)) { name = xmlAttr.AttributeName; } node.SetAttributeValue(name, val); } else { var elm = new XElement(prop.Name); if (obj != null) { Serializer.Serialize(elm, val, expectedType: prop.TypeDescriptor); } void SetNs(XElement e) { e.Name = ns + e.Name.LocalName; foreach (var n in e.Elements()) { SetNs(n); } } SetNs(elm); node.Add(elm); } break; } } node.SetAttributeValue("xmlns", ns); // ask the TestPlanPackageDependency serializer (the one that writes the // <Package.Dependencies> tag in the bottom of e.g. TestPlan files) to // not write the tag for this file. var depSerializer = Serializer.GetSerializer <TestPlanPackageDependency>(); if (depSerializer != null) { depSerializer.WritePackageDependencies = false; } return(true); }
public override bool Serialize(XElement node, object obj, ITypeData expectedType) { if (expectedType.IsA(typeof(PackageFile)) == false) { return(false); } foreach (IMemberData prop in expectedType.GetMembers().Where(s => !s.HasAttribute <XmlIgnoreAttribute>())) { object val = prop.GetValue(obj); string name = prop.Name; var defaultValueAttr = prop.GetAttribute <DefaultValueAttribute>(); if (defaultValueAttr != null) { if (Object.Equals(defaultValueAttr.Value, val)) { continue; } if (defaultValueAttr.Value == null) { var enu = val as IEnumerable; if (enu != null && enu.GetEnumerator().MoveNext() == false) // the value is an empty IEnumerable { continue; // We take an empty IEnumerable to be the same as null } } } if (name == "RelativeDestinationPath") { name = "Path"; } if (name == "DoObfuscate") { name = "Obfuscate"; } if (name == "Plugins") { XElement plugins = new XElement("Plugins"); Serializer.Serialize(plugins, val, prop.TypeDescriptor); node.Add(plugins); continue; } if (name == "IgnoredDependencies") { if (val is List <string> igDeps) { foreach (string igDep in igDeps) { node.Add(new XElement("IgnoreDependency") { Value = igDep }); } continue; } } if (name == "CustomData") { if (val is List <ICustomPackageData> packageActions) { foreach (ICustomPackageData action in packageActions) { if (action is MissingPackageData) { continue; } XElement xAction = new XElement(action.GetType().GetDisplayAttribute().Name); Serializer.Serialize(xAction, action, TypeData.GetTypeData(action)); node.Add(xAction); } } continue; } node.SetAttributeValue(name, val); } return(true); }
public override bool Deserialize(XElement node, ITypeData t, Action <object> setter) { if (node.Name.LocalName == "File" && t.IsA(typeof(PackageFile))) { PackageFile packageFile = new PackageFile(); foreach (XAttribute attr in node.Attributes()) { switch (attr.Name.LocalName) { case "Path": packageFile.RelativeDestinationPath = attr.Value; break; case "SourcePath": packageFile.SourcePath = attr.Value; break; case "LicenseRequired": packageFile.LicenseRequired = attr.Value; break; } } foreach (XElement elm in node.Elements()) { if (elm.Name.LocalName == "Plugins") { Serializer.Deserialize(elm, o => packageFile.Plugins = o as List <PluginFile>, typeof(List <PluginFile>)); continue; } if (elm.Name.LocalName == "IgnoreDependency") { packageFile.IgnoredDependencies.Add(elm.Value); continue; } var handlingPlugins = plugins.Where(s => s.GetType().GetDisplayAttribute().Name == elm.Name.LocalName).ToArray(); if (handlingPlugins.Length > 0) { if (handlingPlugins.Length > 1) { Log.Warning($"Detected multiple plugins able to handle XMl tag {elm.Name.LocalName}. Unexpected behavior may occur."); } ICustomPackageData p = handlingPlugins[0]; if (elm.HasAttributes || !elm.IsEmpty) { Serializer.Deserialize(elm, o => p = (ICustomPackageData)o, p.GetType()); } packageFile.CustomData.Add(p); continue; } packageFile.CustomData.Add(new MissingPackageData(elm)); } setter.Invoke(packageFile); return(true); } return(false); }