using OpenTap.Plugins.BasicSteps;
|
using NUnit.Framework;
|
using System;
|
using System.Collections.Generic;
|
using System.Collections.ObjectModel;
|
using System.Collections.Specialized;
|
using System.Diagnostics;
|
using System.Linq;
|
using System.Xml.Serialization;
|
using System.ComponentModel;
|
using System.IO;
|
using System.Text;
|
using OpenTap.Cli;
|
using System.Threading;
|
|
namespace OpenTap.Engine.UnitTests
|
{
|
[TestFixture]
|
public class TypeDataTest
|
{
|
class ClassWithPropertyWithoutGetter
|
{
|
// previously reflecting this with TypeData would cause an exception to happen.
|
public double MyValue { set { } }
|
}
|
[Test]
|
public void ClassPropertyWithoutGetter()
|
{
|
var type = TypeData.FromType(typeof(ClassWithPropertyWithoutGetter));
|
var members = type.GetMembers();
|
Assert.IsTrue(members.Any(x => x.Name == nameof(ClassWithPropertyWithoutGetter.MyValue)));
|
}
|
|
[Test]
|
public void SimpleDerivedTypesTest()
|
{
|
ITypeData baseType = TypeData.FromType(typeof(IResultListener));
|
var types = TypeData.GetDerivedTypes(baseType);
|
CollectionAssert.IsNotEmpty(types);
|
CollectionAssert.AllItemsAreNotNull(types);
|
CollectionAssert.AllItemsAreUnique(types);
|
Assert.IsTrue(types.All(t => t.DescendsTo(baseType)));
|
}
|
|
[PluginOrder(before: typeof(DotNetTypeDataSearcher))]
|
public class TypeDataSearcherTestImpl : ITypeDataSearcher, ITypeDataProvider, ITypeDataSearcherCacheInvalidated, ITypeDataSourceProvider
|
{
|
public class MemberDataTestImpl : IMemberData
|
{
|
public ITypeData DeclaringType { get; set; }
|
|
public ITypeData TypeDescriptor { get; set; }
|
|
public bool Writable => true;
|
|
public bool Readable => true;
|
|
public IEnumerable<object> Attributes { get; set; }
|
|
public string Name { get; set; }
|
|
public object GetValue(object owner)
|
{
|
return Value;
|
}
|
|
public void SetValue(object owner, object value)
|
{
|
Value = value;
|
}
|
|
public static object Value { get; set; }
|
}
|
|
|
public class TypeDataTestImpl : ITypeData
|
{
|
public ITypeData BaseType { get; set; }
|
|
public bool CanCreateInstance => Creator != null;
|
|
public IEnumerable<object> Attributes => new object[] { new DisplayAttribute("unittesting") };
|
|
public string Name { get; set; }
|
|
public object CreateInstance(object[] arguments)
|
{
|
return Creator.Invoke();
|
}
|
|
|
public IMemberData GetMember(string name)
|
{
|
if (name == "Hello")
|
return HelloMember;
|
return null;
|
}
|
|
public IEnumerable<IMemberData> GetMembers()
|
{
|
return new IMemberData[] { HelloMember };
|
}
|
|
private IMemberData HelloMember;
|
private Func<object> Creator;
|
public TypeDataTestImpl(string name, ITypeData baseType, Func<object> creator)
|
{
|
Creator = creator;
|
Name = name;
|
BaseType = baseType;
|
HelloMember = new MemberDataTestImpl()
|
{
|
Name = "Hello",
|
Attributes = new object[] { new Cli.CommandLineArgumentAttribute("test") },
|
TypeDescriptor = TypeData.FromType(typeof(string)),
|
DeclaringType = this
|
};
|
}
|
}
|
|
class TestTypeSource : ITypeDataSource
|
{
|
public string Name => "TestTypeSource";
|
List<ITypeData> types = new List<ITypeData>();
|
public string Location => ":test:";
|
public IEnumerable<ITypeData> Types => types.AsReadOnly();
|
public IEnumerable<object> Attributes => Array.Empty<object>();
|
public IEnumerable<ITypeDataSource> References { get; } = Array.Empty<ITypeDataSource>();
|
public string Version => "1.0.0";
|
internal void AddType(ITypeData type) => types.Add(type);
|
|
}
|
|
static readonly TestTypeSource TypeSource = new TestTypeSource();
|
|
static readonly ObservableCollection<ITypeData> hardcodedTypes = new ObservableCollection<ITypeData>
|
{
|
new TypeDataTestImpl( "UnitTestType", TypeData.FromType(typeof(IResultListener)),null),
|
new TypeDataTestImpl( "UnitTestCliActionType", TypeData.FromType(typeof(ICliAction)),() => new SomeTestAction())
|
};
|
|
static TypeDataSearcherTestImpl()
|
{
|
hardcodedTypes.ForEach(TypeSource.AddType);
|
}
|
|
public static void AddType(string name, ITypeData baseType)
|
{
|
hardcodedTypes.Add(new TypeDataTestImpl(name, baseType, null));
|
}
|
|
static SessionLocal<bool> enabled = new SessionLocal<bool>();
|
public static bool Enable { get => enabled.Value; set => enabled.Value = value; }
|
|
private List<ITypeData> _types = new List<ITypeData>();
|
public IEnumerable<ITypeData> Types => Enable ? (_types.Count != hardcodedTypes.Count ? null : _types) : Enumerable.Empty<ITypeData>();
|
|
public void Search()
|
{
|
_types = hardcodedTypes.ToList();
|
}
|
|
public ITypeDataSource GetSource(ITypeData typeData)
|
{
|
if (typeData is TypeDataTestImpl)
|
return TypeSource;
|
return null;
|
}
|
|
public double Priority => 1;
|
|
public ITypeData GetTypeData(string identifier) => hardcodedTypes.FirstOrDefault(x => x.Name == identifier);
|
|
public ITypeData GetTypeData(object obj)
|
{
|
if (obj is SomeTestAction)
|
return hardcodedTypes.Last();
|
return null;
|
}
|
|
event EventHandler<TypeDataCacheInvalidatedEventArgs> cacheInvalidated;
|
public event EventHandler<TypeDataCacheInvalidatedEventArgs> CacheInvalidated
|
{
|
add
|
{
|
if (cacheInvalidated == null)
|
{
|
hardcodedTypes.CollectionChanged += HardcodedTypesOnCollectionChanged;
|
}
|
cacheInvalidated += value;
|
}
|
remove
|
{
|
cacheInvalidated -= value;
|
if (cacheInvalidated == null)
|
{
|
hardcodedTypes.CollectionChanged -= HardcodedTypesOnCollectionChanged;
|
}
|
}
|
}
|
|
void HardcodedTypesOnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
{
|
cacheInvalidated?.Invoke(sender, new TypeDataCacheInvalidatedEventArgs());
|
}
|
}
|
|
interface NonDerivedInterface { }
|
|
[Test]
|
public void NonDerivedInterfaceDerivedTypes()
|
{
|
Assert.IsEmpty(TypeData.FromType(typeof(NonDerivedInterface)).DerivedTypes);
|
}
|
|
[Test]
|
public void ITypeDataSearcherTest()
|
{
|
TypeDataSearcherTestImpl.Enable = true;
|
PluginManager.Search();
|
ITypeData baseType = TypeData.FromType(typeof(IResultListener));
|
var types = TypeData.GetDerivedTypes(baseType);
|
TypeDataSearcherTestImpl.Enable = false;
|
CollectionAssert.IsNotEmpty(types);
|
CollectionAssert.AllItemsAreNotNull(types);
|
CollectionAssert.AllItemsAreUnique(types);
|
Assert.IsTrue(types.All(t => t.DescendsTo(baseType)));
|
Assert.IsTrue(types.Any(t => t.Name == "UnitTestType"));
|
}
|
|
[Test]
|
public void ITypeDataSearcherTest3()
|
{
|
TypeData.GetDerivedTypes<ITestStep>().Count();
|
TypeDataSearcherTestImpl.Enable = true;
|
TypeData.GetDerivedTypes<ITestStep>().Count();
|
int invalidated = 0;
|
TypeData.TypeCacheInvalidated += (obj, evt) =>
|
{
|
invalidated += 1;
|
};
|
try
|
{
|
ITypeData baseType = TypeData.FromType(typeof(IResultListener));
|
Assert.IsNotNull(TypeData.GetTypeData("UnitTestType"));
|
|
TypeData.GetDerivedTypes<ITestStep>().Count();
|
var c1 = TypeData.GetDerivedTypes<IResultListener>().Count();
|
TypeDataSearcherTestImpl.AddType("UnitTestType2", baseType);
|
TypeData.GetDerivedTypes<ITestStep>().Count();
|
var c2 = TypeData.GetDerivedTypes<IResultListener>().Count();
|
TypeDataSearcherTestImpl.AddType("UnitTestType3", baseType);
|
TypeData.GetDerivedTypes<ITestStep>().Count();
|
var c3 = TypeData.GetDerivedTypes<IResultListener>().Count();
|
Assert.IsTrue(c1 + 1 == c2);
|
Assert.IsTrue(c2 + 1 == c3);
|
Assert.IsTrue(invalidated == 2);
|
|
}
|
finally
|
{
|
TypeDataSearcherTestImpl.Enable = false;
|
}
|
}
|
|
|
|
[Browsable(false)]
|
private class SomeTestAction : ICliAction
|
{
|
public static bool WasRun = false;
|
public int Execute(CancellationToken cancellationToken)
|
{
|
WasRun = true;
|
return 0;
|
}
|
}
|
|
|
|
[Test]
|
public void ITypeDataSearcherTest2()
|
{
|
using (Session.Create())
|
{
|
TypeDataSearcherTestImpl.Enable = true;
|
PluginManager.Search();
|
try
|
{
|
|
var actionTypes = TypeData.GetDerivedTypes<ICliAction>();
|
Assert.IsTrue(actionTypes.Any(t => t.Name.EndsWith("UnitTestCliActionType")));
|
SomeTestAction.WasRun = false;
|
CliActionExecutor.Execute(new string[] {"unittesting", "--test", "hello"});
|
Assert.IsTrue(SomeTestAction.WasRun);
|
Assert.AreEqual("hello", TypeDataSearcherTestImpl.MemberDataTestImpl.Value);
|
}
|
finally
|
{
|
TypeDataSearcherTestImpl.Enable = false;
|
}
|
}
|
}
|
|
[Test]
|
public void ITypeDataSourceTest2()
|
{
|
var td2= TypeData.GetTypeData(new DelayStep());
|
var td3= TypeData.GetTypeData(new DialogStep());
|
var source = TypeData.GetTypeDataSource(td2);
|
var v1 = source.Version;
|
var a1 =td2.AsTypeData().Assembly;
|
var v2 = a1.Version;
|
var v3 = a1.SemanticVersion;
|
Assert.IsTrue(source.Location.Contains("OpenTap.Plugins.BasicSteps.dll"));
|
Assert.IsTrue(TypeData.GetTypeDataSource(td3) == TypeData.GetTypeDataSource(td2));
|
Assert.IsTrue(source.Types.Contains(td2.AsTypeData()));
|
Assert.IsTrue(source.Types.Contains(td3.AsTypeData()));
|
|
using (Session.Create())
|
{
|
TypeDataSearcherTestImpl.Enable = true;
|
var td = TypeData.GetTypeData("UnitTestType");
|
Assert.AreEqual(2, TypeData.GetTypeDataSource(td).Types.Count());
|
}
|
}
|
}
|
|
public interface IExpandedObject
|
{
|
object GetValue(string name);
|
void SetValue(string name, object value);
|
string[] Names { get; }
|
}
|
|
public class ExpandedMemberData : IMemberData
|
{
|
public ITypeData DeclaringType { get; set; }
|
|
public IEnumerable<object> Attributes => Array.Empty<object>();
|
|
public string Name { get; set; }
|
|
public bool Writable => true;
|
|
public bool Readable => true;
|
|
public ITypeData TypeDescriptor
|
{
|
get
|
{
|
var desc = DeclaringType as ExpandedTypeInfo;
|
var value = desc.Object.GetValue(Name);
|
if (value == null) return null;
|
return TypeData.GetTypeData(value);
|
}
|
}
|
|
public object GetValue(object owner)
|
{
|
return ((IExpandedObject)owner).GetValue(Name);
|
}
|
|
public void SetValue(object owner, object value)
|
{
|
((IExpandedObject)owner).SetValue(Name, value);
|
}
|
}
|
|
public class ExpandedTypeInfo : ITypeData
|
{
|
public ITypeData InnerDescriptor;
|
public IExpandedObject Object;
|
public ITypeDataProvider Provider { get; set; }
|
|
public string Name => ExpandMemberDataProvider.exp + InnerDescriptor.Name;
|
|
public IEnumerable<object> Attributes => InnerDescriptor.Attributes;
|
|
public ITypeData BaseType => InnerDescriptor;
|
|
public bool CanCreateInstance => InnerDescriptor.CanCreateInstance;
|
|
public object CreateInstance(object[] arguments)
|
{
|
return InnerDescriptor.CreateInstance(arguments);
|
}
|
|
public IMemberData GetMember(string name)
|
{
|
return new ExpandedMemberData { DeclaringType = this, Name = name };
|
}
|
|
public IEnumerable<IMemberData> GetMembers()
|
{
|
var innerMembers = InnerDescriptor.GetMembers();
|
|
foreach(var name in Object.Names)
|
{
|
yield return new ExpandedMemberData { DeclaringType = this, Name = name };
|
}
|
foreach (var mem in innerMembers)
|
yield return mem;
|
}
|
}
|
|
public class ExpandMemberDataProvider : ITypeDataProvider
|
{
|
public double Priority => 1;
|
internal const string exp = "exp@";
|
public ITypeData GetTypeData(string identifier)
|
{
|
if (identifier.StartsWith(exp))
|
{
|
var tp = TypeData.GetTypeData(identifier.Substring(exp.Length));
|
if(tp != null)
|
{
|
return new ExpandedTypeInfo() { InnerDescriptor = tp, Object = null, Provider = this };
|
}
|
}
|
return null;
|
}
|
|
bool excludeSelf = false;
|
public ITypeData GetTypeData(object obj)
|
{
|
if (obj is IExpandedObject exp && excludeSelf == false)
|
{
|
excludeSelf = true;
|
var FoundType = TypeData.GetTypeData(obj);
|
excludeSelf = false;
|
if (FoundType != null)
|
{
|
var expDesc = new ExpandedTypeInfo();
|
expDesc.InnerDescriptor = FoundType;
|
expDesc.Provider = this;
|
expDesc.Object = exp;
|
return expDesc;
|
}
|
}
|
return null;
|
}
|
}
|
|
|
public class MyExpandedObject : IExpandedObject
|
{
|
public double MyProp1 { get; set; }
|
|
Dictionary<string, object> extra = new Dictionary<string, object>();
|
public string[] Names => extra.Keys.ToArray();
|
|
public object GetValue(string name)
|
{
|
object @out = null;
|
extra.TryGetValue(name, out @out);
|
return @out;
|
}
|
|
public void SetValue(string name, object value)
|
{
|
extra[name] = value;
|
}
|
}
|
|
[TestFixture]
|
public class MemberDataProviderTests
|
{
|
[Test]
|
public void AnnotationsTest()
|
{
|
var ds = new DelayStep();
|
var tp = AnnotationCollection.Annotate(ds);
|
var mems = tp.Get<IMembersAnnotation>().Members;
|
var cnt = mems.Count(x =>
|
{
|
var access = x.Get<IAccessAnnotation>();
|
if (access == null)
|
return true;
|
if (x.Get<IMemberAnnotation>().Member.HasAttribute<XmlIgnoreAttribute>())
|
return false;
|
var brows = x.Get<IMemberAnnotation>().Member.GetAttribute<BrowsableAttribute>();
|
if (brows != null && !brows.Browsable) return false;
|
if (access.IsReadOnly == false && access.IsVisible == true)
|
return true;
|
return false;
|
});
|
|
|
Assert.AreEqual(5, cnt);
|
}
|
|
[Test]
|
public void MemberDataTest()
|
{
|
var obj = new DelayStep();
|
var td = TypeData.GetTypeData(obj);
|
var td2 = TypeData.GetTypeData(obj);
|
|
Assert.AreEqual(td, td2);
|
Assert.IsNotNull(td);
|
foreach (var mem in td.GetMembers())
|
{
|
if (mem.Name == "Parent")
|
{
|
Debug.Assert(mem.HasAttribute<XmlIgnoreAttribute>());
|
}
|
Debug.WriteLine(string.Format("Member: {0} {1}", mem.Name, mem.GetValue(obj)));
|
}
|
}
|
|
[Test]
|
public void DerivedTypesTest()
|
{
|
var ilist = TypeData.FromType(typeof(System.Collections.IList));
|
var cmplists = TypeData.FromType(typeof(ComponentSettings)).DerivedTypes.Where(x => x.DescendsTo(ilist));
|
var reslists = cmplists.Where(x => x.ElementType.DescendsTo(typeof(IResource))).ToArray();
|
var inst = reslists.Select(x => ComponentSettings.GetCurrent(x.Type));
|
Assert.IsTrue(reslists.Contains(TypeData.FromType(typeof(InstrumentSettings))));
|
Assert.IsFalse(reslists.Contains(TypeData.FromType(typeof(ConnectionSettings))));
|
Assert.IsTrue(inst.Contains(InstrumentSettings.Current));
|
}
|
|
[Test]
|
public void MemberData2Test()
|
{
|
var obj = new MyExpandedObject() { MyProp1 = 10 };
|
obj.SetValue("asd", 10);
|
|
var td = TypeData.GetTypeData(obj);
|
Assert.IsNotNull(td);
|
foreach (var mem in td.GetMembers())
|
{
|
Debug.WriteLine(string.Format("Member: {0} {1}", mem.Name, mem.GetValue(obj)));
|
}
|
|
var td2 = TypeData.GetTypeData("System.Windows.WindowState");
|
}
|
|
class NestedClass
|
{
|
public double X { get; set; }
|
}
|
|
/// <summary>
|
/// This test verifies the reflection behavior of TypeData to ensure it does not change in the future unpurposedly.
|
/// </summary>
|
[Test]
|
public void TypeDataBehaviors()
|
{
|
|
var obj = new NestedClass();
|
var t = TypeData.GetTypeData(obj);
|
Assert.AreEqual(nameof(NestedClass), t.GetDisplayAttribute().Name);
|
var members = t.GetMembers();
|
Assert.AreEqual(1, members.Count());
|
var x = members.FirstOrDefault();
|
Assert.AreEqual(x, t.GetMember(nameof(NestedClass.X)));
|
Assert.IsTrue(x.Readable);
|
Assert.IsTrue(x.Writable);
|
Assert.AreEqual(t, x.DeclaringType);
|
Assert.AreEqual(TypeData.FromType(typeof(double)), x.TypeDescriptor);
|
Assert.AreEqual(nameof(NestedClass.X), x.GetDisplayAttribute().Name);
|
}
|
|
|
[Test]
|
public void MemberDataSerializeTest()
|
{
|
var obj = new MyExpandedObject() { MyProp1 = 10 };
|
var obj2 = new MyExpandedObject() { MyProp1 = 10 };
|
var obj3 = new MyExpandedObject() { MyProp1 = 10 };
|
//obj.SetValue("asd", 10);
|
obj.SetValue("sub2", obj2);
|
obj2.SetValue("sub3", obj3);
|
|
obj3.SetValue("_10", 10);
|
obj3.SetValue("_20", 20);
|
obj3.SetValue("_array_test", new double[] { 1, 2, 3, 4, 5, 6, 7, 8 });
|
|
var ser = new TapSerializer();
|
var str = ser.SerializeToString(obj);
|
|
var outobj = ser.DeserializeFromString(str);
|
var str2 = ser.SerializeToString(outobj);
|
}
|
|
[Display("I am a class")]
|
public class DataInterfaceTestClass
|
{
|
[Unit("Hz")]
|
public double SimpleNumber { get; set; }
|
|
[AvailableValues("AvailableNumbers")]
|
[Display("From Available")]
|
[Unit("s")]
|
|
public double FromAvailable { get; set; }
|
|
[Unit("s")]
|
[AvailableValues("AvailableNumbers")]
|
public Enabled<double> FromAvailable2 { get; set; } = new Enabled<double>();
|
|
[AvailableValues(nameof(AvailableNumbers))]
|
public List<double> SelectedMulti { get; set; } = new List<double> { 1, 2 };
|
|
|
public IEnumerable<string> AvailableStrings => new[] { "hello", "world", "!" };
|
[AvailableValues(nameof(AvailableStrings))]
|
public List<string> SelectedMultiStrings { get; set; } = new List<string> { };
|
|
|
[Unit("s")]
|
public IEnumerable<double> AvailableNumbers { get; set; } = new double[] { 1, 2, 3, 4, 5 };
|
|
public bool ThingEnabled { get; set; }
|
[EnabledIf("ThingEnabled", true, HideIfDisabled = true)]
|
public string ICanBeEnabled { get; set; }
|
|
[Flags]
|
public enum MultiSelectEnum
|
{
|
|
A = 1,
|
B = 2,
|
C = 4
|
}
|
|
public MultiSelectEnum EnumValues { get; set; } = MultiSelectEnum.A;
|
|
public List<MultiSelectEnum> SelectableValues { get; set; } = new List<MultiSelectEnum> { MultiSelectEnum.A, MultiSelectEnum.A | MultiSelectEnum.B };
|
|
public enum SingleEnum
|
{
|
[Display("AAA", Order: 2)]
|
A,
|
B
|
}
|
|
public SingleEnum TheSingleEnum { get; set; }
|
|
public IEnumerable<SingleEnum> OneEnum => new[] { SingleEnum.A };
|
[AvailableValues(nameof(OneEnum))]
|
public SingleEnum AvailSingleEnum { get; set; } = SingleEnum.A;
|
|
|
public List<ScpiInstrument> Instruments { get; set; } = new List<ScpiInstrument>();
|
|
[AvailableValues(nameof(Instruments))]
|
public IResource ResourceWithAvailable { get; set; }
|
public double? NullableDouble { get; set; }
|
public class Data1
|
{
|
public string X { get; set; }
|
}
|
|
List<Data1> list = new List<Data1> { new Data1 { X = "5" }, new Data1 { X = "1" } };
|
|
[Browsable(true)]
|
[XmlIgnore]
|
public IReadOnlyList<Data1> Data1List
|
{
|
get => list.AsReadOnly();
|
set { }
|
}
|
|
public List<Data1> Data2List { get; set; } = new List<Data1> { new Data1 { X = "1" } };
|
|
public Data1[] DataArray { get; set; } = new Data1[] { new Data1 { X = "5" }, new Data1 { X = "Y" } };
|
|
[DirectoryPath]
|
public Enabled<string> EnabledDirectoryString { get; set; }
|
|
[Display("Do Something")]
|
[Browsable(true)]
|
public void ButtonExample()
|
{
|
Clicks++;
|
}
|
|
public int Clicks;
|
|
[Browsable(true)]
|
public int MethodExample(int X, int Y)
|
{
|
return X + Y;
|
}
|
|
[Flags]
|
public enum LongEnum: long{
|
Test0 = 1L << 0,
|
Test1 = 1L << 1,
|
Test2 = 1L << 2,
|
Test3 = 1L << 3,
|
Test4 = 1L << 4,
|
Test5 = 1L << 5,
|
Test6 = 1L << 6,
|
Test7 = 1L << 7,
|
Test8 = 1L << 8,
|
Test9 = 1L << 9,
|
Test10 = 1L << 10,
|
Test11 = 1L << 11,
|
Test12 = 1L << 12,
|
Test13 = 1L << 13,
|
Test14 = 1L << 14,
|
Test15 = 1L << 15,
|
Test16 = 1L << 16,
|
Test17 = 1L << 17,
|
Test18 = 1L << 18,
|
Test19 = 1L << 19,
|
Test20 = 1L << 20,
|
Test21 = 1L << 21,
|
Test22 = 1L << 22,
|
Test23 = 1L << 23,
|
Test24 = 1L << 24,
|
Test25 = 1L << 25,
|
Test26 = 1L << 26,
|
Test27 = 1L << 27,
|
Test28 = 1L << 28,
|
Test29 = 1L << 29,
|
Test30 = 1L << 30,
|
Test31 = 1L << 31,
|
Test32 = 1L << 32,
|
Test33 = 1L << 33,
|
Test34 = 1L << 34,
|
Test35 = 1L << 35,
|
Test36 = 1L << 36,
|
Test37 = 1L << 37,
|
Test38 = 1L << 38,
|
Test39 = 1L << 39,
|
Test40 = 1L << 40,
|
Test41 = 1L << 41,
|
Test42 = 1L << 42,
|
Test43 = 1L << 43,
|
Test44 = 1L << 44,
|
Test45 = 1L << 45,
|
Test46 = 1L << 46,
|
Test47 = 1L << 47,
|
Test48 = 1L << 48,
|
Test49 = 1L << 49,
|
Test50 = 1L << 50,
|
Test51 = 1L << 51,
|
Test52 = 1L << 52,
|
Test53 = 1L << 53,
|
Test54 = 1L << 54,
|
Test55 = 1L << 55,
|
Test56 = 1L << 56,
|
Test57 = 1L << 57,
|
Test58 = 1L << 58,
|
Test59 = 1L << 59,
|
Test60 = 1L << 60,
|
Test61 = 1L << 61,
|
Test62 = 1L << 62,
|
Test63 = 1L << 63,
|
}
|
|
public LongEnum LongEnumValue { get; set; }
|
|
}
|
|
|
[Test]
|
public void DataInterfaceProviderTest2()
|
{
|
var sval = AnnotationCollection.Annotate(DataInterfaceTestClass.SingleEnum.A).Get<IStringValueAnnotation>().Value;
|
Assert.AreEqual("AAA", sval);
|
InstrumentSettings.Current.Add(new ScpiInstrument());
|
DataInterfaceTestClass testobj = new DataInterfaceTestClass();
|
|
AnnotationCollection annotations = AnnotationCollection.Annotate(testobj, Array.Empty<IAnnotation>());
|
var disp = annotations.Get<DisplayAttribute>();
|
Assert.IsNotNull(disp);
|
var objectValue = annotations.Get<IObjectValueAnnotation>();
|
Assert.AreEqual(testobj, objectValue.Value);
|
|
var members = annotations.Get<IMembersAnnotation>();
|
foreach (var member in members.Members)
|
{
|
Assert.AreEqual(member.ParentAnnotation, annotations);
|
var mem = member.Get<IMemberAnnotation>();
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.EnumValues))
|
{
|
var proxy = member.Get<IMultiSelectAnnotationProxy>();
|
var selected = proxy.SelectedValues.ToArray();
|
proxy.SelectedValues = member.Get<IAvailableValuesAnnotationProxy>().AvailableValues;
|
}
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.SelectableValues))
|
{
|
|
}
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.LongEnumValue))
|
{
|
var proxy = member.Get<IMultiSelectAnnotationProxy>();
|
var selected = proxy.SelectedValues.ToArray();
|
Assert.AreEqual(0, selected.Length);
|
proxy.SelectedValues = member.Get<IAvailableValuesAnnotationProxy>().AvailableValues;
|
Assert.AreEqual(64, proxy.SelectedValues.Count());
|
}
|
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.ButtonExample))
|
{
|
var member2 = member.Get<IMethodAnnotation>();
|
member2.Invoke();
|
Assert.AreEqual(1, testobj.Clicks);
|
var access = member.Get<IAccessAnnotation>();
|
Assert.IsTrue(access.IsVisible);
|
Assert.IsTrue(access.IsReadOnly);
|
}
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.MethodExample))
|
{
|
var methodAnnotation = member.Get<IMethodAnnotation>();
|
Assert.IsNull(methodAnnotation); // MethodExample has arguments. Should be used by IMethodAnnotation.
|
var del = (Delegate)member.Get<IObjectValueAnnotation>().Value;
|
int result = (int)del.DynamicInvoke(5, 10);
|
Assert.AreEqual(15, result);
|
}
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.EnabledDirectoryString))
|
{
|
var enabledMembers = member.Get<IMembersAnnotation>().Members.ToArray();
|
Assert.AreEqual(2, enabledMembers.Length);
|
var valueMember = enabledMembers[1];
|
var directoryPathAttr = valueMember.Get<DirectoryPathAttribute>();
|
Assert.IsNotNull(directoryPathAttr);
|
}
|
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.AvailSingleEnum))
|
{
|
// #4702 : AvailableValuesAttribute should override enum behavior.
|
var avail = member.Get<IAvailableValuesAnnotation>();
|
Assert.AreEqual(1, avail.AvailableValues.Cast<object>().Count());
|
}
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.FromAvailable))
|
{
|
var avail = member.Get<IAvailableValuesAnnotationProxy>();
|
var available = avail.AvailableValues.ToArray();
|
|
avail.SelectedValue = available[2];
|
var subavail = avail.SelectedValue.Get<IAvailableValuesAnnotationProxy>();
|
Assert.IsNull(subavail);
|
var unit = avail.SelectedValue.Get<UnitAttribute>();
|
Assert.IsNotNull(unit);
|
|
var str = avail.SelectedValue.Get<IStringValueAnnotation>();
|
Assert.IsNotNull(str);
|
var val = str.Value;
|
}
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.FromAvailable2))
|
{
|
var subMembers = member.Get<IMembersAnnotation>();
|
var valueMember = subMembers.Members.FirstOrDefault(x => x.Get<IMemberAnnotation>().Member.Name == nameof(Enabled<int>.Value));
|
var unit = valueMember.Get<UnitAttribute>();
|
Assert.IsNotNull(unit);
|
var subunit = valueMember.Get<IAvailableValuesAnnotationProxy>().AvailableValues.FirstOrDefault().Get<UnitAttribute>();
|
Assert.AreEqual(unit, subunit);
|
var val = valueMember.Get<IStringValueAnnotation>();
|
val.Value = "123";
|
var nowVal = val.Value;
|
annotations.Write();
|
annotations.Read();
|
Assert.AreEqual(nowVal, val.Value);
|
|
}
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.TheSingleEnum))
|
{
|
var avail = member.Get<IAvailableValuesAnnotationProxy>();
|
var bEnum = avail.AvailableValues.First();
|
var bDisplay = bEnum.Get<IStringValueAnnotation>();
|
Assert.AreEqual("B", bDisplay.Value);
|
|
// order inverted because of display order.
|
var aEnum = avail.AvailableValues.Last();
|
var aDisplay = aEnum.Get<IStringValueAnnotation>();
|
Assert.AreEqual("AAA", aDisplay.Value);
|
}
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.Instruments))
|
{
|
var prox = member.Get<IAvailableValuesAnnotationProxy>();
|
var instprox = prox.AvailableValues.FirstOrDefault();
|
var col = instprox.Get<ICollectionAnnotation>();
|
Assert.IsNull(col);
|
}
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.NullableDouble))
|
{
|
var num = member.Get<IStringValueAnnotation>();
|
Assert.IsNotNull(num);
|
num.Value = "5";
|
var val = member.Get<IObjectValueAnnotation>();
|
Assert.AreEqual(5, (double)val.Value);
|
num.Value = "";
|
Assert.IsNull(val.Value);
|
|
}
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.Data1List))
|
{
|
var prox = member.Get<ICollectionAnnotation>();
|
var annotated = prox.AnnotatedElements.ToArray();
|
member.Write();
|
}
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.Data2List))
|
{
|
|
|
var prox = member.Get<ICollectionAnnotation>();
|
|
|
void addElement(string text)
|
{
|
var newelem = prox.NewElement();
|
newelem.Get<IMembersAnnotation>().Members.FirstOrDefault().Get<IStringValueAnnotation>().Value = text;
|
prox.AnnotatedElements = prox.AnnotatedElements.Append(newelem);
|
}
|
|
member.Write();
|
prox.AnnotatedElements = prox.AnnotatedElements.Skip(1);
|
addElement("2");
|
addElement("3");
|
addElement("4");
|
member.Write();
|
var lst = testobj.Data2List;
|
Assert.IsTrue(lst[0].X == "2" && lst[1].X == "3" && lst[2].X == "4" && lst.Count == 3);
|
|
prox.AnnotatedElements = prox.AnnotatedElements.Reverse();
|
member.Write();
|
Assert.IsTrue(lst[2].X == "2" && lst[1].X == "3" && lst[0].X == "4" && lst.Count == 3);
|
var tmplst = prox.AnnotatedElements.ToList();
|
tmplst.RemoveAt(1);
|
prox.AnnotatedElements = tmplst;
|
member.Write();
|
Assert.IsTrue(lst[1].X == "2" && lst[0].X == "4" && lst.Count == 2);
|
|
|
}
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.DataArray))
|
{
|
var prox = member.Get<ICollectionAnnotation>();
|
var annotated = prox.AnnotatedElements.ToArray();
|
var newelem = prox.NewElement();
|
newelem.Get<IObjectValueAnnotation>().Value = new DataInterfaceTestClass.Data1();
|
prox.AnnotatedElements = prox.AnnotatedElements.Append(newelem);
|
try
|
{
|
member.Write();
|
}
|
catch
|
{
|
// See OpenTAP issue #347 -- functionality was added to allow writing to fixed size collections by resizing them
|
Assert.Fail("This shouldn't throw an exception");
|
}
|
member.Read();
|
}
|
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.ResourceWithAvailable))
|
{
|
// Verify that "AvailableValuesAnnotation" is chosen over "ResourceAnnotation".
|
Assert.AreEqual(2, member.Count(x => x is IAvailableValuesAnnotation));
|
var firstAvail = member.Get<IAvailableValuesAnnotation>().ToString();
|
var firstAvailName = "AvailableValuesAnnotation";
|
Assert.IsTrue(firstAvail.Contains(firstAvailName));
|
var secondAvail = member.GetAll<IAvailableValuesAnnotation>().Last();
|
var secondAvailName = "ResourceAnnotation";
|
Assert.IsTrue(secondAvail.ToString().Contains(secondAvailName));
|
}
|
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.SelectedMulti))
|
{
|
var proxy = member.Get<IMultiSelectAnnotationProxy>();
|
var avail = member.Get<IAvailableValuesAnnotationProxy>();
|
proxy.SelectedValues = avail.AvailableValues;
|
annotations.Write(testobj);
|
Assert.IsTrue(testobj.SelectedMulti.ToHashSet().SetEquals(testobj.AvailableNumbers));
|
proxy.SelectedValues = Array.Empty<AnnotationCollection>();
|
annotations.Write(testobj);
|
Assert.AreEqual(0, testobj.SelectedMulti.Count);
|
}
|
|
if (mem.Member.Name == nameof(DataInterfaceTestClass.SelectedMultiStrings))
|
{
|
var proxy = member.Get<IMultiSelectAnnotationProxy>();
|
var avail = member.Get<IAvailableValuesAnnotationProxy>();
|
proxy.SelectedValues = avail.AvailableValues;
|
annotations.Write(testobj);
|
Assert.IsTrue(testobj.SelectedMultiStrings.ToHashSet().SetEquals(testobj.AvailableStrings));
|
proxy.SelectedValues = Array.Empty<AnnotationCollection>();
|
annotations.Write(testobj);
|
Assert.AreEqual(0, testobj.SelectedMulti.Count);
|
}
|
}
|
annotations.Write(testobj);
|
|
}
|
|
[Flags]
|
public enum FlagTestEnum
|
{
|
A = 1,
|
B = 2,
|
C = 4
|
}
|
|
public class Delay2Step : TestStep
|
{
|
[Display("Time Delay")]
|
public double TimeDelay { get; set; }
|
|
[Display("Time Delay")]
|
public double TimeDelay2 { get; set; }
|
|
[AvailableValues(nameof(AvailableValues))]
|
public string SelectedValue { get; set; }
|
public IEnumerable<string> AvailableValues => AvailableValuesField;
|
public IEnumerable<string> AvailableValuesField = new string[0] ;
|
|
public FlagTestEnum SelectedValues { get; set; } = FlagTestEnum.A;
|
|
public FlagTestEnum ExpectedValues = FlagTestEnum.A | FlagTestEnum.B | FlagTestEnum.C;
|
|
public override void Run()
|
{
|
if (TimeDelay != TimeDelay2)
|
throw new Exception($"{nameof(TimeDelay)} != {nameof(TimeDelay2)}");
|
if(SelectedValues != ExpectedValues) //SelectedValues must be set to the ExpectedValues.
|
throw new Exception("Expected SelectedValues to be set to all AvailableValues");
|
}
|
}
|
|
/// <summary>
|
/// Delay step that is quick to run.
|
/// </summary>
|
class FakeDelayStep : DelayStep
|
{
|
public override void Run()
|
{
|
|
}
|
}
|
|
|
[Test]
|
public void SweepLoopProviderTest()
|
{
|
System.Globalization.CultureInfo.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
|
var sweep = new SweepLoop();
|
var delay1 = new FakeDelayStep();
|
sweep.ChildTestSteps.Add(delay1);
|
|
var delay2 = new Delay2Step() {AvailableValuesField = new[] { "A", "B", "C" }};
|
sweep.ChildTestSteps.Add(delay2);
|
|
var delay3 = new Delay2Step() { AvailableValuesField = new[] { "A", "B", "D" }};
|
sweep.ChildTestSteps.Add(delay3);
|
|
var annotation = AnnotationCollection.Annotate(sweep);
|
|
var smem = annotation.GetMember(nameof(SweepLoop.SweepMembers));
|
{
|
{
|
var select = smem.Get<IMultiSelect>();
|
var avail = smem.Get<IAvailableValuesAnnotation>();
|
|
select.Selected = new object[] { };
|
annotation.Write(sweep);
|
annotation.Read(sweep);
|
Assert.AreEqual(0, select.Selected.Cast<object>().Count());
|
|
select.Selected = new object[] { avail.AvailableValues.Cast<object>().First() };
|
annotation.Write(sweep);
|
annotation.Read(sweep);
|
Assert.AreEqual(3, select.Selected.Cast<object>().Count());
|
|
Assert.AreEqual(4, avail.AvailableValues.Cast<object>().Count()); // DelayStep only has on property.
|
select.Selected = smem.Get<IAvailableValuesAnnotation>().AvailableValues;
|
annotation.Write(sweep);
|
annotation.Read(sweep);
|
}
|
}
|
|
var smem2 = annotation.GetMember(nameof(SweepLoop.SweepParameters));
|
{
|
var collection = smem2.Get<ICollectionAnnotation>();
|
{
|
var new_element = collection.NewElement();
|
collection.AnnotatedElements = collection.AnnotatedElements.Append(new_element).ToArray();
|
var new_element_members = new_element.Get<IMembersAnnotation>();
|
var members = new_element_members.Members.ToArray();
|
Assert.AreEqual(4, members.Length);
|
|
var enabled_element = members[0];
|
Assert.IsTrue(enabled_element.Get<IMemberAnnotation>().Member.Name == "Enabled");
|
Assert.IsTrue((bool) enabled_element.Get<IObjectValueAnnotation>().Value == true);
|
|
var delay_element = members[1];
|
var delay_value = delay_element.Get<IStringValueAnnotation>();
|
Assert.IsTrue(delay_value.Value.Contains("0.1 s")); // the default value for DelayStep is 0.1s.
|
delay_value.Value = "0.1 s";
|
|
var selected_element = members[2];
|
var available_for_Select = selected_element.Get<IAvailableValuesAnnotationProxy>();
|
// ~Since they only have two available values in common, the list should only contain those two elements.~
|
// Actually since this behavior conflicts with Enabled<> behavior, it just has the available values from the first one.
|
Assert.IsTrue(available_for_Select.AvailableValues.Cast<object>().Count() == 3);
|
|
annotation.Write();
|
}
|
var firstDelay = sweep.SweepParameters.First().Values.ElementAt(0);
|
var delay_value2 = collection.AnnotatedElements.First().Get<IMembersAnnotation>().Members.ElementAt(1)
|
.Get<IStringValueAnnotation>();
|
Assert.AreEqual(0.1, (double)firstDelay);
|
delay_value2.Value = "0.01 s";
|
annotation.Write();
|
for (int i = 0; i < 5; i++)
|
{
|
var new_element2 = collection.NewElement();
|
collection.AnnotatedElements = collection.AnnotatedElements.Append(new_element2).ToArray();
|
var new_element2_members = new_element2.Get<IMembersAnnotation>().Members.ToArray();
|
|
var enabled_element2 = new_element2_members[0];
|
|
Assert.IsTrue(enabled_element2.Get<IMemberAnnotation>().Member.Name == "Enabled");
|
Assert.IsTrue((bool)enabled_element2.Get<IObjectValueAnnotation>().Value == true);
|
if (i == 2 || i == 3)
|
{
|
enabled_element2.Get<IObjectValueAnnotation>().Value = false;
|
}
|
|
var delay_element2 = new_element2_members.First(x => x.Get<IMemberAnnotation>().Member.Name == "DelaySecs");
|
var delay_value3 = delay_element2.Get<IStringValueAnnotation>();
|
// SweepLoop should copy the previous value for new rows.
|
Assert.IsTrue(delay_value3.Value.Contains("0.01 s"));
|
}
|
|
foreach (var elem in collection.AnnotatedElements)
|
{
|
var selected_values_annotation = elem.Get<IMembersAnnotation>().Members.First(x => x.Get<IMemberAnnotation>().Member.Name == "SelectedValues");
|
var sel = selected_values_annotation.Get<IMultiSelectAnnotationProxy>();
|
Assert.IsNotNull(sel);
|
var sel_avail = selected_values_annotation.Get<IAvailableValuesAnnotationProxy>();
|
sel.SelectedValues = sel_avail.AvailableValues;
|
}
|
|
annotation.Write();
|
{
|
// remove an additional disable row.
|
// this verifies that removing rows works.
|
var lst = collection.AnnotatedElements.ToList();
|
lst.RemoveAt(3);
|
collection.AnnotatedElements = lst;
|
annotation.Write();
|
}
|
annotation.Read();
|
{
|
var elem = collection.AnnotatedElements.First();
|
var mem2 = elem.GetMember("DelaySecs");
|
mem2.Get<IStringValueAnnotation>().Value = "1.123 s";
|
annotation.Write();
|
annotation.Read();
|
var nowvalue = mem2.Get<IStringValueAnnotation>().Value;
|
Assert.AreEqual("1.123 s", nowvalue);
|
}
|
}
|
|
var rlistener = new PlanRunCollectorListener() { CollectResults = true };
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(sweep);
|
var run = plan.Execute(new[] { rlistener });
|
Assert.AreEqual(Verdict.NotSet, run.Verdict);
|
|
// one of the sweep rows was disabled.
|
Assert.AreEqual(13, rlistener.StepRuns.Count);
|
|
{ // verify that when child steps are deleted, the list is updated.
|
sweep.ChildTestSteps.Remove(delay2);
|
sweep.ChildTestSteps.Remove(delay3);
|
annotation.Read();
|
var av = smem.Get<IAvailableValuesAnnotation>().AvailableValues.Cast<object>().ToList();
|
Assert.AreEqual(2, av.Count); // Select All + Time Delay.
|
}
|
}
|
[Test]
|
public void SweepLoopRangeCheck()
|
{
|
var plan = new TestPlan();
|
var sweep = new SweepLoopRange();
|
var delay = new DelayStep();
|
var delay2 = new Delay2Step();
|
sweep.ChildTestSteps.Add(delay);
|
sweep.ChildTestSteps.Add(delay2);
|
plan.ChildTestSteps.Add(sweep);
|
|
var a = AnnotationCollection.Annotate(sweep);
|
var member = TypeData.GetTypeData(sweep).GetMember(nameof(SweepLoopRange.SweepProperties));
|
var b = a.Get<IMembersAnnotation>().Members.First(x => x.Get<IMemberAnnotation>().Member == member);
|
var proxy = b.Get<IMultiSelectAnnotationProxy>();
|
var avail = b.Get<IAvailableValuesAnnotationProxy>();
|
proxy.SelectedValues = avail.AvailableValues;
|
a.Write();
|
Assert.AreEqual(3, sweep.SweepProperties.Count);
|
sweep.ChildTestSteps.Remove(delay); // this should cause the SweepProperty to be removed.
|
var delayStepType = TypeData.GetTypeData((delay));
|
Assert.AreEqual(2, sweep.SweepProperties.Count);
|
foreach (var mem in sweep.SweepProperties)
|
{
|
Assert.AreNotEqual(delayStepType, mem.DeclaringType);
|
}
|
}
|
|
[Test]
|
public void DataInterfaceProviderTest()
|
{
|
DataInterfaceTestClass testobj = new DataInterfaceTestClass();
|
dataInterfaceProviderInnerTest(testobj);
|
}
|
|
void dataInterfaceProviderInnerTest(object testobj)
|
{
|
|
var _annotation = AnnotationCollection.Annotate(testobj);
|
|
ITypeData desc = TypeData.GetTypeData(testobj);
|
IMemberData mem = desc.GetMember("FromAvailable");
|
var named = _annotation.Get<INamedMembersAnnotation>();
|
|
var annotation = named.GetMember(mem);
|
IAvailableValuesAnnotationProxy prov = annotation.Get<IAvailableValuesAnnotationProxy>();
|
IObjectValueAnnotation val = annotation.Get<IObjectValueAnnotation>();
|
val.Value = prov.AvailableValues.Cast<object>().FirstOrDefault();
|
|
var display = annotation.Get<IDisplayAnnotation>();
|
var unit = annotation.Get<UnitAttribute>();
|
|
var mem2 = desc.GetMember("SimpleNumber");
|
var annotation2 = named.GetMember(mem2);
|
var unit2 = annotation2.Get<UnitAttribute>();
|
var num = annotation2.Get<IStringValueAnnotation>();
|
var currentVal = num.Value;
|
num.Value = "4";
|
try
|
{
|
num.Value = "asd";
|
}
|
catch (Exception)
|
{
|
|
}
|
currentVal = num.Value;
|
Assert.AreEqual(currentVal, "4 Hz");
|
{
|
var mem3 = desc.GetMember("AvailableNumbers");
|
var annotation3 = named.GetMember(mem3);
|
var numseq = annotation3.Get<IStringValueAnnotation>();
|
var numbersstring = numseq.Value;
|
numseq.Value = "1:100";
|
annotation3.Write(testobj);
|
Assert.AreEqual(100, ((System.Collections.IEnumerable)mem3.GetValue(testobj)).Cast<object>().Count());
|
}
|
{
|
var mem3 = desc.GetMember("ICanBeEnabled");
|
var annotation3 = named.GetMember(mem3);
|
var enabled = annotation3.Get<IAccessAnnotation>();
|
Assert.IsTrue(enabled.IsReadOnly);
|
Assert.IsFalse(enabled.IsVisible);
|
|
var mem4 = desc.GetMember("ThingEnabled");
|
var annotation4 = named.GetMember(mem4);
|
annotation4.Get<IObjectValueAnnotation>().Value = true;
|
annotation4.Write(testobj);
|
//annotation4.Read(testobj);
|
annotation3.Read(testobj);
|
Assert.IsFalse(enabled.IsReadOnly);
|
Assert.IsTrue(enabled.IsVisible);
|
}
|
|
{
|
var mem3 = desc.GetMember("EnumValues");
|
var annotation3 = named.GetMember(mem3);
|
var select = annotation3.Get<IMultiSelect>();
|
//select.Selected = select.AvailableValues.Cast<object>().ToArray();
|
//annotation3.Write(testobj);
|
//Assert.AreEqual(DataInterfaceTestClass.MultiSelectEnum.A | DataInterfaceTestClass.MultiSelectEnum.B| DataInterfaceTestClass.MultiSelectEnum.C, testobj.EnumValues);
|
}
|
|
{
|
var mem3 = desc.GetMember("SelectableValues");
|
var annotation3 = named.GetMember(mem3);
|
var col = annotation3.Get<ICollectionAnnotation>();
|
|
var annotated = col.AnnotatedElements.ToArray();
|
Assert.AreEqual(2, annotated.Length);
|
col.AnnotatedElements = new[] { col.NewElement(), col.NewElement(), col.NewElement(), col.NewElement(), col.NewElement(), col.NewElement() };
|
annotated = col.AnnotatedElements.ToArray();
|
var num5 = annotated[3];
|
//var avail1 = num5.Get<IMultiSelect>().AvailableValues.Cast<object>().ToArray()[1];
|
//num5.Get<IMultiSelect>().Selected = new[] { num5.Get<IMultiSelect>().AvailableValues.Cast<object>().ToArray()[1] };
|
//var enumv1 = DataInterfaceTestClass.MultiSelectEnum.B;
|
//annotation3.Write(testobj);
|
//Assert.AreEqual(enumv1, testobj.SelectableValues[3]);
|
}
|
|
|
}
|
|
[Test]
|
public void ExpandedDataInterfaceProviderTest()
|
{
|
var exp = new MyExpandedObject();
|
exp.SetValue("_test_", 10);
|
exp.SetValue("_test_array_", new double[] { 1, 2, 3, 4, 5, 6 });
|
ITypeData desc = TypeData.GetTypeData(exp);
|
foreach (var member in desc.GetMembers())
|
{
|
AnnotationCollection annotation = AnnotationCollection.Create(exp, member);
|
foreach (var anot in annotation)
|
{
|
Debug.WriteLine("Member {0} Annotation: {1}", member.Name, anot);
|
}
|
}
|
}
|
|
[Test]
|
public void MultiSelectAnnotationsInterfaceTest()
|
{
|
var plan = new TestPlan();
|
var steps = new List<DialogStep> { new DialogStep { UseTimeout = false }, new DialogStep { UseTimeout = false }, new DialogStep { UseTimeout = true } };
|
plan.ChildTestSteps.AddRange(steps);
|
|
var mem = AnnotationCollection.Annotate(steps);
|
var val = mem.Get<IMembersAnnotation>();
|
Assert.IsNotNull(val);
|
|
var useTimeoutMember = mem.GetMember(nameof(DialogStep.UseTimeout));
|
Assert.IsNull(useTimeoutMember.Get<IObjectValueAnnotation>().Value); // since one is different, this should be null.
|
useTimeoutMember.Get<IObjectValueAnnotation>().Value = true; // set all UseTimeout to true.
|
|
var messageMember = mem.GetMember(nameof(DialogStep.Message));
|
string theMessage = "My message";
|
messageMember.Get<IStringValueAnnotation>().Value = theMessage;
|
mem.Write();
|
foreach (var step in steps)
|
{
|
Assert.IsTrue(string.Compare(theMessage, step.Message) == 0);
|
Assert.IsTrue(step.UseTimeout);
|
}
|
|
{
|
// check Break Conditions
|
var cval = BreakConditionProperty.GetBreakCondition(steps[0]);
|
Assert.AreEqual(BreakCondition.Inherit, cval);
|
var bk = mem.GetMember("BreakConditions");
|
var descriptor = bk.GetMember("Value").Get<IValueDescriptionAnnotation>();
|
var description = descriptor.Describe();
|
var tostringer = bk.GetMember("Value").Get<IStringReadOnlyValueAnnotation>();
|
var tostringvalue = tostringer.Value;
|
|
Assert.AreEqual("Break on Error (inherited from engine settings).", description);
|
Assert.AreEqual("Break on Error", tostringvalue);
|
var enabled = bk.Get<IEnabledValueAnnotation>();
|
Assert.IsNotNull(enabled.Value.Get<IAvailableValuesAnnotationProxy>());
|
|
Assert.IsFalse((bool)(enabled.IsEnabled.Get<IObjectValueAnnotation>().Value));
|
enabled.IsEnabled.Get<IObjectValueAnnotation>().Value = true;
|
mem.Write();
|
mem.Read();
|
|
cval = BreakConditionProperty.GetBreakCondition(steps[0]);
|
Assert.AreEqual(BreakCondition.BreakOnError, cval);
|
Assert.IsTrue((bool)enabled.IsEnabled.Get<IObjectValueAnnotation>().Value);
|
enabled.IsEnabled.Get<IObjectValueAnnotation>().Value = false;
|
mem.Write();
|
cval = BreakConditionProperty.GetBreakCondition(steps[0]);
|
Assert.AreEqual(BreakCondition.Inherit, cval);
|
}
|
}
|
|
// Class to assert title of dialog user interface
|
class DialogTestUserInterface : IUserInputInterface
|
{
|
public void RequestUserInput(object dataObject, TimeSpan Timeout, bool modal)
|
{
|
var a = AnnotationCollection.Annotate(dataObject);
|
var display = a.Get<IDisplayAnnotation>();
|
Assert.AreEqual(1, a.GetAll<IDisplayAnnotation>().Count());
|
Assert.AreEqual("Title", display.Name);
|
}
|
}
|
[Test]
|
public void TestDisplayAnnotationForDialogStep()
|
{
|
var currentUserInterface = UserInput.Interface;
|
var menuInterface = new DialogTestUserInterface();
|
UserInput.SetInterface(menuInterface);
|
try
|
{
|
var plan = new TestPlan();
|
var step = new DialogStep { UseTimeout = false };
|
plan.Steps.Add(step);
|
plan.Execute();
|
}
|
finally
|
{
|
UserInput.SetInterface((IUserInputInterface) currentUserInterface);
|
}
|
}
|
|
[Display("Title")]
|
class DialogDisplay
|
{
|
[Display("Serial Number")]
|
public string SerialNumber { get; set; }
|
}
|
|
class DisplayDialogStep : TestStep
|
{
|
public DisplayDialogStep() { }
|
|
public override void Run()
|
{
|
var req = new DialogDisplay();
|
UserInput.Request(req, TimeSpan.FromSeconds(1000), false);
|
}
|
}
|
|
[Test]
|
public void TestDisplayDialog()
|
{
|
var currentUserInterface = UserInput.Interface;
|
var menuInterface = new DialogTestUserInterface();
|
UserInput.SetInterface(menuInterface);
|
try
|
{
|
var plan = new TestPlan();
|
var step = new DisplayDialogStep();
|
|
plan.Steps.Add(step);
|
plan.Execute();
|
}
|
finally
|
{
|
UserInput.SetInterface((IUserInputInterface)currentUserInterface);
|
}
|
}
|
|
[Test]
|
public void MultiSelectAnnotationsInterfaceTest3()
|
{
|
var plan = new TestPlan();
|
var steps = new List<DialogStep> { new DialogStep { UseTimeout = false }, new DialogStep { UseTimeout = false }, new DialogStep { UseTimeout = true } };
|
BreakConditionProperty.SetBreakCondition(steps[0], BreakCondition.BreakOnError);
|
BreakConditionProperty.SetBreakCondition(steps[1], BreakCondition.BreakOnFail);
|
BreakConditionProperty.SetBreakCondition(steps[2], BreakCondition.BreakOnInconclusive);
|
plan.ChildTestSteps.AddRange(steps);
|
|
var mem = AnnotationCollection.Annotate(steps);
|
var bk = mem.GetMember("BreakConditions");
|
var descriptor = bk.GetMember("Value").Get<IValueDescriptionAnnotation>();
|
var description = descriptor.Describe();
|
var tostringer = bk.GetMember("Value").Get<IStringReadOnlyValueAnnotation>();
|
var tostringvalue = tostringer.Value;
|
StringAssert.Contains("different", description);
|
Assert.AreEqual("", tostringvalue);
|
|
BreakConditionProperty.SetBreakCondition(steps[0], 0);
|
BreakConditionProperty.SetBreakCondition(steps[1], 0);
|
BreakConditionProperty.SetBreakCondition(steps[2], 0);
|
mem.Read();
|
var tostringvalue2 = tostringer.Value;
|
Assert.AreEqual("None", tostringvalue2);
|
}
|
|
[Test]
|
public void MultiSelectAnnotationsInterfaceTest2()
|
{
|
var plan = new TestPlan();
|
var steps = new List<ProcessStep> { new ProcessStep {}, new ProcessStep {}, new ProcessStep {} };
|
plan.ChildTestSteps.AddRange(steps);
|
|
var mem = AnnotationCollection.Annotate(steps);
|
|
{
|
// check Break Conditions
|
var cval =steps[0].ResultRegularExpressionPattern;
|
Assert.IsFalse(cval.IsEnabled);
|
var bk = mem.GetMember("ResultRegularExpressionPattern");
|
var enabled = bk.Get<IEnabledValueAnnotation>();
|
Assert.IsFalse((bool)(enabled.IsEnabled.Get<IObjectValueAnnotation>().Value));
|
enabled.IsEnabled.Get<IObjectValueAnnotation>().Value = true;
|
mem.Write();
|
mem.Read();
|
|
cval = steps[0].ResultRegularExpressionPattern;
|
Assert.IsTrue(cval.IsEnabled);
|
Assert.IsTrue((bool)enabled.IsEnabled.Get<IObjectValueAnnotation>().Value);
|
enabled.IsEnabled.Get<IObjectValueAnnotation>().Value = false;
|
mem.Write();
|
cval = steps[0].ResultRegularExpressionPattern;
|
Assert.IsFalse(cval.IsEnabled);
|
}
|
|
|
}
|
|
[Test]
|
public void DisallowParentInput()
|
{
|
// #3666 Custom sweeping with parents having output properties.
|
// If an input depends on an output from a parent, it will hang forever.
|
// this test ensures that the output is not available for selection in the GUI.
|
ReadInputStep step1 = new ReadInputStep();
|
OutputParentStep theParent = new OutputParentStep();
|
OutputParentStep step3 = new OutputParentStep();
|
OutputParentStep step4 = new OutputParentStep();
|
theParent.ChildTestSteps.Add(step1);
|
theParent.ChildTestSteps.Add(step3);
|
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(theParent);
|
plan.ChildTestSteps.Add(step4);
|
|
var annotation = AnnotationCollection.Annotate(step1);
|
var inputAnnotation = annotation.GetMember(nameof(ReadInputStep.Input));
|
var avail = inputAnnotation.Get<IAvailableValuesAnnotation>();
|
var setVal = avail as IAvailableValuesSelectedAnnotation;
|
foreach (var val in avail.AvailableValues.Cast<object>().ToArray())
|
{
|
setVal.SelectedValue = val;
|
annotation.Write(step1);
|
}
|
|
step1.Input.Step = theParent;
|
var run = plan.Execute();
|
|
}
|
|
[Test]
|
public void SweepLoopAnnotation()
|
{
|
var sweep = new SweepLoop();
|
var delay = new DelayStep() { DelaySecs = 0.001 };
|
var verdict = new IfStep();
|
sweep.ChildTestSteps.Add(delay);
|
sweep.ChildTestSteps.Add(verdict);
|
sweep.SweepParameters.Add(new SweepParam(new[] { MemberData.Create(typeof(DelayStep).GetProperty(nameof(DelayStep.DelaySecs))) }));
|
sweep.SweepParameters.Add(new SweepParam(new[] { MemberData.Create(typeof(IfStep).GetProperty(nameof(IfStep.InputVerdict))) }));
|
double[] values = new double[] { 0.01, 0.02, 0.03 };
|
sweep.SweepParameters[0].Resize(values.Length);
|
|
for (int i = 0; i < values.Length; i++)
|
{
|
sweep.SweepParameters[0].Values.SetValue(values[i], i);
|
}
|
|
sweep.OnDeserialized(); // force sanitize sweep values.
|
|
for (int i = 1; i < values.Length; i++)
|
{
|
var val = sweep.SweepParameters[1].Values.GetValue(i);
|
var val1 = sweep.SweepParameters[1].Values.GetValue(0);
|
Assert.AreNotSame(val, val1);
|
Assert.IsNull(((IInput)val1).Step);
|
}
|
|
var swep = AnnotationCollection.Annotate(sweep);
|
|
swep.Write();
|
var sweepMembers = swep.Get<IMembersAnnotation>().Members.First(x => x.Get<IMemberAnnotation>().Member.Name == nameof(SweepLoop.SweepMembers));
|
var availableValues = sweepMembers.Get<IAvailableValuesAnnotation>().AvailableValues.OfType<IMemberData>().ToArray();
|
// DelaySecs, InputVerdict, TargetVerdict, Action. -> Verify that TestStep.Name or Enabled is not in there.
|
Assert.AreEqual(4, availableValues.Length);
|
Assert.IsFalse(availableValues.Contains(TypeData.FromType(typeof(TestStep)).GetMember(nameof(TestStep.Name))));
|
Assert.IsFalse(availableValues.Contains(TypeData.FromType(typeof(TestStep)).GetMember(nameof(TestStep.Enabled))));
|
Assert.IsTrue(availableValues.Contains(TypeData.FromType(typeof(DelayStep)).GetMember(nameof(DelayStep.DelaySecs))));
|
Assert.IsTrue(availableValues.Contains(TypeData.FromType(typeof(IfStep)).GetMember(nameof(IfStep.InputVerdict))));
|
Assert.IsTrue(availableValues.Contains(TypeData.FromType(typeof(IfStep)).GetMember(nameof(IfStep.TargetVerdict))));
|
Assert.IsTrue(availableValues.Contains(TypeData.FromType(typeof(IfStep)).GetMember(nameof(IfStep.Action))));
|
|
var sweepParameters = swep.GetMember(nameof(SweepLoop.SweepParameters));
|
var elements = sweepParameters.Get<ICollectionAnnotation>().AnnotatedElements;
|
int i2 = 0;
|
foreach (var elem in elements)
|
{
|
{
|
var delayMember = elem.GetMember(nameof(DelayStep.DelaySecs));
|
var currentValue = (double)delayMember.Get<IObjectValueAnnotation>().Value;
|
Assert.AreEqual(values[i2], currentValue);
|
}
|
{
|
var ifMember = elem.GetMember(nameof(IfStep.InputVerdict));
|
var avail = ifMember.Get<IAvailableValuesAnnotationProxy>();
|
avail.SelectedValue = avail.AvailableValues.Last();
|
}
|
i2++;
|
}
|
swep.Write();
|
for (int i = 1; i < values.Length; i++)
|
{
|
var val = sweep.SweepParameters[1].Values.GetValue(i);
|
var val1 = sweep.SweepParameters[1].Values.GetValue(0);
|
|
Assert.AreNotSame(val, val1);
|
Assert.IsNotNull(((IInput)val1).Step);
|
}
|
}
|
|
public class EnabledVirtualBaseClass : TestStep
|
{
|
|
public virtual Enabled<double> EnabledValue { get; set; } = new Enabled<double>();
|
|
public override void Run()
|
{
|
}
|
}
|
|
public class EnabledVirtualClass : EnabledVirtualBaseClass
|
{
|
public override Enabled<double> EnabledValue { get; set; }
|
}
|
|
/// <summary>
|
/// This shows issue #4666 related to Enabled properties that are null and multi selected.
|
/// </summary>
|
[Test]
|
public void AnnotationVirtualEnabledProperty()
|
{
|
var obj = new EnabledVirtualClass();
|
var obj2 = new EnabledVirtualClass();
|
|
var annotation = AnnotationCollection.Annotate(new[] { obj, obj2 });
|
annotation.Read();
|
var enabledValueAnnotation = annotation.GetMember("EnabledValue");
|
var val = enabledValueAnnotation.Get<IObjectValueAnnotation>().Value;
|
var members2 = enabledValueAnnotation.Get<IMembersAnnotation>();
|
var mems = members2.Members.ToArray();
|
mems[0].Get<IObjectValueAnnotation>().Value?.ToString();
|
mems[1].Get<IObjectValueAnnotation>().Value?.ToString();
|
|
mems[0].Write();
|
mems[1].Write();
|
}
|
class InputAnnotationStep : TestStep
|
{
|
public Input<Verdict> Input { get; set; } = new Input<Verdict>();
|
public override void Run() { }
|
}
|
[Test]
|
public void AnnotatedInputTest()
|
{
|
var plan = new TestPlan();
|
plan.Steps.Add(new DelayStep());
|
InputAnnotationStep step;
|
plan.Steps.Add(step = new InputAnnotationStep());
|
|
var annotation = AnnotationCollection.Annotate(step);
|
var inputMember = annotation.Get<INamedMembersAnnotation>().GetMember(TypeData.FromType(typeof(InputAnnotationStep)).GetMember(nameof(InputAnnotationStep.Input)));
|
var proxy = inputMember.Get<IAvailableValuesAnnotationProxy>();
|
proxy.SelectedValue = proxy.AvailableValues.Skip(1).FirstOrDefault(); //skip 'None'.
|
annotation.Write(step);
|
|
Assert.IsTrue(step.Input.Step == plan.Steps[0]);
|
}
|
|
[Test]
|
public void IfVerdictReadError()
|
{
|
TestPlan plan = new TestPlan();
|
IfStep ifStep = new IfStep();
|
plan.ChildTestSteps.Add(ifStep);
|
var annotations = AnnotationCollection.Annotate(ifStep);
|
if (annotations.Get<IMembersAnnotation>() is IMembersAnnotation members)
|
{
|
var ifAnnotations = members.Members.FirstOrDefault();
|
if (ifAnnotations.Get<IMembersAnnotation>() is IMembersAnnotation thisIsGoingToCrash)
|
{
|
var err = thisIsGoingToCrash.Members;
|
err.FirstOrDefault().Read();
|
}
|
ifAnnotations.Read();
|
}
|
}
|
|
public class EmbeddedTest
|
{
|
// this should give EmbeddedTest all the virtual properties of DataInterfaceTestClass.
|
[Display("Embedded Things")]
|
[EmbedProperties(PrefixPropertyName = false)]
|
public DataInterfaceTestClass EmbeddedThings { get; set; } = new DataInterfaceTestClass();
|
}
|
[Test]
|
public void EmbeddedPropertiesReflectionAndAnnotationBig()
|
{
|
dataInterfaceProviderInnerTest(new EmbeddedTest());
|
}
|
|
interface IReferencingStep : ITestStep
|
{
|
IReferencingStep ReferencedStep { get; set; }
|
}
|
class ReferencingStep : TestStep, IReferencingStep
|
{
|
public override void Run()
|
{
|
throw new NotImplementedException();
|
}
|
|
public IReferencingStep ReferencedStep { get; set; }
|
}
|
|
[Test]
|
public void ReferencedStepAnnotation()
|
{
|
var step1 = new ReferencingStep();
|
var step2 = new DelayStep();
|
var step3 = new ReferencingStep();
|
var plan = new TestPlan();
|
var member = TypeData.FromType(typeof(ReferencingStep)).GetMember(nameof(ReferencingStep.ReferencedStep));
|
plan.ChildTestSteps.AddRange(new ITestStep[] { step1, step2, step3 });
|
var a = AnnotationCollection.Annotate(step3);
|
var avail = a.Get<IMembersAnnotation>().Members.First(x => x.Get<IMemberAnnotation>().Member == member).Get<IAvailableValuesAnnotation>();
|
var values = avail.AvailableValues;
|
if(values.Cast<ITestStep>().Any(x => (x is IReferencingStep) == false))
|
{
|
Assert.Fail("List should only contain " + nameof(IReferencingStep));
|
}
|
Assert.AreEqual(plan.ChildTestSteps.Count(x => x is ReferencingStep), values.Cast<object>().Count());
|
}
|
|
public class StepMultiSelectStep : TestStep
|
{
|
public DelayStep DelayStep { get; set; }
|
public List<ITestStep> DelaySteps { get; set; } = new List<ITestStep>();
|
public override void Run()
|
{
|
|
}
|
}
|
|
[Test]
|
public void StepListMultiSelect()
|
{
|
var tp = new TestPlan();
|
tp.ChildTestSteps.Add(new DelayStep() { Name = "Delay 1" });
|
tp.ChildTestSteps.Add(new DelayStep() { Name = "Delay 2" });
|
StepMultiSelectStep step1 = new StepMultiSelectStep();
|
tp.ChildTestSteps.Add(step1);
|
|
var a = AnnotationCollection.Annotate(step1);
|
var delaySteps = a.GetMember("DelaySteps");
|
delaySteps.Get<IMultiSelectAnnotationProxy>().SelectedValues = delaySteps.Get<IAvailableValuesAnnotationProxy>().AvailableValues;
|
a.Write();
|
Assert.AreEqual(3, step1.DelaySteps.Distinct().Count());
|
|
var serializer = new TapSerializer();
|
var testplanxml = serializer.SerializeToString(tp);
|
Assert.IsTrue(testplanxml.Contains("<DelayStep>")); // ensure that it doesnt say type="" in the by-reference elements in the list.
|
var tp2 = (TestPlan)serializer.DeserializeFromString(testplanxml);
|
var d1 = tp2.ChildTestSteps[0];
|
var d2 = tp2.ChildTestSteps[1];
|
var m = (StepMultiSelectStep)tp2.ChildTestSteps[2];
|
Assert.IsTrue(m.DelaySteps[0] == d1);
|
Assert.IsTrue(m.DelaySteps[1] == d2);
|
}
|
|
/// <summary> Class for testing embedding the same class twice and using attributes. </summary>
|
public class EmbeddedTest2
|
{
|
|
[EmbedProperties(PrefixPropertyName = true, Prefix = "Emba")]
|
[Display("A")]
|
public DataInterfaceTestClass EmbeddedThingsA { get; private set; } = new DataInterfaceTestClass();
|
|
|
[EmbedProperties(PrefixPropertyName = true, Prefix = "Embb")]
|
[Display("B")]
|
public DataInterfaceTestClass EmbeddedThingsB { get; private set; } = new DataInterfaceTestClass();
|
}
|
|
|
/// <summary>
|
/// This verifies that attributes sensitive to property names gets properly transformed.
|
/// This test verifies AvailableValuesAttribute and EnabledIfAttribute.
|
/// </summary>
|
[Test]
|
public void EmbeddedPropertiesReflectionAndAnnotation2()
|
{
|
|
var obj = new EmbeddedTest2();
|
var td = TypeData.GetTypeData(obj);
|
var annotated = AnnotationCollection.Annotate(obj);
|
annotated.Read();
|
var same = annotated.Get<IMembersAnnotation>().Members.First(x => x.Get<IMemberAnnotation>().Member.Name == "Emba.FromAvailable");
|
var availableValues = same.Get<IAvailableValuesAnnotation>().AvailableValues.Cast<object>().ToArray(); // this will most likely fail.
|
var prox = same.Get<IAvailableValuesAnnotationProxy>();
|
prox.SelectedValue = prox.AvailableValues.Last();
|
annotated.Write();
|
|
var enabledAnnotation = annotated.Get<IMembersAnnotation>().Members.First(x => x.Get<IMemberAnnotation>().Member.Name == "Embb.ICanBeEnabled");
|
Assert.IsFalse(enabledAnnotation.Get<IAccessAnnotation>().IsVisible);
|
var enablingAnnotation = annotated.Get<IMembersAnnotation>().Members.First(x => x.Get<IMemberAnnotation>().Member.Name == "Embb.ThingEnabled");
|
enablingAnnotation.Get<IObjectValueAnnotation>().Value = true;
|
annotated.Write();
|
annotated.Read();
|
Assert.IsTrue(enabledAnnotation.Get<IAccessAnnotation>().IsVisible);
|
}
|
|
public class EmbeddedValidatingObject : ValidatingObject
|
{
|
public double[] TestValues => new double[] {1, 2, 3, 4, 5};
|
[AvailableValues(nameof(TestValues))]
|
|
[Display("Test")]
|
public double Test { get; set; }
|
|
public const string ErrorMessage = "Test must be positive.";
|
public EmbeddedValidatingObject()
|
{
|
Rules.Add(() => Test > 0, ErrorMessage, nameof(Test));
|
}
|
}
|
|
public class EmbeddedValidatingObjectTestClass : TestStep
|
{
|
[EmbedProperties]
|
[Display("Sub")]
|
public EmbeddedValidatingObject Embedded { get; set; } = new EmbeddedValidatingObject();
|
|
public EmbeddedValidatingObject OtherNonEmbedded { get; set; }
|
|
public double Test2 { get; set; }
|
public override void Run()
|
{
|
|
}
|
}
|
|
[Test]
|
[TestCase(-0.0, EmbeddedValidatingObject.ErrorMessage)]
|
[TestCase(1.0, "")]
|
public void EmbeddedValidatingObjectTest(double value, string error)
|
{
|
// try to get the error message
|
EmbeddedValidatingObjectTestClass val = new EmbeddedValidatingObjectTestClass();
|
val.Embedded.Test = value;
|
var a = AnnotationCollection.Annotate(val).Get<IMembersAnnotation>().Members;
|
StringBuilder errors = new StringBuilder();
|
foreach (var member in a)
|
{
|
if (member.Get<IMemberAnnotation>().Member.Name != "Embedded.Test") continue;
|
|
foreach (var att in member.OfType<IErrorAnnotation>())
|
{
|
foreach (var line in att.Errors)
|
errors.AppendLine(line);
|
}
|
}
|
Assert.IsTrue(errors.ToString().Contains(error));
|
}
|
|
[Test]
|
public void EmbeddedExternalTestPlanParameter()
|
{
|
var plan = new TestPlan();
|
var step = new EmbeddedValidatingObjectTestClass();
|
|
plan.ChildTestSteps.Add(step);
|
var member = TypeData.GetTypeData(step).GetMember("Embedded.Test");
|
plan.ExternalParameters.Add(step, member);
|
var member2 = TypeData.GetTypeData(plan).GetMember("Sub \\ Test");
|
// for external parameters Display name == property name.
|
Assert.IsNotNull(member2);
|
}
|
|
class BlankStep : TestStep
|
{
|
public override void Run()
|
{
|
|
}
|
}
|
|
[Test]
|
public void AnnotateBlankStep()
|
{
|
var step = new BlankStep();
|
var a = AnnotationCollection.Annotate(step);
|
var members = a.Get<IMembersAnnotation>().Members;
|
var members2 = members.ToDictionary(x => x.Get<IMemberAnnotation>().Member.Name);
|
var v = members2["BreakConditions"];
|
|
}
|
|
public class EmbedInstrumentStep : TestStep
|
{
|
public InstrumentUsingEmbed Instrument { get; set; }
|
public override void Run() { }
|
}
|
|
public class EmbedSomeSettingsOnInstrument
|
{
|
public double Frequencey { get; set; }
|
}
|
|
public class InstrumentUsingEmbed : Instrument
|
{
|
[EmbedProperties]
|
public EmbedSomeSettingsOnInstrument Settings { get; set; }
|
}
|
|
/// <summary>
|
/// Previously there was an issue where instruments could not be properly
|
/// deserialized if they had embedded properties. This test verifies that it works.
|
/// </summary>
|
[Test]
|
public void EmbedWithInstrumentTest()
|
{
|
var instr = new InstrumentUsingEmbed();
|
var instr2 = new InstrumentUsingEmbed();
|
try
|
{
|
InstrumentSettings.Current.Add(instr);
|
InstrumentSettings.Current.Add(instr2);
|
var step = new EmbedInstrumentStep { Instrument = instr2 };
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(step);
|
using (var str = new MemoryStream())
|
{
|
plan.Save(str);
|
str.Seek(0, SeekOrigin.Begin);
|
plan = TestPlan.Load(str, "Embed.TapPlan");
|
}
|
step = (EmbedInstrumentStep)plan.ChildTestSteps[0];
|
Assert.IsTrue(step.Instrument == instr2);
|
}
|
finally
|
{
|
InstrumentSettings.Current.Remove(instr);
|
InstrumentSettings.Current.Remove(instr2);
|
}
|
}
|
|
[Test]
|
public void StepDescriptionTest()
|
{
|
string descriptionName = "OpenTap.Description";
|
var step = new DelayStep();
|
var description = TypeData.GetTypeData(step).GetMember(descriptionName);
|
var descriptionString = (string)description.GetValue(step);
|
var descriptionString2 = "Note: this is a test. \n" + descriptionString;
|
|
var xml = new TapSerializer().SerializeToString(step);
|
Assert.IsFalse(xml.Contains(descriptionName), "Description in: {0}", xml); // since the default value was serialized the XML does not contain that.
|
description.SetValue(step, descriptionString2);
|
|
//verify that it serializes correctly.
|
|
var xml2 = new TapSerializer().SerializeToString(step);
|
Assert.IsTrue(xml2.Contains(descriptionName)); // In this case it is not the default value.
|
var step2 = Utils.DeserializeFromString<DelayStep>(xml2);
|
Assert.AreEqual(descriptionString2, (string)TypeData.GetTypeData(step).GetMember(descriptionName).GetValue(step2));
|
|
var step3 = Utils.DeserializeFromString<DelayStep>(xml);
|
Assert.AreEqual(descriptionString, (string)TypeData.GetTypeData(step).GetMember(descriptionName).GetValue(step3));
|
|
}
|
|
class AvailableStep1 : TestStep
|
{
|
[Browsable(false)]
|
public string[] Available { get; set; } = new[] { "On", "Off" };
|
[AvailableValues(nameof(Available))]
|
public string MyValue { get; set; }
|
public override void Run()
|
{
|
throw new NotImplementedException();
|
}
|
}
|
class AvailableStep2 : TestStep
|
{
|
private string[] avail = new[] {"Blue", "Green", "Red"};
|
[Browsable(false)]
|
public string[] Available {
|
get => avail;
|
set
|
{
|
if (!avail.SequenceEqual(value))
|
throw new InvalidOperationException();
|
avail = value;
|
}
|
}
|
[AvailableValues(nameof(Available))]
|
public string MyValue { get; set; }
|
public override void Run()
|
{
|
throw new NotImplementedException();
|
}
|
}
|
|
[Test]
|
public void TestSweepSameNamedAvailableValues()
|
{
|
var plan = new TestPlan();
|
var sweep = new SweepParameterStep();
|
var step1 = new AvailableStep1();
|
var step2 = new AvailableStep2();
|
plan.Steps.Add(sweep);
|
sweep.ChildTestSteps.Add(step1);
|
sweep.ChildTestSteps.Add(step2);
|
string name = nameof(AvailableStep1.MyValue);
|
|
ParameterManager.Parameterize(sweep, TypeData.GetTypeData(step1).GetMember(name), new ITestStepParent[]{step1}, name);
|
ParameterManager.Parameterize(sweep, TypeData.GetTypeData(step2).GetMember(name), new ITestStepParent[]{step2}, name);
|
|
var valParam = (ParameterMemberData)TypeData.GetTypeData(sweep).GetMember(name);
|
Assert.IsNotNull(valParam);
|
|
var annotation = AnnotationCollection.Annotate(sweep);
|
var strings = annotation.GetMember(name).Get<IAvailableValuesAnnotation>().AvailableValues.Cast<string>().ToArray();
|
annotation.Write();
|
|
Assert.IsFalse(step1.Available.SequenceEqual(step2.Available));
|
|
|
}
|
}
|
}
|
