// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Xml.Linq;
|
|
namespace OpenTap.Plugins
|
{
|
/// <summary> Serializer implementation for parameters. </summary>
|
[Display("Parameter Serializer", "Works with parameters in the test plan.")]
|
public class ExternalParameterSerializer : TapSerializerPlugin
|
{
|
/// <summary>
|
/// Structure for holding data about <see cref="TestPlan.ExternalParameters"/>
|
/// </summary>
|
public struct ExternalParamData
|
{
|
/// <summary>
|
/// The object
|
/// </summary>
|
public ITestStep Object;
|
/// <summary>
|
/// The external param property.
|
/// </summary>
|
public IMemberData Property;
|
/// <summary>
|
/// The name of the external test plan parameter.
|
/// </summary>
|
public string Name;
|
}
|
/// <summary> The order of this serializer. </summary>
|
public override double Order => 50;
|
|
List<XElement> currentNode = new List<XElement>();
|
|
/// <summary>
|
/// Stores the data if a test plan was not serialized but the external keyword was used.
|
/// </summary>
|
public readonly List<ExternalParamData> UnusedExternalParamData = new List<ExternalParamData>();
|
|
/// <summary>
|
/// Pre-Loaded external parameter Name/Value sets.
|
/// </summary>
|
public readonly Dictionary<string, string> PreloadedValues = new Dictionary<string, string>();
|
|
static readonly XName External = "external";
|
static readonly XName Scope = "Scope";
|
static readonly XName Parameter = "Parameter";
|
|
bool loadScopeParameter(Guid scope, ITestStep step, IMemberData member, string parameter)
|
{
|
ITestStepParent parent;
|
if (scope == Guid.Empty)
|
{
|
parent = step.GetParent<TestPlan>();
|
}
|
else
|
{
|
ITestStep subparent = step.Parent as ITestStep;
|
while (subparent != null)
|
{
|
if (subparent.Id == scope)
|
break;
|
subparent = subparent.Parent as ITestStep;
|
}
|
|
parent = subparent;
|
}
|
|
if (parent == null) return false;
|
var newParameter = member.Parameterize(parent, step, parameter);
|
if (newParameter.ParameterizedMembers.Skip(1).Any())
|
{
|
// merge occured. See similar code in ExternalParameters.
|
if (ParameterManager.UnmergableListType(newParameter))
|
{
|
member.Unparameterize(newParameter, step);
|
Log.Warning("Unable merge parameters {0}, since their types do not support it.", parameter);
|
}
|
}
|
|
return true;
|
}
|
|
void loadPreloadedvalues(TestPlan plan)
|
{
|
foreach (var value in PreloadedValues)
|
{
|
var ext = plan.ExternalParameters.Get(value.Key);
|
if (ext == null) continue;
|
try
|
{
|
ext.Value = value.Value;
|
}
|
catch
|
{
|
|
}
|
}
|
|
// Update all external parameter values.
|
// This is generally redundant, since they were all serialized with the same values.
|
// but just to be sure.
|
foreach (var extParam in plan.ExternalParameters.Entries)
|
extParam.Value = extParam.Value;
|
}
|
|
XElement rootNode;
|
/// <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.
|
// This should be ensured by DeferredLoadOrder.Last, so we should make sure not to use this priority for other things.
|
Serializer.DeferLoad(() =>
|
{
|
loadPreloadedvalues(_plan);
|
}, TapSerializer.DeferredLoadOrder.ExternalParameter);
|
|
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];
|
});
|
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);
|
}
|
}
|
|
/// <summary>
|
/// This dictionary is used to cache which parent steps point to which child test steps via a parameter.
|
/// Hence it maps (step,member) to (parent, member).
|
/// </summary>
|
Dictionary<(object step, IMemberData member), (object parent, ParameterMemberData parentMember)> parameterReverseLookup =
|
new Dictionary<(object step, IMemberData member), (object parent, ParameterMemberData parentMember)>();
|
HashSet<ITestStepParent> reversedParents = new HashSet<ITestStepParent>();
|
|
/// <summary> Serialization implementation. </summary>
|
public override bool Serialize( XElement elem, object obj, ITypeData expectedType)
|
{
|
if (currentNode.Contains(elem)) return false;
|
|
|
var objSerializer = Serializer.SerializerStack.OfType<IConstructingSerializer>().FirstOrDefault();
|
if (objSerializer?.CurrentMember == null || false == objSerializer.Object is ITestStep)
|
return false;
|
|
|
ITestStep step = (ITestStep)objSerializer.Object;
|
|
var member = objSerializer.CurrentMember;
|
// here I need to check if any of its parent steps are forwarding
|
// its member data.
|
|
{
|
// update reverse lookup.
|
ITestStepParent parameterParent = step.Parent;
|
while (parameterParent != null)
|
{
|
if (reversedParents.Add(parameterParent))
|
{
|
var parameters = TypeData.GetTypeData(parameterParent)
|
.GetMembers()
|
.OfType<ParameterMemberData>();
|
|
foreach (var parameter in parameters)
|
{
|
foreach (var set in parameter.ParameterizedMembers)
|
parameterReverseLookup.Add(set, (parameterParent, parameter));
|
}
|
|
parameterParent = parameterParent.Parent;
|
}
|
else
|
{
|
break;
|
}
|
}
|
}
|
|
if (parameterReverseLookup.TryGetValue(((object)step, member), out (object parameterParent, ParameterMemberData parameterMember) parentMember) == false) return false;
|
|
elem.SetAttributeValue(Parameter, parentMember.parameterMember.Name);
|
if (parentMember.parameterParent is ITestStep parentStep)
|
elem.SetAttributeValue(Scope, parentStep.Id.ToString());
|
// skip
|
try
|
{
|
currentNode.Add(elem);
|
return Serializer.Serialize(elem, obj, expectedType);
|
}
|
finally
|
{
|
currentNode.Remove(elem);
|
}
|
}
|
}
|
}
|
