Esempio n. 1
0
        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);
            }
        }
Esempio n. 2
0
        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);
            }
        }
Esempio n. 3
0
        public void SweepLoop2Test()
        {
            var plan  = new TestPlan();
            var sweep = new SweepParameterStep();
            var step  = new ScopeTestStep();

            plan.ChildTestSteps.Add(sweep);
            sweep.ChildTestSteps.Add(step);


            sweep.SweepValues.Add(new SweepRow());
            sweep.SweepValues.Add(new SweepRow());

            TypeData.GetTypeData(step).GetMember(nameof(ScopeTestStep.A)).Parameterize(sweep, step, "Parameters \\ A");
            TypeData.GetTypeData(step).GetMember(nameof(ScopeTestStep.EnabledTest)).Parameterize(sweep, step, nameof(ScopeTestStep.EnabledTest));



            var td1     = TypeData.GetTypeData(sweep.SweepValues[0]);
            var memberA = td1.GetMember("Parameters \\ A");

            memberA.SetValue(sweep.SweepValues[0], 10);
            memberA.SetValue(sweep.SweepValues[1], 20);

            {
                // verify Enabled<T> works with SweepParameterStep.
                var annotation = AnnotationCollection.Annotate(sweep);
                var col        = annotation.GetMember(nameof(SweepParameterStep.SelectedParameters)).Get <IStringReadOnlyValueAnnotation>().Value;
                Assert.AreEqual("A, EnabledTest", col);
                var elements = annotation.GetMember(nameof(SweepParameterStep.SweepValues))
                               .Get <ICollectionAnnotation>().AnnotatedElements
                               .Select(elem => elem.GetMember(nameof(ScopeTestStep.EnabledTest)))
                               .ToArray();
                annotation.Write();
                Assert.IsFalse((bool)elements[0].GetMember("IsEnabled").Get <IObjectValueAnnotation>().Value);
                elements[0].GetMember("IsEnabled").Get <IObjectValueAnnotation>().Value = true;
                annotation.Write();
                Assert.IsFalse((bool)elements[1].GetMember("IsEnabled").Get <IObjectValueAnnotation>().Value);
                Assert.IsTrue((bool)elements[0].GetMember("IsEnabled").Get <IObjectValueAnnotation>().Value);
            }

            var str      = new TapSerializer().SerializeToString(plan);
            var plan2    = (TestPlan) new TapSerializer().DeserializeFromString(str);
            var sweep2   = (SweepParameterStep)plan2.Steps[0];
            var td2      = TypeData.GetTypeData(sweep2);
            var members2 = td2.GetMembers();
            var rows     = sweep2.SweepValues;

            Assert.AreEqual(2, rows.Count);
            var msgmem = TypeData.GetTypeData(rows[0]).GetMember("Parameters \\ A");

            Assert.AreEqual(10, msgmem.GetValue(rows[0]));

            // this feature was disabled.
            //var annotated = AnnotationCollection.Annotate(sweep2);
            //var messageMember = annotated.GetMember(nameof(ScopeTestStep.A));
            //Assert.IsFalse(messageMember.Get<IEnabledAnnotation>().IsEnabled);

            var run = plan2.Execute();

            Assert.AreEqual(Verdict.Pass, run.Verdict);

            Assert.IsTrue(((ScopeTestStep)sweep2.ChildTestSteps[0]).Collection.SequenceEqual(new[] { 10, 20 }));

            var name = sweep.GetFormattedName();

            Assert.AreEqual("Sweep A, EnabledTest", name);
        }