public CMElementUI MakeCopy(TestCasesStructure __testCaseStruct) { Element newCopyElement = _elementReal.makeCopy(__testCaseStruct); CMElementUI newCopyMask = new CMElementUI(newCopyElement); return(newCopyMask); }
public TestObject() { testCasesStruct = new TestCasesStructure(); testCasesStruct.ParentTestObject = this; testDataStruct = new TestDataStructure(); testDataStruct.TestObject = this; }
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); }
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); }
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)); }
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)); }
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)); }
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"; }
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); }
public FaultyEquivalenceClassesTestCasesGenerator(IList <Dependency> deps, TestCasesStructure structure, int maxFaultyTestCases) : base(deps, structure, maxFaultyTestCases) { }
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; }