using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Linq;
|
using System.Runtime.CompilerServices;
|
|
namespace OpenTap
|
{
|
static class ParameterManager
|
{
|
public class ScopeMember
|
{
|
public ITestStepParent Scope { get; }
|
public IMemberData Member { get; }
|
|
public ScopeMember(ITestStepParent scope, IMemberData member)
|
{
|
Scope = scope;
|
Member = member;
|
}
|
|
string scopeName
|
{
|
get
|
{
|
switch (Scope)
|
{
|
case ITestStep step:
|
return step.GetFormattedName();
|
case TestPlan _: return "Test plan";
|
case object x: return x.ToString();
|
default: return "null";
|
}
|
}
|
}
|
|
public override string ToString() => $"'{Member.GetDisplayAttribute().Name}' from '{scopeName}'";
|
|
static IEnumerable<ITestStepParent> getScopes(ITestStepParent step)
|
{
|
while (step != null)
|
{
|
yield return step;
|
step = step.Parent;
|
}
|
}
|
|
static ITestStepParent[] getCommonParents(ITestStepParent[] array)
|
{
|
if (array.Length == 0) return Array.Empty<ITestStepParent>();
|
var firstArray = getScopes(array[0].Parent).Reverse().ToArray();
|
int cnt = firstArray.Length;
|
for (int i = 1; i < array.Length; i++)
|
{
|
var secondArray = getScopes(array[i].Parent).Reverse().ToArray();
|
cnt = Math.Min(cnt, secondArray.Length);
|
int j = 0;
|
foreach (var item in secondArray)
|
{
|
if (item != firstArray[j])
|
{
|
cnt = j;
|
break;
|
}
|
j += 1;
|
if (j == cnt)
|
break;
|
}
|
}
|
|
Array.Resize(ref firstArray, cnt);
|
Array.Reverse(firstArray);
|
return firstArray;
|
}
|
|
public static IEnumerable<object> GetScopes(object source)
|
{
|
switch (source)
|
{
|
case ITestStepParent[] array:
|
return getCommonParents(array);
|
case ITestStepParent step:
|
return getScopes(step.Parent);
|
default: return Array.Empty<object>();
|
}
|
}
|
|
|
public static (object Scope, IMemberData member) GetScope(object[] owners, IMemberData member)
|
{
|
foreach (var scope in GetScopes(owners))
|
{
|
if (scope is ITestStepParent parent)
|
{
|
var forwardedMembers = TypeData.GetTypeData(scope)
|
.GetMembers().OfType<IParameterMemberData>();
|
var f = forwardedMembers.FirstOrDefault(x => owners.All(y => x.ContainsMember((y, member))));
|
if(f != null)
|
return (parent, f);
|
}
|
}
|
|
return (null, null);
|
}
|
}
|
|
[HelpLink("EditorHelp.chm::/CreatingATestPlan/Scoped Parameters/Readme.html")]
|
public class NamingQuestion : ValidatingObject
|
{
|
public struct ScopeItem
|
{
|
public ITestStepParent Object { get; set; }
|
public override string ToString()
|
{
|
if (Object is ITestStep step)
|
return "Test Step '" + step.GetFormattedName() +"'";
|
if (Object is TestPlan plan)
|
return "Test Plan '" + plan.Name +"'";
|
return null;
|
}
|
}
|
|
public string Name { get; internal set; }
|
[Display("Name", "Name of the parameter. Groups are delimited by \\'." +
|
" This may be the same as an existing parameter name in which case they will be merged.")]
|
[SuggestedValues(nameof(SuggestedNames))]
|
//When merging the value type must be the same for all parameters." +
|
// "\nIt cannot be the same as a non-parameter name.
|
public string SelectedName
|
{
|
get => selectedName;
|
set
|
{
|
if (value == "") return; // fixes a bug related to SuggestedValueAttribute
|
selectedName = value;
|
}
|
}
|
string selectedName;
|
IEnumerable<string> getMemberNames()
|
{
|
if (Scope.Object == null) return Enumerable.Empty<string>();
|
return TypeData.GetTypeData(Scope.Object).GetMembers()
|
.OfType<IParameterMemberData>()
|
.Select(x => x.Name);
|
}
|
|
public IEnumerable<string> SuggestedNames => new[] {defaultFullName}
|
.Concat(getMemberNames())
|
.Distinct();
|
|
[Display("Scope", "The location of the parameter. This must be a parent of the step(s) containing the settings.")]
|
[AvailableValues(nameof(AvailableScopes))]
|
public ScopeItem Scope
|
{
|
get => scope;
|
set
|
{
|
bool useDefaultName = SelectedName == defaultFullName;
|
scope = value;
|
if (useDefaultName)
|
SelectedName = defaultFullName;
|
}
|
}
|
|
ScopeItem scope;
|
|
IEnumerable<(string message, string error)> getMessage()
|
{
|
var selectedName = SelectedName?.Trim() ?? "";
|
|
if(Scope.Object is ITestStepParent step)
|
{
|
string name;
|
if (step is TestPlan plan)
|
name = $"test plan '{plan.Name}'";
|
else
|
name = $"test step '{(step as ITestStep)?.GetFormattedName()}'";
|
var existing = TypeData.GetTypeData(step).GetMember(selectedName.Trim());
|
var originalExisting = TypeData.GetTypeData(step).GetMember(defaultFullName);
|
|
if (existing != null && (step != originalScope || !ReferenceEquals(originalExisting, existing)))
|
{
|
var t1 = existing?.TypeDescriptor;
|
var t2 = member?.TypeDescriptor;
|
if (t1 != null && t2 != null && typeComparison(t1, t2) != null)
|
{
|
var error = $"Cannot merge properties of this kind.";
|
yield return (error, error);
|
yield break;
|
}
|
var val = existing.GetValue(step);
|
var cloner = new ObjectCloner(val);
|
if (member.HasAttribute<UnmergableAttribute>() || existing.HasAttribute<UnmergableAttribute>())
|
{
|
var error = $"The selected property does not support merging.";
|
yield return (error, error);
|
yield break;
|
}
|
|
if (member is IParameterMemberData memberAsParameter && originalExisting is IParameterMemberData targetParameter)
|
{
|
// Verify that a parameter does not get merged with another parameter that has it in its list of dependencies. (cyclic dependency).
|
var dependencyList = Utils.FlattenHeirarchy(
|
targetParameter.ParameterizedMembers.Select(x => x.Member)
|
.OfType<IParameterMemberData>(),
|
x => x.ParameterizedMembers.Select(x2 => x2.Member).OfType<IParameterMemberData>());
|
if (dependencyList.Contains(memberAsParameter))
|
{
|
var error = $"The selected scope's parameter cannot be merged with a parameterization that it depends on.";
|
yield return (error, error);
|
yield break;
|
}
|
}
|
if( cloner.CanClone(step, member.TypeDescriptor) == false)
|
{
|
var error = $"Cannot merge properties of this kind.";
|
yield return (error, error);
|
yield break;
|
}
|
else
|
{
|
yield return ($"Merge with an existing parameter on {name}.", null);
|
}
|
}
|
else if(!isEdit)
|
yield return ($"Create new parameter on {name}.", null);
|
|
if (isEdit)
|
{
|
var availSettingsCount = AvailableSettings.Count();
|
if (Settings.Count == 0)
|
{
|
yield return ("Remove the parameter.", null);
|
yield break;
|
}
|
if (Settings.Count < availSettingsCount)
|
yield return ("Remove settings from being controlled by the parameter.", null);
|
|
if (step == originalScope)
|
{
|
if (Equals(defaultFullName, selectedName) == false)
|
yield return ($"Rename parameter to '{SelectedName}'.", null);
|
}
|
else
|
yield return ($"Move parameter to {name}.", null);
|
}
|
}
|
}
|
|
[Display("Message", Order: 1)]
|
[Layout(LayoutMode.FullRow | LayoutMode.WrapText, 3)]
|
[Browsable(true)]
|
public string Message => string.Join("\n", getMessage().Select(x => x.message));
|
|
public IEnumerable<object> AvailableSettings => scopeMembers;
|
|
public bool SelectedSettingAvailable => scopeMembers != null;
|
|
[AvailableValues(nameof(AvailableSettings))]
|
[EnabledIf(nameof(SelectedSettingAvailable), true, HideIfDisabled = true)]
|
[Display("Settings", "Select which settings are controlled by this parameter. To remove the parameter, deselect all of them.")]
|
public List<ScopeMember> Settings { get; set; }
|
|
public IEnumerable<ScopeItem> AvailableScopes => ScopeMember.GetScopes(source).OfType<ITestStepParent>()
|
.Select(x => new ScopeItem{Object = x});
|
|
readonly ITestStepParent[] source;
|
|
readonly string defaultName;
|
// default group (if step parameter)
|
readonly string[] defaultGroup;
|
|
public string OverrideDefaultName;
|
string defaultFullName
|
{
|
get
|
{
|
if (OverrideDefaultName != null)
|
return OverrideDefaultName;
|
return string.Join(" \\ ", defaultGroup.Append(defaultName).Select(x => x.Trim()));
|
}
|
}
|
|
HashSet<ITypeData> numericTypes = new HashSet<ITypeData>() {
|
TypeData.FromType(typeof(decimal)), TypeData.FromType(typeof(double)), TypeData.FromType(typeof(float)),
|
TypeData.FromType(typeof(long)), TypeData.FromType(typeof(int)), TypeData.FromType(typeof(short)), TypeData.FromType(typeof(sbyte)),
|
TypeData.FromType(typeof(ulong)), TypeData.FromType(typeof(uint)), TypeData.FromType(typeof(ushort)), TypeData.FromType(typeof(byte))
|
};
|
string typeComparison(ITypeData firstType, ITypeData secondType)
|
{
|
if (Equals(firstType, secondType))
|
return null;
|
if (numericTypes.Contains(firstType) && numericTypes.Contains(secondType))
|
return null;
|
return "Value types must match to support merging parameters";
|
}
|
|
string validateName()
|
{
|
if (string.IsNullOrWhiteSpace(SelectedName))
|
return "Name cannot be left empty.";
|
return null;
|
}
|
|
IMemberData member;
|
|
ScopeMember[] scopeMembers;
|
|
public string GetError() => getMessage().FirstOrDefault(x => x.error != null).error;
|
|
bool isEdit => scopeMembers != null;
|
object originalScope;
|
public NamingQuestion(ITestStepParent[] source, IMemberData member, ScopeMember[] scopeMembers = null, object originalScope = null)
|
{
|
Rules.Add(() => validateName() == null, validateName, nameof(SelectedName));
|
Rules.Add(() => GetError() == null, () => getMessage().FirstOrDefault(x => x.error != null).error, nameof(Message));
|
this.member = member;
|
this.source = source;
|
this.scopeMembers = scopeMembers;
|
this.originalScope = originalScope;
|
Settings = scopeMembers?.ToList();
|
var display = member.GetDisplayAttribute();
|
Name = "Parameterize '" + display.Name + "'";
|
|
if (display.Group.FirstOrDefault() == "Parameters")
|
defaultGroup = display.Group;
|
else
|
defaultGroup = new[] {"Parameters"}.Concat(display.Group).ToArray();
|
|
defaultName = display.Name;
|
|
Scope = AvailableScopes.FirstOrDefault();
|
SelectedName = defaultFullName;
|
}
|
|
[Submit]
|
[Layout(LayoutMode.FloatBottom | LayoutMode.FullRow)]
|
public OkCancel Response { get; set; }
|
}
|
public enum OkCancel
|
{
|
[Display("OK", "Accept the selected configuration.")]
|
Ok = 1,
|
[Display("Cancel", "Discard changes to the test plan.")]
|
Cancel = 2
|
}
|
|
static TraceSource log = Log.CreateSource("Parameter");
|
|
[ThreadStatic]
|
private static bool parameterSanityCheckDelayed;
|
|
[ThreadStatic]
|
private static bool quickSanityCheck;
|
|
public static IDisposable WithSanityCheckDelayed() => WithSanityCheckDelayed(false);
|
|
public static IDisposable WithSanityCheckDelayed(bool quickCheck)
|
{
|
if (parameterSanityCheckDelayed)
|
return Utils.WithDisposable(() => { });
|
parameterSanityCheckDelayed = true;
|
quickSanityCheck = quickCheck;
|
return Utils.WithDisposable(() => parameterSanityCheckDelayed = false);
|
}
|
|
public static void Parameterize(ITestStepParent scope, IMemberData targetMember, ITestStepParent[] source, string selectedName)
|
{
|
var currentMember = TypeData.GetTypeData(scope).GetMember(selectedName);
|
object currentValue = currentMember?.GetValue(scope);
|
using (WithSanityCheckDelayed())
|
{
|
foreach (var src in source)
|
{
|
// Try to fetch the member, multi select might make some members hide each-other non-perfectly.
|
var member = TypeData.GetTypeData(src).GetMember(targetMember.Name) ?? targetMember;
|
var newMember = member.Parameterize(scope, src, selectedName);
|
if (currentValue != null)
|
newMember.SetValue(scope, currentValue);
|
}
|
}
|
}
|
|
public static void CreateParameter(ITestStepMenuModel s, ITestStepParent preselectedScope, bool showDialog)
|
{
|
var source = s.Source;
|
|
var parameterUserRequest = new NamingQuestion(source, s.Member);
|
if (preselectedScope != null)
|
parameterUserRequest.Scope = new NamingQuestion.ScopeItem {Object = preselectedScope};
|
|
if (showDialog)
|
UserInput.Request(parameterUserRequest, modal: true);
|
parameterUserRequest.SelectedName = parameterUserRequest.SelectedName.Trim();
|
if (parameterUserRequest.Response == OkCancel.Cancel)
|
return;
|
|
var err = parameterUserRequest.Error;
|
if (string.IsNullOrWhiteSpace(err) == false)
|
{
|
log.Error("{0}", err);
|
return;
|
}
|
|
var scope = parameterUserRequest.Scope.Object;
|
Parameterize(scope, s.Member, source, parameterUserRequest.SelectedName);
|
}
|
|
public static bool UnmergableListType(IMemberData property)
|
{
|
var propertyType = property.TypeDescriptor;
|
// merging IEnumerable is not supported (unless its a string).
|
if (propertyType.DescendsTo(typeof(IEnumerable)))
|
{
|
if (propertyType.IsA(typeof(string)) == false)
|
{
|
var elementType = propertyType.AsTypeData()?.ElementType;
|
if (elementType == null || elementType.IsNumeric == false)
|
return true;
|
}
|
}
|
|
return false;
|
}
|
|
public static void EditParameter(ITestStepMenuModel ui)
|
{
|
var member = (ParameterMemberData)ui.Member;
|
var scopeMembers = member.ParameterizedMembers.Select(x => new ScopeMember((ITestStepParent)x.Source, x.Member)).ToArray();
|
var parameterUserRequest = new NamingQuestion(scopeMembers.Select(x => (ITestStepParent)x.Scope).ToArray(), ui.Member, scopeMembers, originalScope: ui.Source.First())
|
{
|
Name = $"Edit Parameter '{ui.Member.GetDisplayAttribute().Name}'"
|
};
|
parameterUserRequest.Scope = new NamingQuestion.ScopeItem { Object = ui.Source.First() };
|
parameterUserRequest.SelectedName = ui.Member.Name;
|
parameterUserRequest.OverrideDefaultName = ui.Member.Name;
|
|
var prevScope = parameterUserRequest.Scope;
|
|
UserInput.Request(parameterUserRequest, true);
|
if (parameterUserRequest.Response == OkCancel.Cancel || string.IsNullOrWhiteSpace(parameterUserRequest.Name))
|
return;
|
|
var err = parameterUserRequest.Error;
|
if (string.IsNullOrWhiteSpace(err) == false)
|
{
|
log.Error("{0}", err);
|
return;
|
}
|
|
using (WithSanityCheckDelayed())
|
{
|
foreach (var oldScopeMember in scopeMembers)
|
{
|
if (parameterUserRequest.SelectedName != member.Name ||
|
parameterUserRequest.Settings.Contains(oldScopeMember) == false ||
|
prevScope.Object != parameterUserRequest.Scope.Object)
|
oldScopeMember.Member.Unparameterize((ParameterMemberData) ui.Member, oldScopeMember.Scope);
|
}
|
|
var target = parameterUserRequest.Scope.Object;
|
var selectedName = parameterUserRequest.SelectedName;
|
bool anyCreated = false;
|
foreach (var newScopeMember in parameterUserRequest.Settings)
|
{
|
var scope = newScopeMember.Scope;
|
if (selectedName != member.Name ||
|
scopeMembers.Contains(newScopeMember) == false ||
|
prevScope.Object != target)
|
{
|
newScopeMember.Member.Parameterize(target, scope, selectedName);
|
anyCreated = true;
|
}
|
}
|
|
if (anyCreated)
|
{
|
// Update the value, to make sure all parameterized properties
|
// has the right value.
|
var param = TypeData.GetTypeData(target).GetMember(selectedName);
|
param.SetValue(target, param.GetValue(target));
|
}
|
}
|
|
var step = ui.Source.First();
|
checkParameterSanity(step);
|
}
|
|
public static bool CanUnparameter(ITestStepMenuModel menuItemModel) => CanUnparameter(menuItemModel.Member, menuItemModel.Source);
|
public static bool CanParameter(ITestStepMenuModel menuItemModel) => CanParameter(menuItemModel.Member, menuItemModel.Source);
|
public static bool CanEditParameter(ITestStepMenuModel menuItemModel) => IsValidParameter(menuItemModel.Member, menuItemModel.Source, false);
|
|
static bool isParameterized(ITestStepParent item, IMemberData member) => item.GetParents().Any(parent =>
|
TypeData.GetTypeData(parent).GetMembers().OfType<ParameterMemberData>()
|
.Any(x => x.ContainsMember(item, member)));
|
static bool IsValidParameter(IMemberData property, ITestStepParent[] steps, bool checkTestPlan = true)
|
{
|
if (steps.Length == 0) return false;
|
if (property == null) return false;
|
if (property.HasAttribute<System.Xml.Serialization.XmlIgnoreAttribute>())
|
{
|
// XmlIgnored properties cannot be serialized, so external property does not work for them.
|
return false;
|
}
|
|
if (property.HasAttribute<UnparameterizableAttribute>())
|
return false;
|
|
foreach (var x in steps)
|
{
|
if (property.Readable == false || property.Writable == false) return false;
|
if (x is ITestStep step && step.IsReadOnly)
|
return false;
|
if (checkTestPlan && x is TestPlan) return false;
|
}
|
|
return true;
|
}
|
|
public static bool CanParameter(IMemberData property, ITestStepParent[] steps)
|
{
|
if (IsValidParameter(property, steps) == false)
|
return false;
|
return !steps.Any(step => isParameterized(step, property));
|
}
|
public static bool CanUnparameter(IMemberData property, ITestStepParent[] steps)
|
{
|
if (IsValidParameter(property, steps) == false)
|
return false;
|
return steps.Any(step => isParameterized(step, property));
|
}
|
|
|
public static bool CanAutoParameterize(IMemberData property, ITestStepParent[] steps )
|
{
|
if (steps.Length == 0) return false;
|
if (property == null) return false;
|
|
var parameterUserRequest = new NamingQuestion(steps, property);
|
|
var err = parameterUserRequest.Error;
|
if (string.IsNullOrWhiteSpace(err) == false)
|
return false;
|
|
return true;
|
}
|
|
public static void RemoveParameter(ITestStepMenuModel data)
|
{
|
if (data.Member is ParameterMemberData member)
|
{
|
foreach (var (obj, mem) in member.ParameterizedMembers.ToArray())
|
mem.Unparameterize(member, obj);
|
}
|
else
|
{
|
throw new Exception("Invalid parameter");
|
}
|
}
|
|
public static void Unparameterize(ITestStepMenuModel data)
|
{
|
List<ITestStepParent> targets = new List<ITestStepParent>();
|
using (WithSanityCheckDelayed())
|
{
|
foreach (var src in data.Source)
|
{
|
IMemberData property;
|
var (scope, member) = ScopeMember.GetScope(new[] {src}, data.Member);
|
if (scope == null || member == null)
|
{
|
// this may occur if src does not actually have the right member, but just a member with the same name.
|
// in this case we just extract the member with the right name and use that.
|
property = TypeData.GetTypeData(src).GetMember(data.Member.Name);
|
(scope, member) = ScopeMember.GetScope(new[]
|
{
|
src
|
}, property);
|
}
|
else
|
{
|
property = data.Member;
|
}
|
|
if (scope is ITestStepParent p)
|
{
|
targets.Add(p);
|
property.Unparameterize((ParameterMemberData) member, src);
|
}
|
}
|
}
|
|
foreach (var src in data.Source.Concat(targets))
|
{
|
checkParameterSanity(src);
|
}
|
}
|
|
class ChangeId
|
{
|
public int Value { get; set; }
|
}
|
// used to store test plan change ids
|
// if the test plan did not change since last sanity check,
|
// then we can do it a lot faster.
|
static readonly ConditionalWeakTable<ITestStepParent, ChangeId> recordedChangeIds = new ConditionalWeakTable<ITestStepParent, ChangeId>();
|
|
public static bool CheckParameterSanity(ParameterMemberData parameter, bool overrideCache = false)
|
{
|
if (parameter.Target is ITestStepParent par)
|
return CheckParameterSanity(par, new IMemberData[] {parameter}, overrideCache);
|
return false;
|
}
|
|
public static bool CheckParameterSanity(ITestStepParent step, ICollection<IMemberData> parameters, bool overrideCache = false)
|
{
|
if (parameterSanityCheckDelayed)
|
{
|
// in some cases we may want to do a sanity check even if it has been delayed.
|
if(quickSanityCheck == false)
|
return true;
|
var changeid = recordedChangeIds.GetValue(step, x => new ChangeId());
|
if (changeid.Value == step.ChildTestSteps.ChangeId)
|
return true;
|
}
|
foreach (var elem in parameters)
|
{
|
if (elem is ParameterMemberData)
|
return checkParameterSanity(step, parameters, overrideCache);
|
}
|
return true;
|
}
|
|
/// <summary>
|
/// Verify that source of a declared parameter on a parent also exists in the step hierarchy.
|
/// </summary>
|
public static bool checkParameterSanity(ITestStepParent step, ICollection<IMemberData> parameters, bool overrideCache = false)
|
{
|
bool isSane = true;
|
var changeid = recordedChangeIds.GetValue(step, x => new ChangeId());
|
foreach (var _item in parameters.ToArray())
|
{
|
if (_item is ParameterMemberData item)
|
{
|
|
if (changeid.Value == step.ChildTestSteps.ChangeId && item.AnyDynamicMembers == false && !overrideCache)
|
{
|
continue;
|
}
|
foreach (var fwd in item.ParameterizedMembers)
|
{
|
// Multiple situations possible.
|
// 1. the step is no longer a child of the parent to which it has parameterized a setting.
|
// 2. the member of a parameter no longer exists.
|
// 3. the child has been deleted from the step heirarchy.
|
|
var parameterSource = fwd.Source as ITestStepParent;
|
if (parameterSource == null) continue;
|
var member = fwd.Member;
|
bool isParent = false;
|
if (parameterSource == step)
|
{
|
// the parameter is parementerized on itself.
|
isParent = true;
|
}
|
else if (changeid.Value != step.ChildTestSteps.ChangeId || overrideCache)
|
{
|
// now iterate up to confirm that there is an unbroken chain between the parameter source and target.
|
var stepi = parameterSource;
|
while (stepi != null)
|
{
|
if (stepi.Parent == step)
|
{
|
isParent = true;
|
break;
|
}
|
stepi = stepi.Parent;
|
}
|
}
|
else
|
{
|
isParent = true;
|
}
|
|
if (member is IParameterMemberData)
|
isSane &= CheckParameterSanity(parameterSource, [member]);
|
|
bool memberDisposed = member is IDynamicMemberData dynamicMember && dynamicMember.IsDisposed;
|
|
if (!memberDisposed && member is EmbeddedMemberData emb)
|
{ // This is a special case, if the member is not as such dynamic, but an embedded member, then the owner member could have been disposed.
|
if (emb.OwnerMember is IDynamicMemberData dynamicMember2 && dynamicMember2.IsDisposed)
|
memberDisposed = true;
|
}
|
if (memberDisposed || isParent == false )
|
{
|
member.Unparameterize(item, parameterSource);
|
if (!isParent)
|
log.Info("Step {0} is no longer a child step of the parameter owner. Removing from {1}.",
|
(parameterSource as ITestStep)?.GetFormattedName() ?? parameterSource?.ToString(), item.Name);
|
else
|
log.Warning("Member {0} no longer exists, unparameterizing member.", member.Name);
|
isSane = false;
|
}
|
}
|
}
|
}
|
// only update the change id for this step if sanity check passed.
|
if(isSane)
|
changeid.Value = step.ChildTestSteps.ChangeId;
|
|
return isSane;
|
}
|
|
static bool checkParameterSanity(ITestStepParent step)
|
{
|
if (step == null) return true;
|
|
ParameterMemberData[] parameters;
|
using(WithSanityCheckDelayed()) // sanity checks are being done inside check members.
|
parameters = TypeData.GetTypeData(step).GetMembers().OfType<ParameterMemberData>().ToArray();
|
var isSane = CheckParameterSanity(step, parameters);
|
if(step.Parent is ITestStepParent parent)
|
return checkParameterSanity(parent) & isSane;
|
return isSane;
|
}
|
|
|
public class SettingsName : IStringReadOnlyValueAnnotation
|
{
|
AnnotationCollection annotation;
|
public SettingsName(AnnotationCollection a) => annotation = a;
|
|
public string Value
|
{
|
get
|
{
|
var members = annotation.Get<IObjectValueAnnotation>()?.Value as List<ScopeMember>;
|
if (members == null) return "";
|
return string.Join(", ", members.Select(x => x.ToString()));
|
}
|
}
|
}
|
}
|
}
|
