public CMElementUI MakeCopy(TestCasesStructure __testCaseStruct)
        {
            Element     newCopyElement = _elementReal.makeCopy(__testCaseStruct);
            CMElementUI newCopyMask    = new CMElementUI(newCopyElement);

            return(newCopyMask);
        }
Beispiel #2
0
 public TestObject()
 {
     testCasesStruct = new TestCasesStructure();
     testCasesStruct.ParentTestObject = this;
     testDataStruct            = new TestDataStructure();
     testDataStruct.TestObject = this;
 }
Beispiel #3
0
        public IUndoableEdit DeleteCombination(TestCasesStructure structure)
        {
            CompoundEdit ce = new CompoundEdit();

            if (structure != null)
            {
                //delete the reference from all test cases
                foreach (TestCase testCase in structure.TestCases)
                {
                    if (testCase.Combinations.Contains(combination))
                    {
                        ce.AddEdit(
                            EditFactory.instance.CreateRemoveCombinationEdit(testCase, combination));
                        testCase.RemoveCombination(combination);
                    }
                }
                //delete the combination from all other combinations
                foreach (Combination combination1 in combination.ParentDependency.Combinations)
                {
                    if (combination1.Combinations.Contains(combination))
                    {
                        ce.AddEdit(EditFactory.instance.CreateRemoveCombinationEdit(combination1, combination1));
                        combination1.RemoveCombination(combination);
                    }
                }
            }
            ce.AddEdit(EditFactory.instance.CreateRemoveCombinationEdit(combination.ParentDependency, combination));
            combination.ParentDependency.RemoveCombination(combination);
            return(ce);
        }
Beispiel #4
0
        protected void setUp()
        {
            //test a combination from 3 elements
            structure = new TestCasesStructure();
            elem1     = new Element(structure);
            eq11      = new EquivalenceClass(elem1);
            eq12      = new EquivalenceClass(elem1);
            eq13      = new EquivalenceClass(elem1);
            elem2     = new Element(structure);
            eq21      = new EquivalenceClass(elem2);
            eq22      = new EquivalenceClass(elem2);
            eq23      = new EquivalenceClass(elem2);
            eq24      = new EquivalenceClass(elem2);
            elem3     = new Element(structure);
            eq31      = new EquivalenceClass(elem3);
            eq32      = new EquivalenceClass(elem3);
            eq33      = new EquivalenceClass(elem3);

            dep = new Dependency(structure);
            foreach (Element element in structure.Elements)
            {
                dep.AddElement(element);
                foreach (EquivalenceClass equivalenceClass in element.EquivalenceClasses)
                {
                    dep.AddEquivalenceClass(equivalenceClass);
                }
            }
            dep.RemoveEquivalenceClass(eq24);
        }
        protected void setUp()
        {
            //test a combination from 3 elements
            structure = new TestCasesStructure();
            Element elem1 = new Element(structure);

            eq11 = new EquivalenceClass(elem1);
            eq12 = new EquivalenceClass(elem1);
            eq13 = new EquivalenceClass(elem1);
            Element elem2 = new Element(structure);

            eq21 = new EquivalenceClass(elem2);
            eq22 = new EquivalenceClass(elem2);
            eq23 = new EquivalenceClass(elem2);
            Element elem3 = new Element(structure);

            eq31 = new EquivalenceClass(elem3);
            eq32 = new EquivalenceClass(elem3);
            eq33 = new EquivalenceClass(elem3);

            dep = new Dependency(structure);
            foreach (Element element in structure.Elements)
            {
                dep.AddElement(element);
                foreach (EquivalenceClass equivalenceClass in element.EquivalenceClasses)
                {
                    dep.AddEquivalenceClass(equivalenceClass);
                }
            }

            combi1 = new CaseMaker.Entities.Testcases.Combination(dep);
            combi2 = new CaseMaker.Entities.Testcases.Combination(dep);
            combi3 = new CaseMaker.Entities.Testcases.Combination(dep);
            combi4 = new CaseMaker.Entities.Testcases.Combination(dep);
            combi5 = new CaseMaker.Entities.Testcases.Combination(dep);

            combi1.AddEquivalenceClass(eq11);
            combi1.AddEquivalenceClass(eq22);
            combi1.AddEquivalenceClass(eq33);


            combi2.AddEquivalenceClass(eq21);
            combi2.AddEquivalenceClass(eq11);
            combi2.AddEquivalenceClass(eq32);

            combi3.AddEquivalenceClass(eq13);
            combi3.AddEquivalenceClass(eq23);
            combi3.AddEquivalenceClass(eq31);

            combi4.AddEquivalenceClass(eq12);
            combi4.AddEquivalenceClass(eq22);
            combi4.AddEquivalenceClass(eq32);

            combi5.AddEquivalenceClass(eq11);
            combi5.AddEquivalenceClass(eq23);
            combi5.AddEquivalenceClass(eq31);
        }
