using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Diagnostics;
|
using System.Globalization;
|
using System.IO;
|
using System.Linq;
|
using System.Xml.Serialization;
|
using NUnit.Framework;
|
using OpenTap.Engine.UnitTests;
|
using OpenTap.Engine.UnitTests.TestTestSteps;
|
using OpenTap.EngineUnitTestUtils;
|
using OpenTap.Plugins.BasicSteps;
|
|
namespace OpenTap.UnitTests
|
{
|
public class AnnotationTest
|
{
|
[Test]
|
public void TestPlanReferenceNameTest()
|
{
|
var step = new DelayStep();
|
var testPlanReference = new TestPlanReference();
|
var repeatStep = new RepeatStep();
|
repeatStep.ChildTestSteps.Add(testPlanReference);
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(step);
|
plan.ChildTestSteps.Add(repeatStep);
|
|
var mem = AnnotationCollection.Annotate(repeatStep).Get<IMembersAnnotation>().Members
|
.FirstOrDefault(x => x.Get<IMemberAnnotation>().Member.Name == nameof(RepeatStep.TargetStep));
|
var avail = mem.Get<IAvailableValuesAnnotationProxy>().AvailableValues;
|
var availStrings = avail.Select(x => x.Get<IStringReadOnlyValueAnnotation>().Value).ToArray();
|
Assert.IsTrue(availStrings.Contains(step.GetFormattedName()));
|
Assert.IsTrue(availStrings.Contains(testPlanReference.GetFormattedName()));
|
|
}
|
|
[Test]
|
public void TestStepDuplicateIdWarning()
|
{
|
using var session = Session.Create(SessionOptions.OverlayComponentSettings);
|
var path = Path.GetTempFileName();
|
try
|
{
|
// The two delay steps have identical IDs -- verify we get a warning while loading this plan
|
var testplan = @"<?xml version=""1.0"" encoding=""utf-8""?>
|
<TestPlan type=""OpenTap.TestPlan"" Locked=""false"">
|
<Steps>
|
<TestStep type=""OpenTap.Plugins.BasicSteps.DelayStep"" Id=""419bfb67-ed07-4b7c-a653-b9504372fe4a"">
|
<Enabled>true</Enabled>
|
<Name>Delay 1</Name>
|
</TestStep>
|
<TestStep type=""OpenTap.Plugins.BasicSteps.DelayStep"" Id=""419bfb67-ed07-4b7c-a653-b9504372fe4a"">
|
<Enabled>true</Enabled>
|
<Name>Delay 2</Name>
|
</TestStep>
|
</Steps>
|
</TestPlan>
|
";
|
File.WriteAllText(path, testplan);
|
|
{ // Verify loading generates no warnings or errors
|
var listener = new TestTraceListener();
|
Log.AddListener(listener);
|
var tp = TestPlan.Load(path);
|
Log.RemoveListener(listener);
|
|
Assert.That(listener.ErrorMessage.Count, Is.EqualTo(0));
|
Assert.That(listener.WarningMessage.Any(warning => warning == "Duplicate test step ID found. The duplicate ID has been changed for step 'Delay 2'."));
|
}
|
|
}
|
finally
|
{
|
if (File.Exists(path))
|
File.Delete(path);
|
}
|
|
}
|
[Test]
|
public void TestTestPlanReferenceDuplicates()
|
{
|
using var session = Session.Create(SessionOptions.OverlayComponentSettings);
|
var tempfiles = new[]
|
{
|
Path.GetTempFileName(),
|
Path.GetTempFileName(),
|
Path.GetTempFileName(),
|
};
|
|
try
|
{
|
{ // Create test plans
|
new TestPlan() { ChildTestSteps = { new DelayStep(), new DelayStep() } }.Save((tempfiles[0]));
|
new TestPlan()
|
{
|
ChildTestSteps =
|
{
|
new TestPlanReference() { Filepath = new MacroString() { Text = tempfiles[0] } },
|
new TestPlanReference() { Filepath = new MacroString() { Text = tempfiles[0] } },
|
}
|
}.Save(tempfiles[1]);
|
new TestPlan()
|
{
|
ChildTestSteps =
|
{
|
new TestPlanReference() { Filepath = new MacroString() { Text = tempfiles[1] } },
|
new TestPlanReference() { Filepath = new MacroString() { Text = tempfiles[1] } },
|
}
|
}.Save(tempfiles[2]);
|
}
|
|
{ // Verify loading generates no warnings or errors
|
var listener = new TestTraceListener();
|
Log.AddListener(listener);
|
var tp = TestPlan.Load(tempfiles[2]);
|
((TestPlanReference)tp.ChildTestSteps[0]).LoadTestPlan();
|
((TestPlanReference)tp.ChildTestSteps[1]).LoadTestPlan();
|
Log.RemoveListener(listener);
|
|
Assert.That(listener.ErrorMessage.Count, Is.EqualTo(0));
|
Assert.That(listener.WarningMessage.Count, Is.EqualTo(0));
|
}
|
}
|
finally
|
{
|
foreach (var tempfile in tempfiles)
|
if (File.Exists(tempfile))
|
File.Delete(tempfile);
|
}
|
}
|
|
[Test]
|
public void TestPlanReferenceAnnotationTest()
|
{
|
|
var planname = Guid.NewGuid().ToString() + ".TestPlan";
|
{
|
var innerplan = new TestPlan();
|
var step = new DelayStep();
|
innerplan.Steps.Add(step);
|
innerplan.ExternalParameters.Add(step,
|
TypeData.GetTypeData(step).GetMember(nameof(DelayStep.DelaySecs)));
|
innerplan.Save(planname);
|
}
|
try
|
{
|
var outerplan = new TestPlan();
|
var tpr = new TestPlanReference();
|
outerplan.Steps.Add(tpr);
|
{
|
var annotation = AnnotationCollection.Annotate(tpr);
|
var loadTestPlanMem = annotation.GetMember("LoadTestPlan");
|
var enabled = loadTestPlanMem.Get<IEnabledAnnotation>();
|
Assert.IsFalse(enabled.IsEnabled);
|
|
var filePathMem = annotation.GetMember("Filepath");
|
var fpEnabled = filePathMem.Get<IEnabledAnnotation>();
|
Assert.IsTrue(fpEnabled?.IsEnabled ?? true);
|
var fpString = filePathMem.Get<IStringValueAnnotation>();
|
fpString.Value = planname;
|
annotation.Write();
|
annotation.Read();
|
Assert.IsTrue(enabled.IsEnabled);
|
|
|
}
|
|
|
tpr.Filepath.Text = planname;
|
tpr.LoadTestPlan();
|
{
|
var annotation = AnnotationCollection.Annotate(tpr);
|
var delaymem = annotation.GetMember("Time Delay");
|
Assert.IsNotNull(delaymem);
|
}
|
}
|
finally
|
{
|
File.Delete(planname);
|
}
|
|
}
|
|
[Test]
|
public void ArrayStepNameAnnotationTest()
|
{
|
var step1 = new DelayStep() { Name = "A" };
|
var step2 = new DelayStep() { Name = "A" };
|
var step3 = new DelayStep() { Name = "A" };
|
var steps = new ITestStep[]
|
{
|
step1, step2, step3
|
};
|
|
Assert.AreEqual(GetValue(steps), "A");
|
step2.Name = "B";
|
Assert.IsNull(GetValue(steps));
|
|
static string GetValue(ITestStep[] steps)
|
{
|
var annotations = AnnotationCollection.Annotate(steps);
|
var membersAnnotation = annotations.Get<IMembersAnnotation>();
|
var memberAnnotation = membersAnnotation.Members.First(m => m.Name == "Step Name");
|
var stepNameAnnotation = memberAnnotation.Get<IStringReadOnlyValueAnnotation>();
|
Assert.DoesNotThrow(() => _ = stepNameAnnotation.Value);
|
return stepNameAnnotation.Value;
|
}
|
}
|
|
|
[Test]
|
public void SweepLoopEnabledTest()
|
{
|
var plan = new TestPlan();
|
var sweep = new SweepLoop();
|
var prog = new ProcessStep();
|
plan.ChildTestSteps.Add(sweep);
|
sweep.ChildTestSteps.Add(prog);
|
|
sweep.SweepParameters.Add(new SweepParam(new [] {TypeData.FromType(prog.GetType()).GetMember(nameof(ProcessStep.RegularExpressionPattern))}));
|
|
var a = AnnotationCollection.Annotate(sweep);
|
a.Read();
|
var a2 = a.GetMember(nameof(SweepLoop.SweepParameters));
|
var col = a2.Get<ICollectionAnnotation>();
|
var new1 = col.NewElement();
|
col.AnnotatedElements = col.AnnotatedElements.Append(col.NewElement(), new1);
|
|
var enabledmem = new1.Get<IMembersAnnotation>().Members.Last();
|
var boolmember = enabledmem.Get<IMembersAnnotation>().Members.First();
|
var val = boolmember.Get<IObjectValueAnnotation>();
|
val.Value = true;
|
|
a.Write();
|
|
var sweepParam = sweep.SweepParameters.FirstOrDefault();
|
var en = (Enabled<string>)sweepParam.Values[1];
|
Assert.IsTrue(en.IsEnabled); // from val.Value = true.
|
|
}
|
|
public class ErrorMetadataDutResource : Dut
|
{
|
[MetaData(true)]
|
public double ErrorProperty { get; set; } = -5;
|
|
public ErrorMetadataDutResource()
|
{
|
this.Rules.Add(() => ErrorProperty > 0, "Error property must be > 0", nameof(ErrorProperty));
|
}
|
}
|
|
[Test]
|
public void MetadataErrorAnnotation()
|
{
|
var p = new MetadataPromptObject() {Resources = new Dut[] {new ErrorMetadataDutResource()}};
|
|
var test = AnnotationCollection.Annotate(p);
|
var forwarded = test.Get<IForwardedAnnotations>();
|
var member = forwarded.Forwarded.FirstOrDefault(x =>
|
x.Get<IMemberAnnotation>().Member.Name == nameof(ErrorMetadataDutResource.ErrorProperty));
|
|
var error = member.GetAll<IErrorAnnotation>().SelectMany(x => x.Errors).ToArray();
|
Assert.AreEqual(1, error.Length);
|
|
void checkValue(string value, int errors)
|
{
|
member.Get<IStringValueAnnotation>().Value = value;
|
test.Write();
|
test.Read();
|
|
error = member.GetAll<IErrorAnnotation>().SelectMany(x => x.Errors).ToArray();
|
Assert.AreEqual(errors, error.Length);
|
}
|
|
for (int i = 0; i < 4; i++)
|
{
|
checkValue("2.0", 0); // no errors.
|
checkValue("-2.0", 1); // validation failed.
|
checkValue("invalid", 2); // validation failed + parse error.
|
}
|
}
|
|
public class ClassWithMacroString
|
{
|
public MacroString String { get; set; } = new MacroString();
|
}
|
|
[Test]
|
public void TestClassWithMacroStringMultiSelect()
|
{
|
var elements = new[] {new ClassWithMacroString(), new ClassWithMacroString()};
|
var elems = AnnotationCollection.Annotate(elements);
|
var sv = elems.GetMember(nameof(ClassWithMacroString.String)).Get<IStringValueAnnotation>();
|
sv.Value = "test";
|
elems.Write();
|
Assert.IsNotNull(sv.Value);
|
// Check that multi-edit works.
|
foreach (var elem in elements)
|
{
|
Assert.AreEqual("test", elem.String.ToString());
|
}
|
|
// verify that the same MacroPath instance is not being used.
|
var elem2 = AnnotationCollection.Annotate(elements[0]);
|
var sv2 = elem2.GetMember(nameof(ClassWithMacroString.String)).Get<IStringValueAnnotation>();
|
sv2.Value = "test2";
|
elem2.Write();
|
|
Assert.AreEqual("test", elements[1].String.ToString());
|
Assert.AreEqual("test2", elements[0].String.ToString());
|
elems.Read();
|
Assert.IsNull(sv.Value);
|
}
|
|
public class StepWithMacroString : TestStep
|
{
|
public string A { get; set; } = "Hello";
|
public MacroString MacroString { get; set; }
|
public override void Run()
|
{
|
}
|
}
|
|
[Test]
|
public void TestMacroStringContext()
|
{
|
var plan = new TestPlan();
|
var step = new StepWithMacroString();
|
plan.ChildTestSteps.Add(step);
|
step.MacroString = new MacroString(step);
|
Assert.IsTrue(step.MacroString.Context == plan.ChildTestSteps.First(), "MacroString Context is set.");
|
|
plan = new TapSerializer().Clone(plan) as TestPlan;
|
step = plan.ChildTestSteps.First() as StepWithMacroString;
|
|
Assert.IsTrue(step.MacroString.Context == plan.ChildTestSteps.First(), "MacroString Context is set.");
|
}
|
|
public class ClassWithMethodAnnotation
|
{
|
public int TimesCalled { private set; get; }
|
[Browsable(true)]
|
public void CallableMethod() => TimesCalled += 1;
|
}
|
|
[Test]
|
public void TestMultiSelectCallMethodAnnotation()
|
{
|
var elements = new[] {new ClassWithMethodAnnotation(), new ClassWithMethodAnnotation()};
|
var annotation = AnnotationCollection.Annotate(elements);
|
var method = annotation.GetMember(nameof(ClassWithMethodAnnotation.CallableMethod)).Get<IMethodAnnotation>();
|
method.Invoke();
|
foreach(var elem in elements)
|
Assert.AreEqual(1, elem.TimesCalled);
|
}
|
|
|
public class ClassWithListOfString : TestStep
|
{
|
public class NestedObject
|
{
|
public bool State { get; set; }
|
public IEnumerable<int> Avail => Enumerable.Range(State ? 5 : 0, 5);
|
[AvailableValues(nameof(Avail))]
|
public int SelectedInt { get; set; }
|
}
|
|
public List<string> List { get; set; } = new List<string>{"A", "B"};
|
|
[AvailableValues(nameof(List))]
|
public string Selected { get; set; }
|
|
public List<NestedObject> List2 { get; set; } = new List<NestedObject>{};
|
|
public override void Run()
|
{
|
|
}
|
}
|
|
[Test]
|
public void ListOfObjectAnnotation()
|
{
|
var obj = new ClassWithListOfString();
|
var a = AnnotationCollection.Annotate(obj);
|
var member = a.GetMember(nameof(ClassWithListOfString.List2));
|
var col = member.Get<ICollectionAnnotation>();
|
var newelem = col.NewElement();
|
col.AnnotatedElements = new[] { newelem };
|
|
a.Write();
|
a.Read();
|
|
// if we take the first element here, then previously updates would be lost after the first read.
|
// - at least if reading from the point of view of an available values proxy.
|
newelem = col.AnnotatedElements.FirstOrDefault();
|
newelem.GetMember("State").Get<IStringValueAnnotation>().Value = "true";
|
a.Write();
|
a.Read();
|
var selected = newelem.GetMember("SelectedInt").Get<IAvailableValuesAnnotationProxy>().SelectedValue;
|
var vals = newelem.GetMember("SelectedInt").Get<IAvailableValuesAnnotationProxy>().AvailableValues;
|
// verify that the available values corresponds to NestedObject.State = true;
|
Assert.IsTrue(vals.Select(x => x.Source).SequenceEqual(obj.List2[0].Avail.Cast<object>()));
|
}
|
|
|
[Test]
|
public void ListOfStringAnnotation()
|
{
|
var obj = new ClassWithListOfString();
|
var a = AnnotationCollection.Annotate(obj);
|
var member = a.GetMember(nameof(ClassWithListOfString.List));
|
var col = member.Get<ICollectionAnnotation>();
|
var newelem = col.NewElement();
|
Assert.IsTrue(newelem.Get<IReflectionAnnotation>().ReflectionInfo.DescendsTo(typeof(string)));
|
Assert.IsNotNull(newelem.Get<IObjectValueAnnotation>().Value);
|
}
|
|
[Test]
|
public void ListOfStringAnnotation2()
|
{
|
var obj = new ClassWithListOfString();
|
var targetObject = new SequenceStep();
|
var obj2 = new ClassWithListOfString();
|
targetObject.ChildTestSteps.Add(obj);
|
targetObject.ChildTestSteps.Add(obj2);
|
obj2.List.Add("C");
|
var selectedMember = TypeData.GetTypeData(obj).GetMember(nameof(ClassWithListOfString.Selected));
|
selectedMember.Parameterize(targetObject, obj, selectedMember.Name);
|
Assert.Throws<Exception>(() => selectedMember.Parameterize(targetObject, obj, selectedMember.Name));
|
selectedMember.Parameterize(targetObject, obj2, selectedMember.Name);
|
Assert.Throws<Exception>(() => selectedMember.Parameterize(targetObject, obj2, selectedMember.Name));
|
|
var b = AnnotationCollection.Annotate(targetObject);
|
var avail = b.GetMember(selectedMember.Name).Get<IAvailableValuesAnnotation>();
|
Assert.AreEqual(2, avail.AvailableValues.Cast<object>().Count());
|
}
|
|
[Test]
|
public void ListOfStringAnnotationTpr()
|
{
|
var tp = new TestPlan();
|
var stepa = new ClassWithListOfString();
|
var selectedMember = TypeData.GetTypeData(stepa).GetMember(nameof(ClassWithListOfString.Selected));
|
var stepb = new ClassWithListOfString();
|
tp.ChildTestSteps.Add(stepa);
|
tp.ChildTestSteps.Add(stepb);
|
selectedMember.Parameterize(tp, stepa, selectedMember.Name);
|
selectedMember.Parameterize(tp, stepb, selectedMember.Name);
|
|
var name = Guid.NewGuid().ToString() + ".TapPlan";
|
|
tp.Save(name);
|
var plan2 = new TestPlan();
|
var tpr = new TestPlanReference();
|
plan2.ChildTestSteps.Add(tpr);
|
tpr.Filepath.Text = name;
|
tpr.LoadTestPlan();
|
File.Delete(name);
|
|
var member = AnnotationCollection.Annotate(tpr).GetMember(selectedMember.Name);
|
var avail = member.Get<IAvailableValuesAnnotation>();
|
Assert.AreEqual(2, avail.AvailableValues.Cast<object>().Count());
|
}
|
|
class MenuTestUserInterface : IUserInputInterface, IUserInterface
|
{
|
[Flags]
|
public enum Mode
|
{
|
Standard = 1,
|
Rename = 2,
|
Create = 4,
|
TestPlan = 8,
|
Remove = 16,
|
ExpectNoRename = 32,
|
RenameBlank = 64,
|
Merge = 128,
|
Error = 256,
|
Cancel = 512
|
}
|
public bool WasInvoked;
|
public string SelectName { get; set; }
|
|
public Mode SelectedMode;
|
|
public string LastError = "";
|
|
|
public string ErrorString { get; set; }
|
|
public void RequestUserInput(object dataObject, TimeSpan Timeout, bool modal)
|
{
|
var datas = AnnotationCollection.Annotate(dataObject);
|
var selectedName = datas.GetMember("SelectedName");
|
var message = datas.GetMember("Message");
|
var response = datas.GetMember("Response");
|
var resp = response.Get<IAvailableValuesAnnotationProxy>();
|
if (SelectedMode.HasFlag(Mode.Cancel))
|
{
|
resp.SelectedValue =
|
resp.AvailableValues.First(x => x.Get<IStringValueAnnotation>().Value == "Cancel");
|
}
|
|
|
selectedName.Get<IStringValueAnnotation>().Value = SelectName;
|
|
var scope = datas.GetMember("Scope");
|
var avail = scope.Get<IAvailableValuesAnnotationProxy>();
|
var values = avail.AvailableValues.ToArray();
|
|
avail.SelectedValue = avail.AvailableValues.First(); // sequence step!
|
if (SelectedMode.HasFlag(Mode.TestPlan))
|
{
|
avail.SelectedValue = avail.AvailableValues.Last();
|
}
|
|
if (SelectedMode.HasFlag(Mode.Remove))
|
{
|
var settings = datas.GetMember("Settings");
|
settings.Get<IMultiSelectAnnotationProxy>().SelectedValues = Array.Empty<AnnotationCollection>();
|
}
|
Assert.IsTrue(values.Length > 0);
|
datas.Write();
|
|
if (SelectedMode.HasFlag(Mode.Rename))
|
{
|
var msg = message.Get<IStringValueAnnotation>().Value;
|
|
Assert.AreEqual(false == SelectedMode.HasFlag(Mode.ExpectNoRename), msg.Contains("Rename "));
|
}
|
|
if (SelectedMode.HasFlag(Mode.RenameBlank))
|
{
|
var error = selectedName.Get<IErrorAnnotation>().Errors.First();
|
Assert.AreEqual("Name cannot be left empty.", error);
|
}
|
|
if (SelectedMode == (Mode.Create|Mode.TestPlan))
|
{
|
var msg = message.Get<IStringValueAnnotation>().Value;
|
Assert.IsTrue(msg.Contains("Create new parameter "));
|
}
|
|
LastError = message.Get<IErrorAnnotation>()?.Errors.FirstOrDefault();
|
if (SelectedMode == (Mode.Merge|Mode.TestPlan))
|
{
|
var msg = message.Get<IStringValueAnnotation>().Value;
|
Assert.IsTrue(msg.Contains("Merge with an existing parameter "));
|
}
|
|
if (SelectedMode.HasFlag(Mode.Error))
|
{
|
Assert.IsTrue(LastError != null);
|
if(ErrorString != null)
|
Assert.IsTrue(LastError.Contains(ErrorString));
|
}
|
|
WasInvoked = true;
|
}
|
|
public void NotifyChanged(object obj, string property) { }
|
}
|
|
[Test]
|
public void TestReparameterize()
|
{
|
var testplan = new TestPlan();
|
var seq = new SequenceStep();
|
var delay = new DelayStep();
|
seq.ChildTestSteps.Add(delay);
|
testplan.ChildTestSteps.Add(seq);
|
seq.ChildTestSteps.Add(new VerdictStep() { Verdict = Verdict.Pass });
|
|
var timeDelay = AnnotationCollection.Annotate(delay).GetMember("DelaySecs");
|
var menu = timeDelay.Get<MenuAnnotation>();
|
var icons = menu.MenuItems.ToLookup(x => x.Get<IIconAnnotation>()?.IconName ?? "");
|
|
var parameterize = icons[IconNames.ParameterizeOnParent].First();
|
var unparameterize = icons[IconNames.Unparameterize].First();
|
|
void invoke(AnnotationCollection a)
|
{
|
a.Get<IMethodAnnotation>().Invoke();
|
}
|
|
void run()
|
{
|
var planRun = testplan.Execute();
|
Assert.AreEqual(Verdict.Pass, planRun.Verdict);
|
}
|
|
{ // Verify nothing breaks when parameterizing, unparameterizing, and reparameterizing
|
run();
|
invoke(parameterize);
|
run();
|
invoke(unparameterize);
|
run();
|
invoke(parameterize);
|
run();
|
invoke(unparameterize);
|
run();
|
}
|
}
|
|
[Test]
|
public void MenuAnnotationTest()
|
{
|
var currentUserInterface = UserInput.Interface;
|
var menuInterface = new MenuTestUserInterface();
|
UserInput.SetInterface(menuInterface);
|
try
|
{
|
var plan = new TestPlan();
|
var sequenceRoot = new SequenceStep();
|
var sequence = new SequenceStep();
|
var step = new DelayStep();
|
plan.Steps.Add(sequenceRoot);
|
sequenceRoot.ChildTestSteps.Add(sequence);
|
var step2 = new DelayStep();
|
sequenceRoot.ChildTestSteps.Add(step);
|
sequence.ChildTestSteps.Add(step2);
|
|
{ // basic functionalities test
|
|
var member = AnnotationCollection.Annotate(step2).GetMember(nameof(DelayStep.DelaySecs));
|
var menu = member.Get<MenuAnnotation>();
|
|
var items = menu.MenuItems;
|
|
var icons = items.ToLookup(item =>
|
item.Get<IIconAnnotation>()?.IconName ?? "");
|
var parameterizeOnTestPlan = icons[IconNames.ParameterizeOnTestPlan].First();
|
Assert.IsNotNull(parameterizeOnTestPlan);
|
|
// invoking this method should
|
var method = parameterizeOnTestPlan.Get<IMethodAnnotation>();
|
method.Invoke();
|
Assert.IsNotNull(plan.ExternalParameters.Get("Parameters \\ Time Delay"));
|
|
var unparameterize = icons[IconNames.Unparameterize].First();
|
unparameterize.Get<IMethodAnnotation>().Invoke();
|
Assert.IsNull(plan.ExternalParameters.Get("Parameters \\ Time Delay"));
|
|
var createOnParent = icons[IconNames.ParameterizeOnParent].First();
|
Assert.IsNotNull(createOnParent);
|
createOnParent.Get<IMethodAnnotation>().Invoke();
|
Assert.IsNotNull(TypeData.GetTypeData(sequence).GetMember("Parameters \\ Time Delay"));
|
|
unparameterize.Get<IMethodAnnotation>().Invoke();
|
Assert.IsNull(TypeData.GetTypeData(sequence).GetMember("Parameters \\ Time Delay"));
|
|
menuInterface.SelectName = "A";
|
|
var parameterize = icons[IconNames.Parameterize].First();
|
parameterize.Get<IMethodAnnotation>().Invoke();
|
Assert.IsTrue(menuInterface.WasInvoked);
|
|
{
|
// verify that the right icon annotation now appears.
|
var member2 = AnnotationCollection.Annotate(step2).GetMember(nameof(DelayStep.DelaySecs));
|
var parameterized = member2.Get<ParameterizedIconAnnotation>();
|
Assert.IsNotNull(parameterized);
|
var disabled = member2.GetAll<IEnabledAnnotation>().Any(x => x.IsEnabled == false);
|
Assert.IsTrue(disabled);
|
}
|
|
var newParameter = TypeData.GetTypeData(sequence).GetMember("A");
|
Assert.IsNotNull(newParameter);
|
unparameterize.Get<IMethodAnnotation>().Invoke();
|
Assert.IsNull(TypeData.GetTypeData(sequence).GetMember("A"));
|
parameterize.Get<IMethodAnnotation>().Invoke();
|
|
var editParameter = AnnotationCollection.Annotate(sequence).GetMember("A").Get<MenuAnnotation>()
|
.MenuItems
|
.FirstOrDefault(x => x.Get<IconAnnotationAttribute>()?.IconName == IconNames.EditParameter);
|
|
menuInterface.SelectName = " ";
|
menuInterface.SelectedMode = MenuTestUserInterface.Mode.RenameBlank;
|
editParameter.Get<IMethodAnnotation>().Invoke();
|
Assert.IsNotNull(TypeData.GetTypeData(sequence).GetMember("A"));
|
Assert.IsNull(TypeData.GetTypeData(sequence).GetMember(""));
|
|
|
menuInterface.SelectName = "B";
|
menuInterface.SelectedMode = MenuTestUserInterface.Mode.Rename;
|
editParameter.Get<IMethodAnnotation>().Invoke();
|
|
var bMember = TypeData.GetTypeData(sequence).GetMember("B");
|
Assert.IsNull(TypeData.GetTypeData(sequence).GetMember("A"));
|
Assert.IsNotNull(bMember);
|
menuInterface.SelectedMode |= MenuTestUserInterface.Mode.ExpectNoRename;
|
editParameter = AnnotationCollection.Annotate(sequence).GetMember("B").Get<MenuAnnotation>()
|
.MenuItems
|
.FirstOrDefault(x => x.Get<IconAnnotationAttribute>()?.IconName == IconNames.EditParameter);
|
|
editParameter.Get<IMethodAnnotation>().Invoke();
|
Assert.IsTrue(object.ReferenceEquals(bMember, TypeData.GetTypeData(sequence).GetMember("B")));
|
|
|
unparameterize.Get<IMethodAnnotation>().Invoke();
|
|
Assert.IsNull(TypeData.GetTypeData(sequence).GetMember("B"));
|
|
menuInterface.SelectedMode = MenuTestUserInterface.Mode.Create | MenuTestUserInterface.Mode.TestPlan;
|
parameterize.Get<IMethodAnnotation>().Invoke();
|
|
{
|
var member2 = AnnotationCollection.Annotate(plan).GetMember("B");
|
|
{
|
// verify that the right icon annotation now appears.
|
var parameter = member2.GetAll<IInteractiveIconAnnotation>()
|
.First(x => x.IconName == IconNames.EditParameter);
|
Assert.IsNotNull(parameter.Action.Get<IMethodAnnotation>());
|
}
|
|
var edit = member2.Get<MenuAnnotation>().MenuItems.FirstOrDefault(x =>
|
x.Get<IconAnnotationAttribute>()?.IconName == IconNames.EditParameter);
|
menuInterface.SelectedMode = MenuTestUserInterface.Mode.Rename| MenuTestUserInterface.Mode.TestPlan;
|
menuInterface.SelectName = "C";
|
edit.Get<IMethodAnnotation>().Invoke();
|
|
member2 = AnnotationCollection.Annotate(plan).GetMember("C");
|
edit = member2.Get<MenuAnnotation>().MenuItems.FirstOrDefault(x =>
|
x.Get<IconAnnotationAttribute>()?.IconName == IconNames.EditParameter);
|
|
menuInterface.SelectedMode = MenuTestUserInterface.Mode.Remove;
|
edit.Get<IMethodAnnotation>().Invoke();
|
Assert.IsNull(AnnotationCollection.Annotate(plan).GetMember("C"));
|
}
|
}
|
|
{ // test multi-select
|
var memberMulti = AnnotationCollection.Annotate(new[] {step, step2})
|
.GetMember(nameof(DelayStep.DelaySecs));
|
var menuMulti = memberMulti.Get<MenuAnnotation>();
|
Assert.IsNotNull(menuMulti);
|
|
var icons2 = menuMulti.MenuItems.ToLookup(x => x.Get<IIconAnnotation>()?.IconName ?? "");
|
var parmeterizeOnTestPlanMulti = icons2[IconNames.ParameterizeOnTestPlan].First();
|
parmeterizeOnTestPlanMulti.Get<IMethodAnnotation>().Invoke();
|
Assert.AreEqual(2, plan.ExternalParameters.Entries.FirstOrDefault().Properties.Count());
|
{
|
// check that the right icon appeared.
|
var memberMulti2 = AnnotationCollection.Annotate(new[] {step, step2})
|
.GetMember(nameof(DelayStep.DelaySecs));
|
bool parameterizedIcon = memberMulti2.GetAll<IIconAnnotation>().Any(x => x.IconName == IconNames.Parameterized);
|
Assert.IsTrue(parameterizedIcon);
|
}
|
|
var unparmeterizePlanMulti = icons2[IconNames.Unparameterize].First();
|
unparmeterizePlanMulti.Get<IMethodAnnotation>().Invoke();
|
Assert.IsNull(plan.ExternalParameters.Entries.FirstOrDefault());
|
|
var parmeterizeOnParentMulti = icons2[IconNames.ParameterizeOnParent].First();
|
Assert.IsFalse(parmeterizeOnParentMulti.Get<IEnabledAnnotation>().IsEnabled);
|
}
|
|
{ // Test Plan Enabled Items Locked
|
var annotation = AnnotationCollection.Annotate(step);
|
var menu = annotation.GetMember(nameof(DelayStep.DelaySecs))
|
.Get<MenuAnnotation>();
|
var icons = menu.MenuItems.ToLookup(x => x.Get<IIconAnnotation>()?.IconName ?? "");
|
icons[IconNames.ParameterizeOnTestPlan].First().Get<IMethodAnnotation>().Invoke();
|
annotation.Read();
|
|
Assert.IsFalse(icons[IconNames.ParameterizeOnTestPlan].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(icons[IconNames.Parameterize].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(icons[IconNames.ParameterizeOnParent].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsTrue(icons[IconNames.Unparameterize].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(icons[IconNames.EditParameter].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(icons[IconNames.RemoveParameter].First().Get<IEnabledAnnotation>().IsEnabled);
|
|
var planAnnotation = AnnotationCollection.Annotate(plan);
|
var planMenu = planAnnotation.GetMember("Parameters \\ Time Delay")
|
.Get<MenuAnnotation>();
|
var planIcons = planMenu.MenuItems.ToLookup(x => x.Get<IIconAnnotation>()?.IconName ?? "");
|
Assert.IsFalse(planIcons[IconNames.ParameterizeOnTestPlan].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(planIcons[IconNames.Parameterize].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsTrue(planIcons[IconNames.EditParameter].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(planIcons[IconNames.ParameterizeOnParent].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(planIcons[IconNames.Unparameterize].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsTrue(planIcons[IconNames.RemoveParameter].First().Get<IEnabledAnnotation>().IsEnabled);
|
|
plan.Locked = true;
|
menu = AnnotationCollection.Annotate(step).GetMember(nameof(DelayStep.DelaySecs))
|
.Get<MenuAnnotation>();
|
icons = menu.MenuItems.ToLookup(x => x.Get<IIconAnnotation>()?.IconName ?? "");
|
Assert.IsFalse(icons[IconNames.ParameterizeOnTestPlan].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(icons[IconNames.Parameterize].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(icons[IconNames.ParameterizeOnParent].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(icons[IconNames.Unparameterize].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(icons[IconNames.EditParameter].First().Get<IEnabledAnnotation>().IsEnabled);
|
planAnnotation = AnnotationCollection.Annotate(plan);
|
planMenu = planAnnotation.GetMember("Parameters \\ Time Delay")
|
.Get<MenuAnnotation>();
|
planIcons = planMenu.MenuItems.ToLookup(x => x.Get<IIconAnnotation>()?.IconName ?? "");
|
Assert.IsFalse(planIcons[IconNames.ParameterizeOnTestPlan].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(planIcons[IconNames.Parameterize].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(planIcons[IconNames.EditParameter].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(planIcons[IconNames.ParameterizeOnParent].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(planIcons[IconNames.Unparameterize].First().Get<IEnabledAnnotation>().IsEnabled);
|
Assert.IsFalse(planIcons[IconNames.RemoveParameter].First().Get<IEnabledAnnotation>().IsEnabled);
|
}
|
{
|
// remove parameter
|
plan.Locked = false;
|
var planAnnotation = AnnotationCollection.Annotate(plan);
|
var menu = planAnnotation.GetMember("Parameters \\ Time Delay").Get<MenuAnnotation>();
|
var removeItem = menu.MenuItems.First(x => x.Get<IconAnnotationAttribute>()?.IconName == IconNames.RemoveParameter);
|
removeItem.Get<IMethodAnnotation>().Invoke();
|
planAnnotation = AnnotationCollection.Annotate(plan);
|
// after removing there is not Time Delay parameter..
|
Assert.IsNull(planAnnotation.GetMember("Parameters \\ Time Delay"));
|
}
|
{// Break Conditions
|
var member = AnnotationCollection.Annotate(step2).GetMember("BreakConditions");
|
Assert.NotNull(member);
|
var menu = member.Get<MenuAnnotation>();
|
Assert.NotNull(menu);
|
var parameterize = menu.MenuItems.FirstOrDefault(x =>
|
x.Get<IIconAnnotation>()?.IconName == IconNames.ParameterizeOnTestPlan);
|
Assert.IsTrue(parameterize.Get<IAccessAnnotation>().IsVisible);
|
|
Assert.AreEqual(1, TypeData.GetTypeData(plan).GetMembers().Count(x => x.Name.Contains("BreakConditions") || x.Name.Contains("BreakConditions")));
|
parameterize.Get<IMethodAnnotation>().Invoke();
|
Assert.AreEqual(2, TypeData.GetTypeData(plan).GetMembers().Count(x => x.Name.Contains("Break Conditions") || x.Name.Contains("BreakConditions")));
|
|
}
|
}
|
finally
|
{
|
UserInput.SetInterface(currentUserInterface as IUserInputInterface);
|
}
|
}
|
|
[Test]
|
public void MenuAnnotationTest4()
|
{
|
var currentUserInterface = UserInput.Interface;
|
var menuInterface = new MenuTestUserInterface();
|
UserInput.SetInterface(menuInterface);
|
try
|
{
|
var plan = new TestPlan();
|
var sequence = new SequenceStep();
|
var step = new DelayStep();
|
plan.Steps.Add(sequence);
|
sequence.ChildTestSteps.Add(step);
|
|
{
|
var p1 = TypeData.GetTypeData(step).GetMember(nameof(step.DelaySecs)).Parameterize(sequence, step, "A");
|
p1.Parameterize(plan, sequence, p1.Name);
|
|
var editParameterIcon = AnnotationCollection.Annotate(sequence).GetMember(p1.Name).Get<MenuAnnotation>().MenuItems
|
.First(x => x.Get<IconAnnotationAttribute>()?.IconName == IconNames.EditParameter);
|
|
menuInterface.SelectedMode = MenuTestUserInterface.Mode.TestPlan | MenuTestUserInterface.Mode.Error;
|
menuInterface.SelectName = p1.Name;
|
|
editParameterIcon.Get<IMethodAnnotation>().Invoke();
|
|
}
|
}
|
finally
|
{
|
UserInput.SetInterface(currentUserInterface as IUserInputInterface);
|
}
|
}
|
|
[Test]
|
public void MenuAnnotationTest2()
|
{
|
var currentUserInterface = UserInput.Interface;
|
var menuInterface = new MenuTestUserInterface();
|
UserInput.SetInterface(menuInterface);
|
try
|
{
|
var plan = new TestPlan();
|
var delay = new DelayStep();
|
plan.Steps.Add(delay);
|
|
{ // basic functionalities test
|
var member = AnnotationCollection.Annotate(delay).GetMember(nameof(DelayStep.DelaySecs));
|
var menu = member.Get<MenuAnnotation>();
|
var items = menu.MenuItems;
|
|
var icons = items.ToLookup(item =>
|
item.Get<IIconAnnotation>()?.IconName ?? "");
|
var parameterizeOnTestPlan = icons[IconNames.ParameterizeOnTestPlan].First();
|
Assert.IsNotNull(parameterizeOnTestPlan);
|
|
// invoking this method should
|
var method = parameterizeOnTestPlan.Get<IMethodAnnotation>();
|
method.Invoke();
|
Assert.IsNotNull(plan.ExternalParameters.Get("Parameters \\ Time Delay"));
|
|
member = AnnotationCollection.Annotate(delay).GetMember(nameof(DelayStep.DelaySecs));
|
menu = member.Get<MenuAnnotation>();
|
items = menu.MenuItems;
|
|
icons = items.ToLookup(item =>
|
item.Get<IIconAnnotation>()?.IconName ?? "");
|
parameterizeOnTestPlan = icons[IconNames.ParameterizeOnTestPlan].First();
|
Assert.IsNotNull(parameterizeOnTestPlan);
|
|
// This fails, which it should not.
|
Assert.IsFalse(parameterizeOnTestPlan.Get<IEnabledAnnotation>().IsEnabled);
|
}
|
}
|
finally
|
{
|
UserInput.SetInterface(currentUserInterface as IUserInputInterface);
|
}
|
|
}
|
[Test]
|
public void MenuAnnotationTest3()
|
{
|
var currentUserInterface = UserInput.Interface;
|
var menuInterface = new MenuTestUserInterface();
|
UserInput.SetInterface(menuInterface);
|
try
|
{
|
const string doubleTimeDelay = "Parameters \\ Time Delay";
|
const string byteTimeDelay = "Parameters \\ Byte Time Delay";
|
const string shortTimeDelay = "Parameters \\ Short Time Delay";
|
var plan = new TestPlan();
|
var delay1 = new DelayStep();
|
var delay2 = new ByteDelayStep();
|
var delay3 = new ShortDelayStep();
|
plan.Steps.Add(delay1);
|
plan.Steps.Add(delay2);
|
plan.Steps.Add(delay3);
|
|
{ // basic functionalities test
|
var member = AnnotationCollection.Annotate(delay1).GetMember(nameof(DelayStep.DelaySecs));
|
var menu = member.Get<MenuAnnotation>();
|
var items = menu.MenuItems;
|
|
var icons = items.ToLookup(item => item.Get<IIconAnnotation>()?.IconName ?? "");
|
var parameterizeOnTestPlan = icons[IconNames.ParameterizeOnTestPlan].First();
|
Assert.IsNotNull(parameterizeOnTestPlan);
|
var method = parameterizeOnTestPlan.Get<IMethodAnnotation>();
|
method.Invoke();
|
Assert.IsNotNull(plan.ExternalParameters.Get(doubleTimeDelay));
|
|
member = AnnotationCollection.Annotate(delay2).GetMember(nameof(ByteDelayStep.DelaySecs));
|
menu = member.Get<MenuAnnotation>();
|
items = menu.MenuItems;
|
|
icons = items.ToLookup(item => item.Get<IIconAnnotation>()?.IconName ?? "");
|
parameterizeOnTestPlan = icons[IconNames.ParameterizeOnTestPlan].First();
|
Assert.IsNotNull(parameterizeOnTestPlan);
|
method = parameterizeOnTestPlan.Get<IMethodAnnotation>();
|
method.Invoke();
|
Assert.IsNotNull(plan.ExternalParameters.Get(byteTimeDelay));
|
|
member = AnnotationCollection.Annotate(delay3).GetMember(nameof(ShortDelayStep.DelaySecs));
|
menu = member.Get<MenuAnnotation>();
|
items = menu.MenuItems;
|
|
icons = items.ToLookup(item => item.Get<IIconAnnotation>()?.IconName ?? "");
|
parameterizeOnTestPlan = icons[IconNames.ParameterizeOnTestPlan].First();
|
Assert.IsNotNull(parameterizeOnTestPlan);
|
method = parameterizeOnTestPlan.Get<IMethodAnnotation>();
|
method.Invoke();
|
Assert.IsNotNull(plan.ExternalParameters.Get(shortTimeDelay));
|
|
var editParameter = AnnotationCollection.Annotate(plan).GetMember(byteTimeDelay).Get<MenuAnnotation>()
|
.MenuItems
|
.FirstOrDefault(x => x.Get<IconAnnotationAttribute>()?.IconName == IconNames.EditParameter);
|
|
// Try to merge byte time delay and time delay parameters
|
menuInterface.SelectName = doubleTimeDelay;
|
menuInterface.SelectedMode = MenuTestUserInterface.Mode.Rename | MenuTestUserInterface.Mode.Cancel;
|
|
editParameter.Get<IMethodAnnotation>().Invoke();
|
Assert.IsNull(menuInterface.LastError);
|
|
// Try to merge byte time delay and short time delay parameters, overflow exception occurs
|
editParameter = AnnotationCollection.Annotate(plan).GetMember(shortTimeDelay).Get<MenuAnnotation>()
|
.MenuItems
|
.FirstOrDefault(x => x.Get<IconAnnotationAttribute>()?.IconName == IconNames.EditParameter);
|
|
menuInterface.SelectName = byteTimeDelay;
|
menuInterface.SelectedMode = MenuTestUserInterface.Mode.Rename | MenuTestUserInterface.Mode.Cancel;
|
|
editParameter.Get<IMethodAnnotation>().Invoke();
|
Assert.IsNull(menuInterface.LastError);
|
|
menuInterface.SelectedMode = MenuTestUserInterface.Mode.Rename;
|
// Try to merge byte and short time delay parameters, this is allowed
|
delay3.DelaySecs = 12;
|
editParameter.Get<IMethodAnnotation>().Invoke();
|
Assert.IsNull(menuInterface.LastError);
|
|
// Try to set an overflowed value
|
member = AnnotationCollection.Annotate(plan).GetMember(byteTimeDelay);
|
member.SetValue(50000);
|
var memberParam = member.Get<NumberAnnotation>();
|
Assert.IsNotNull(memberParam.Errors);
|
}
|
}
|
finally
|
{
|
UserInput.SetInterface(currentUserInterface as IUserInputInterface);
|
}
|
}
|
|
public class ShortDelayStep : TestStep
|
{
|
[Display("Short Time Delay")]
|
public short DelaySecs { get; set; } = 222;
|
public override void Run()
|
{
|
TapThread.Sleep(Time.FromSeconds(DelaySecs));
|
}
|
}
|
|
public class ByteDelayStep : TestStep
|
{
|
[Display("Byte Time Delay")]
|
public sbyte DelaySecs { get; set; } = 3;
|
public override void Run()
|
{
|
TapThread.Sleep(Time.FromSeconds(DelaySecs));
|
}
|
}
|
|
public class TwoDelayStep : TestStep
|
{
|
public double DelaySecs { get; set; }
|
public double DelaySecs2 { get; set; }
|
public override void Run()
|
{
|
|
}
|
}
|
|
[Test]
|
public void ParameterizeTest()
|
{
|
var plan = new TestPlan();
|
var delayStep = new DelayStep();
|
plan.ChildTestSteps.Add(delayStep);
|
|
// Check can parameterize
|
var member = AnnotationCollection.Annotate(delayStep).GetMember(nameof(DelayStep.DelaySecs));
|
var menu = member.Get<MenuAnnotation>();
|
var menuItems = menu.MenuItems;
|
var icons = menuItems.ToLookup(item => item.Get<IIconAnnotation>()?.IconName ?? "");
|
var parameterizeIcon = icons[IconNames.Parameterize].First();
|
Assert.IsTrue(parameterizeIcon.Get<IAccessAnnotation>().IsVisible);
|
parameterizeIcon = icons[IconNames.Unparameterize].First();
|
Assert.IsFalse(parameterizeIcon.Get<IAccessAnnotation>().IsVisible);
|
|
// Parameterize
|
var delayMember = TypeData.GetTypeData(delayStep).GetMember(nameof(DelayStep.DelaySecs));
|
delayMember.Parameterize(plan, delayStep, "Delay");
|
|
// Check can parameterize
|
member = AnnotationCollection.Annotate(delayStep).GetMember(nameof(DelayStep.DelaySecs));
|
menu = member.Get<MenuAnnotation>();
|
menuItems = menu.MenuItems;
|
icons = menuItems.ToLookup(item => item.Get<IIconAnnotation>()?.IconName ?? "");
|
parameterizeIcon = icons[IconNames.Parameterize].First();
|
Assert.IsFalse(parameterizeIcon.Get<IAccessAnnotation>().IsVisible);
|
parameterizeIcon = icons[IconNames.Unparameterize].First();
|
Assert.IsTrue(parameterizeIcon.Get<IAccessAnnotation>().IsVisible);
|
|
// Set read only
|
delayStep.IsReadOnly = true;
|
|
// Check can parameterize
|
member = AnnotationCollection.Annotate(delayStep).GetMember(nameof(DelayStep.DelaySecs));
|
menu = member.Get<MenuAnnotation>();
|
menuItems = menu.MenuItems;
|
icons = menuItems.ToLookup(item => item.Get<IIconAnnotation>()?.IconName ?? "");
|
parameterizeIcon = icons[IconNames.Unparameterize].First();
|
Assert.IsFalse(parameterizeIcon.Get<IAccessAnnotation>().IsVisible);
|
}
|
|
[Test]
|
public void TestMergedInputVerdict([Values(true, false)]bool availableProxy)
|
{
|
var dialog = new DialogStep();
|
var if1 = new IfStep();
|
var if2 = new IfStep();
|
var if3 = new IfStep();
|
var plan = new TestPlan()
|
{
|
ChildTestSteps =
|
{
|
dialog, if1, if2, if3
|
}
|
};
|
|
ITestStep[] merged = { if1, if2, if3 };
|
|
void setInputVerdict(AnnotationCollection a, ITestStep targetStep)
|
{
|
var member = a.GetMember(nameof(if1.InputVerdict));
|
if (availableProxy)
|
{
|
var avail = member.Get<IAvailableValuesAnnotationProxy>();
|
var sel = avail.AvailableValues.First(av =>
|
av.GetMember("Step").Get<IObjectValueAnnotation>().Value == targetStep);
|
avail.SelectedValue = sel;
|
}
|
else
|
{
|
var input = new Input<Verdict>()
|
{
|
Property = TypeData.FromType(typeof(DialogStep)).GetMember(nameof(dialog.Verdict)),
|
Step = targetStep
|
};
|
member.Get<IObjectValueAnnotation>().Value = input;
|
}
|
|
a.Write();
|
a.Read();
|
}
|
|
{ // Test multiselect editing
|
var a = AnnotationCollection.Annotate(merged);
|
setInputVerdict(a, dialog);
|
Assert.AreSame(dialog, if1.InputVerdict.Step);
|
Assert.AreSame(dialog, if2.InputVerdict.Step);
|
Assert.AreSame(dialog, if3.InputVerdict.Step);
|
}
|
|
{ // Unset all
|
var a = AnnotationCollection.Annotate(merged);
|
setInputVerdict(a, null);
|
Assert.AreSame(null, if1.InputVerdict.Step);
|
Assert.AreSame(null, if2.InputVerdict.Step);
|
Assert.AreSame(null, if3.InputVerdict.Step);
|
}
|
|
{ // Set if1 independent of if2
|
var a = AnnotationCollection.Annotate(if1);
|
setInputVerdict(a, if2);
|
Assert.AreSame(if2, if1.InputVerdict.Step);
|
Assert.AreSame(null, if2.InputVerdict.Step);
|
Assert.AreSame(null, if3.InputVerdict.Step);
|
}
|
|
{ // Set if2 independent of if1
|
var a = AnnotationCollection.Annotate(if2);
|
setInputVerdict(a, if1);
|
Assert.AreSame(if2, if1.InputVerdict.Step);
|
Assert.AreSame(if1, if2.InputVerdict.Step);
|
Assert.AreSame(null, if3.InputVerdict.Step);
|
}
|
|
{ // Set all back to dialog
|
var a = AnnotationCollection.Annotate(merged);
|
setInputVerdict(a, dialog);
|
Assert.AreSame(dialog, if1.InputVerdict.Step);
|
Assert.AreSame(dialog, if2.InputVerdict.Step);
|
Assert.AreSame(dialog, if3.InputVerdict.Step);
|
}
|
|
{ // Unset all
|
var a = AnnotationCollection.Annotate(merged);
|
setInputVerdict(a, null);
|
Assert.AreSame(null, if1.InputVerdict.Step);
|
Assert.AreSame(null, if2.InputVerdict.Step);
|
Assert.AreSame(null, if3.InputVerdict.Step);
|
}
|
}
|
|
public class DoubleOut : TestStep
|
{
|
[Output] public double Out { get; set; } = 123;
|
public override void Run() { }
|
}
|
|
public class DoubleIn : TestStep
|
{
|
public Input<double> In { get; set; } = new();
|
public override void Run() { }
|
}
|
|
[Test]
|
public void TestSerializeMergedInput()
|
{
|
var plan = new TestPlan();
|
var out1 = new DoubleOut();
|
var seq = new SequenceStep();
|
var in1 = new DoubleIn { Name = "In 1" };
|
var in2 = new DoubleIn { Name = "In 2" };
|
var in3 = new DoubleIn { Name = "In 3" };
|
plan.ChildTestSteps.AddRange([out1, seq]);
|
ITestStep[] merged = [in1, in2, in3];
|
seq.ChildTestSteps.AddRange(merged);
|
|
{ // Parameterize `In` on the parent sequence step
|
var a = AnnotationCollection.Annotate(merged);
|
var mem = a.GetMember(nameof(in1.In));
|
var icon = mem.Get<MenuAnnotation>().MenuItems
|
.FirstOrDefault(m => m.Get<IIconAnnotation>().IconName == IconNames.ParameterizeOnParent);
|
var method = icon.Get<IMethodAnnotation>();
|
method.Invoke();
|
a.Write();
|
a.Read();
|
}
|
|
{ // Assign the parameterized member to the output from `Out`
|
var a = AnnotationCollection.Annotate(seq);
|
var mem = a.GetMember("Parameters \\ In");
|
var avail = mem.Get<IAvailableValuesAnnotationProxy>();
|
avail.SelectedValue = avail.AvailableValues.LastOrDefault();
|
a.Write();
|
a.Read();
|
}
|
|
{ // Verify the merged inputs are wired up correctly in this session
|
Input<double> parameter = (Input<double>)TypeData.GetTypeData(seq).GetMember("Parameters \\ In").GetValue(seq);
|
Assert.AreEqual(parameter.Step.Id, out1.Id);
|
Assert.AreEqual(in1.In.Step.Id, out1.Id);
|
Assert.AreEqual(in2.In.Step.Id, out1.Id);
|
Assert.AreEqual(in3.In.Step.Id, out1.Id);
|
}
|
|
{ // Verify the merged inputs are wired up correctly after reloading
|
var ser = new TapSerializer() { IgnoreErrors = false, ThrowOnErrors = true, };
|
var str = ser.SerializeToString(plan);
|
var plan2 = (TestPlan)ser.DeserializeFromString(str);
|
|
out1 = (DoubleOut)plan2.ChildTestSteps[0];
|
seq = (SequenceStep)plan2.ChildTestSteps[1];
|
in1 = (DoubleIn)seq.ChildTestSteps[0];
|
in2 = (DoubleIn)seq.ChildTestSteps[1];
|
in3 = (DoubleIn)seq.ChildTestSteps[2];
|
|
Input<double> parameter = (Input<double>)TypeData.GetTypeData(seq).GetMember("Parameters \\ In").GetValue(seq);
|
Assert.AreEqual(parameter.Step.Id, out1.Id);
|
Assert.AreEqual(in1.In.Step.Id, out1.Id);
|
Assert.AreEqual(in2.In.Step.Id, out1.Id);
|
Assert.AreEqual(in3.In.Step.Id, out1.Id);
|
}
|
}
|
|
[Test]
|
public void TestMergedInputVerdict2([Values(true, false)] bool availableProxy)
|
{
|
var repeat1 = new RepeatStep() { Action = RepeatStep.RepeatStepAction.While };
|
var repeat2 = new RepeatStep() { Action = RepeatStep.RepeatStepAction.While };
|
var plan = new TestPlan()
|
{
|
ChildTestSteps =
|
{
|
repeat1, repeat2
|
}
|
};
|
|
ITestStep[] merged = { repeat1, repeat2 };
|
|
void setInputVerdict(AnnotationCollection a, ITestStep targetStep)
|
{
|
var member = a.GetMember(nameof(repeat1.TargetStep));
|
if (availableProxy)
|
{
|
var avail = member.Get<IAvailableValuesAnnotationProxy>();
|
var sel = avail.AvailableValues.FirstOrDefault(av =>
|
av.Get<IObjectValueAnnotation>().Value == targetStep);
|
avail.SelectedValue = sel;
|
}
|
else
|
{
|
member.Get<IObjectValueAnnotation>().Value = targetStep;
|
}
|
|
a.Write();
|
a.Read();
|
}
|
|
{ // Test multiselect editing
|
var a = AnnotationCollection.Annotate(merged);
|
setInputVerdict(a, repeat1);
|
Assert.AreSame(repeat1, repeat1.TargetStep);
|
Assert.AreSame(repeat1, repeat1.TargetStep);
|
}
|
|
{ // Set repeat1 independent of repeat2
|
var a = AnnotationCollection.Annotate(repeat1);
|
setInputVerdict(a, repeat2);
|
Assert.AreSame(repeat2, repeat1.TargetStep);
|
Assert.AreSame(repeat1, repeat2.TargetStep);
|
}
|
|
{ // Set repeat2 independent of repeat1
|
var a = AnnotationCollection.Annotate(repeat2);
|
setInputVerdict(a, repeat1);
|
Assert.AreSame(repeat2, repeat1.TargetStep);
|
Assert.AreSame(repeat1, repeat2.TargetStep);
|
}
|
|
{ // Set all back to repeat1
|
var a = AnnotationCollection.Annotate(merged);
|
setInputVerdict(a, repeat1);
|
Assert.AreSame(repeat1, repeat1.TargetStep);
|
Assert.AreSame(repeat1, repeat2.TargetStep);
|
}
|
}
|
|
[Test]
|
public void ParameterizeOnParentTest()
|
{
|
var plan = new TestPlan();
|
var seqStep = new SequenceStep();
|
plan.ChildTestSteps.Add(seqStep);
|
var delayStep = new DelayStep();
|
seqStep.ChildTestSteps.Add(delayStep);
|
|
// Check can parameterize
|
var member = AnnotationCollection.Annotate(delayStep).GetMember(nameof(DelayStep.DelaySecs));
|
var menu = member.Get<MenuAnnotation>();
|
var menuItems = menu.MenuItems;
|
var icons = menuItems.ToLookup(item => item.Get<IIconAnnotation>()?.IconName ?? "");
|
var parameterizeIcon = icons[IconNames.Parameterize].First();
|
Assert.IsTrue(parameterizeIcon.Get<IAccessAnnotation>().IsVisible);
|
parameterizeIcon = icons[IconNames.Unparameterize].First();
|
Assert.IsFalse(parameterizeIcon.Get<IAccessAnnotation>().IsVisible);
|
|
// Parameterize
|
var delayMember = TypeData.GetTypeData(delayStep).GetMember(nameof(DelayStep.DelaySecs));
|
delayMember.Parameterize(seqStep, delayStep, "Delay");
|
|
// Check can parameterize
|
member = AnnotationCollection.Annotate(delayStep).GetMember(nameof(DelayStep.DelaySecs));
|
menu = member.Get<MenuAnnotation>();
|
menuItems = menu.MenuItems;
|
icons = menuItems.ToLookup(item => item.Get<IIconAnnotation>()?.IconName ?? "");
|
parameterizeIcon = icons[IconNames.Parameterize].First();
|
Assert.IsFalse(parameterizeIcon.Get<IAccessAnnotation>().IsVisible);
|
parameterizeIcon = icons[IconNames.Unparameterize].First();
|
Assert.IsTrue(parameterizeIcon.Get<IAccessAnnotation>().IsVisible);
|
|
var paramIconAnnotation = member.Get<ISettingReferenceIconAnnotation>();
|
Assert.AreEqual(seqStep.Id, paramIconAnnotation.TestStepReference);
|
Assert.AreEqual("Delay", paramIconAnnotation.MemberName);
|
|
// Set read only
|
delayStep.IsReadOnly = true;
|
|
// Check can parameterize
|
member = AnnotationCollection.Annotate(delayStep).GetMember(nameof(DelayStep.DelaySecs));
|
menu = member.Get<MenuAnnotation>();
|
menuItems = menu.MenuItems;
|
icons = menuItems.ToLookup(item => item.Get<IIconAnnotation>()?.IconName ?? "");
|
parameterizeIcon = icons[IconNames.Unparameterize].First();
|
Assert.IsFalse(parameterizeIcon.Get<IAccessAnnotation>().IsVisible);
|
}
|
|
/// <summary>
|
/// When the test plan is changed, parameters that becomes invalid needs to be removed.
|
/// This is done by doing some checks in DynamicMemberTypeDataProvider.
|
/// In this test it is verified that that behavior works as expected.
|
/// </summary>
|
[Test]
|
public void AutoRemoveParameters()
|
{
|
var plan = new TestPlan();
|
var step = new TwoDelayStep();
|
plan.ChildTestSteps.Add(step);
|
var member = TypeData.GetTypeData(step).GetMember(nameof(step.DelaySecs));
|
var parameter = member.Parameterize(plan, step, "delay");
|
Assert.IsNotNull(TypeData.GetTypeData(plan).GetMember(parameter.Name));
|
plan.ChildTestSteps.Remove(step);
|
Assert.IsNull(TypeData.GetTypeData(plan).GetMember(parameter.Name));
|
|
var seq = new SequenceStep();
|
plan.ChildTestSteps.Add(seq);
|
seq.ChildTestSteps.Add(step);
|
parameter = member.Parameterize(seq, step, "delay");
|
Assert.IsNotNull(TypeData.GetTypeData(seq).GetMember(parameter.Name));
|
seq.ChildTestSteps.Remove(step);
|
Assert.IsNull(TypeData.GetTypeData(seq).GetMember(parameter.Name));
|
|
seq.ChildTestSteps.Add(step);
|
parameter = member.Parameterize(seq, step, "delay");
|
var member2 = TypeData.GetTypeData(seq).GetMember(parameter.Name);
|
Assert.IsNotNull(member2);
|
Assert.AreEqual(member2, parameter);
|
var parameter2 = member2.Parameterize(plan, seq, "delay");
|
Assert.IsNotNull(TypeData.GetTypeData(plan).GetMember(parameter2.Name));
|
plan.ChildTestSteps.Remove(seq);
|
Assert.IsNull(TypeData.GetTypeData(plan).GetMember(parameter2.Name));
|
Assert.IsNotNull(TypeData.GetTypeData(seq).GetMember(parameter.Name));
|
|
plan.ChildTestSteps.Add(seq);
|
parameter2 = member2.Parameterize(plan, seq, "delay");
|
var member3 = TypeData.GetTypeData(step).GetMember(nameof(TwoDelayStep.DelaySecs2));
|
var parameter3 = member3.Parameterize(plan, step, "delay2");
|
Assert.IsNotNull(TypeData.GetTypeData(plan).GetMember(parameter2.Name));
|
Assert.IsNotNull(TypeData.GetTypeData(plan).GetMember(parameter3.Name));
|
Assert.IsNotNull(TypeData.GetTypeData(seq).GetMember(parameter.Name));
|
seq.ChildTestSteps.Remove(step);
|
Assert.IsNull(TypeData.GetTypeData(plan).GetMember(parameter2.Name));
|
Assert.IsNull(TypeData.GetTypeData(plan).GetMember(parameter3.Name));
|
Assert.IsNull(TypeData.GetTypeData(seq).GetMember(parameter.Name));
|
}
|
|
[Test]
|
public void EnabledAnnotated()
|
{
|
var step = new ProcessStep();
|
var a = AnnotationCollection.Annotate(step);
|
var x = a.GetMember(nameof(step.RegularExpressionPattern));
|
var str = x.GetMember("Value");
|
var strval =str.Get<IStringValueAnnotation>();
|
var v1 = strval.Value.ToString();
|
Assert.AreEqual("(.*)", v1);
|
step.RegularExpressionPattern.Value = "test";
|
a.Read();
|
var v2 = strval.Value;
|
Assert.AreEqual("test", v2);
|
}
|
|
[Test]
|
public void TestPlanAnnotated()
|
{
|
var plan = new TestPlan();
|
var step = new DelayStep();
|
plan.ChildTestSteps.Add(step);
|
var stepType = TypeData.GetTypeData(step);
|
var mem = stepType.GetMember(nameof(DelayStep.DelaySecs));
|
mem.Parameterize(plan, step, "delay");
|
|
var a = AnnotationCollection.Annotate(plan);
|
var members = a.Get<IMembersAnnotation>().Members;
|
|
bool filterCol(AnnotationCollection col)
|
{
|
if (col.Get<IAccessAnnotation>() is IAccessAnnotation access)
|
{
|
if (access.IsVisible == false) return false;
|
}
|
|
var m = col.Get<IMemberAnnotation>().Member;
|
|
var browsable = m.GetAttribute<BrowsableAttribute>();
|
|
// Browsable overrides everything
|
if (browsable != null) return browsable.Browsable;
|
|
var xmlIgnore = m.GetAttribute<XmlIgnoreAttribute>();
|
if (xmlIgnore != null)
|
return false;
|
|
if (m.HasAttribute<OutputAttribute>())
|
return true;
|
if (!m.Writable || !m.Readable)
|
return false;
|
return true;
|
}
|
|
members = members.Where(filterCol).ToArray();
|
// Name, delay
|
Assert.AreEqual(5, members.Count());
|
|
AnnotationCollection getMember(string name) => members.FirstOrDefault(x => x.Get<IMemberAnnotation>().Member.Name == name);
|
|
var nameMem = getMember(nameof(TestPlan.Name));
|
Assert.IsNotNull(nameMem);
|
Assert.IsTrue(nameMem.Get<IAccessAnnotation>().IsReadOnly);
|
var delayMember = getMember("delay");
|
Assert.IsNotNull(delayMember);
|
Assert.IsFalse(delayMember.Get<IAccessAnnotation>().IsReadOnly);
|
var lockedMember = getMember(nameof(TestPlan.Locked));
|
Assert.IsNotNull(lockedMember);
|
Assert.IsFalse(lockedMember.Get<IAccessAnnotation>().IsReadOnly);
|
var breakConditionsMember = getMember("BreakConditions");
|
Assert.IsNotNull(breakConditionsMember);
|
var en = breakConditionsMember.GetMember("IsEnabled");
|
en.Get<IObjectValueAnnotation>().Value = true;
|
en.Write();
|
a.Write();
|
|
var descr = AnnotationCollection.Annotate(step).GetMember("BreakConditions").GetMember("Value")
|
.Get<IValueDescriptionAnnotation>().Describe();
|
Assert.AreEqual("Break on Error (inherited from test plan).", descr);
|
|
{
|
var stepAnnotation = AnnotationCollection.Annotate(step);
|
var enabled = stepAnnotation.GetMember("BreakConditions").GetMember("IsEnabled").Get<IObjectValueAnnotation>();
|
enabled.Value = true;
|
//stepAnnotation.Write();
|
var value = stepAnnotation.GetMember("BreakConditions").GetMember("Value").Get<IObjectValueAnnotation>();
|
var thing = stepAnnotation.GetMember("BreakConditions").GetMember("Value");
|
var proxy = thing.Get<IMultiSelectAnnotationProxy>();
|
var sel = proxy.SelectedValues.ToArray();
|
value.Value = BreakCondition.BreakOnInconclusive;
|
stepAnnotation.Write();
|
var descr2 = stepAnnotation.GetMember("BreakConditions").GetMember("Value")
|
.Get<IValueDescriptionAnnotation>().Describe();
|
|
}
|
}
|
|
class ListOfEnumAnnotationClass
|
{
|
public List<string> Strings { get; set; } = new List<string>{"A", "B", "C"};
|
public List<Verdict> Verdicts { get; set; } = new List<Verdict>{Verdict.Aborted, Verdict.Error};
|
public List<DateTime> Dates { get; set; } = new List<DateTime>{DateTime.Now};
|
public List<TimeSpan> TimeSpans { get; set; } = new List<TimeSpan>{TimeSpan.Zero, TimeSpan.Zero};
|
public List<bool> Bools { get; set; } = new List<bool>() {true, false};
|
|
}
|
|
[Test]
|
public void ListOfEnumAnnotation()
|
{
|
var obj = new ListOfEnumAnnotationClass();
|
var annotation = AnnotationCollection.Annotate(obj);
|
Assert.AreEqual(5, TypeData.GetTypeData(obj).GetMembers().Count());
|
|
foreach (var member in TypeData.GetTypeData(obj).GetMembers())
|
{
|
int initCount = (member.GetValue(obj) as IList).Count;
|
var memberAnnotation = annotation.GetMember(member.Name);
|
var collection = memberAnnotation.Get<ICollectionAnnotation>();
|
collection.AnnotatedElements = collection.AnnotatedElements.Append(collection.NewElement());
|
annotation.Write();
|
int finalCount = (TypeData.GetTypeData(obj).GetMember(member.Name).GetValue(obj) as IList).Count;
|
Assert.IsTrue(initCount == finalCount - 1);
|
|
}
|
}
|
|
class ArrayAnnotationClass
|
{
|
public string[] Strings { get; set; } = new string[] {"A", "B", "C"};
|
public Verdict[] Verdicts { get; set; } = new Verdict[] {Verdict.Aborted, Verdict.Error};
|
public DateTime[] Dates { get; set; } = new DateTime[] {DateTime.Now};
|
public TimeSpan[] TimeSpans { get; set; } = new TimeSpan[] {TimeSpan.Zero, TimeSpan.Zero};
|
public bool[] Bools { get; set; } = new bool[] {true, false};
|
}
|
|
[Test]
|
public void AddToFixedSizeAnnotation()
|
{
|
var obj = new ArrayAnnotationClass();
|
var annotation = AnnotationCollection.Annotate(obj);
|
|
Assert.AreEqual(5, TypeData.GetTypeData(obj).GetMembers().Count());
|
|
foreach (var member in TypeData.GetTypeData(obj).GetMembers())
|
{
|
int initCount = (member.GetValue(obj) as IList).Count;
|
var memberAnnotation = annotation.GetMember(member.Name);
|
var collection = memberAnnotation.Get<ICollectionAnnotation>();
|
|
collection.AnnotatedElements = collection.AnnotatedElements.Append(collection.NewElement());
|
|
annotation.Write();
|
int finalCount = (TypeData.GetTypeData(obj).GetMember(member.Name).GetValue(obj) as IList).Count;
|
Assert.IsTrue(initCount == finalCount - 1);
|
}
|
}
|
|
|
[Test]
|
public void MultiSelectParameterize()
|
{
|
// Previously some performance issue causes this use-case to take several minutes.
|
// After fixing I added this test that shows that it does not take an extraordinary amount
|
// of time to parameterize a property on many test steps.
|
|
var plan = new TestPlan();
|
List<DelayStep> steps = new List<DelayStep>();
|
for (int i = 0; i < 500; i++) // note: Run this at 50000 iterations to determine limits.
|
{
|
var step = new DelayStep();
|
plan.ChildTestSteps.Add(step);
|
steps.Add(step);
|
}
|
|
var a = AnnotationCollection.Annotate(steps.ToArray());
|
var menu = a.GetMember(nameof(DelayStep.DelaySecs)).Get<MenuAnnotation>();
|
var parameterize = menu.MenuItems.FirstOrDefault(x =>
|
x.Get<IconAnnotationAttribute>().IconName == IconNames.ParameterizeOnTestPlan);
|
var unparameterize = menu.MenuItems.FirstOrDefault(x =>
|
x.Get<IconAnnotationAttribute>().IconName == IconNames.Unparameterize);
|
|
var sw = Stopwatch.StartNew();
|
parameterize.Get<IMethodAnnotation>().Invoke();
|
|
|
var elapsed = sw.Elapsed;
|
|
var sw4 = Stopwatch.StartNew();
|
var xml = plan.SerializeToString();
|
var serializeElapsed = sw4.Elapsed;
|
|
var sw5= Stopwatch.StartNew();
|
Utils.DeserializeFromString<TestPlan>(xml);
|
var deserializeElapsed = sw5.Elapsed;
|
|
|
Assert.AreEqual(1, TypeData.GetTypeData(plan).GetMembers().OfType<ParameterMemberData>().Count());
|
|
var parameter = TypeData.GetTypeData(plan).GetMembers().OfType<ParameterMemberData>().First();
|
|
var editParameter = AnnotationCollection.Annotate(plan).GetMember(parameter.Name).Get<MenuAnnotation>().MenuItems.First(x =>
|
x.Get<IconAnnotationAttribute>()?.IconName == IconNames.EditParameter);
|
var currentUserInterface = UserInput.Interface;
|
var menuInterface = new MenuTestUserInterface();
|
UserInput.SetInterface(menuInterface);
|
TimeSpan elapsed3 = TimeSpan.MaxValue;
|
try
|
{
|
menuInterface.SelectName = "B";
|
var sw3 = Stopwatch.StartNew();
|
editParameter.Get<IMethodAnnotation>().Invoke();
|
elapsed3 = sw3.Elapsed;
|
|
}
|
finally
|
{
|
UserInput.SetInterface((IUserInputInterface)currentUserInterface);
|
}
|
|
|
var sw2 = Stopwatch.StartNew();
|
unparameterize.Get<IMethodAnnotation>().Invoke();
|
var elapsed2 = sw2.Elapsed;
|
|
Assert.AreEqual(0, TypeData.GetTypeData(plan).GetMembers().OfType<ParameterMemberData>().Count());
|
|
// these limits are found at 50000 entries, so it is assumed that at 500, they will always work
|
// unless some quadratic complexity has been introduced.
|
Assert.IsTrue(serializeElapsed.TotalSeconds < 10);
|
Assert.IsTrue(deserializeElapsed.TotalSeconds < 15);
|
Assert.IsTrue(elapsed.TotalSeconds < 3);
|
Assert.IsTrue(elapsed2.TotalSeconds < 3);
|
Assert.IsTrue(elapsed3.TotalSeconds < 4);
|
}
|
|
public class InstrumentStep1 : TestStep
|
{
|
public Instrument Instrument { get; set; }
|
public override void Run()
|
{
|
}
|
}
|
|
public class InstrumentStep2 : TestStep
|
{
|
public Instrument Instrument { get; set; }
|
public override void Run()
|
{
|
}
|
}
|
|
[Test]
|
public void MultiSelectUnparameterize()
|
{
|
var step1 = new InstrumentStep1();
|
var step2 = new InstrumentStep2();
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(step1);
|
plan.ChildTestSteps.Add(step2);
|
|
{
|
// 1. parameterize them
|
var a = AnnotationCollection.Annotate(new ITestStep[]
|
{
|
step1, step2
|
});
|
|
var member = a.GetMember(nameof(step1.Instrument));
|
member.GetIcon(IconNames.ParameterizeOnTestPlan).Get<IMethodAnnotation>()?.Invoke();
|
}
|
|
// 2. check.
|
Assert.IsNotEmpty(TypeData.GetTypeData(plan).GetMembers().OfType<IParameterMemberData>());
|
|
{
|
// 3. unparameterize them
|
var a = AnnotationCollection.Annotate(new ITestStep[]
|
{
|
step1, step2
|
});
|
|
var member = a.GetMember(nameof(step1.Instrument));
|
member.GetIcon(IconNames.Unparameterize).Get<IMethodAnnotation>()?
|
.Invoke();
|
}
|
|
// 4. check.
|
Assert.IsEmpty(TypeData.GetTypeData(plan).GetMembers().OfType<IParameterMemberData>());
|
}
|
|
|
[Test]
|
public void MultiSelectList()
|
{
|
var step1 = new ClassWithListOfString();
|
var step2 = new ClassWithListOfString();
|
var a = AnnotationCollection.Annotate(new []{step1, step2});
|
var lst = a.GetMember(nameof(step1.List));
|
var valAnnotation = lst.Get<ICollectionAnnotation>();
|
valAnnotation.AnnotatedElements = valAnnotation.AnnotatedElements.Append(valAnnotation.NewElement()).ToArray();
|
a.Write();
|
Assert.IsTrue(step1.List.Count == 3);
|
Assert.IsTrue(step1.List.SequenceEqual(step2.List));
|
Assert.AreNotSame(step1.List, step2.List);
|
}
|
|
[Test]
|
public void FixNullList()
|
{
|
var step1 = new ClassWithListOfString { List = null };
|
|
var a = AnnotationCollection.Annotate(step1);
|
var lst = a.GetMember(nameof(step1.List));
|
var seqAnnotation = lst.Get<ICollectionAnnotation>();
|
var numbers = seqAnnotation.AnnotatedElements.ToArray();
|
seqAnnotation.AnnotatedElements = numbers.Append(seqAnnotation.NewElement());
|
a.Write();
|
// step1.List should not be null as we have just added an element to it.
|
Assert.IsNotNull(step1.List);
|
Assert.AreEqual(1, step1.List.Count);
|
}
|
|
|
[Test]
|
public void ParameterInputsTest()
|
{
|
var plan = new TestPlan();
|
var verdictStep = new VerdictStep();
|
var ifStep1 = new IfStep();
|
var ifStep2 = new IfStep();
|
plan.ChildTestSteps.Add(verdictStep);
|
plan.ChildTestSteps.Add(ifStep1);
|
plan.ChildTestSteps.Add(ifStep2);
|
var member = TypeData.GetTypeData(ifStep1).GetMember(nameof(ifStep1.InputVerdict));
|
Assert.IsTrue(ParameterManager.CanParameter(member, new ITestStepParent[] {ifStep1}));
|
ParameterManager.Parameterize(plan, member, new ITestStepParent[] {ifStep1, ifStep2}, "A");
|
|
var verdictParameter = TypeData.GetTypeData(plan).GetMember("A");
|
|
var value = (Input<Verdict>)verdictParameter.GetValue(plan);
|
Assert.IsFalse(object.ReferenceEquals(ifStep1.InputVerdict, ifStep2.InputVerdict));
|
verdictParameter.SetValue(plan, value);
|
value.Step = verdictStep;
|
TypeData.GetTypeData(plan).GetMember("A").SetValue(plan, value);
|
Assert.IsFalse(object.ReferenceEquals(ifStep1.InputVerdict, ifStep2.InputVerdict));
|
Assert.IsTrue(object.ReferenceEquals(ifStep1.InputVerdict.Step, ifStep2.InputVerdict.Step));
|
|
}
|
|
[Test]
|
public void RemoveFromFixedSizeAnnotation()
|
{
|
var obj = new ArrayAnnotationClass();
|
var annotation = AnnotationCollection.Annotate(obj);
|
|
Assert.AreEqual(5, TypeData.GetTypeData(obj).GetMembers().Count());
|
|
foreach (var member in TypeData.GetTypeData(obj).GetMembers())
|
{
|
int initCount = (member.GetValue(obj) as IList).Count;
|
var memberAnnotation = annotation.GetMember(member.Name);
|
var collection = memberAnnotation.Get<ICollectionAnnotation>();
|
|
collection.AnnotatedElements = collection.AnnotatedElements
|
.Take(collection.AnnotatedElements.Count() - 1).ToList();
|
|
annotation.Write();
|
int finalCount = (TypeData.GetTypeData(obj).GetMember(member.Name).GetValue(obj) as IList).Count;
|
Assert.IsTrue(initCount == finalCount + 1);
|
}
|
|
}
|
|
public class TestStepWithLists : TestStep
|
{
|
public List<double> DoubleValues { get; set; } = new List<double>();
|
|
public class Item
|
{
|
public double X { get; set; }
|
}
|
|
public List<Item> Items { get; set; } = new List<Item>();
|
public override void Run()
|
{
|
|
}
|
}
|
|
[Test]
|
public void ParameteriseLists()
|
{
|
var obj1 = new TestStepWithLists();
|
var obj2 = new TestStepWithLists();
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(obj1);
|
plan.ChildTestSteps.Add(obj2);
|
|
void doTest(string name, TestStepWithLists obj, bool canAnnotate)
|
{
|
var a1 = AnnotationCollection.Annotate(obj).GetMember(name);
|
var p = a1.GetIcon(IconNames.ParameterizeOnTestPlan);
|
if (canAnnotate)
|
{
|
Assert.IsTrue(p.Get<IEnabledAnnotation>().IsEnabled);
|
p.Get<IMethodAnnotation>().Invoke();
|
p.Read();
|
Assert.IsFalse(p.Get<IEnabledAnnotation>().IsEnabled);
|
}
|
else
|
{
|
Assert.IsFalse(p.Get<IEnabledAnnotation>().IsEnabled);
|
}
|
}
|
|
doTest(nameof(obj1.DoubleValues), obj1, true);
|
doTest(nameof(obj2.DoubleValues), obj2, true);
|
doTest(nameof(obj1.Items), obj1, true);
|
doTest(nameof(obj2.Items), obj2, true);
|
|
// finally, test that modifying the value also propagates.
|
var items = AnnotationCollection.Annotate(plan).GetMember("Parameters \\ " + nameof(obj1.Items));
|
Assert.IsNotNull(items);
|
|
var collection = items.Get<ICollectionAnnotation>();
|
collection.AnnotatedElements = collection.AnnotatedElements.Append(collection.NewElement()).ToArray();
|
items.Write();
|
|
Assert.AreEqual(1, obj1.Items.Count);
|
Assert.AreEqual(1, obj2.Items.Count);
|
|
// not same reference.
|
Assert.AreNotEqual(obj1.Items, obj2.Items);
|
}
|
|
[Test]
|
public void AddExternalParameterWarning()
|
{
|
var obj1 = new TestStepWithLists();
|
var obj2 = new TestStepWithLists();
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(obj1);
|
plan.ChildTestSteps.Add(obj2);
|
var member= TypeData.GetTypeData(obj1).GetMember(nameof(obj1.Items));
|
plan.ExternalParameters.Add(obj1, member, "items");
|
|
// produces warning, does not add since the item type is not compatible.
|
var ext = plan.ExternalParameters.Add(obj2, member, "items");
|
Assert.AreEqual(1, ext.Properties.Count());
|
|
}
|
|
public class MemberWithException
|
{
|
public class SubThing
|
{
|
public double Value => throw new ArgumentNullException();
|
}
|
public SubThing Value
|
{
|
get => throw new ArgumentNullException();
|
set { }
|
}
|
|
public SubThing Value2
|
{
|
set{}
|
}
|
|
}
|
|
[Test]
|
public void TestMemberWithExceptionAnnotation()
|
{
|
var annotation = AnnotationCollection.Annotate(new MemberWithException());
|
Assert.AreEqual(1, annotation.Get<IMembersAnnotation>().Members.Count());
|
annotation.Read();
|
Assert.AreEqual(1, annotation.Get<IMembersAnnotation>().Members.Count());
|
}
|
|
[Test]
|
public void SweepParametersAnnotation()
|
{
|
var plan = new TestPlan();
|
var sweep = new SweepParameterStep();
|
var log = new LogStep() { };
|
log.LogMessage = "msg0";
|
plan.Steps.Add(sweep);
|
sweep.ChildTestSteps.Add(log);
|
AnnotationCollection.Annotate(log)
|
.GetMember(nameof(log.LogMessage))
|
.ExecuteIcon(IconNames.ParameterizeOnParent);
|
|
AnnotationCollection.Annotate(sweep)
|
.GetMember(nameof(sweep.SweepValues))
|
.ExecuteIcon(IconNames.ParameterizeOnTestPlan);
|
|
var sweepValues = AnnotationCollection.Annotate(plan).GetMember("Parameters \\ Sweep \\ Sweep Values");
|
Assert.IsNotNull(sweepValues);
|
var collection = sweepValues.Get<ICollectionAnnotation>();
|
for (int i = 0; i < 5; i++)
|
{
|
collection.AnnotatedElements = collection.AnnotatedElements.Append(collection.NewElement());
|
sweepValues.Write();
|
sweepValues.Read();
|
Assert.IsTrue(collection.AnnotatedElements.Count() == i + 1);
|
var row1 = collection.AnnotatedElements.Last();
|
var enabledMember = row1.GetMember("Enabled");
|
var valueMember = row1.GetMember("Parameters \\ Log Message");
|
valueMember.SetValue("msg" + i);
|
Assert.IsNotNull(enabledMember);
|
Assert.IsNotNull(valueMember);
|
}
|
|
sweepValues.Write();
|
for (int i = 0; i < 5; i++)
|
{
|
Assert.AreEqual("msg" + i, sweep.SweepValues[i].Values["Parameters \\ Log Message"]);
|
}
|
}
|
|
[Display("Validation Error Step")]
|
public class ValidationErrorTestStep : TestStep
|
{
|
public bool HasValidationErrors { get; set; }
|
public ValidationErrorTestStep()
|
{
|
Rules.Add(() => !HasValidationErrors, "Validation errors", nameof(ValidationErrorTestStep));
|
}
|
public override void Run()
|
{
|
}
|
}
|
|
[Test]
|
public void SweepParametersValidationTest()
|
{
|
var plan = new TestPlan();
|
var sweep = new SweepParameterStep();
|
var errorStep = new DelayStep() {Name = "errorStep"};
|
var noErrorStep = new DelayStep() {Name = "noErrorStep"};
|
var validationErrorStep = new ValidationErrorTestStep();
|
|
plan.ChildTestSteps.Add(sweep);
|
sweep.ChildTestSteps.Add(errorStep);
|
sweep.ChildTestSteps.Add(noErrorStep);
|
sweep.ChildTestSteps.Add(validationErrorStep);
|
|
TypeData.GetTypeData(errorStep).GetMember(nameof(errorStep.DelaySecs))
|
.Parameterize(sweep, errorStep, nameof(errorStep.DelaySecs));
|
TypeData.GetTypeData(validationErrorStep).GetMember(nameof(validationErrorStep.HasValidationErrors))
|
.Parameterize(sweep, validationErrorStep, nameof(validationErrorStep.HasValidationErrors));
|
|
void addRow(double delay, bool validationErrors)
|
{
|
sweep.SweepValues.Add(new SweepRow(sweep));
|
var td = TypeData.GetTypeData(sweep.SweepValues[0]);
|
var timeDelay = td.GetMember(nameof(errorStep.DelaySecs));
|
var valErrors = td.GetMember(nameof(validationErrorStep.HasValidationErrors));
|
|
timeDelay.SetValue(sweep.SweepValues.Last(), delay);
|
valErrors.SetValue(sweep.SweepValues.Last(), validationErrors);
|
}
|
|
// First row has no errors
|
addRow(1, false);
|
// Second row has an invalid time delay
|
addRow(-1, false);
|
// Third row as validation errors
|
addRow(1, true);
|
// Fourth row has an invalid time delay and validation errors
|
addRow(-1, true);
|
|
void TestErrors()
|
{
|
|
var lines = sweep.Error.Split('\n');
|
|
// Test errors outside of run
|
|
{
|
// Test row 1
|
var row = lines.Where(l => l.Contains("Row 1"));
|
CollectionAssert.IsEmpty(row);
|
}
|
|
{
|
// Test row 2
|
var row = lines.Where(l => l.Contains("Row 2")).ToArray();
|
Assert.AreEqual(1, row.Length);
|
Assert.IsTrue(row.First().Contains($"Delay must be a positive value."),
|
"Row 2 should have an invalid DelaySecs value.");
|
}
|
|
{
|
// Test row 3
|
var row = lines.Where(l => l.Contains("Row 3")).ToArray();
|
Assert.AreEqual(1, row.Length);
|
Assert.IsTrue(row.Any(r => r.Contains("Validation Error Step - Validation errors")),
|
"Row 3 should have validation errors.");
|
}
|
|
{
|
// Test row 4
|
var row = lines.Where(l => l.Contains("Row 4")).ToArray();
|
Assert.AreEqual(2, row.Length);
|
var row1 = row.First();
|
Assert.IsTrue(row1.Contains($"Delay must be a positive value."),
|
"Row 4 should have an invalid DelaySecs value.");
|
var row2 = row.Last();
|
Assert.IsTrue(row2.Contains("Validation Error Step - Validation errors"),
|
"Row 4 should have validation errors.");
|
}
|
}
|
TestErrors();
|
|
var t = TapThread.Start(() => { plan.Execute(); });
|
|
while (plan.IsRunning == false)
|
TapThread.Sleep(10);
|
|
// Validation should work while the test plan is running by returning the most recent validation error string
|
TestErrors();
|
|
|
while (plan.IsRunning)
|
TapThread.Sleep(10);
|
|
TestErrors();
|
}
|
|
[Test]
|
public void SweepLoopUnparameterizable()
|
{
|
var plan = new TestPlan();
|
var sweep = new SweepLoop();
|
var delay = new DelayStep();
|
plan.ChildTestSteps.Add(sweep);
|
sweep.ChildTestSteps.Add(delay);
|
var members = new List<IMemberData>()
|
{TypeData.GetTypeData(delay).GetMember(nameof(delay.DelaySecs))};
|
sweep.SweepParameters.Add(new SweepParam(members));
|
|
var sweepParametersAnnotation = AnnotationCollection.Annotate(sweep).GetMember(nameof(sweep.SweepParameters));
|
Assert.IsFalse(sweepParametersAnnotation.GetIcon(IconNames.ParameterizeOnTestPlan).Get<IEnabledAnnotation>().IsEnabled);
|
var nameAnnotation = AnnotationCollection.Annotate(sweep).GetMember(nameof(sweep.Name));
|
Assert.IsTrue(nameAnnotation.GetIcon(IconNames.ParameterizeOnTestPlan).Get<IEnabledAnnotation>().IsEnabled);
|
}
|
|
[TestCase(nameof(DialogStep.Title), nameof(DialogStep.Message), true)]
|
[TestCase(nameof(DialogStep.Buttons), nameof(DialogStep.Message), false)]
|
[TestCase(nameof(DialogStep.Message), nameof(DialogStep.Buttons), false)]
|
[TestCase(nameof(DialogStep.Title), nameof(DialogStep.Buttons), false)]
|
[TestCase(nameof(DialogStep.Title), nameof(DialogStep.UseTimeout), false)]
|
[TestCase(nameof(DialogStep.UseTimeout), nameof(DialogStep.Buttons), false)]
|
[TestCase(nameof(DialogStep.Timeout), nameof(DialogStep.Message), false)]
|
[TestCase(nameof(DialogStep.Message), nameof(DialogStep.Timeout), false)]
|
public void TestMergeBadParameters(string paramA, string paramB, bool canMerge)
|
{
|
var plan = new TestPlan();
|
var dialog = new DialogStep();
|
plan.Steps.Add(dialog);
|
var a = AnnotationCollection.Annotate(dialog);
|
var menuInterface = new MenuTestUserInterface();
|
var currentInterface = UserInput.Interface as IUserInputInterface;
|
UserInput.SetInterface(menuInterface);
|
try
|
{
|
menuInterface.SelectName = "a";
|
menuInterface.SelectedMode = MenuTestUserInterface.Mode.Create | MenuTestUserInterface.Mode.TestPlan;
|
a.GetMember(paramA).GetIcon(IconNames.Parameterize).Get<IMethodAnnotation>().Invoke();
|
if (canMerge)
|
{
|
menuInterface.SelectedMode = MenuTestUserInterface.Mode.Merge | MenuTestUserInterface.Mode.TestPlan;
|
}
|
else
|
{
|
menuInterface.SelectedMode = MenuTestUserInterface.Mode.Merge |
|
MenuTestUserInterface.Mode.TestPlan | MenuTestUserInterface.Mode.Error;
|
menuInterface.ErrorString = "Cannot merge properties of this kind.";
|
}
|
a.GetMember(paramB).GetIcon(IconNames.Parameterize).Get<IMethodAnnotation>().Invoke();
|
}
|
finally
|
{
|
UserInput.SetInterface(currentInterface);
|
}
|
}
|
|
class BoolArrayClass
|
{
|
public List<bool> A { get; set; }= new List<bool>();
|
public bool[] B { get; set; }= new bool[0];
|
//public int[] C { get; set; }= new int[0];
|
//public List<int> D { get; set; }= new List<int>();
|
public List<object> E { get; set; }= new List<object>();
|
public List<Verdict> F { get; set; }= new List<Verdict>();
|
public Verdict[] G { get; set; }= new Verdict[0];
|
}
|
|
[Test]
|
public void TestSetBoolArrayValues()
|
{
|
var obj = new BoolArrayClass() ;
|
var a = AnnotationCollection.Annotate(obj);
|
foreach (var mem in a.Get<IMembersAnnotation>().Members)
|
{
|
for (int i = 0; i < 5; i++)
|
{
|
a.Read();
|
var col = mem.Get<ICollectionAnnotation>();
|
col.AnnotatedElements = col.AnnotatedElements.Append(col.NewElement());
|
mem.Write();
|
Assert.AreEqual(i + 1, col.AnnotatedElements.Count());
|
}
|
}
|
}
|
|
public class SuggestedValuesObject
|
{
|
public List<int> SuggestedValues { get; set; } = new List<int> {1, 2, 3};
|
[SuggestedValues(nameof(SuggestedValues))]
|
public int SelectedValue { get; set; }
|
|
[AvailableValues(nameof(SuggestedValues))]
|
public int SelectedValue2 { get; set; }
|
}
|
|
[Test]
|
public void SuggestedAndAvailableValuesUpdateTest()
|
{
|
// an issue was discovered that when the list of suggested values is updated, without replacing it with
|
// a new list instance the an issue occurs because the ISuggestedValueAnnotationProxy does some internal caching.
|
var obj = new SuggestedValuesObject();
|
var a = AnnotationCollection.Annotate(obj);
|
var sv = a.GetMember(nameof(obj.SelectedValue)).Get<ISuggestedValuesAnnotationProxy>();
|
var av = a.GetMember(nameof(obj.SelectedValue2)).Get<IAvailableValuesAnnotationProxy>();
|
Assert.AreEqual(3, sv.SuggestedValues.Count());
|
Assert.AreEqual(3, av.AvailableValues.Count());
|
obj.SuggestedValues.Add(4);
|
a.Read();
|
Assert.AreEqual(4, sv.SuggestedValues.Count()); // Failed initially
|
Assert.AreEqual(4, av.AvailableValues.Count());
|
}
|
|
public class InstrumentStep : TestStep
|
{
|
public IInstrument Instrument { get; set; }
|
public override void Run()
|
{
|
}
|
}
|
|
[Test]
|
public void TestSetStringResourceTest()
|
{
|
using (Session.Create(SessionOptions.OverlayComponentSettings))
|
{
|
var step = new InstrumentStep();
|
var instrument = new DummyInstrument() { Name = "Instr" };
|
InstrumentSettings.Current.Add(instrument);
|
|
var a = AnnotationCollection.Annotate(step);
|
var instr = a.GetMember(nameof(step.Instrument));
|
var strval = instr.Get<IStringValueAnnotation>();
|
var current = strval.Value;
|
Assert.AreNotEqual(instrument.Name, current); // this should be null or some other default value.
|
strval.Value = instrument.Name;
|
a.Write();
|
a.Read();
|
var next = strval.Value;
|
Assert.AreEqual(instrument, step.Instrument);
|
Assert.AreEqual(instrument.Name, next);
|
}
|
}
|
|
|
class ClassWithNumbers
|
{
|
[Unit("things")]
|
public int[] Values { get; set; } = new int[] {1, 2, 3};
|
}
|
|
[Test]
|
public void TestNumberSequenceAnnotation()
|
{
|
var obj = new ClassWithNumbers();
|
var annotation = AnnotationCollection.Annotate(obj);
|
var str = annotation.GetMember(nameof(obj.Values)).Get<IStringValueAnnotation>();
|
var err = annotation.GetMember(nameof(obj.Values)).Get<IErrorAnnotation>();
|
// this should not throw.
|
str.Value = "asd";
|
Assert.IsTrue(err.Errors.Count() == 1);
|
str.Value = "1, 2, 3, 4";
|
Assert.IsTrue(err.Errors.Count() == 0);
|
annotation.Write();
|
Assert.IsTrue(obj.Values.SequenceEqual(new int[] {1, 2, 3, 4}));
|
}
|
|
[Test]
|
public void WriteMergedAnnotationTest()
|
{
|
var names = new[] { "name1", "name1", "name2" };
|
var delaySteps = new DelayStep[3];
|
for (int i = 0; i < 3; i++)
|
{
|
var delay = new DelayStep() { Name = names[i] };
|
delaySteps[i] = delay;
|
}
|
|
var a = AnnotationCollection.Annotate(delaySteps);
|
{ // verify merge fails
|
var mem = a.GetMember(nameof(DelayStep.Name));
|
var name = mem.Get<MergedValueAnnotation>();
|
Assert.AreEqual(null, name.Value);
|
}
|
{ // Verify collection is not modified on write
|
a.Write();
|
CollectionAssert.AreEqual(names, delaySteps.Select(d => d.Name));
|
}
|
{ // Verify merge succeeds
|
delaySteps[2].Name = "name1";
|
a.Read();
|
var mem = a.GetMember(nameof(DelayStep.Name));
|
var name = mem.Get<MergedValueAnnotation>();
|
Assert.AreEqual("name1", name.Value);
|
}
|
}
|
|
public class DutAndInstrumentResource : Resource, IDut, IInstrument
|
{
|
}
|
|
public class DutAndInstrumentUser : TestStep
|
{
|
public IDut DUT { get; set; }
|
public IInstrument Instrument { get; set; }
|
public DutAndInstrumentResource Both { get; set; }
|
public override void Run()
|
{
|
}
|
}
|
[Test]
|
public void AvailableResourcesTest()
|
{
|
using var session = Session.Create(SessionOptions.OverlayComponentSettings);
|
DutSettings.Current.Clear();
|
InstrumentSettings.Current.Clear();
|
|
var ins = new DutAndInstrumentResource() { Name = "The Instrument" };
|
var dut = new DutAndInstrumentResource() { Name = "The DUT" };
|
|
InstrumentSettings.Current.Add(ins);
|
DutSettings.Current.Add(dut);
|
|
var step = new DutAndInstrumentUser();
|
var a = AnnotationCollection.Annotate(step);
|
|
DutAndInstrumentResource[] getAvailable(string name) =>
|
a.GetMember(name).Get<IAvailableValuesAnnotation>().AvailableValues.Cast<DutAndInstrumentResource>().ToArray();
|
|
var availableInstruments = getAvailable(nameof(step.Instrument));
|
var availableDuts = getAvailable(nameof(step.DUT));
|
var availableBoth = getAvailable(nameof(step.Both));
|
|
Assert.AreEqual(2, availableInstruments.Length);
|
CollectionAssert.Contains(availableBoth, ins);
|
CollectionAssert.Contains(availableBoth, dut);
|
|
Assert.AreEqual(2, availableDuts.Length);
|
CollectionAssert.Contains(availableBoth, ins);
|
CollectionAssert.Contains(availableBoth, dut);
|
|
Assert.AreEqual(2, availableBoth.Length);
|
CollectionAssert.Contains(availableBoth, ins);
|
CollectionAssert.Contains(availableBoth, dut);
|
}
|
|
[Test]
|
public void AvailableValuesUpdateTest()
|
{
|
var step = new AvailableValuesUpdateTest();
|
var annotation = AnnotationCollection.Annotate(step);
|
var a = annotation.GetMember(nameof(step.A));
|
var b = annotation.GetMember(nameof(step.B));
|
var a1 = a.Get<IAvailableValuesAnnotationProxy>();
|
var b1 = b.Get<IAvailableValuesAnnotationProxy>();
|
|
bool doTest()
|
{
|
// A available values is not allowed to contain the value of B and vice versa.
|
var test2 = b1.AvailableValues.Select(x => x.Get<IObjectValueAnnotation>().Value).Contains(a1.SelectedValue.Get<IObjectValueAnnotation>().Value);
|
var test1 = a1.AvailableValues.Select(x => x.Get<IObjectValueAnnotation>().Value).Contains(b1.SelectedValue.Get<IObjectValueAnnotation>().Value);
|
var b1val = b1.SelectedValue.Get<IObjectValueAnnotation>().Value;
|
var a1val = a1.SelectedValue.Get<IObjectValueAnnotation>().Value;
|
|
if (Equals(b1val, a1val))
|
return false;
|
return !test1 && !test2;
|
}
|
|
for (int i = 0; i < 10; i++)
|
{
|
Assert.IsTrue(doTest());
|
|
b1.SelectedValue = b1.AvailableValues.FirstOrDefault(x => !Equals(x.Get<IObjectValueAnnotation>().Value,
|
b1.SelectedValue.Get<IObjectValueAnnotation>().Value));
|
|
annotation.Write();
|
annotation.Read();
|
Assert.IsTrue(doTest());
|
a1.SelectedValue = a1.AvailableValues.FirstOrDefault(x => !Equals(x.Get<IObjectValueAnnotation>().Value,
|
a1.SelectedValue.Get<IObjectValueAnnotation>().Value));
|
|
annotation.Write();
|
annotation.Read();
|
Assert.IsTrue(doTest());
|
}
|
|
for (int i = 0; i < 5; i++)
|
{
|
var number = annotation.GetMember(nameof(step.FromIncreasingNumber));
|
var number1 = number.Get<IAvailableValuesAnnotationProxy>();
|
var numbers = number1.AvailableValues.Select(x => (int)x.Get<IObjectValueAnnotation>().Value).ToArray();
|
Assert.AreEqual(step.IncreasingNumber, numbers[0]);
|
var numberIncrease = annotation.GetMember(nameof(step.IncreaseNumber)).Get<IMethodAnnotation>();
|
numberIncrease.Invoke();
|
annotation.Read();
|
}
|
}
|
|
public enum Overlapping
|
{
|
A = 0,
|
X = 1,
|
Z = 2, // there is one constraint, which is that the selected name must be the first one. Otherwise Overlapping.Z.ToString() => "Y"
|
[Obsolete]
|
[Browsable(false)]
|
Y = 2,
|
[Browsable(false)]
|
[Obsolete]
|
Y2 = 2,
|
W = 3
|
}
|
|
class ClassWithOverlapping
|
{
|
public Overlapping Overlapping { get; set; } = Overlapping.X;
|
}
|
[Test]
|
public void OverlappingEnumTest()
|
{
|
var o = new ClassWithOverlapping();
|
var a = AnnotationCollection.Annotate(o);
|
var a2 = a.GetMember(nameof(o.Overlapping));
|
var available = a2.Get<IAvailableValuesAnnotation>().AvailableValues.Cast<Overlapping>();
|
CollectionAssert.AreEqual(available, new[] { Overlapping.A, Overlapping.X, Overlapping.Z, Overlapping.W });
|
|
var a3 = a2.Get<IAvailableValuesAnnotationProxy>();
|
var strValues = a3.AvailableValues.Select(x => x.Get<IStringReadOnlyValueAnnotation>().Value).ToArray();
|
CollectionAssert.AreEqual(strValues, new[] { "A", "X", "Z", "W" });
|
a3.SelectedValue = a3.AvailableValues.Skip(2).FirstOrDefault();
|
a.Write();
|
a.Read();
|
Assert.AreEqual(Overlapping.Z, o.Overlapping);
|
}
|
|
class EnabledThings
|
{
|
public double X { get; set; }
|
}
|
|
class MaybeEnabled : IEnabledAnnotation
|
{
|
public bool IsEnabled { get; set; }
|
}
|
|
public class TestAnnotator : IAnnotator
|
{
|
public double Priority => 0;
|
public void Annotate(AnnotationCollection annotations)
|
{
|
// Disable 'X' of EnabledThings using multiple IEnabledAnnotations:
|
var member = annotations.Get<IMemberAnnotation>()?.Member;
|
if (member != null && member.Name == "X" && TypeData.FromType(typeof(EnabledThings)).GetMember("X") == member)
|
{
|
annotations.Add(new MaybeEnabled(){IsEnabled = true});
|
annotations.Add(new MaybeEnabled(){IsEnabled = false});
|
annotations.Add(new MaybeEnabled(){IsEnabled = true});
|
}
|
}
|
}
|
|
[Test]
|
public void TestMultipleEnabled()
|
{
|
var obj = new EnabledThings();
|
var obj2 = new EnabledThings();
|
var x2 = AnnotationCollection.Annotate(new[] { obj, obj2 }).GetMember("X");
|
// after multi-selecting this should be disabled.
|
// when this issue occured it was not.
|
var enabled = x2.Get<IEnabledAnnotation>().IsEnabled;
|
Assert.IsFalse(enabled);
|
}
|
|
public class AvailableValuesArrayUser
|
{
|
#region Test strings
|
|
public List<string> AvailableStrings { get; set; } = new List<string>() { "A", "B", "C" };
|
|
[AvailableValues(nameof(AvailableStrings))]
|
public List<string> SelectedStringsList { get; set; } = new List<string>();
|
|
[AvailableValues(nameof(AvailableStrings))]
|
public string[] SelectedStringsArray { get; set; } = Array.Empty<string>();
|
|
#endregion
|
|
#region Test numbers
|
|
public List<int> AvailableNumbers { get; set; } = new List<int>() { 7, 9, 13 };
|
|
[AvailableValues(nameof(AvailableNumbers))]
|
public List<int> SelectedNumbersList { get; set; } = new List<int>();
|
|
[AvailableValues(nameof(AvailableNumbers))]
|
public int[] SelectedNumbersArray { get; set; } = Array.Empty<int>();
|
|
#endregion
|
}
|
|
[Test]
|
public void TestAddToArrayWithAvailableValues()
|
{
|
{ // Test writing strings
|
var av = new AvailableValuesArrayUser();
|
var a = AnnotationCollection.Annotate(av);
|
var selectedItems = a.GetMember(nameof(av.SelectedStringsArray));
|
|
var availProxy = selectedItems.Get<IAvailableValuesAnnotationProxy>();
|
var multiselect = selectedItems.Get<IMultiSelectAnnotationProxy>();
|
|
{
|
multiselect.SelectedValues = availProxy.AvailableValues.Take(2);
|
a.Write();
|
a.Read();
|
|
Assert.AreEqual(2, av.SelectedStringsArray.Length);
|
Assert.AreEqual("A", av.SelectedStringsArray[0]);
|
Assert.AreEqual("B", av.SelectedStringsArray[1]);
|
}
|
|
{
|
multiselect.SelectedValues = availProxy.AvailableValues.Skip(2).Take(1);
|
a.Write();
|
a.Read();
|
|
Assert.AreEqual(1, av.SelectedStringsArray.Length);
|
Assert.AreEqual("C", av.SelectedStringsArray[0]);
|
}
|
}
|
|
{ // Test writing numbers
|
var av = new AvailableValuesArrayUser();
|
var a = AnnotationCollection.Annotate(av);
|
var selectedItems = a.GetMember(nameof(av.SelectedNumbersArray));
|
|
var availProxy = selectedItems.Get<IAvailableValuesAnnotationProxy>();
|
var multiselect = selectedItems.Get<IMultiSelectAnnotationProxy>();
|
|
{
|
multiselect.SelectedValues = availProxy.AvailableValues.Take(2);
|
a.Write();
|
a.Read();
|
|
Assert.AreEqual(2, av.SelectedNumbersArray.Length);
|
Assert.AreEqual(7, av.SelectedNumbersArray[0]);
|
Assert.AreEqual(9, av.SelectedNumbersArray[1]);
|
}
|
|
{
|
multiselect.SelectedValues = availProxy.AvailableValues.Skip(2).Take(1);
|
a.Write();
|
a.Read();
|
|
Assert.AreEqual(1, av.SelectedNumbersArray.Length);
|
Assert.AreEqual(13, av.SelectedNumbersArray[0]);
|
}
|
}
|
}
|
|
[Test]
|
public void TestAddToListWithAvailableValues()
|
{
|
{ // Test writing strings
|
var av = new AvailableValuesArrayUser();
|
|
var a = AnnotationCollection.Annotate(av);
|
var selectedItems = a.GetMember(nameof(av.SelectedStringsList));
|
|
var availProxy = selectedItems.Get<IAvailableValuesAnnotationProxy>();
|
var multiselect = selectedItems.Get<IMultiSelectAnnotationProxy>();
|
|
{
|
// Test writing two values
|
multiselect.SelectedValues = availProxy.AvailableValues.Take(2);
|
a.Write();
|
a.Read();
|
|
Assert.AreEqual(2, av.SelectedStringsList.Count);
|
Assert.AreEqual("A", av.SelectedStringsList[0]);
|
Assert.AreEqual("B", av.SelectedStringsList[1]);
|
}
|
|
{
|
multiselect.SelectedValues = availProxy.AvailableValues.Skip(2).Take(1);
|
a.Write();
|
a.Read();
|
|
Assert.AreEqual(1, av.SelectedStringsList.Count);
|
Assert.AreEqual("C", av.SelectedStringsList[0]);
|
}
|
}
|
{ // Test writing numbers
|
var av = new AvailableValuesArrayUser();
|
var a = AnnotationCollection.Annotate(av);
|
var selectedItems = a.GetMember(nameof(av.SelectedNumbersList));
|
|
var availProxy = selectedItems.Get<IAvailableValuesAnnotationProxy>();
|
var multiselect = selectedItems.Get<IMultiSelectAnnotationProxy>();
|
|
{
|
// Test writing strings
|
multiselect.SelectedValues = availProxy.AvailableValues.Take(2);
|
a.Write();
|
a.Read();
|
|
Assert.AreEqual(2, av.SelectedNumbersList.Count);
|
Assert.AreEqual(7, av.SelectedNumbersList[0]);
|
Assert.AreEqual(9, av.SelectedNumbersList[1]);
|
}
|
|
{
|
multiselect.SelectedValues = availProxy.AvailableValues.Skip(2).Take(1);
|
a.Write();
|
a.Read();
|
|
Assert.AreEqual(1, av.SelectedNumbersList.Count);
|
Assert.AreEqual(13, av.SelectedNumbersList[0]);
|
}
|
}
|
}
|
|
[AllowAnyChild]
|
public class ReadOnlyDelays : TestStep
|
{
|
public ReadOnlyDelays()
|
{
|
for (int i = 0; i < 3; i++)
|
{
|
// TestStep.IsReadOnly does not cause the settings to be read-only, but if the ChildTetSteps.IsReadOnly is set this is the case.
|
ChildTestSteps.Add(new DelayStep() { IsReadOnly = true });
|
}
|
|
ChildTestSteps.IsReadOnly = true;
|
}
|
|
public override void Run()
|
{
|
|
}
|
}
|
|
[Test]
|
public void TestReadOnlyStepSettings()
|
{
|
var step = new ReadOnlyDelays();
|
var a = AnnotationCollection.Annotate(step.ChildTestSteps[0]);
|
var member = a.GetMember(nameof(DelayStep.DelaySecs));
|
Assert.IsTrue(member.GetAll<IEnabledAnnotation>().Any(x => x.IsEnabled == false));
|
}
|
|
public class DateTimeStep : TestStep
|
{
|
public DateTime MyDate { get; set; }
|
public override void Run()
|
{
|
throw new NotImplementedException();
|
}
|
}
|
|
[Test]
|
public void TestTimeAnnotations()
|
{
|
var times = new DateTimeStep();
|
var a = AnnotationCollection.Annotate(times);
|
var members = a.Get<IMembersAnnotation>().Members.ToLookup(m => m.Name);
|
|
var date = members[nameof(DateTimeStep.MyDate)].First();
|
var dsv = date.Get<IStringValueAnnotation>();
|
|
string[] GetErrors() => date.GetAll<IErrorAnnotation>().SelectMany(a => a.Errors).ToArray();
|
|
Assert.AreEqual(default(DateTime), times.MyDate);
|
StringAssert.StartsWith("0001-01-01", dsv.Value);
|
times.MyDate = DateTime.Parse("1000-11-30", DateTimeFormatInfo.InvariantInfo);
|
a.Read();
|
StringAssert.StartsWith("1000-11-30", dsv.Value);
|
|
dsv.Value = "1978-07-27";
|
Assert.AreEqual(0, GetErrors().Count());
|
a.Write();
|
|
Assert.AreEqual(7, times.MyDate.Month);
|
Assert.AreEqual(27, times.MyDate.Day);
|
Assert.AreEqual(1978, times.MyDate.Year);
|
|
dsv.Value = "garbage string";
|
|
Assert.AreEqual(1, GetErrors().Count());
|
|
dsv.Value = "0001-01-01";
|
Assert.AreEqual(0, GetErrors().Count());
|
}
|
|
[Test]
|
public void TestTimeSpanAnnotationError()
|
{
|
var timeStep = new TestPlanTimespan.TimespanStep();
|
var annotations = AnnotationCollection.Annotate(timeStep);
|
var member = annotations.GetMember("TestProp");
|
var annotation = member.Get<TimeSpanAnnotation>();
|
Assert.DoesNotThrow(() =>
|
{
|
annotation.Value = "test123";
|
});
|
Assert.AreEqual(1, annotation.Errors.Count());
|
}
|
}
|
}
|
