/// <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); } }
public TestStepTypeData(ITypeData innerType) { this.innerType = innerType; if (innerType.DescendsTo(typeof(TestPlan))) { members = extraMembersTestPlan; } else { members = extraMembers; } }
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> Deserialization implementation. </summary> public override bool Deserialize(XElement elem, ITypeData t, Action <object> setResult) { if (t.DescendsTo(typeof(ITestStep))) { if (elem.HasElements == false) { Guid stepGuid; if (Guid.TryParse(elem.Value, out stepGuid)) { Serializer.DeferLoad(() => { if (stepLookup.ContainsKey(stepGuid)) { setResult(stepLookup[stepGuid]); } else { Log.Warning("Unable to find referenced step {0}", stepGuid); } }); return(true); } } else { if (currentNode.Contains(elem)) { return(false); } ITestStep step = null; currentNode.Add(elem); try { if (Serializer.Deserialize(elem, x => step = (ITestStep)x, t)) { setResult(step); FixupStep(step, true); return(true); } }finally { currentNode.Remove(elem); } return(false); } } return(false); }
/// <summary> Deserialization implementation. </summary> public override bool Deserialize(XElement element, ITypeData t, Action <object> setter) { if (t.DescendsTo(TypeData.FromType(typeof(IConstResourceProperty)))) { if (element.IsEmpty) { return(true); // Dont do anything with a <port/> } var name = element.Attribute("Name"); if (name == null) { return(true); } Serializer.Deserialize(element.Element("Device"), obj => { var resource = obj as IResource; if (obj is ComponentSettings) { // for legacy support. type argument was a component settings, not a device. In this case used index to get the resource. obj = ComponentSettings.GetCurrent(obj.GetType()); var lst = (IList)obj; var dev = element.Element("Device"); if (dev != null && int.TryParse(dev.Value, out int index) && index >= 0 && lst.Count > index) { resource = ((IList)obj)[index] as IResource; } } if (resource == null) { return; } foreach (var resProp in resource.GetConstProperties()) { if (TypeData.GetTypeData(resProp).DescendsTo(t) && resProp.Name == name.Value) { setter(resProp); return; } } }, typeof(IResource)); return(true); } return(false); }
public bool Deserialize(XElement node, ITypeData t, Action <object> setter) { // 1. 'Iterate and Replace' if the node is the test plan node, we want to find all test step sub-nodes and replace the types. if (t.DescendsTo(typeof(TestPlan))) { iterateAndReplaceTypesInXml(node, node); } else if (node.Attribute(postScaleAttr) is XAttribute attribute) { // 2. do post-scaling. // when the old step was detected the property was marked with this post-scale attribute to show that it should scale it after deserialization. // this is because the old step used milliseconds, but the new one uses seconds. attribute.Remove(); // remove the attribute to avoid hitting this again. // this new setter applies the post-scaling that was added to the attributes during 'iterate and replace'. Action <object> newSetter = x => setter(double.Parse(x.ToString()) * double.Parse(attribute.Value)); // call the deserializer to actually deserialize the property, but direct it to use the new setter instead of the original. return(TapSerializer.GetCurrentSerializer().Deserialize(node, newSetter, t)); } return(false); }
/// <summary> Deserialization implementation. </summary> public override bool Deserialize(XElement elem, ITypeData t, Action <object> setter) { if (rootNode == null && t.DescendsTo(typeof(TestPlan))) { rootNode = elem; TestPlan _plan = null; bool ok = Serializer.Deserialize(elem, x => { _plan = (TestPlan)x; setter(_plan); }, t); // preloaded values should be handled as the absolute last thing // 2x Defer is used to ensure that there's a very little chance that it will be overwritten // but idealy there should be a way for ordering defers. Serializer.DeferLoad(() => { loadPreloadedvalues(_plan); Serializer.DeferLoad(() => loadPreloadedvalues(_plan)); }); return(ok); } if (elem.HasAttributes == false || currentNode.Contains(elem)) { return(false); } var parameter = elem.Attribute(External)?.Value ?? elem.Attribute(Parameter)?.Value; if (string.IsNullOrWhiteSpace(parameter)) { return(false); } var stepSerializer = Serializer.SerializerStack.OfType <ObjectSerializer>().FirstOrDefault(); var step = stepSerializer?.Object as ITestStep; if (step == null) { return(false); } var member = stepSerializer.CurrentMember; Guid.TryParse(elem.Attribute(Scope)?.Value, out Guid scope); if (!loadScopeParameter(scope, step, member, parameter)) { Serializer.DeferLoad(() => loadScopeParameter(scope, step, member, parameter)); } if (scope != Guid.Empty) { return(false); } var plan = Serializer.SerializerStack.OfType <TestPlanSerializer>().FirstOrDefault()?.Plan; if (plan == null) { currentNode.Add(elem); try { UnusedExternalParamData.Add(new ExternalParamData { Object = (ITestStep)stepSerializer.Object, Property = stepSerializer.CurrentMember, Name = parameter }); return(Serializer.Deserialize(elem, setter, t)); } finally { currentNode.Remove(elem); } } currentNode.Add(elem); try { bool ok = Serializer.Deserialize(elem, setter, t); var ext = plan.ExternalParameters.Get(parameter); Serializer.DeferLoad(() => { var ext2 = plan.ExternalParameters.Get(parameter); if (ext2 == null) { return; } if (PreloadedValues.ContainsKey(ext2.Name)) { // If there is a preloaded value, use that. ext2.Value = PreloadedValues[ext2.Name]; } else { ext2.Value = ext2.Value; } }); if (ext != null && PreloadedValues.ContainsKey(ext.Name)) { // If there is a preloaded value, use that. ext.Value = PreloadedValues[ext.Name]; } return(ok); } finally { currentNode.Remove(elem); } }
public override bool Deserialize(XElement node, ITypeData t, Action <object> setter) { if (t.DescendsTo(typeof(ITestStepParent)) == false) { return(false); } if (node.Element(stepInputsName) is XElement subelems && activeElements.Contains(node) == false) { var tps = Serializer.GetSerializer <TestPlanSerializer>(); ITestStepParent step = null; var prevsetter = setter; setter = x => prevsetter(step = x as ITestStepParent); var plan = tps.Plan; InputOutputMember[] items = null; if (tps != null && Serializer.Deserialize(subelems, x => items = (InputOutputMember[])x, TypeData.FromType(typeof(InputOutputMember[])))) { bool ok = false; activeElements.Add(node); try { ok = Serializer.Deserialize(node, setter, t); } catch { activeElements.Remove(node); } void connectInputs() { if (step == null) { return; } foreach (var elem in items) { ITestStepParent source; if (elem.Id == Guid.Empty) { source = plan; } else { source = plan.ChildTestSteps.GetStep(elem.Id); } var sourceType = TypeData.GetTypeData(source); var targetType = TypeData.GetTypeData(step); var sourceMember = sourceType.GetMember(elem.Member); var targetMember = targetType.GetMember(elem.TargetMember); if (sourceMember != null && targetMember != null) { InputOutputRelation.Assign(step, targetMember, source, sourceMember); } } } if (ok) { Serializer.DeferLoad(connectInputs); } return(ok); } } return(false); }