Beispiel #6
0
        public void CreateRemoveStdCombinationEditTest()
        {
            TestCasesStructure structure      = new TestCasesStructure();
            StdCombination     stdCombination = new StdCombination();

            ce.AddEdit(EditFactory.instance.CreateRemoveStdCombinationEdit(structure, stdCombination));
            structure.AddStdCombination(stdCombination);
            ce.End();
            ce.Undo();
            Assert.IsTrue(structure.StdCombinations.Contains(stdCombination));
            ce.Redo();
            Assert.IsFalse(structure.StdCombinations.Contains(stdCombination));
        }
Beispiel #7
0
        public void CreateRemoveTestCaseEditTest()
        {
            TestCasesStructure structure = new TestCasesStructure();
            TestCase           testCase  = new TestCase(structure);

            ce.AddEdit(EditFactory.instance.CreateRemoveTestCaseEdit(structure, testCase));
            structure.RemoveTestCase(testCase);
            ce.End();
            ce.Undo();
            Assert.IsTrue(structure.TestCases.Contains(testCase));
            ce.Redo();
            Assert.IsFalse(structure.TestCases.Contains(testCase));
        }
Beispiel #8
0
        public void CreateRemoveDependencyEditTest()
        {
            TestCasesStructure structure  = new TestCasesStructure();
            Dependency         dependency = new Dependency(structure);

            ce.AddEdit(EditFactory.instance.CreateRemoveDependencyEdit(structure, dependency));
            structure.RemoveDependency(dependency);
            ce.End();
            ce.Undo();
            Assert.IsTrue(structure.Dependencies.Contains(dependency));
            ce.Redo();
            Assert.IsFalse(structure.Dependencies.Contains(dependency));
        }
Beispiel #9
0
        public void CreateRemoveElementEditTest()
        {
            TestCasesStructure structure = new TestCasesStructure();
            Element            element   = new Element(structure);

            ce.AddEdit(EditFactory.instance.CreateRemoveElementEdit(structure, element));
            structure.RemoveElement(element);
            ce.End();
            ce.Undo();
            Assert.IsTrue(structure.Elements.Contains(element));
            ce.Redo();
            Assert.IsFalse(structure.Elements.Contains(element));
        }
        public static IList <Effect> CreateNewEffects(IList <CMEffectUI> __newEffectsMaskList,
                                                      TestCasesStructure __Structure)
        {
            IList <Effect> newEffectList = new List <Effect>();

            foreach (CMEffectUI efMask in __newEffectsMaskList)
            {
                Effect newEffect = new Effect(__Structure);
                efMask.HashCodeIdentifier = newEffect.GetHashCodeReal();
                fillEffectReal(efMask, newEffect);
                newEffectList.Add(newEffect);
            }
            return(newEffectList);
        }
 public void SaveAll(TestObject to)
 {
     Save(to);
     if (to.TestCasesStruct == null)
     {
         TestCasesStructure strc = new TestCasesStructure();
         to.TestCasesStruct = strc;
         AddNew(strc);
     }
     else
     {
         Save(to.TestCasesStruct);
     }
 }
        protected void setUp()
        {
            structure = new TestCasesStructure();

            Element element = new Element(structure);

            element.Name = "One";

            Element element1 = new Element(structure);

            element1.Name = "Dos";

            Element element2 = new Element(structure);

            element2.Name = "Element Untitled 1";
        }
