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 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 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());
}
public void CyclicScopeTest()
{
var seq = new SequenceStep();
var delay = new DelayStep()
{
DelaySecs = 1.5
};
seq.ChildTestSteps.Add(delay);
var member = TypeData.GetTypeData(delay).GetMember("Time Delay");
member.Parameterize(seq, delay, "something");
var value = AnnotationCollection.Annotate(delay).GetMember("DelaySecs").Get <IObjectValueAnnotation>();
var value2 = AnnotationCollection.Annotate(seq).GetMember("something").Get <IObjectValueAnnotation>();
try
{
member.Parameterize(delay, seq, "something");
Assert.Fail("Parameterize should have thrown an exception.");
}
catch (ArgumentException)
{
}
// Stack overflow...
value = AnnotationCollection.Annotate(delay).GetMember("DelaySecs").Get <IObjectValueAnnotation>();
value2 = AnnotationCollection.Annotate(seq).GetMember("something").Get <IObjectValueAnnotation>();
Assert.IsNotNull(value);
Assert.IsNotNull(value2);
}
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);
tpr.Filepath.Text = planname;
tpr.LoadTestPlan();
var annotation = AnnotationCollection.Annotate(tpr);
var members = annotation.Get <IMembersAnnotation>().Members;
var delaymem = annotation.GetMember("Time Delay");
Assert.IsNotNull(delaymem);
}
finally
{
File.Delete(planname);
}
}
public void ScopedInputAnnotationWithSweepTest()
{
var sweepStep = new SweepParameterStep();
var verdictStep = new VerdictStep();
sweepStep.ChildTestSteps.Add(verdictStep);
var ifStep = new IfStep();
sweepStep.ChildTestSteps.Add(ifStep);
var member = TypeData.GetTypeData(ifStep).GetMember(nameof(IfStep.InputVerdict));
var parameterizedMember = member.Parameterize(sweepStep, ifStep, member.Name);
var annotation = AnnotationCollection.Annotate(sweepStep);
var memberAnnotation = annotation.GetMember(nameof(sweepStep.SweepValues));
var col = memberAnnotation.Get <ICollectionAnnotation>();
col.AnnotatedElements = new[] { col.NewElement() };
annotation.Write();
annotation.Read();
var member2Annotation = col.AnnotatedElements.FirstOrDefault().GetMember(parameterizedMember.Name);
var avail = member2Annotation.Get <IAvailableValuesAnnotation>();
Assert.IsNotNull(avail);
// available values: None, verdict from itself, verdict from SetVerdict.
Assert.AreEqual(3, avail.AvailableValues.Cast <object>().Count());
var strings = avail.AvailableValues.Cast <object>().Select(x => x.ToString()).ToArray();
Assert.IsTrue(strings.Contains($"Verdict from {ifStep.GetFormattedName()}"));
Assert.IsTrue(strings.Contains("None"));
Assert.IsTrue(strings.Contains($"Verdict from {verdictStep.GetFormattedName()}"));
}
public void ScopedInputAnnotationWithSweepTestSerialized()
{
var plan = new TestPlan();
var sweepStep = new SweepParameterStep();
plan.Steps.Add(sweepStep);
var verdictStep = new VerdictStep();
sweepStep.ChildTestSteps.Add(verdictStep);
var ifStep = new IfStep();
sweepStep.ChildTestSteps.Add(ifStep);
var member = TypeData.GetTypeData(ifStep).GetMember(nameof(IfStep.InputVerdict));
var parameterizedMember = member.Parameterize(sweepStep, ifStep, member.Name);
var annotation = AnnotationCollection.Annotate(sweepStep);
var memberAnnotation = annotation.GetMember(nameof(sweepStep.SweepValues));
var col = memberAnnotation.Get <ICollectionAnnotation>();
col.AnnotatedElements = new[] { col.NewElement() };
annotation.Write();
annotation.Read();
var sweepValuesMember = TypeData.GetTypeData(sweepStep).GetMember(nameof(sweepStep.SweepValues));
sweepValuesMember.Parameterize(plan, sweepStep, "SweepValues");
var planstr = plan.SerializeToString();
var plan2 = Utils.DeserializeFromString <TestPlan>(planstr);
var ext = plan2.ExternalParameters.Get("SweepValues");
Assert.IsNotNull(ext);
}
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 void ScopedInputAnnotationTest()
{
var seqStep = new SequenceStep();
var verdictStep = new VerdictStep();
seqStep.ChildTestSteps.Add(verdictStep);
var ifStep = new IfStep();
seqStep.ChildTestSteps.Add(ifStep);
var member = TypeData.GetTypeData(ifStep).GetMember(nameof(IfStep.InputVerdict));
var parameterizedMember = member.Parameterize(seqStep, ifStep, member.Name);
var annotation = AnnotationCollection.Annotate(seqStep);
var memberAnnotation = annotation.GetMember(parameterizedMember.Name);
var avail = memberAnnotation.Get <IAvailableValuesAnnotation>();
Assert.IsNotNull(avail);
// available values: None, verdict from itself, verdict from SetVerdict.
Assert.AreEqual(3, avail.AvailableValues.Cast <object>().Count());
var strings = avail.AvailableValues.Cast <object>().Select(x => x.ToString()).ToArray();
Assert.IsTrue(strings.Contains($"Verdict from {ifStep.GetFormattedName()}"));
Assert.IsTrue(strings.Contains("None"));
Assert.IsTrue(strings.Contains($"Verdict from {verdictStep.GetFormattedName()}"));
}
public void TestNameInputOutputType()
{
GenerateOutputStep outputStep = new GenerateOutputStep();
inputStep = new HandleInputStep();
var plan = new TestPlan();
plan.ChildTestSteps.Add(outputStep);
plan.ChildTestSteps.Add(inputStep);
var annotation = AnnotationCollection.Annotate(inputStep);
var inputAnnotation = annotation.GetMember(nameof(HandleInputStep.InputBoolArray));
SetOutputProperty(inputAnnotation);
inputAnnotation = annotation.GetMember(nameof(HandleInputStep.InputDouble));
SetOutputProperty(inputAnnotation);
inputAnnotation = annotation.GetMember(nameof(HandleInputStep.InputDoubleArray));
SetOutputProperty(inputAnnotation);
inputAnnotation = annotation.GetMember(nameof(HandleInputStep.InputString));
SetOutputProperty(inputAnnotation);
inputAnnotation = annotation.GetMember(nameof(HandleInputStep.InputStringArray));
SetOutputProperty(inputAnnotation);
inputAnnotation = annotation.GetMember(nameof(HandleInputStep.InputStringList));
SetOutputProperty(inputAnnotation);
annotation.Write(inputStep);
AssertFormatName("{Input Bool Array}", "False, True");
AssertFormatName("{Input Double}", "1");
AssertFormatName("{Input Double Array}", "1, 2.2");
AssertFormatName("{Input String}", "Something");
AssertFormatName("{Input String Array}", "tom, dick");
AssertFormatName("{Input String List}", "One, Two, Three");
}
public void ScopeStepTest()
{
var diag = new DialogStep()
{
UseTimeout = true
};
var diag2 = new DialogStep();
var scope = new SequenceStep();
string parameterName = "Scope\"" + DisplayAttribute.GroupSeparator + "Title"; // name intentionally weird to mess with the serializer.
scope.ChildTestSteps.Add(diag);
scope.ChildTestSteps.Add(diag2);
var member = TypeData.GetTypeData(diag).GetMember("Title");
member.Parameterize(scope, diag, parameterName);
member.Parameterize(scope, diag2, parameterName);
TypeData.GetTypeData(diag).GetMember("Timeout").Parameterize(scope, diag, "Group\\The Timeout");
var annotation = AnnotationCollection.Annotate(scope);
var titleMember = annotation.GetMember(parameterName);
titleMember.Get <IStringValueAnnotation>().Value = "New title";
annotation.Write();
Assert.AreEqual("New title", diag.Title);
Assert.AreEqual("New title", diag2.Title);
var timeoutMember = annotation.GetMember("Group\\The Timeout");
Assert.IsFalse(timeoutMember.Get <IAccessAnnotation>().IsReadOnly);
Assert.AreEqual("Group", TypeData.GetTypeData(scope).GetMember("Group\\The Timeout").GetDisplayAttribute().Group[0]);
var plan = new TestPlan();
plan.Steps.Add(scope);
var str = new TapSerializer().SerializeToString(plan);
var plan2 = (TestPlan) new TapSerializer().DeserializeFromString(str);
var scope2 = plan2.Steps[0];
var annotation2 = AnnotationCollection.Annotate(scope2);
var titleMember2 = annotation2.GetMember(parameterName);
Assert.IsNotNull(titleMember2);
titleMember2.Get <IStringValueAnnotation>().Value = "New Title 2";
annotation2.Write();
foreach (var step in scope2.ChildTestSteps.Cast <DialogStep>())
{
Assert.AreEqual(step.Title, "New Title 2");
}
var forwardedMember = (ParameterMemberData)TypeData.GetTypeData(scope2).GetMember(parameterName);
Assert.IsNotNull(forwardedMember);
member.Unparameterize(forwardedMember, scope2.ChildTestSteps[0]);
Assert.IsNotNull(TypeData.GetTypeData(scope2).GetMember(parameterName));
member.Unparameterize(forwardedMember, scope2.ChildTestSteps[1]);
Assert.IsNull(TypeData.GetTypeData(scope2).GetMember(parameterName)); // last 'Title' removed.
}
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);
}
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 void SweepLoopRange2Test()
{
var plan = new TestPlan();
var sweep = new SweepParameterRangeStep();
var numberstep = new ScopeTestStep();
plan.ChildTestSteps.Add(sweep);
sweep.ChildTestSteps.Add(numberstep);
var member = TypeData.GetTypeData(numberstep).GetMember("A");
member.Parameterize(sweep, numberstep, "A");
sweep.SelectedParameters = Enumerable.Empty <ParameterMemberData>().ToList();
Assert.AreEqual(0, sweep.SelectedParameters.Count());
{
var a = AnnotationCollection.Annotate(sweep);
var m = a.GetMember(nameof(SweepParameterRangeStep.SelectedParameters));
var sweptMember = a.GetMember("A");
Assert.IsTrue(sweptMember.Get <IEnabledAnnotation>().IsEnabled);
var ms = m.Get <IMultiSelectAnnotationProxy>();
var avail = m.Get <IAvailableValuesAnnotationProxy>();
ms.SelectedValues = avail.AvailableValues;
a.Write();
sweptMember = a.GetMember("A");
Assert.IsFalse(sweptMember.Get <IEnabledAnnotation>().IsEnabled);
}
Assert.AreEqual(1, sweep.SelectedParameters.Count());
sweep.SweepStart = 1;
sweep.SweepEnd = 10;
sweep.SweepPoints = 10;
Assert.IsTrue(string.IsNullOrEmpty(sweep.Error));
plan.Execute();
Assert.IsTrue(Enumerable.Range(1, 10).SequenceEqual(numberstep.Collection));
{
var sweep2 = new SweepLoopRange();
plan.ChildTestSteps.Add(sweep2);
// verify that sweep Behavior selected value can be displayed.
var annotation = AnnotationCollection.Annotate(sweep);
var mem = annotation.GetMember(nameof(SweepParameterRangeStep.SweepBehavior));
var proxy = mem.Get <IAvailableValuesAnnotationProxy>();
var selectedBehavior = proxy.SelectedValue.Get <IStringReadOnlyValueAnnotation>();
Assert.AreEqual("Linear", selectedBehavior.Value);
}
}
public void TestBreakConditionsLocked()
{
var plan = new TestPlan();
var a = AnnotationCollection.Annotate(plan);
var mem = a.GetMember("BreakConditions");
Assert.IsFalse(mem.Get <IAccessAnnotation>().IsReadOnly);
plan.Locked = true;
a.Read();
Assert.IsTrue(mem.Get <IAccessAnnotation>().IsReadOnly);
plan.Locked = false;
a.Read();
Assert.IsFalse(mem.Get <IAccessAnnotation>().IsReadOnly);
}
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);
}
public void RequestUserInput(object dataObject, TimeSpan Timeout, bool modal)
{
var datas = AnnotationCollection.Annotate(dataObject);
var selectedName = datas.GetMember("SelectedName");
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!
Assert.IsTrue(values.Length > 0);
datas.Write();
WasInvoked = true;
}
public void AnnotatedFormattedName()
{
// both annotating the step itself and TestStep.Name should give the same GetFormatted read-only string.
var delay = new DelayStep()
{
DelaySecs = 0.1, Name = "Delay: {Time Delay}"
};
var annotation = AnnotationCollection.Annotate(delay);
var formattedName = annotation.Get <IStringReadOnlyValueAnnotation>().Value;
Assert.AreEqual("Delay: 0.1 s", formattedName);
var formattedName2 = annotation.GetMember(nameof(TestStep.Name)).Get <IStringReadOnlyValueAnnotation>().Value;
Assert.AreEqual("Delay: 0.1 s", formattedName2);
}
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);
}
}
public void RequestUserInput(object dataObject, TimeSpan Timeout, bool modal)
{
var datas = AnnotationCollection.Annotate(dataObject);
var selectedName = datas.GetMember("Output");
var avail = selectedName.Get <IAvailableValuesAnnotationProxy>();
avail.SelectedValue = avail.AvailableValues.First(x => (x.Source.ToString().Contains(SelectName)));
var response = datas.GetMember("Response");
var availRespons = response.Get <IAvailableValuesAnnotationProxy>();
availRespons.SelectedValue =
availRespons.AvailableValues.FirstOrDefault(x => x.Source.ToString().Contains("Cancel") == false);
datas.Write();
WasInvoked = true;
}
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);
}
}
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()));
}
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);
selectedMember.Parameterize(targetObject, obj2, selectedMember.Name);
// TODO:
var b = AnnotationCollection.Annotate(targetObject);
var avail = b.GetMember(selectedMember.Name).Get <IAvailableValuesAnnotation>();
Assert.AreEqual(2, avail.AvailableValues.Cast <object>().Count());
}
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 void TestMenuAnnotationForInputOutputRelations()
{
var userInput = UserInput.GetInterface();
var request = new SelectAssignmentFromAnnotationMenu();
UserInput.SetInterface(request);
try
{
var step1 = new OutputInput {
Output = 5, Input = 5, Name = "Step 1"
};
var step2 = new OutputInput {
ExpectedInput = 5, CheckExpectedInput = true, Name = "Step 2"
};
var step3 = new OutputInput {
ExpectedInput = 5, CheckExpectedInput = true, Name = "Step 3"
};
var plan = new TestPlan();
plan.ChildTestSteps.AddRange(new[] { step1, step2, step3 });
var menu = AnnotationCollection.Annotate(step2).GetMember(nameof(OutputInput.Input))
.Get <MenuAnnotation>();
request.SelectName = "Step 1";
menu.MenuItems.First(x => x.Get <IconAnnotationAttribute>().IconName == IconNames.AssignOutput).Get <IMethodAnnotation>().Invoke();
request.SelectName = "Step 2";
menu = AnnotationCollection.Annotate(step3).GetMember(nameof(OutputInput.Input))
.Get <MenuAnnotation>();
menu.MenuItems.First(x => x.Get <IconAnnotationAttribute>().IconName == IconNames.AssignOutput).Get <IMethodAnnotation>().Invoke();
var run = plan.Execute();
Assert.AreEqual(Verdict.Pass, run.Verdict);
Assert.IsTrue(request.WasInvoked);
}
finally
{
UserInput.SetInterface(userInput);
}
}
private void PrintExternalParameters(TraceSource log)
{
var annotation = AnnotationCollection.Annotate(Plan).Get <IMembersAnnotation>();
log.Info("Listing {0} External Test Plan Parameters:", Plan.ExternalParameters.Entries.Count);
foreach (var member in annotation.Members)
{
if (member.Get <IMemberAnnotation>()?.Member is ParameterMemberData param)
{
var multiValues = member.Get <IMultiSelectAnnotationProxy>()?.SelectedValues;
string printStr = "";
if (multiValues != null)
{
foreach (var val in multiValues)
{
printStr += string.Format("{0} | ", val.Get <IStringReadOnlyValueAnnotation>()?.Value ?? val.Get <IObjectValueAnnotation>()?.Value?.ToString() ?? "");
}
printStr = printStr.Remove(printStr.Length - 3); // Remove trailing delimiter
}
else
{
printStr = member.Get <IStringReadOnlyValueAnnotation>()?.Value ?? member.Get <IObjectValueAnnotation>()?.Value?.ToString();
}
log.Info(" {0} = {1}", param.Name, printStr);
if (member.Get <IAvailableValuesAnnotationProxy>() is IAvailableValuesAnnotationProxy avail)
{
log.Info(" Available Values:");
foreach (var val in avail.AvailableValues ?? new AnnotationCollection[0])
{
log.Info(" {0}", val.Get <IStringReadOnlyValueAnnotation>()?.Value ?? val.Get <IObjectValueAnnotation>()?.Value?.ToString() ?? "");
}
}
}
}
}
public void SweepLoopDisabledMembersOnMultiSelect()
{
var plan = new TestPlan();
var sweep = new SweepParameterRangeStep();
var sweep2 = new SweepParameterRangeStep();
var numberstep = new ScopeTestStep();
var numberstep2 = new ScopeTestStep();
plan.ChildTestSteps.Add(sweep);
plan.ChildTestSteps.Add(sweep2);
sweep.ChildTestSteps.Add(numberstep);
sweep2.ChildTestSteps.Add(numberstep2);
var member = TypeData.GetTypeData(numberstep).GetMember("A");
member.Parameterize(sweep, numberstep, "A");
member.Parameterize(sweep2, numberstep2, "A");
sweep.SelectedParameters = Enumerable.Empty <ParameterMemberData>().ToList();
Assert.AreEqual(0, sweep.SelectedParameters.Count());
{
var a = AnnotationCollection.Annotate(sweep);
var m = a.GetMember(nameof(SweepParameterRangeStep.SelectedParameters));
var sweptMember = a.GetMember("A");
Assert.IsTrue(sweptMember.Get <IEnabledAnnotation>().IsEnabled);
var ms = m.Get <IMultiSelectAnnotationProxy>();
var avail = m.Get <IAvailableValuesAnnotationProxy>();
ms.SelectedValues = avail.AvailableValues;
a.Write();
sweptMember = a.GetMember("A");
Assert.IsFalse(sweptMember.Get <IEnabledAnnotation>().IsEnabled);
}
{
var a = AnnotationCollection.Annotate(new object[] { sweep, sweep2 });
var amem = a.GetMember("A");
var ienabled = amem.Get <IEnabledAnnotation>();
Assert.IsFalse(ienabled.IsEnabled);
}
}
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(members.Count(), 4);
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();
}
}
void IUserInputInterface.RequestUserInput(object dataObject, TimeSpan Timeout, bool modal)
{
if (readerThread == null)
{
lock (readerLock)
{
if (readerThread == null)
{
readerThread = TapThread.Start(() =>
{
while (true)
{
lines.Add(Console.ReadLine());
}
}, "Console Reader");
}
}
}
DateTime TimeoutTime;
if (Timeout == TimeSpan.MaxValue)
{
TimeoutTime = DateTime.MaxValue;
}
else
{
TimeoutTime = DateTime.Now + Timeout;
}
if (Timeout >= new TimeSpan(0, 0, 0, 0, int.MaxValue))
{
Timeout = new TimeSpan(0, 0, 0, 0, -1);
}
do
{
if (platforDialogMutex.WaitOne(Timeout))
{
break;
}
if (DateTime.Now >= TimeoutTime)
{
throw new TimeoutException("Request User Input timed out");
}
} while (true);
try
{
Log.Flush();
var a = AnnotationCollection.Annotate(dataObject);
var mems = a.Get <IMembersAnnotation>()?.Members;
if (mems == null)
{
return;
}
mems = mems.Concat(a.Get <IForwardedAnnotations>()?.Forwarded ?? Array.Empty <AnnotationCollection>());
var title = TypeData.GetTypeData(dataObject)?.GetMember("Name")?.GetValue(dataObject) as string;
if (string.IsNullOrWhiteSpace(title) == false)
{
Console.WriteLine(title);
}
bool isBrowsable(IMemberData m)
{
var browsable = m.GetAttribute <System.ComponentModel.BrowsableAttribute>();
// Browsable overrides everything
if (browsable != null)
{
return(browsable.Browsable);
}
if (m is IMemberData mem)
{
if (m.HasAttribute <OutputAttribute>())
{
return(true);
}
if (!mem.Writable || !mem.Readable)
{
return(false);
}
return(true);
}
return(false);
}
foreach (var _message in mems)
{
var mem = _message.Get <IMemberAnnotation>()?.Member;
if (mem != null)
{
if (!isBrowsable(mem))
{
continue;
}
}
log.Flush();
var str = _message.Get <IStringValueAnnotation>();
if (str == null)
{
continue;
}
var name = _message.Get <DisplayAttribute>()?.Name;
start:
var isVisible = _message.Get <IAccessAnnotation>()?.IsVisible ?? true;
if (!isVisible)
{
continue;
}
var isReadOnly = _message.Get <IAccessAnnotation>()?.IsReadOnly ?? false;
if (isReadOnly)
{
Console.WriteLine($"{str.Value}");
continue;
}
var proxy = _message.Get <IAvailableValuesAnnotationProxy>();
List <string> options = null;
bool pleaseEnter = true;
if (proxy != null)
{
pleaseEnter = false;
options = new List <string>();
int index = 0;
var current_value = proxy.SelectedValue;
foreach (var value in proxy.AvailableValues)
{
var v = value.Get <IStringValueAnnotation>();
if (v != null)
{
Console.Write("{1}: '{0}'", v.Value, index);
if (value == current_value)
{
Console.WriteLine(" (default)");
}
else
{
Console.WriteLine();
}
}
options.Add(v?.Value);
index++;
}
Console.Write("Please enter a number or name ");
}
var layout = _message.Get <IMemberAnnotation>()?.Member.GetAttribute <LayoutAttribute>();
bool showName = layout?.Mode.HasFlag(LayoutMode.FullRow) == true ? false : true;
if (pleaseEnter)
{
Console.Write("Please enter ");
}
if (showName)
{
Console.Write($"{name} ({str.Value}): ");
}
else
{
Console.Write($"({str.Value}): ");
}
var read = (awaitReadLine(TimeoutTime) ?? "").Trim();
if (read == "")
{
// accept the default value.
continue;
}
try
{
if (options != null && int.TryParse(read, out int result))
{
if (result < options.Count)
{
read = options[result];
}
else
{
goto start;
}
}
str.Value = read;
var err = a.Get <IErrorAnnotation>();
IEnumerable <string> errors = err?.Errors;
_message.Write();
if (errors?.Any() == true)
{
Console.WriteLine("Unable to parse value {0}", read);
goto start;
}
}
catch (Exception)
{
Console.WriteLine("Unable to parse '{0}'", read);
goto start;
}
}
a.Write();
}
finally
{
platforDialogMutex.ReleaseMutex();
}
}
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);
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 = "B";
editParameter.Get <IMethodAnnotation>().Invoke();
Assert.IsNull(TypeData.GetTypeData(sequence).GetMember("A"));
Assert.IsNotNull(TypeData.GetTypeData(sequence).GetMember("B"));
}
{ // 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());
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);
}
}
