Пример #1
0
        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);
            }
        }
Пример #2
0
        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));
        }