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 RunSweep([Values(true, false)] bool acrossRuns, [Values(true, false)] bool allEnabled)
{
var tp = new TestPlan();
var sl = new SweepLoop()
{
CrossPlan = acrossRuns ? SweepLoop.SweepBehaviour.Across_Runs : SweepLoop.SweepBehaviour.Within_Run
};
var ds = new SweepTestStep();
sl.ChildTestSteps.Add(ds);
sl.SweepParameters.Add(new SweepParam(new[] { TypeData.GetTypeData(ds).GetMember("SweepProp") }, 2, 3, 5, 7));
sl.EnabledRows = new bool[] { true, allEnabled, true, true };
tp.ChildTestSteps.Add(sl);
using (var st = new MemoryStream())
{
tp.Save(st);
st.Seek(0, 0);
tp = TestPlan.Load(st, tp.Path);
}
ds = tp.ChildTestSteps[0].ChildTestSteps[0] as SweepTestStep;
if (acrossRuns)
{
foreach (var rowEnabled in sl.EnabledRows)
{
if (rowEnabled)
{
var pr = tp.Execute();
Assert.IsFalse(pr.FailedToStart);
Assert.AreEqual(Verdict.NotSet, pr.Verdict);
}
}
}
else
{
var pr = tp.Execute();
Assert.IsFalse(pr.FailedToStart);
}
if (allEnabled)
{
Assert.AreEqual(17, ds.Value);
}
else
{
Assert.AreEqual(14, ds.Value);
}
}
public void SweepSameNameDifferentGroup()
{
var loop = new SweepLoop();
var a = new StepTypeA();
var b = new StepTypeB();
loop.ChildTestSteps.Add(a);
loop.ChildTestSteps.Add(b);
loop.SweepParameters.Add(new SweepParam(new [] { TypeData.GetTypeData(a).GetMember(nameof(StepTypeA.Property)) }, (double)5, (double)5));
loop.SweepParameters.Add(new SweepParam(new [] { TypeData.GetTypeData(b).GetMember(nameof(StepTypeB.Property)) }, (double)15, (double)15));
var plan = new TestPlan();
plan.Steps.Add(loop);
var run = plan.Execute();
Assert.AreEqual(Verdict.Pass, run.Verdict);
}
public void SweepRaceBug()
{
// test that validation rules can be checked while the test plan is running
// without causing an error. The validation rules does not need to do actual validation
// but since SweepLoop and SweepLoopRange modifies its child steps this could cause an error
// as shown by SweepRaceBugCheckStep and SweepRaceBugStep.
var plan = new TestPlan();
var repeat = new RepeatStep {
Count = 10, Action = RepeatStep.RepeatStepAction.Fixed_Count
};
var loop = new SweepLoop();
repeat.ChildTestSteps.Add(loop);
loop.ChildTestSteps.Add(new SweepRaceBugStep()
{
});
loop.ChildTestSteps.Add(new SweepRaceBugCheckStep()
{
});
var steptype = TypeData.FromType(typeof(SweepRaceBugStep));
var member = steptype.GetMember(nameof(SweepRaceBugStep.Frequency));
var member2 = TypeData.FromType(typeof(SweepRaceBugCheckStep)).GetMember(nameof(SweepRaceBugCheckStep.Frequency2));
var lst = new List <SweepParam>();
double[] values = new double[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
lst.Add(new SweepParam(new[] { member }, values.Cast <object>().ToArray()));
lst.Add(new SweepParam(new[] { member2 }, values.Cast <object>().ToArray()));
loop.SweepParameters = lst;
var loopRange = new SweepLoopRange();
loopRange.SweepStart = 1;
loopRange.SweepEnd = 10;
loopRange.SweepPoints = 10;
loopRange.ChildTestSteps.Add(new SweepRaceBugStep()
{
});
loopRange.ChildTestSteps.Add(new SweepRaceBugCheckStep()
{
});
loopRange.SweepProperties = new List <IMemberData> {
member, member2
};
var repeat2 = new RepeatStep {
Count = 10, Action = RepeatStep.RepeatStepAction.Fixed_Count
};
repeat2.ChildTestSteps.Add(loopRange);
var parallel = new ParallelStep();
plan.ChildTestSteps.Add(parallel);
parallel.ChildTestSteps.Add(repeat);
parallel.ChildTestSteps.Add(repeat2);
TestPlanRun run = null;
TapThread.Start(() => run = plan.Execute());
TapThread.Start(() =>
{
while (run == null)
{
loopRange.Error.ToList();
}
});
while (run == null)
{
loop.Error.ToList();
}
Assert.AreEqual(Verdict.NotSet, run.Verdict);
}
public void RunSweepWithInterruptions(bool loopRange)
{
IEnumerable <int> check;
var tp = new TestPlan();
TestStep sweep;
if (loopRange)
{
var sweepRange = new SweepLoopRange();
sweepRange.SweepStart = 10;
sweepRange.SweepEnd = 30;
sweepRange.SweepStep = 1;
sweepRange.SweepProperties = new List <IMemberData>()
{
TypeData.FromType(typeof(SweepTestStep)).GetMember("SweepProp")
};
sweep = sweepRange;
check = Enumerable.Range(10, (int)(sweepRange.SweepEnd - sweepRange.SweepStart + 1));
}
else
{
check = Enumerable.Range(10, 20);
var sweepRange = new SweepLoop();
var lst = new List <SweepParam>();
lst.Add(new SweepParam(new[] { TypeData.FromType(typeof(SweepTestStep)).GetMember("SweepProp") }, check.Cast <object>().ToArray()));
sweepRange.SweepParameters = lst;
sweep = sweepRange;
}
var step = new SweepTestStep();
tp.ChildTestSteps.Add(sweep);
sweep.ChildTestSteps.Add(step);
var rlistener = new PlanRunCollectorListener()
{
CollectResults = true
};
bool done = false;
void interruptOperations()
{
// this is to reproduce an error previously happening when the
// SweepLoopRange.Error value was getted.
// this would have changed the value of SweepProp intermiddently.
while (!done)
{
// so bother as much as possible...
var error2 = sweep.Error;
}
}
var trd = new Thread(interruptOperations);
trd.Start();
var result = tp.Execute(new[] { rlistener });
done = true;
trd.Join();
var results = rlistener.Results.Select(x => (int)x.Result.Columns[0].Data.GetValue(0)).ToArray();
Assert.IsTrue(results.SequenceEqual(check));
}
