using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Collections.Immutable;
|
using System.ComponentModel;
|
using System.Diagnostics;
|
using System.Linq;
|
using System.Runtime.CompilerServices;
|
using System.Xml.Serialization;
|
|
|
namespace OpenTap
|
{
|
/// <summary> This interface speeds up accessing dynamic members as it avoids having to access a global table to store the information. </summary>
|
interface IDynamicMembersProvider
|
{
|
IImmutableDictionary<string, IMemberData> DynamicMembers { get; set; }
|
}
|
|
interface IDynamicMemberValue
|
{
|
// this value is incremented whenever new dynamic members are added or removed.
|
int TypeDataKey { get; set; }
|
bool TryGetValue(IMemberData member, out object value);
|
void SetValue(IMemberData member, object value);
|
}
|
|
/// <summary> Extensions for parameter operations. </summary>
|
public static class ParameterExtensions
|
{
|
/// <summary> Parameterizes a member from one object unto another.
|
/// If the name matches an existing parameter, the member will be added to that. </summary>
|
/// <param name="target"> The object on which to add a new member. </param>
|
/// <param name="member"> The member to forward. </param>
|
/// <param name="source"> The owner of the forwarded member. </param>
|
/// <param name="name"> The name of the new property. If null, the name of the source member will be used.</param>
|
/// <returns>The parameterization of the member..</returns>
|
public static ParameterMemberData Parameterize(this IMemberData member, object target, object source, string name)
|
{
|
return DynamicMember.ParameterizeMember(target, member, source, name);
|
}
|
|
/// <summary> Removes a parameterization of a member. </summary>
|
/// <param name="parameterizedMember"> The parameterized member owned by the source. </param>
|
/// <param name="parameter"> The parameter to remove it from.</param>
|
/// <param name="source"> The source of the member. </param>
|
public static void Unparameterize(this IMemberData parameterizedMember, ParameterMemberData parameter, object source)
|
{
|
DynamicMember.UnparameterizeMember(parameter, parameterizedMember, source);
|
}
|
|
/// <summary>
|
/// Finds the parameter that parameterizes this member on 'source'. If no parameter is found null is returned.
|
/// </summary>
|
/// <param name="target"> The object owning the parameter.</param>
|
/// <param name="source"> The source of the member. </param>
|
/// <param name="parameterizedMember"> The parameterized member owned by the source. </param>
|
/// <returns></returns>
|
internal static IParameterMemberData GetParameter(this IMemberData parameterizedMember, object target, object source)
|
{
|
if (source == null)
|
throw new ArgumentNullException(nameof(source));
|
if (parameterizedMember == null)
|
throw new ArgumentNullException(nameof(parameterizedMember));
|
|
var parameterMembers = TypeData.GetTypeData(target).GetMembers().OfType<IParameterMemberData>();
|
foreach (var fwd in parameterMembers)
|
{
|
if (fwd.ContainsMember((source, parameterizedMember)))
|
return fwd;
|
}
|
return null;
|
}
|
|
/// <summary> Returns true if a member is parameters </summary>
|
public static bool IsParameterized(this IMemberData member, object source) =>
|
DynamicMember.IsParameterized(member, source);
|
}
|
|
/// <summary>
|
/// A member that represents a parameter. The parameter controls the value of a set of parameterized members.
|
/// Parameterized members can be added/removed using IMemberData.Parameterize() and IMemberData.Unparameterize()
|
/// </summary>
|
/// <remarks>
|
/// The first member have special meaning since it decides which attributes the parameter will have.
|
/// If the member is later removed from the parameter (unparameterized), the first additional member will take its place.
|
/// </remarks>
|
public class ParameterMemberData : IParameterMemberData, IDynamicMemberData
|
{
|
internal ParameterMemberData(object target, object source, IMemberData member, string name)
|
{
|
var names = name.Split('\\');
|
Target = target;
|
DeclaringType = TypeData.GetTypeData(target);
|
parameterMembers = new ParameterMembers(source, member, ImmutableHashSet<(object Source, IMemberData Member)>.Empty);
|
|
Name = name;
|
|
var disp = member.GetDisplayAttribute();
|
|
var displayName = names[names.Length - 1].Trim();
|
var displayGroup = names.Take(names.Length - 1).Select(x => x.Trim()).ToArray();
|
|
displayAttribute = new DisplayAttribute(displayName, disp.Description, Order: -5, Groups: displayGroup);
|
}
|
|
readonly DisplayAttribute displayAttribute;
|
object[] attributes;
|
/// <summary> Gets the attributes on this member. </summary>
|
public IEnumerable<object> Attributes
|
{
|
get
|
{
|
if (attributes != null) return attributes;
|
// copy all attributes from first member.
|
// if there is no display attribute, create one.
|
bool found = false;
|
|
// remove the attributes that should not follow the
|
static bool FilterAttributes(object attr)
|
{
|
switch (attr)
|
{
|
case ColumnDisplayNameAttribute: return false;
|
case ExternalParameterAttribute: return false;
|
default: return true;
|
}
|
}
|
|
var attrs = member.Attributes.Where(FilterAttributes).ToArray();
|
for (int i = 0; i < attrs.Length; i++)
|
{
|
if (false == (attrs[i] is DisplayAttribute))
|
continue;
|
attrs[i] = displayAttribute;
|
found = true;
|
break;
|
}
|
|
if (!found)
|
Sequence.Append(ref attrs, displayAttribute);
|
return attributes = attrs;
|
}
|
}
|
|
/// <summary> The target object to which this member is added.
|
/// This should always be the same as the argument to GetValue/SetValue. </summary>
|
internal object Target { get; }
|
|
/// <summary> Immutable data structure for managing parameter members. </summary>
|
// implementing ICollection gives performance benefits for calling Enumerable.Contains
|
readonly struct ParameterMembers : ICollection<(object, IMemberData)>
|
{
|
public readonly object Source;
|
public readonly IMemberData Member;
|
public readonly ImmutableHashSet<(object Source, IMemberData Member)> Additional;
|
|
public ParameterMembers(object source, IMemberData member, ImmutableHashSet<(object Source, IMemberData Member)> additionalMembers)
|
{
|
Source = source;
|
Member = member;
|
Additional = additionalMembers;
|
if (source != null)
|
Count = additionalMembers.Count + 1;
|
else
|
Count = 0;
|
}
|
|
public ParameterMembers Add(object newSource, IMemberData newMember)
|
{
|
if (Equals(newSource, Source) && Equals(newMember, Member))
|
return this;
|
|
return new ParameterMembers(Source, Member, Additional.Add((newSource, newMember)));
|
}
|
|
public ParameterMembers Remove(object removeSource, IMemberData removeMember)
|
{
|
if (Equals(Source, removeSource) && Equals(Member, removeMember))
|
{
|
if (Additional.IsEmpty)
|
{
|
return new ParameterMembers(null, removeMember, ImmutableHashSet<(object Source, IMemberData Member)>.Empty);
|
}
|
var fst = Additional.First();
|
return new ParameterMembers(fst.Source, fst.Member, Additional.Remove(fst));
|
}
|
return new ParameterMembers(Source,Member , Additional.Remove((removeSource, removeMember)));
|
}
|
|
public IEnumerator<(object, IMemberData)> GetEnumerator()
|
{
|
if (Source != null)
|
{
|
yield return (Source, Member);
|
|
foreach (var member in Additional)
|
yield return member;
|
}
|
}
|
|
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
|
|
public bool Contains(object findSource, IMemberData findMember) => Equals(findSource, Source) && Equals(findMember, Member) || Additional.Contains((findSource, findMember));
|
public void Add((object, IMemberData) item)
|
{
|
throw new NotSupportedException("This class is readonly, create a new instance instead.");
|
}
|
public void Clear()
|
{
|
throw new NotSupportedException("This class is readonly, create a new instance instead.");
|
}
|
public bool Contains((object, IMemberData) item) => Contains(item.Item1, item.Item2);
|
|
public void CopyTo((object, IMemberData)[] array, int arrayIndex)
|
{
|
array[arrayIndex] = (Source, Member);
|
foreach (var elem in Additional)
|
{
|
arrayIndex++;
|
array[arrayIndex] = elem;
|
}
|
}
|
public bool Remove((object, IMemberData) item)
|
{
|
throw new NotSupportedException("This class is readonly, create a new instance instead.");
|
}
|
public int Count { get; }
|
public bool IsReadOnly => true;
|
}
|
|
ParameterMembers parameterMembers;
|
object source => parameterMembers.Source;
|
IMemberData member => parameterMembers.Member;
|
IEnumerable<(object Source, IMemberData Member)> additionalMembers => parameterMembers.Additional;
|
|
/// <summary> Gets the value of this member. </summary>
|
public object GetValue(object owner)
|
{
|
Debug.Assert(source != null, "Using deleted parameter member data.");
|
return member.GetValue(source);
|
}
|
|
/// <summary> Sets the value of this member on the owner. </summary>
|
public void SetValue(object owner, object value)
|
{
|
// this gets a bit complicated now.
|
// we have to ensure that the value is not just same object type, but not the same object
|
// in some cases. Hence we need special cloning of the value.
|
|
var cloner = new ObjectCloner(value);
|
|
member.SetValue(source, cloner.Clone(true, source, member.TypeDescriptor));
|
|
foreach (var (addContext, addMember) in additionalMembers)
|
{
|
var cloned = cloner.Clone(false, addContext, addMember.TypeDescriptor);
|
if (cloned != null)
|
addMember.SetValue(addContext, cloned); // This will throw an exception if it is not assignable.
|
}
|
}
|
|
/// <summary> The members and objects that make up the aggregation of this parameter. </summary>
|
public IEnumerable<(object Source, IMemberData Member)> ParameterizedMembers => parameterMembers;
|
|
|
internal bool ContainsMember(object Source, IMemberData Member) => parameterMembers.Contains(Source, Member);
|
|
/// <summary> The target object type. </summary>
|
public ITypeData DeclaringType { get; }
|
|
/// <summary> The declared type of this property. This is the type of the first member added to the parameter.
|
/// Subsequent members does not need to have the same type, but they should be conversion compatible. e.g
|
/// if the first member is an int, subsequent members can be other numeric types or string as well. </summary>
|
public ITypeData TypeDescriptor => member.TypeDescriptor;
|
|
/// <summary> If this member is writable. Usually true for parameters.</summary>
|
public bool Writable => member.Writable;
|
/// <summary> If this member is readable. Usually true for parameters. </summary>
|
public bool Readable => member.Readable;
|
/// <summary> The declared name of this parameter. This parameter can be referred to by this name. It may contain spaces etc. </summary>
|
public string Name { get; }
|
|
internal void AddAdditionalMember(object newSource, IMemberData newMember)
|
{
|
if (source == newSource && newMember == member)
|
throw new Exception("Member is already parameterized.");
|
|
parameterMembers = parameterMembers.Add(newSource, newMember);
|
}
|
|
/// <summary>
|
/// Removes a forwarded member. If it was the original member, the first additional member will be used.
|
/// If no additional members are present, then true will be returned, signalling that the forwarded member no longer exists.
|
/// </summary>
|
/// <param name="delMember">The forwarded member.</param>
|
/// <param name="delSource">The object owning 'delMember'</param>
|
/// <returns>True if the last member/source pair has been removed. If this happens the parameter should be removed
|
/// from the target object.</returns>
|
internal bool RemoveMember(IMemberData delMember, object delSource)
|
{
|
var count = parameterMembers.Count;
|
parameterMembers = parameterMembers.Remove(delSource, delMember);
|
var newCount = parameterMembers.Count;
|
if (count != newCount)
|
{
|
if(newCount == 0)
|
DynamicMember.RemoveDynamicMember(Target, this);
|
return true;
|
}
|
return false;
|
}
|
|
/// <summary> Completely removes the parameter from a type. </summary>
|
public void Remove()
|
{
|
var oldMembers = parameterMembers;
|
parameterMembers = new ParameterMembers();
|
foreach (var member in oldMembers)
|
{
|
DynamicMember.UnregisterParameter(member.Item2, member.Item1, this);
|
}
|
|
DynamicMember.RemoveDynamicMember(Target, this);
|
}
|
|
bool IDynamicMemberData.IsDisposed => source == null;
|
|
// it can be useful to know if there are any dynamic members because it
|
// can make the sanity checks a lot faster.
|
internal bool AnyDynamicMembers => parameterMembers.Count > 0;
|
}
|
|
class AcceleratedDynamicMember<TAccel> : DynamicMember
|
{
|
|
public Func<object, object> ValueGetter;
|
public Action<object, object> ValueSetter;
|
|
public override void SetValue(object owner, object value)
|
{
|
if (owner is TAccel)
|
ValueSetter(owner, value);
|
else
|
base.SetValue(owner, value);
|
}
|
|
public override object GetValue(object owner)
|
{
|
if (owner is TAccel)
|
return ValueGetter(owner);
|
return base.GetValue(owner);
|
}
|
}
|
|
/// <summary> Dynamic Member</summary>
|
public class DynamicMember : IMemberData
|
{
|
/// <summary> Attributes </summary>
|
public virtual IEnumerable<object> Attributes { get; set; } = Array.Empty<object>();
|
/// <summary> Name of the member </summary>
|
public string Name { get; set; }
|
/// <summary> Declaring type. This should be the type of the target object. </summary>
|
public ITypeData DeclaringType { get; set; }
|
/// <summary> Describes the value of the member. </summary>
|
public ITypeData TypeDescriptor { get; set; }
|
/// <summary> If the member is writable. </summary>
|
public bool Writable { get; set; }
|
/// <summary> If the member is readable. This should generally be true. </summary>
|
public bool Readable { get; set; }
|
|
/// <summary> The default value of the member. </summary>
|
public object DefaultValue { get; set; }
|
|
readonly ConditionalWeakTable<object, object> valueLookup = new ConditionalWeakTable<object, object>();
|
|
/// <summary>
|
/// Creates an instance of the dynamic member.
|
/// </summary>
|
public DynamicMember()
|
{
|
|
}
|
/// <summary> This overload allows two DynamicMembers to share the same Get/Set value backing field.</summary>
|
/// <param name="base"></param>
|
public DynamicMember(DynamicMember @base)
|
{
|
valueLookup = @base.valueLookup;
|
}
|
|
|
/// <summary> Sets the value of the member. </summary>
|
public virtual void SetValue(object owner, object value)
|
{
|
if (owner is IDynamicMemberValue dmv)
|
{
|
dmv.SetValue(this, value);
|
return;
|
}
|
valueLookup.Remove(owner);
|
if (Equals(value, DefaultValue) == false)
|
valueLookup.Add(owner, value);
|
}
|
|
/// <summary> Gets the value of the member. </summary>
|
public virtual object GetValue(object owner)
|
{
|
if (owner is IDynamicMemberValue dmv)
|
{
|
if (dmv.TryGetValue(this, out var value2))
|
return value2;
|
return DefaultValue;
|
}
|
|
if (valueLookup.TryGetValue(owner, out object value))
|
return value ?? DefaultValue;
|
return DefaultValue;
|
}
|
|
class KeyBox
|
{
|
public int Key { get; set; }
|
}
|
static ConditionalWeakTable<object, KeyBox> typeDataKeys = new ConditionalWeakTable<object, KeyBox>();
|
|
internal static int GetTypeDataKey(object target)
|
{
|
if (target is IDynamicMemberValue dv)
|
return dv.TypeDataKey;
|
if (typeDataKeys.TryGetValue(target, out var box))
|
return box.Key;
|
return 0;
|
}
|
|
internal static void BumpTypeDataKey(object target)
|
{
|
if (target is IDynamicMemberValue dv)
|
dv.TypeDataKey += 1;
|
else if (typeDataKeys.TryGetValue(target, out var box))
|
box.Key += 1;
|
else
|
typeDataKeys.Add(target, new KeyBox { Key = 1 });
|
}
|
|
/// <summary> Adds a dynamic member to the object. </summary>
|
public static void AddDynamicMember(object target, IMemberData member)
|
{
|
var members = (ImmutableDictionary<string, IMemberData>)DynamicMemberTypeDataProvider.TestStepTypeData.DynamicMembers.GetValue(target);
|
var newMembers = members.SetItem(member.Name, member);
|
DynamicMemberTypeDataProvider.TestStepTypeData.DynamicMembers.SetValue(target, newMembers);
|
BumpTypeDataKey(target);
|
}
|
|
/// <summary> Removes a dynamic member to the object. </summary>
|
public static void RemoveDynamicMember(object target, IMemberData member)
|
{
|
var members = (ImmutableDictionary<string, IMemberData>)DynamicMemberTypeDataProvider.TestStepTypeData.DynamicMembers.GetValue(target);
|
DynamicMemberTypeDataProvider.TestStepTypeData.DynamicMembers.SetValue(target, members.Remove(member.Name));
|
BumpTypeDataKey(target);
|
}
|
|
/// <summary> Returns all members of an object. </summary>
|
internal static IEnumerable<IMemberData> GetDynamicMembers(object target)
|
{
|
var members = (ImmutableDictionary<string, IMemberData>)DynamicMemberTypeDataProvider.TestStepTypeData.DynamicMembers.GetValue(target);
|
return members.Values;
|
}
|
|
/// <summary> the test plan stores a hashset of all current parameterizations, so this can be used
|
/// to check if something is already parameterized.</summary>
|
static TestPlan GetPlanFor(object source)
|
{
|
while (source is ITestStepParent source2)
|
{
|
if (source is TestPlan plan) return plan;
|
source = source2.Parent;
|
}
|
|
return null;
|
}
|
|
static void registerParameter(IMemberData member, object source, ParameterMemberData parameter)
|
{
|
if (source is IParameterizedMembersCache cache)
|
cache.RegisterParameterizedMember(member, parameter);
|
else
|
GetPlanFor(source)?.RegisterParameter(member, source);
|
}
|
internal static void UnregisterParameter(IMemberData member, object source, ParameterMemberData parameter)
|
{
|
if (source is IParameterizedMembersCache cache)
|
cache.UnregisterParameterizedMember(member, parameter);
|
else
|
GetPlanFor(source)?.UnregisterParameter(member, source);
|
}
|
|
static bool isRegisteredParameter(IMemberData member, object source)
|
{
|
if (source is IParameterizedMembersCache cache)
|
return cache.GetParameterFor(member) != null;
|
return GetPlanFor(source)?.IsRegistered(member, source) ?? false;
|
}
|
|
|
internal static ParameterMemberData ParameterizeMember(object target, IMemberData member, object source, string name)
|
{
|
if (target == null) throw new ArgumentNullException(nameof(target));
|
if (member == null) throw new ArgumentNullException(nameof(member));
|
if (source == null) throw new ArgumentNullException(nameof(source));
|
if (name == null) throw new ArgumentNullException(nameof(name));
|
if (source == target) throw new InvalidOperationException("Source and target cannot be the same object.");
|
if (name.Length == 0) throw new ArgumentException("Cannot be an empty string.", nameof(name));
|
{ // Verify that the member belongs to the type.
|
var sourceType = TypeData.GetTypeData(source);
|
if (!sourceType.GetMembers().Contains(member))
|
throw new ArgumentException("The member does not belong to the source object type");
|
}
|
if (IsParameterized(member, source))
|
{
|
bool bad = true;
|
if (source is IParameterizedMembersCache cache)
|
{
|
// this is a rare case that can occur if a test step has been
|
// in two different test plans and the old parameters are lingering in the old plan.
|
// in this case try to fix the parameterized state by
|
// checking for parameter sanity.
|
var param = cache.GetParameterFor(member);
|
ParameterManager.CheckParameterSanity(param, true);
|
bad = IsParameterized(member, source);
|
}
|
if (bad)
|
throw new Exception("the member is already parameterized");
|
}
|
|
if (member.HasAttribute<UnparameterizableAttribute>())
|
throw new ArgumentException("Member cannot be parameterized", nameof(member));
|
|
var targetType = TypeData.GetTypeData(target);
|
using (ParameterManager.WithSanityCheckDelayed())
|
{
|
var existingMember = targetType.GetMember(name);
|
|
if (existingMember == null)
|
{
|
var newMember = new ParameterMemberData(target, source, member, name);
|
|
AddDynamicMember(target, newMember);
|
registerParameter(member, source, newMember);
|
return newMember;
|
}
|
|
if (existingMember is ParameterMemberData fw)
|
{
|
fw.AddAdditionalMember(source, member);
|
registerParameter(member, source, fw);
|
return fw;
|
}
|
|
throw new Exception("A member by that name already exists.");
|
}
|
}
|
|
internal static void UnparameterizeMember(ParameterMemberData parameterMember, IMemberData member, object source)
|
{
|
if (parameterMember == null) throw new ArgumentNullException(nameof(parameterMember));
|
if (parameterMember == null)
|
throw new Exception($"Member {parameterMember.Name} is not a forwarded member.");
|
|
parameterMember.RemoveMember(member, source);
|
UnregisterParameter(member, source, parameterMember);
|
}
|
|
/// <summary>
|
/// Returns true if the member/object combination is parameterized. Note, this only work if they are child steps of a test plan.
|
/// </summary>
|
internal static bool IsParameterized(IMemberData member, object obj) => isRegisteredParameter(member, obj);
|
}
|
|
class DynamicMemberTypeDataProvider : IStackedTypeDataProvider
|
{
|
class BreakConditionDynamicMember : DynamicMember
|
{
|
public BreakConditionDynamicMember(DynamicMember breakConditions) : base(breakConditions)
|
{
|
|
}
|
|
public BreakConditionDynamicMember()
|
{
|
|
}
|
|
public override void SetValue(object owner, object value)
|
{
|
if (owner is IBreakConditionProvider bc)
|
{
|
bc.BreakCondition = (BreakCondition)value;
|
return;
|
}
|
|
base.SetValue(owner, value);
|
}
|
|
public override object GetValue(object owner)
|
{
|
if (owner is IBreakConditionProvider bc)
|
return bc.BreakCondition;
|
return base.GetValue(owner);
|
}
|
}
|
|
|
class DescriptionDynamicMember : DynamicMember
|
{
|
public override void SetValue(object owner, object value)
|
{
|
if (owner is IDescriptionProvider bc)
|
{
|
bc.Description = (string)value;
|
return;
|
}
|
|
base.SetValue(owner, value);
|
}
|
|
public override object GetValue(object owner)
|
{
|
string result;
|
if (owner is IDescriptionProvider bc)
|
result = bc.Description;
|
else
|
result = (string)base.GetValue(owner);
|
if (result == null)
|
result = TypeData.GetTypeData(owner).GetDisplayAttribute().Description;
|
return result;
|
}
|
}
|
|
class DynamicMembersMember : DynamicMember
|
{
|
public override void SetValue(object owner, object value)
|
{
|
if (owner is IDynamicMembersProvider bc)
|
{
|
bc.DynamicMembers = (IImmutableDictionary<string, IMemberData>)value;
|
return;
|
}
|
|
base.SetValue(owner, value);
|
}
|
|
public override object GetValue(object owner)
|
{
|
IImmutableDictionary<string, IMemberData> result;
|
if (owner is IDynamicMembersProvider bc)
|
result = bc.DynamicMembers;
|
else
|
result = (IImmutableDictionary<string, IMemberData>)base.GetValue(owner);
|
|
return result;
|
}
|
}
|
|
public class DynamicTestStepTypeData : ITypeData
|
{
|
public DynamicTestStepTypeData(TestStepTypeData innerType, object target)
|
{
|
BaseType = innerType;
|
this.target = target;
|
}
|
|
readonly object target;
|
|
public IEnumerable<object> Attributes => BaseType.Attributes;
|
public string Name => BaseType.Name;
|
public ITypeData BaseType { get; }
|
|
IDictionary<string, IMemberData> getDynamicMembers()
|
{
|
var dynamicMembers = (IDictionary<string, IMemberData>)TestStepTypeData.DynamicMembers.GetValue(target);
|
// dynamicMembers can be null after the last element is removed.
|
if (dynamicMembers == null) return EmptyDictionary<string, IMemberData>.Instance;
|
if (target is ITestStepParent step)
|
{
|
// if it is a test step type, check that the parameters declared on a parent step
|
// actually comes from a child step.
|
if (!ParameterManager.CheckParameterSanity(step, dynamicMembers.Values))
|
{
|
// members modified, reload.
|
dynamicMembers = (IDictionary<string, IMemberData>)TestStepTypeData.DynamicMembers.GetValue(target);
|
}
|
}
|
|
return dynamicMembers ?? EmptyDictionary<string, IMemberData>.Instance;
|
}
|
|
public IEnumerable<IMemberData> GetMembers()
|
{
|
var dynamicMembers = getDynamicMembers();
|
var members = BaseType.GetMembers();
|
if (dynamicMembers.Count > 0)
|
members = members.Concat(dynamicMembers.Values);
|
return members;
|
}
|
|
public IMemberData GetMember(string name)
|
{
|
var extra = getDynamicMembers();
|
if (extra.TryGetValue(name, out var value))
|
return value;
|
return BaseType.GetMember(name);
|
}
|
|
public object CreateInstance(object[] arguments) => BaseType.CreateInstance(arguments);
|
|
public bool CanCreateInstance => BaseType.CanCreateInstance;
|
|
public override string ToString() => "*" + BaseType;
|
|
public override bool Equals(object obj)
|
{
|
if (obj is DynamicTestStepTypeData other)
|
return Equals(other.target, target) && Equals(other.BaseType, BaseType);
|
|
return false;
|
}
|
|
public override int GetHashCode()
|
{
|
// Random factors for hashing (primes to reduce the risk of collision).
|
return ((((BaseType?.GetHashCode() ?? 0) + 86533973) * 25714789 + (target?.GetHashCode() ?? 0) + 67186051) * 63349417);
|
}
|
}
|
|
internal class TestStepTypeData : ITypeData, INotifyDynamicTypeChanged
|
{
|
internal static readonly DynamicMember BreakConditions = new BreakConditionDynamicMember
|
{
|
Name = nameof(BreakConditions),
|
DefaultValue = BreakCondition.Inherit,
|
Attributes = new Attribute[]
|
{
|
new DisplayAttribute("Break Conditions",
|
"When enabled, specify new break conditions. When disabled conditions are inherited from the parent test step, test plan, or engine settings.",
|
"Common", 20001.1),
|
new UnsweepableAttribute(),
|
new NonMetaDataAttribute(),
|
new DefaultValueAttribute(BreakCondition.Inherit)
|
},
|
DeclaringType = TypeData.FromType(typeof(ITestStep)),
|
Readable = true,
|
Writable = true,
|
TypeDescriptor = TypeData.FromType(typeof(BreakCondition))
|
};
|
|
/// <summary>
|
/// This is slightly different from normal BreakConditions as the Display attribute is different.
|
/// </summary>
|
internal static readonly DynamicMember TestPlanBreakConditions = new BreakConditionDynamicMember(BreakConditions)
|
{
|
Name = nameof(BreakConditions),
|
DefaultValue = BreakCondition.Inherit,
|
Attributes = new Attribute[]
|
{
|
new DisplayAttribute("Break Conditions",
|
"When enabled, specify new break conditions. When disabled conditions are inherited from the engine settings.", Order: 3),
|
new UnsweepableAttribute(), new EnabledIfAttribute("Locked", false), new NonMetaDataAttribute(), new DefaultValueAttribute(BreakCondition.Inherit)
|
},
|
DeclaringType = TypeData.FromType(typeof(TestPlan)),
|
Readable = true,
|
Writable = true,
|
TypeDescriptor = TypeData.FromType(typeof(BreakCondition))
|
};
|
|
|
const string descriptionName = "OpenTap.Description";
|
internal static DynamicMember DescriptionMember(ITypeData target)
|
{
|
// TestPlan Description should not be in the Common group.
|
bool isTestPlan = target.DescendsTo(typeof(TestPlan));
|
var displayAttribute = isTestPlan ?
|
new DisplayAttribute("Description", "A short description of this item.", null, 20001.2) :
|
new DisplayAttribute("Description", "A short description of this item.", "Common", 20001.2);
|
|
var descr = new DescriptionDynamicMember
|
{
|
Name = descriptionName,
|
DefaultValue = target.GetDisplayAttribute().Description,
|
Attributes = new Attribute[]
|
{
|
displayAttribute, new LayoutAttribute(LayoutMode.Normal, 3, 3), new UnsweepableAttribute(), new UnparameterizableAttribute(), new DefaultValueAttribute(target.GetDisplayAttribute().Description), new NonMetaDataAttribute()
|
},
|
DeclaringType = isTestPlan ? TypeData.FromType(typeof(TestPlan)) : TypeData.FromType(typeof(ITestStep)),
|
Readable = true,
|
Writable = true,
|
TypeDescriptor = TypeData.FromType(typeof(string))
|
};
|
return descr;
|
}
|
|
internal static readonly DynamicMember DynamicMembers = new DynamicMembersMember()
|
{
|
Name = "ForwardedMembers",
|
DefaultValue = ImmutableDictionary<string, IMemberData>.Empty,
|
DeclaringType = TypeData.FromType((typeof(TestStepTypeData))),
|
Attributes = new Attribute[]
|
{
|
new XmlIgnoreAttribute(), new AnnotationIgnoreAttribute()
|
},
|
Writable = true,
|
Readable = true,
|
TypeDescriptor = TypeData.FromType(typeof(IDictionary<string, IMemberData>))
|
};
|
|
static readonly IMemberData[] extraTestStepMembers =
|
{
|
BreakConditions, DynamicMembers, ChildItemVisibility.VisibilityProperty};
|
static readonly IMemberData[] extraTestPlanMembers =
|
{
|
TestPlanBreakConditions, DynamicMembers
|
};
|
static readonly IMemberData[] othersMembers =
|
{
|
DynamicMembers
|
};
|
readonly IMemberData[] members;
|
|
static IMemberData[] GetMembersRaw(ITypeData innerType)
|
{
|
IMemberData[] members;
|
if (innerType.DescendsTo(typeof(TestPlan)))
|
members = extraTestPlanMembers;
|
else if (innerType.DescendsTo(typeof(ITestStep)))
|
members = extraTestStepMembers;
|
else
|
return othersMembers;
|
var d = DescriptionMember(innerType);
|
var additional2 = dynamicMembersLookup.GetValue().Where(x => innerType.DescendsTo(x.DeclaringType)).OfType<IMemberData>();
|
members = members.Append(d).Concat(additional2).ToArray();
|
|
return members;
|
}
|
|
// memorize the arrays to avoid generating for each instance of test step.
|
static readonly ConditionalWeakTable<ITypeData, IMemberData[]> memberMemorizer =
|
new ConditionalWeakTable<ITypeData, IMemberData[]>();
|
static IMemberData[] GetMembers(ITypeData innerType) => memberMemorizer.GetValue(innerType, GetMembersRaw);
|
|
static readonly Cached<IMemberData[]> dynamicMembersLookup = new Cached<IMemberData[]>(PluginManager.CacheState, () =>
|
{
|
return TypeData.GetDerivedTypes<IDynamicMemberProvider>()
|
.Where(x => x.CanCreateInstance)
|
.Select(x => x.CreateInstanceSafe())
|
.OfType<IDynamicMemberProvider>()
|
.SelectMany(x => x.GetDynamicMembers()).ToArray();
|
});
|
|
|
readonly IMemberData descriptionMember;
|
public TestStepTypeData(ITypeData innerType)
|
{
|
this.innerType = innerType;
|
members = GetMembers(innerType);
|
descriptionMember = members.FirstOrDefault(m => m.Name == descriptionName);
|
}
|
|
public override bool Equals(object obj)
|
{
|
if (obj is TestStepTypeData td2)
|
return td2.innerType.Equals(innerType);
|
return base.Equals(obj);
|
}
|
|
public override int GetHashCode() => innerType.GetHashCode() * 157489213;
|
|
readonly ITypeData innerType;
|
public IEnumerable<object> Attributes => innerType.Attributes;
|
public string Name => innerType.Name;
|
public ITypeData BaseType => innerType;
|
|
public IEnumerable<IMemberData> GetMembers()
|
{
|
return innerType.GetMembers().Concat(members);
|
}
|
|
public IMemberData GetMember(string name)
|
{
|
if (name == BreakConditions.Name) return BreakConditions;
|
if (name == DynamicMembers.Name) return DynamicMembers;
|
if (name == descriptionMember?.Name) return descriptionMember;
|
return innerType.GetMember(name);
|
}
|
|
public object CreateInstance(object[] arguments)
|
{
|
return innerType.CreateInstance(arguments);
|
}
|
|
public bool CanCreateInstance => innerType.CanCreateInstance;
|
|
public override string ToString() => innerType.ToString();
|
public void OnTypeChanged() => TypeDataKey++;
|
|
public int TypeDataKey { get; private set; }
|
|
}
|
|
// memorize for reference equality.
|
static readonly ConditionalWeakTable<ITypeData, TestStepTypeData> dict =
|
new ConditionalWeakTable<ITypeData, TestStepTypeData>();
|
static TestStepTypeData getStepTypeData(ITypeData subtype) =>
|
dict.GetValue(subtype, x => new TestStepTypeData(x));
|
|
public ITypeData GetTypeData(string identifier, TypeDataProviderStack stack)
|
{
|
var subtype = stack.GetTypeData(identifier);
|
if (subtype.DescendsTo(typeof(ITestStepParent)))
|
{
|
var result = getStepTypeData(subtype);
|
return result;
|
}
|
|
return null;
|
|
}
|
|
// cache Dynamic type data for each ITestStepParent (which has parameters).
|
static readonly ConditionalWeakTable<object, DynamicTestStepTypeData> dict2 =
|
new ConditionalWeakTable<object, DynamicTestStepTypeData>();
|
|
public ITypeData GetTypeData(object obj, TypeDataProviderStack stack)
|
{
|
var subtype = stack.GetTypeData(obj);
|
var result = getStepTypeData(subtype);
|
if (TestStepTypeData.DynamicMembers.GetValue(obj) is ImmutableDictionary<string, IMemberData> obj2 && obj2.Count != 0)
|
return dict2.GetValue(obj, o => new DynamicTestStepTypeData(result, o));
|
if (obj is ITestStepParent)
|
return result;
|
|
return null;
|
}
|
public double Priority => 10;
|
}
|
|
/// <summary> An IMemberData that represents a parameter. The parameter controls the value of a set of parameterized members.</summary>
|
public interface IParameterMemberData : IMemberData
|
{
|
/// <summary> The members controlled by this parameter. </summary>
|
IEnumerable<(object Source, IMemberData Member)> ParameterizedMembers { get; }
|
}
|
|
interface INotifyDynamicTypeChanged
|
{
|
void OnTypeChanged();
|
int TypeDataKey { get; }
|
}
|
|
}
|
