public void ParmsCheck()
{
TestPlan testplan = new TestPlan();
DelayStep step1 = new DelayStep();
string myName = "fred";
step1.Name = myName;
testplan.Steps.Add(step1);
testplan.BreakOffered += (s, e) =>
{
Assert.IsTrue(e.TestStepRun.Verdict == Verdict.NotSet);
//Assert.IsTrue(e.TestStepRun.Step.GetStepPath().Contains(myName));
};
testplan.Execute();
}
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 ExecuteTestCase()
{
var btc = new TestCase();
btc.Name = "Serialization Test";
btc.Description = "Test to blah blah blah, yeah really!";
btc.BizUnitVersion = "4.0.0.1";
var fm = new DelayStep {
DelayMilliSeconds = 35
};
btc.SetupSteps.Add(fm);
var bu = new BizUnit(btc);
bu.RunTest();
}
public void AutoRemoveParameters()
{
var plan = new TestPlan();
var step = new DelayStep();
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");
Assert.IsNotNull(TypeData.GetTypeData(plan).GetMember(parameter2.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(seq).GetMember(parameter.Name));
}
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 TestAutoRemoveInputOutputRelation()
{
var plan = new TestPlan();
var delay1 = new DelayStep();
var delay2 = new DelayStep();
plan.ChildTestSteps.Add(delay1);
plan.ChildTestSteps.Add(delay2);
{
var member = TypeData.GetTypeData(delay1).GetMember(nameof(DelayStep.DelaySecs));
InputOutputRelation.Assign(delay2, member, delay1, member);
Assert.IsTrue(InputOutputRelation.IsInput(delay2, member));
Assert.IsTrue(InputOutputRelation.IsOutput(delay1, member));
}
plan.ChildTestSteps.Remove(delay2);
{
var member = TypeData.GetTypeData(delay1).GetMember(nameof(DelayStep.DelaySecs));
Assert.IsFalse(InputOutputRelation.IsInput(delay2, member));
Assert.IsFalse(InputOutputRelation.IsOutput(delay1, member));
}
}
private void GenerateTestPlanWithNDelaySteps(int stepsCount, string filePath, double defaultValue, string externalParameterName)
{
Assert.IsTrue(stepsCount > 0);
// Create a test plan with two DelaySteps.
// Each of the DelaySteps will expose a it's delay property as an external parameter.
TestPlan plan = new TestPlan();
for (int i = 0; i < stepsCount; i++)
{
var delayStep = new DelayStep {
DelaySecs = defaultValue
};
plan.ChildTestSteps.Add(delayStep);
var delayInfo = TypeData.GetTypeData(delayStep);
plan.ExternalParameters.Add(delayStep, delayInfo.GetMember("DelaySecs"), externalParameterName);
}
// Write the test plan to a file
plan.Save(filePath);
}
public void DelaySampleTest()
{
// Create the test case
var testCase = new TestCase();
// Create test steps...
var delayStep = new DelayStep {
DelayMilliSeconds = 500
};
// Add test steps to the required test stage
testCase.ExecutionSteps.Add(delayStep);
// Create a new instance of BizUnit and run the test
var bizUnit = new BizUnit(testCase);
bizUnit.RunTest();
// Save Test Case
TestCase.SaveToFile(testCase, "DelaySampleTest.xml");
}
public void DelayTestCaseTest()
{
DeleteFiles();
int stepDelayDuration = 500;
var step = new DelayStep();
step.DelayMilliSeconds = stepDelayDuration;
var sw = new Stopwatch();
sw.Start();
step.Execute(new Context());
var actualDuration = sw.ElapsedMilliseconds;
Console.WriteLine("Observed delay: {0}", actualDuration);
Assert.AreEqual(stepDelayDuration, actualDuration, 20);
stepDelayDuration = 5;
step.DelayMilliSeconds = stepDelayDuration;
var tc = new TestCase();
tc.ExecutionSteps.Add(step);
TestCase.SaveToFile(tc, "DelayTestCaseTest.xaml");
var bu = new BizUnit(TestCase.LoadFromFile("DelayTestCaseTest.xaml"));
sw = new Stopwatch();
sw.Start();
bu.RunTest();
actualDuration = sw.ElapsedMilliseconds;
Console.WriteLine("Observed delay: {0}", actualDuration);
Assert.AreEqual(actualDuration, stepDelayDuration, 20);
}
public void DelaySampleTest()
{
DeleteFiles();
// Create the test case
var testCase = new TestCase();
// Create test steps...
var delayStep = new DelayStep {
DelayMilliSeconds = 500
};
// Add test steps to the required test stage
testCase.ExecutionSteps.Add(delayStep);
// Create a new instance of BizUnit and run the test
var bizUnit = new TestRunner(testCase);
bizUnit.Run();
// Save Test Case
TestCase.SaveToFile(testCase, Path.Combine(TestContext.CurrentContext.TestDirectory, "DelaySampleTest.xaml"));
}
public void SaveAndLoadExternalScopeParameters()
{
var plan = new TestPlan();
var sequence = new SequenceStep();
var delay = new DelayStep();
plan.Steps.Add(sequence);
sequence.ChildTestSteps.Add(delay);
var newmember = TypeData.GetTypeData(delay).GetMember(nameof(DelayStep.DelaySecs))
.Parameterize(sequence, delay, nameof(DelayStep.DelaySecs));
var fwd = newmember.Parameterize(plan, sequence, nameof(DelayStep.DelaySecs));
Assert.AreEqual(1, plan.ExternalParameters.Entries.Count);
TestPlan newplan;
using (var mem = new MemoryStream())
{
plan.Save(mem);
mem.Seek(0, SeekOrigin.Begin);
newplan = TestPlan.Load(mem, "Test.TapPlan");
}
Assert.AreEqual(1, newplan.ExternalParameters.Entries.Count);
}
public void TimeGuardStepTest(bool stopOnError, Verdict expectedVerdict, Verdict?verdictOnAbort)
{
var plan = new TestPlan();
var guard = new TimeGuardStep {
StopOnTimeout = stopOnError, Timeout = 0.05
};
if (verdictOnAbort != null)
{
guard.TimeoutVerdict = verdictOnAbort.Value;
}
// if this delay step runs to completion, the verdict of the test plan will be NotSet, failing the final assertion.
var delay = new DelayStep {
DelaySecs = 120
};
plan.ChildTestSteps.Add(guard);
guard.ChildTestSteps.Add(delay);
var run = plan.Execute();
Assert.AreEqual(expectedVerdict, run.Verdict);
}
public void MultiLevelScopeSerialization()
{
var plan = new TestPlan();
var seq1 = new SequenceStep();
var seq2 = new SequenceStep();
var delay = new DelayStep();
plan.ChildTestSteps.Add(seq1);
seq1.ChildTestSteps.Add(seq2);
seq2.ChildTestSteps.Add(delay);
var member1 = TypeData.GetTypeData(delay).GetMember(nameof(DelayStep.DelaySecs))
.Parameterize(seq2, delay, "delay");
member1.Parameterize(seq1, seq2, "delay");
var str = new TapSerializer().SerializeToString(plan);
var plan2 = (TestPlan) new TapSerializer().DeserializeFromString(str);
var member2 = TypeData.GetTypeData(plan2.ChildTestSteps[0]).GetMember(member1.Name);
var val = member2.GetValue(plan2.ChildTestSteps[0]);
Assert.AreEqual(delay.DelaySecs, val);
}
public void SweepLoopNoValuesSelected()
{
var plan = new TestPlan();
var sweep = new SweepParameterStep();
var step = new DelayStep();
plan.ChildTestSteps.Add(sweep);
sweep.ChildTestSteps.Add(step);
Assert.Throws(typeof(InvalidOperationException), sweep.PrePlanRun);
// Select parameter to sweep
TypeData.GetTypeData(step).GetMember(nameof(DelayStep.DelaySecs)).Parameterize(sweep, step, nameof(DelayStep.DelaySecs));
try
{
sweep.PrePlanRun();
Assert.Fail("An exception should have been thrown.");
}
catch (InvalidOperationException ex)
{
Assert.AreEqual(ex.Message, "No values selected to sweep");
}
}
public void SetValuesTest()
{
var delayStep1 = new DelayStep();
var delayStep2 = new DelayStep();
var logStep = new LogStep();
var logStep2 = new LogStep();
var fileStep = new MacroFilePathTestStep();
var fileStep2 = new MacroFilePathTestStep();
var ifstep = new IfStep();
fileStep.PathToThing.Text = "<TESTPLANDIR>\\asdasd";
TestPlan plan = new TestPlan();
plan.ChildTestSteps.Add(delayStep1);
plan.ChildTestSteps.Add(delayStep2);
plan.ChildTestSteps.Add(logStep);
plan.ChildTestSteps.Add(logStep2);
plan.ChildTestSteps.Add(fileStep);
plan.ChildTestSteps.Add(fileStep2);
plan.ChildTestSteps.Add(ifstep);
ifstep.InputVerdict.Step = delayStep2;
ifstep.InputVerdict.Property = TypeData.GetTypeData(delayStep1).GetMember("Verdict");
var delayInfo = TypeData.GetTypeData(delayStep1);
var logInfo = TypeData.GetTypeData(logStep);
var fileStepInfo = TypeData.GetTypeData(fileStep);
plan.ExternalParameters.Add(delayStep1, delayInfo.GetMember("DelaySecs"));
plan.ExternalParameters.Add(delayStep2, delayInfo.GetMember("DelaySecs"), "Time Delay");
plan.ExternalParameters.Add(logStep, logInfo.GetMember("Severity"), Name: "Severity");
plan.ExternalParameters.Add(logStep2, logInfo.GetMember("Severity"), Name: "Severity");
plan.ExternalParameters.Add(fileStep, fileStepInfo.GetMember("PathToThing"), Name: "Path1");
plan.ExternalParameters.Add(fileStep2, fileStepInfo.GetMember("PathToThing"), Name: "Path1");
plan.ExternalParameters.Add(ifstep, TypeData.GetTypeData(ifstep).GetMember(nameof(IfStep.InputVerdict)), Name: "InputVerdict");
for (int j = 0; j < 5; j++)
{
for (double x = 0.01; x < 10; x += 3.14)
{
plan.ExternalParameters.Get("Time Delay").Value = x;
Assert.AreEqual(x, delayStep1.DelaySecs);
Assert.AreEqual(x, delayStep2.DelaySecs);
}
plan.ExternalParameters.Get("Severity").Value = LogSeverity.Error;
Assert.AreEqual(LogSeverity.Error, logStep.Severity);
Assert.AreEqual(LogSeverity.Error, logStep2.Severity);
plan.ExternalParameters.Get("Path1").Value = plan.ExternalParameters.Get("Path1").Value;
string planstr = null;
using (var memstream = new MemoryStream())
{
plan.Save(memstream);
planstr = Encoding.UTF8.GetString(memstream.ToArray());
}
Assert.IsTrue(planstr.Contains(@"Parameter=""Time Delay"""));
Assert.IsTrue(planstr.Contains(@"Parameter=""Severity"""));
Assert.IsTrue(planstr.Contains(@"Parameter=""Path1"""));
using (var memstream = new MemoryStream(Encoding.UTF8.GetBytes(planstr)))
plan = TestPlan.Load(memstream, planstr);
delayStep1 = (DelayStep)plan.ChildTestSteps[0];
delayStep2 = (DelayStep)plan.ChildTestSteps[1];
logStep = (LogStep)plan.ChildTestSteps[2];
logStep2 = (LogStep)plan.ChildTestSteps[3];
fileStep = (MacroFilePathTestStep)plan.ChildTestSteps[4];
fileStep2 = (MacroFilePathTestStep)plan.ChildTestSteps[5];
ifstep = (IfStep)plan.ChildTestSteps[6];
Assert.IsTrue(fileStep2.PathToThing.Context == fileStep2);
Assert.AreEqual(fileStep2.PathToThing.Text, fileStep.PathToThing.Text);
Assert.AreEqual(delayStep2, ifstep.InputVerdict.Step);
}
}
public void Deserialization_ValidData_CreatesValidInstance()
{
DelayStep step = JsonConvert.DeserializeObject <DelayStep>("{ time: 0.5 }");
Assert.AreEqual(0.5d, step.Time, 0.0001d);
}
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();
}
}
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);
}
}
public void TestNameFormat()
{
var culture = System.Threading.Thread.CurrentThread.CurrentCulture;
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
try
{
DelayStep delay = new DelayStep();
delay.DelaySecs = 1.0;
delay.Name = "Delay of {Time Delay} and {Time Delay}";
var result = delay.GetFormattedName();
Assert.AreEqual(result, "Delay of 1 s and 1 s");
delay.Name = "Delay of {} and {Time Delay2}";
result = delay.GetFormattedName();
Assert.AreEqual(result, delay.Name);
delay.Name = "Delay of {{}} and {{Time Delay2}}";
result = delay.GetFormattedName();
Assert.AreEqual(result, delay.Name);
delay.Name = "Delay of {{}} and {{Time Delay}}";
result = delay.GetFormattedName();
Assert.AreEqual(result, "Delay of {{}} and {1 s}");
DialogStep diag = new DialogStep();
diag.Name = "Timeout of {Timeout Timeout}";
diag.Timeout = 2;
var result2 = diag.GetFormattedName();
Assert.AreEqual(result2, "Timeout of 2 s");
SCPIRegexStep scpiRegex = new SCPIRegexStep();
scpiRegex.RegularExpressionPattern = new Enabled <string> {
Value = "asd", IsEnabled = true
};
scpiRegex.Name = "|{Set Verdict Regular Expression}|";
var result3 = scpiRegex.GetFormattedName();
Assert.AreEqual(result3, "|asd|");
scpiRegex.Instrument = null;
scpiRegex.Name = "|{Instrument}|";
var result4 = scpiRegex.GetFormattedName();
Assert.AreEqual(result4, "|Not Set|");
scpiRegex.Name = "|{asdwasd}|";
var result5 = scpiRegex.GetFormattedName();
Assert.AreEqual(result5, scpiRegex.Name);
var arrayStep = new NullArrayTest()
{
TestArray = new int[] { 1, 3 }
};
arrayStep.Name = "{TestArray}";
var result6 = arrayStep.GetFormattedName();
Assert.AreEqual(result6, "1, 3");
var funkyArray = new FunkyArrayStep();
funkyArray.Name = "{Array}";
var result7 = funkyArray.GetFormattedName();
Assert.AreEqual(result7.Count(x => x == ','), funkyArray.Array.Length - 1);
Assert.IsTrue(result7.Contains(", Test"));
}
finally
{
System.Threading.Thread.CurrentThread.CurrentCulture = culture;
}
}
