using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Linq;
|
using System.Xml.Serialization;
|
|
namespace OpenTap.Plugins.BasicSteps
|
{
|
public class BasicStepsAnnotator : IAnnotator
|
{
|
class SweepParamsAnnotation : IMultiSelect, IAvailableValuesAnnotation, IOwnedAnnotation, IStringReadOnlyValueAnnotation, IHideOnMultiSelectAnnotation
|
{
|
[Display("Select All")]
|
class AllItems
|
{
|
public override string ToString()
|
{
|
return "Select All";
|
}
|
}
|
|
static AllItems allItemsSelect = new AllItems();
|
static AllItems noItems = new AllItems();
|
|
object[] selectedValues;
|
|
|
IEnumerable available = Array.Empty<object>();
|
public IEnumerable AvailableValues => available;
|
List<object> allAvailable = new List<object>();
|
public IEnumerable Selected
|
{
|
get => selectedValues;
|
set => selectedValues = value.Cast<object>().ToArray();
|
}
|
|
public string Value {
|
get
|
{
|
int count = 0;
|
if(selectedValues != null)
|
count = selectedValues.Count(x => (x is AllItems) == false);
|
return string.Format("{0} selected", count);
|
}
|
}
|
static bool memberCanSweep(IMemberData mem) => false == mem.HasAttribute<UnsweepableAttribute>();
|
public void Read(object source)
|
{
|
if (source is ITestStep == false) return;
|
List<object> allItems = new List<object>();
|
available = allItems;
|
|
Dictionary<IMemberData, object> members = new Dictionary<IMemberData, object>();
|
getPropertiesForItem((ITestStep)source, members);
|
|
foreach(var member in members)
|
{
|
if (!memberCanSweep(member.Key))
|
continue;
|
var anot = AnnotationCollection.Create(null, member.Key);
|
var access = anot.Get<ReadOnlyMemberAnnotation>();
|
var rmember = anot.Get<IMemberAnnotation>().Member;
|
if (rmember != null && rmember.Writable)
|
{
|
if (access == null || (!access.IsReadOnly && access.IsVisible))
|
{
|
bool? browsable = rmember.GetAttribute<BrowsableAttribute>()?.Browsable;
|
if (browsable == false) continue;
|
if(browsable == null)
|
{
|
if (rmember.GetAttribute<XmlIgnoreAttribute>() != null)
|
continue;
|
}
|
allItems.Add(member.Key);
|
}
|
}
|
}
|
|
foreach(var swe in (source as SweepLoop).SweepParameters)
|
{
|
if (swe.Member == null) continue;
|
if (members.TryGetValue(swe.Member, out object value))
|
swe.DefaultValue = value;
|
}
|
|
var items = (source as SweepLoop).SweepParameters.Select(x => x.Member).Cast<object>().ToList();
|
if(items.Count == allItems.Count)
|
{
|
items.Insert(0, noItems);
|
allItems.Insert(0, noItems);
|
}
|
else
|
{
|
allItems.Insert(0, allItemsSelect);
|
}
|
var grp = items.GroupBy(x => x is IMemberData mem ? (mem.GetDisplayAttribute().GetFullName() + mem.TypeDescriptor.Name) : "");
|
allAvailable = allItems;
|
available = allItems.GroupBy(x => x is IMemberData mem ? (mem.GetDisplayAttribute().GetFullName() + mem.TypeDescriptor.Name) : "")
|
.Select(x => x.FirstOrDefault()).ToArray();
|
selectedValues = grp.Select(x => x.FirstOrDefault()).ToArray();
|
|
}
|
|
void getPropertiesForItem(ITestStep step, Dictionary<IMemberData, object> members)
|
{
|
if (step is TestPlanReference) return;
|
foreach (ITestStep cs in step.ChildTestSteps)
|
{
|
foreach(var member in TypeData.GetTypeData(cs).GetMembers())
|
{
|
if (members.ContainsKey(member) == false)
|
{
|
members.Add(member, member.GetValue(cs));
|
}
|
}
|
getPropertiesForItem(cs, members);
|
}
|
}
|
|
public void Write(object source)
|
{
|
if (selectedValues == null) return;
|
var otherMember = annotation.ParentAnnotation.Get<IMembersAnnotation>().Members.FirstOrDefault(x => x.Get<IMemberAnnotation>().Member.Name == nameof(SweepLoop.SweepParameters));
|
var sweepPrams = otherMember.Get<IObjectValueAnnotation>().Value as List<SweepParam>;
|
var avail = allAvailable.OfType<IMemberData>().ToLookup(x => x.GetDisplayAttribute().GetFullName() + x.TypeDescriptor.Name, x => x);
|
HashSet<SweepParam> found = new HashSet<SweepParam>();
|
int initCount = sweepPrams.FirstOrDefault()?.Values.Length ?? 0;
|
Dictionary<IMemberData, object> members = null;
|
|
if (selectedValues.Contains(allItemsSelect))
|
selectedValues = this.AvailableValues.Cast<object>().ToArray();
|
if (selectedValues.Contains(noItems) == false && this.AvailableValues.Cast<object>().Contains(noItems))
|
selectedValues = Array.Empty<object>();
|
|
var group = selectedValues.OfType<IMemberData>().Select(x => x.GetDisplayAttribute().GetFullName() + x.TypeDescriptor.Name).Distinct();
|
|
foreach (var memname in group)
|
{
|
var mem = avail[memname];
|
|
SweepParam existing = null;
|
|
foreach (var smem in mem)
|
{
|
existing = sweepPrams.Find(x => x.Members.Contains(smem));
|
}
|
if(existing == null)
|
{
|
existing = new SweepParam(mem.ToArray());
|
if (members == null)
|
{
|
members = new Dictionary<IMemberData, object>();
|
getPropertiesForItem((ITestStep)source, members);
|
}
|
foreach (var smem in mem)
|
{
|
if (members.TryGetValue(smem, out object val))
|
existing.DefaultValue = val;
|
}
|
sweepPrams.Add(existing);
|
}
|
else
|
{
|
existing.Members = existing.Members.Concat(mem).Distinct().ToArray();
|
}
|
existing.Resize(initCount);
|
found.Add(existing);
|
}
|
sweepPrams.RemoveIf(x => found.Contains(x) == false);
|
(source as SweepLoop)?.sanitizeSweepParams(false);
|
otherMember.Read(source);
|
}
|
|
AnnotationCollection annotation;
|
|
public SweepParamsAnnotation(AnnotationCollection annotation)
|
{
|
this.annotation = annotation;
|
}
|
}
|
|
class SweepRow
|
{
|
public bool Enabled { get; set; }
|
public object[] Values { get;}
|
public SweepRow(bool enabled, object[] Values)
|
{
|
this.Values = Values;
|
Enabled = enabled;
|
}
|
}
|
|
class ValueContainerAnnotation : IObjectValueAnnotation
|
{
|
public object Value { get; set; }
|
}
|
class SweepParamsMembers : IMembersAnnotation, IOwnedAnnotation
|
{
|
List<AnnotationCollection> _members = null;
|
public IEnumerable<AnnotationCollection> Members {
|
get{
|
if (_members != null) return _members;
|
var step2 = annotation?.ParentAnnotation.Get<SweepParamsAggregation>();
|
var r = step2.RowAnnotations;
|
|
var val = annotation.Get<IObjectValueAnnotation>().Value as SweepRow;
|
|
var parent = annotation.ParentAnnotation.Source as SweepLoop;
|
var p = parent.SweepParameters;
|
|
Dictionary<object, AnnotationCollection> annotated = new Dictionary<object, AnnotationCollection>();
|
foreach (var elems in r.Values)
|
{
|
var elem = elems[0];
|
if (annotated.ContainsKey(elem)) continue;
|
annotated[elem] = AnnotationCollection.Annotate(elem);
|
}
|
var allsteps = r.Select(x => annotated[x.Value[0]].AnnotateMember(x.Key)).ToArray();
|
var allMembers = allsteps;
|
|
List<AnnotationCollection> lst = new List<AnnotationCollection>(p.Count);
|
var members = r.Keys.ToHashSet();
|
var subSet = allMembers.Where(x => members.Contains(x.Get<IMemberAnnotation>()?.Member)).ToArray();
|
var enabled = annotation.Get<IMembersAnnotation>(@from: this).Members.FirstOrDefault(x => x.Get<IMemberAnnotation>().Member.Name == "Enabled");
|
lst.Add(enabled);
|
for(int i = 0; i < p.Count; i++)
|
{
|
var p2 = p[i].Member;
|
var sub = subSet.FirstOrDefault(x => x.Get<IMemberAnnotation>().Member == p2);
|
if (sub == null)
|
continue;
|
// Sweep loop does not support EnabledIf.
|
var enabledif = sub.FirstOrDefault(x => x.GetType().Name.Contains("EnabledIfAnnotation"));
|
if(enabledif != null)
|
sub.Remove(enabledif);
|
var v = new ValueContainerAnnotation { Value = val.Values[i]};
|
// This is a bit complicated..
|
// we have to make sure that the ValueAnnotation is put very early in the chain.
|
sub.Insert(sub.IndexWhen(x => x is IObjectValueAnnotation) + 1, v);
|
|
lst.Add(sub);
|
}
|
|
return (_members = lst);
|
}
|
|
}
|
|
AnnotationCollection annotation;
|
public SweepParamsMembers(AnnotationCollection annotation)
|
{
|
this.annotation = annotation;
|
}
|
|
public void Read(object source)
|
{
|
if (_members != null)
|
_members.ForEach(x => x.Read(source));
|
}
|
|
public void Write(object source)
|
{
|
if (_members == null) return;
|
var src = source as SweepRow;
|
int index = 0;
|
foreach (var member in _members)
|
{
|
member.Write(source);
|
if (index > 0)
|
{
|
src.Values[index - 1] = member.Get<IObjectValueAnnotation>().Value;
|
}
|
else
|
{
|
src.Enabled = (bool)member.Get<IObjectValueAnnotation>().Value;
|
}
|
|
index += 1;
|
}
|
|
}
|
}
|
|
class SweepParamsAggregation : ICollectionAnnotation, IOwnedAnnotation, IStringReadOnlyValueAnnotation, IAccessAnnotation, IHideOnMultiSelectAnnotation
|
{
|
|
AnnotationCollection annotation;
|
public SweepParamsAggregation(AnnotationCollection annotation)
|
{
|
this.annotation = annotation;
|
}
|
|
Dictionary<IMemberData, List<object>> rowAnnotations = new Dictionary<IMemberData, List<object>>();
|
|
public Dictionary<IMemberData, List<object>> RowAnnotations
|
{
|
get
|
{
|
if (rowAnnotations.Count == 0)
|
{
|
var steps = sweep.RecursivelyGetChildSteps(TestStepSearch.All).ToArray();
|
var properties = steps.Select(x => TypeData.GetTypeData(x).GetMembers()).ToArray();
|
rowAnnotations = new Dictionary<IMemberData, List<object>>();
|
var swparams = annotation.Get<IObjectValueAnnotation>().Value as List<SweepParam>;
|
foreach (var param in swparams)
|
{
|
if(param.Member != null)
|
rowAnnotations.Add(param.Member, new List<object>());
|
}
|
|
for (int i = 0; i < properties.Length; i++)
|
{
|
foreach(var property in properties[i])
|
{
|
if (rowAnnotations.ContainsKey(property) == false)
|
continue;
|
|
rowAnnotations[property].Add(steps[i]);
|
}
|
}
|
|
}
|
return rowAnnotations;
|
}
|
}
|
|
IEnumerable<AnnotationCollection> annotatedElements;
|
|
public IEnumerable<AnnotationCollection> AnnotatedElements
|
{
|
get
|
{
|
|
if (annotatedElements == null)
|
{
|
if (sweep == null) return Enumerable.Empty<AnnotationCollection>();
|
List<AnnotationCollection> lst = new List<AnnotationCollection>();
|
for (int i = 0; i < sweep.EnabledRows.Length; i++)
|
lst.Add(annotateIndex(i));
|
|
annotatedElements = lst;
|
}
|
|
return annotatedElements;
|
}
|
set => annotatedElements = value.ToArray();
|
}
|
|
public string Value => $"Sweep rows: {sweep?.EnabledRows.Length ?? 0}";
|
|
public bool IsReadOnly => (annotation.Get<IObjectValueAnnotation>()?.Value as List<SweepParam>) == null;
|
|
public bool IsVisible => true;
|
|
public AnnotationCollection NewElement()
|
{
|
return annotateIndex(-1);
|
}
|
|
AnnotationCollection annotateIndex(int index = -1)
|
{
|
var sparams = sweep.SweepParameters;
|
SweepRow row;
|
if (index == -1 || index >= sweep.EnabledRows.Length)
|
row = new SweepRow(true, sparams.Select(x => x.Values.DefaultIfEmpty(x.DefaultValue).LastOrDefault()).ToArray());
|
else
|
row = new SweepRow(sweep.EnabledRows[index], sparams.Select(x => x.Values[index]).ToArray());
|
return this.annotation.AnnotateSub(TypeData.GetTypeData(row),row);
|
}
|
|
SweepLoop sweep;
|
|
public void Read(object source)
|
{
|
sweep = annotation.ParentAnnotation.Get<IObjectValueAnnotation>()?.Value as SweepLoop;
|
annotatedElements = null;
|
rowAnnotations.Clear();
|
}
|
|
public void Write(object source)
|
{
|
IList lst = (IList)annotatedElements;
|
if (lst == null) return;
|
|
var sweepParams = sweep.SweepParameters;
|
var count = lst.Count;
|
foreach(var param in sweepParams)
|
param.Resize(count);
|
sweep.EnabledRows = new bool[count];
|
|
int index = 0;
|
foreach(AnnotationCollection a in lst)
|
{
|
a.Write();
|
var row = a.Get<IObjectValueAnnotation>().Value as SweepRow;
|
sweep.EnabledRows[index] = row.Enabled;
|
for (int i = 0; i < row.Values.Length; i++)
|
{
|
sweepParams[i].Values[index] = cloneIfPossible(row.Values[i], sweep);
|
}
|
|
index += 1;
|
}
|
|
sweep.sanitizeSweepParams(log: false); // update size of EnabledRows.
|
}
|
TapSerializer tapSerializer;
|
object cloneIfPossible(object value, object context)
|
{
|
if (value == null) return null;
|
if (StringConvertProvider.TryGetString(value, out string result))
|
{
|
if (StringConvertProvider.TryFromString(result, TypeData.GetTypeData(value), context, out object result2))
|
{
|
return result2;
|
}
|
}
|
if(tapSerializer == null) tapSerializer = new TapSerializer();
|
try
|
{
|
return tapSerializer.DeserializeFromString(tapSerializer.SerializeToString(value),
|
TypeData.GetTypeData(value)) ?? value;
|
}
|
catch
|
{
|
return value;
|
}
|
}
|
}
|
|
class SweepRangeMembersAnnotation : IMultiSelect, IAvailableValuesAnnotation, IOwnedAnnotation, IStringReadOnlyValueAnnotation, IAccessAnnotation, IHideOnMultiSelectAnnotation
|
{
|
object[] selectedValues = Array.Empty<object>();
|
|
IEnumerable available = Array.Empty<object>();
|
public IEnumerable AvailableValues => available;
|
|
public IEnumerable Selected
|
{
|
get => selectedValues;
|
set => selectedValues = value.Cast<object>().ToArray();
|
}
|
public string Value => string.Format("{0} selected", selectedValues?.Count() ?? 0);
|
|
public bool IsReadOnly { get; private set; }
|
|
public bool IsVisible => true;
|
|
public void Read(object source)
|
{
|
if (source is ITestStep == false)
|
{
|
IsReadOnly = true;
|
return;
|
}
|
|
List<object> allItems = new List<object>();
|
available = allItems;
|
|
Dictionary<IMemberData, object> members = SweepLoopRange.GetPropertiesForItems((ITestStep)source);
|
foreach (var member in members)
|
{
|
var anot = AnnotationCollection.Create(null, member.Key);
|
var access = anot.Get<ReadOnlyMemberAnnotation>();
|
var rmember = anot.Get<IMemberAnnotation>().Member;
|
if (rmember != null)
|
{
|
if (access == null || (!access.IsReadOnly && access.IsVisible))
|
{
|
bool? browsable = rmember.GetAttribute<BrowsableAttribute>()?.Browsable;
|
if (browsable == false) continue;
|
if (browsable == null)
|
{
|
if (rmember.GetAttribute<XmlIgnoreAttribute>() != null)
|
continue;
|
}
|
allItems.Add(member.Key);
|
}
|
}
|
}
|
|
Selected = (source as SweepLoopRange).SweepProperties.ToArray();
|
}
|
|
|
|
public void Write(object source)
|
{
|
if (IsReadOnly) return;
|
|
HashSet<IMemberData> found = new HashSet<IMemberData>();
|
foreach (var _mem in selectedValues)
|
{
|
var mem = (IMemberData)_mem;
|
found.Add(mem);
|
}
|
fac.Get<IObjectValueAnnotation>().Value = found.ToList();
|
}
|
|
AnnotationCollection fac;
|
|
public SweepRangeMembersAnnotation(AnnotationCollection fac)
|
{
|
this.fac = fac;
|
}
|
}
|
|
public double Priority => 5;
|
|
class ConvertToSequenceAnnotation : IMethodAnnotation, IMergedMethodAnnotation
|
{
|
readonly AnnotationCollection annotation;
|
public ConvertToSequenceAnnotation(AnnotationCollection annotation)
|
{
|
this.annotation = annotation;
|
}
|
|
public void Invoke()
|
{
|
// only ask for confirmation the first time.
|
// if the user click cancel just stop.
|
bool userShouldConfirm = true;
|
foreach (var step in (ITestStep[])annotation.Source)
|
{
|
bool userClickedProceed = ((TestPlanReference)step).ConvertToSequence(userShouldConfirm, true);
|
if (!userClickedProceed)
|
break;
|
|
userShouldConfirm = false;
|
}
|
}
|
}
|
|
class SweepUnitAttribute : UnitAttribute, IOwnedAnnotation
|
{
|
readonly SweepParameterRangeStep step;
|
public void Update()
|
{
|
var unit = GetUnit();
|
if (unit == null)
|
{
|
Unit = "";
|
PreScaling = 1;
|
StringFormat = "";
|
UseRanges = true;
|
}
|
else
|
{
|
Unit = unit.Unit;
|
PreScaling = unit.PreScaling;
|
StringFormat = unit.StringFormat;
|
UseRanges = unit.UseRanges;
|
UseEngineeringPrefix = unit.UseEngineeringPrefix;
|
}
|
}
|
|
|
public SweepUnitAttribute(SweepParameterRangeStep step) : base("")
|
{
|
this.step = step;
|
}
|
|
public void Read(object source)
|
{
|
Update();
|
}
|
public void Write(object source)
|
{
|
|
}
|
|
internal UnitAttribute GetUnit()
|
{
|
UnitAttribute unit = null;
|
foreach (var member in step.SelectedMembers)
|
{
|
if (member.GetAttribute<UnitAttribute>() is UnitAttribute unit2)
|
{
|
if (unit == null)
|
unit = unit2;
|
else
|
{
|
if (unit.Unit != unit2.Unit)
|
{
|
return null;
|
}
|
if (unit.PreScaling != unit2.PreScaling)
|
return null;
|
if (unit.StringFormat != unit2.StringFormat)
|
return null;
|
|
}
|
}
|
else
|
{
|
return null;
|
}
|
}
|
return unit;
|
|
}
|
|
}
|
|
public void Annotate(AnnotationCollection annotation)
|
{
|
if (annotation.Get<IMemberAnnotation>()?.Member is IMemberData mem)
|
{
|
if (mem.Name == nameof(TestPlanReference.ConvertToSequence)
|
&& annotation.Get<IMergedValueAnnotation>() != null
|
&& mem.DeclaringType.DescendsTo(typeof(TestPlanReference)))
|
{
|
// multi-select: remove the default method handler and use this new way.
|
annotation.RemoveType<IMethodAnnotation>();
|
annotation.Add(new ConvertToSequenceAnnotation(annotation));
|
}
|
|
if (annotation.Source is SweepParameterRangeStep step &&
|
(mem.Name == nameof(SweepParameterRangeStep.SweepStart)
|
|| mem.Name == nameof(SweepParameterRangeStep.SweepStop)
|
|| mem.Name == nameof(SweepParameterRangeStep.SweepStep)))
|
{
|
annotation.Add(new SweepUnitAttribute(step));
|
}
|
|
if (mem.GetAttribute<HideOnMultiSelectAttribute>() is HideOnMultiSelectAttribute attr)
|
annotation.Add(attr);
|
|
if (mem.TypeDescriptor is TypeData cst)
|
{
|
if (mem.DeclaringType.DescendsTo(typeof(SweepLoop)))
|
{
|
if (cst.DescendsTo(typeof(IEnumerable)))
|
{
|
var elem = cst.Type.GetEnumerableElementType();
|
if (elem == typeof(IMemberData))
|
annotation.Add(new SweepParamsAnnotation(annotation));
|
if (elem == typeof(SweepParam))
|
annotation.Add(new SweepParamsAggregation(annotation));
|
}
|
}
|
else if (mem.DeclaringType.DescendsTo(typeof(SweepLoopRange)))
|
{
|
if (cst.DescendsTo(typeof(IEnumerable)))
|
{
|
var elem = cst.Type.GetEnumerableElementType();
|
if (elem == typeof(IMemberData))
|
{
|
annotation.Add(new SweepRangeMembersAnnotation(annotation));
|
}
|
}
|
}
|
}
|
|
if (mem is IParameterMemberData && mem.DeclaringType.DescendsTo(typeof(ISelectedParameters)))
|
{
|
// If the member is a forwarded member on a loopTestStep, it should not be editable because the value
|
// is controlled in the sweep, however it should still be shown.
|
annotation.Add(new DisabledLoopMemberAnnotation(annotation, mem));
|
}
|
|
{
|
// logic to disable parameterizing parameters that are selected by
|
// a sweep loop (ISelectedParameters implementor).
|
if (annotation.Source is ITestStepMenuModel model)
|
{
|
// ISelectedParameter implementing steps.
|
var steps = model.Source.OfType<ISelectedParameters>().ToArray();
|
if (steps.Length > 0)
|
{
|
var iconName = annotation.Get<IIconAnnotation>()?.IconName;
|
if ( iconName == IconNames.Parameterize ||
|
iconName == IconNames.ParameterizeOnParent||
|
iconName == IconNames.ParameterizeOnTestPlan)
|
{
|
if(steps.Any(x => x.SelectedParameters.Contains(model.Member)))
|
{
|
annotation.Add(new DisabledLoopMemberAnnotation(steps, model.Member));
|
}
|
}
|
}
|
}
|
}
|
}
|
|
if (annotation.Get<IReflectionAnnotation>()?.ReflectionInfo is TypeData type && type.Type == typeof(SweepRow))
|
annotation.Add(new SweepParamsMembers(annotation));
|
}
|
class DisabledLoopMemberAnnotation : IEnabledAnnotation
|
{
|
readonly AnnotationCollection annotation;
|
readonly IMemberData member;
|
readonly ISelectedParameters[] steps;
|
public DisabledLoopMemberAnnotation(AnnotationCollection annotation, IMemberData member)
|
{
|
this.annotation = annotation;
|
this.member = member;
|
}
|
public DisabledLoopMemberAnnotation(ISelectedParameters[] steps, IMemberData member)
|
{
|
this.member = member;
|
this.steps = steps;
|
}
|
|
public bool IsEnabled
|
{
|
get
|
{
|
if (annotation?.Source is ISelectedParameters sw && sw.SelectedParameters.Contains(member))
|
return false;
|
if (steps?.Any(x => x.SelectedParameters.Contains(member)) == true)
|
return false;
|
return true;
|
}
|
}
|
}
|
}
|
|
/// <summary> This attribute indicates that a property should not be accessible for multi-selecting.</summary>
|
internal class HideOnMultiSelectAttribute : Attribute, IHideOnMultiSelectAnnotation
|
{
|
|
}
|
}
|