Beispiel #13
0
        protected void setUp()
        {
            //test a combination from 3 elements
            structure = new TestCasesStructure();
            Element elem1 = new Element(structure);

            eq11 = new EquivalenceClass(elem1);
            eq12 = new EquivalenceClass(elem1);
            eq13 = new EquivalenceClass(elem1);
            Element elem2 = new Element(structure);

            eq21 = new EquivalenceClass(elem2);
            eq22 = new EquivalenceClass(elem2);
            eq23 = new EquivalenceClass(elem2);
            Element elem3 = new Element(structure);

            eq31 = new EquivalenceClass(elem3);
            eq32 = new EquivalenceClass(elem3);
            eq33 = new EquivalenceClass(elem3);
        }
Beispiel #14
0
 public FaultyEquivalenceClassesTestCasesGenerator(IList <Dependency> deps, TestCasesStructure structure, int maxFaultyTestCases)
     : base(deps, structure, maxFaultyTestCases)
 {
 }
Beispiel #15
0
 public NegativeCombinationTestCasesGenerator(IList <Dependency> deps, TestCasesStructure structure, int maxNegativeTestCases) : base(deps, structure, maxNegativeTestCases)
 {
 }
 public AllTestCasesGenerator(IList <Dependency> deps, TestCasesStructure structure, int maxTestCases) : base(deps, structure, maxTestCases)
 {
 }
 public TestCasesStructurePermission(User user, TestCasesStructure structure) : base(user)
 {
     structure.AddPermission(this);
 }
 public OneWiseTestCasesGenerator(TestCasesStructure structure, int maxPositiveTC)
 {
     this.structure     = structure;
     this.maxPositiveTC = maxPositiveTC;
 }
 public FaultyCombinationTestCasesGenerator(IList <Dependency> deps, TestCasesStructure structure, int maxFaultyTestCases)
     : base(deps, structure, maxFaultyTestCases)
 {
 }
        protected void setUp()
        {
            //test a combination from 3 elements
            structure = new TestCasesStructure();
            Element          elem1 = new Element(structure);
            EquivalenceClass eq11  = new EquivalenceClass(elem1);
            EquivalenceClass eq12  = new EquivalenceClass(elem1);
            EquivalenceClass eq13  = new EquivalenceClass(elem1);
            Element          elem2 = new Element(structure);
            EquivalenceClass eq21  = new EquivalenceClass(elem2);
            EquivalenceClass eq22  = new EquivalenceClass(elem2);
            EquivalenceClass eq23  = new EquivalenceClass(elem2);
            Element          elem3 = new Element(structure);
            EquivalenceClass eq31  = new EquivalenceClass(elem3);
            EquivalenceClass eq32  = new EquivalenceClass(elem3);
            EquivalenceClass eq33  = new EquivalenceClass(elem3);

            dep  = new Dependency(structure);
            dep2 = new Dependency(structure);
            dep3 = new Dependency(structure);
            foreach (Element element in structure.Elements)
            {
                dep.AddElement(element);
                foreach (EquivalenceClass equivalenceClass in element.EquivalenceClasses)
                {
                    dep.AddEquivalenceClass(equivalenceClass);
                }
            }

            Combination combi4;
            Combination combi3;
            Combination combi1;
            Combination combi2;

            combi1 = new Combination(dep);
            combi2 = new Combination(dep2);
            combi3 = new Combination(dep);
            combi4 = new Combination(dep3);

            combi1.AddEquivalenceClass(eq11);
            combi1.AddEquivalenceClass(eq22);
            combi1.AddEquivalenceClass(eq33);


            combi2.AddEquivalenceClass(eq21);
            combi2.AddEquivalenceClass(eq11);
            combi2.AddEquivalenceClass(eq32);

            combi3.AddEquivalenceClass(eq13);
            combi3.AddEquivalenceClass(eq23);
            combi3.AddCombination(combi4);


            test1 = new TestCase(structure);
            test2 = new TestCase(structure);
            test3 = new TestCase(structure);
            test4 = new TestCase(structure);
            test5 = new TestCase(structure);


            test1.AddCombination(combi1);
            test1.AddCombination(combi4);

            test2.AddCombination(combi3);
            test2.AddCombination(combi4);

            test3.AddCombination(combi2);
            test3.AddCombination(combi1);

            test4.AddCombination(combi3);

            test5.AddCombination(combi2);
            test5.AddCombination(combi4);
        }
 public NegativeEquivalenceClassesTestCasesGenerator(IList <Dependency> deps, TestCasesStructure structure, int maxNegativeTestCases) : base(deps, structure, maxNegativeTestCases)
 {
 }
        public IUndoableEdit DeleteCommonTestCasesPolicy(TestCasesStructure structure, State tcState, IList <Dependency> deps)
        {
            StructureManager sm = new StructureManager(structure);

            return(sm.DeleteCommonTestCases(tcState, deps));
        }
        public IUndoableEdit GenerateOneWiseTestCases(TestCasesStructure structure, int maxTestCases)
        {
            IGenerator gen = new OneWiseTestCasesGenerator(structure, maxTestCases);

            return(gen.Generate());
        }
        public WorkflowTestCasesGenerator(IList <Dependency> deps, TestCasesStructure structure, int maxPositiveTestCases, State state) : base(deps, structure, maxPositiveTestCases)

        {
            genState = state;
        }
 public NegativeTestCasesGenerator(IList <Dependency> deps, TestCasesStructure structure, int maxNegativeTestCases) : base(deps, structure, maxNegativeTestCases)
 {
     genState = State.NEGATIVE;
 }
 public AbstractTestCaseGenerator(IList <Dependency> deps, TestCasesStructure structure, int maxTestCases)
 {
     dependencies      = deps;
     this.structure    = structure;
     this.maxTestCases = maxTestCases;
 }
        public IUndoableEdit DeleteCombinationPolicy(Combination combination, TestCasesStructure structure)
        {
            CombinationManager cm = new CombinationManager(combination);

            return(cm.DeleteCombination(structure));
        }
 public StructureManager(TestCasesStructure structure)
 {
     this.structure = structure;
 }
        public IUndoableEdit GenerateTestCases(TestCasesGenerationOperation operation, IList <Dependency> dependencies,
                                               int maxTestCases)
        {
            IGenerator gen;

            if (dependencies.Count == 0)
            {
                throw new ArgumentException("The dependencies list cannot be empty");
            }
            TestCasesStructure structure = dependencies[0].ParentStructure;

            switch (operation)
            {
            case TestCasesGenerationOperation.ALL:
                gen = new AllTestCasesGenerator(dependencies, structure, maxTestCases);
                break;

            case TestCasesGenerationOperation.FAULTY:
                gen = new FaultyTestCasesGenerator(dependencies, structure, maxTestCases);
                break;

            case TestCasesGenerationOperation.FAULTY_COMBINATIONS:
                gen = new FaultyCombinationTestCasesGenerator(dependencies, structure, maxTestCases);
                break;

            case TestCasesGenerationOperation.FAULTY_EQUIVALENCECLASSES:
                gen = new FaultyEquivalenceClassesTestCasesGenerator(dependencies, structure, maxTestCases);
                break;

            case TestCasesGenerationOperation.NEGATIVE:
                gen = new NegativeTestCasesGenerator(dependencies, structure, maxTestCases);
                break;

            case TestCasesGenerationOperation.NEGATIVE_COMBINATIONS:
                gen = new NegativeCombinationTestCasesGenerator(dependencies, structure, maxTestCases);
                break;

            case TestCasesGenerationOperation.NEGATIVE_EQUIVALENCECLASSES:
                gen = new NegativeEquivalenceClassesTestCasesGenerator(dependencies, structure, maxTestCases);
                break;

            case TestCasesGenerationOperation.POSITIVE:
                gen = new PositiveTestCasesGenerator(dependencies, structure, maxTestCases);
                break;

            case TestCasesGenerationOperation.WORKFLOW_POSITIVE:
                gen = new WorkflowTestCasesGenerator(dependencies, structure, maxTestCases, State.POSITIVE);
                break;

            case TestCasesGenerationOperation.WORKFLOW_NEGATIVE:
                gen = new WorkflowTestCasesGenerator(dependencies, structure, maxTestCases, State.NEGATIVE);
                break;

            case TestCasesGenerationOperation.WORKFLOW_FAULTY:
                gen = new WorkflowTestCasesGenerator(dependencies, structure, maxTestCases, State.POSITIVE);
                break;

            default:
                throw new NotImplementedException("Operation not implemented");
            }
            return(gen.Generate());
        }
 public FaultyTestCasesGenerator(IList <Dependency> deps, TestCasesStructure structure, int maxFaultyTestCases)
     : base(deps, structure, maxFaultyTestCases)
 {
     genState = State.FAULTY;
 }