/// <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);
}
