protected IUndoableEdit FillTestCasesFromNegativeCombinations(ICollection <TestCase> testCases)
{
CompoundEdit ce = new CompoundEdit();
TestCase testCase = null;
foreach (Dependency dependency in dependencies)
{
foreach (Combination combination in dependency.Combinations)
{
if (combination.CurrentState == State.NEGATIVE)
{
testCase = new TestCase();
ce.AddEdit(EditFactory.instance.CreateChangePropertyEdit(testCase, "Origin", TestCaseOrigin.GENERATED));
testCase.Origin = TestCaseOrigin.GENERATED;
ce.AddEdit(PolicyFactory.instance.AddCombinationToTestCasePolicy(testCase, combination));
testCases.Add(testCase);
}
}
}
return(ce);
}
public void GenerateUpdateDeleteEquivalence()
{
CompoundEdit ce = new CompoundEdit();
IGenerator gen = new PermutationCombinationsGenerator(dep, 80000, CombinationsGenerationOption.OVERWRITE);
ce.AddEdit(gen.Generate());
//deleting an equivalence
IGenerator genUpdater = new PermutationCombinationsGenerator(dep, 80000, CombinationsGenerationOption.UPDATE);
ce.AddEdit(EditFactory.instance.CreateRemoveEquivalenceClassEdit(dep, eq12));
dep.RemoveEquivalenceClass(eq12);
ce.AddEdit(genUpdater.Generate());
Assert.AreEqual(18, dep.Combinations.Count);
Assert.AreEqual(10, dep.Combinations[9].Position);
Assert.IsTrue(dep.Combinations[9].EquivalenceClasses.Contains(eq13));
Assert.IsTrue(dep.Combinations[9].EquivalenceClasses.Contains(eq21));
Assert.IsTrue(dep.Combinations[9].EquivalenceClasses.Contains(eq31));
//add a new equivalence
ce.AddEdit(EditFactory.instance.CreateRemoveEquivalenceClassEdit(dep, eq24));
dep.AddEquivalenceClass(eq24);
ce.AddEdit(genUpdater.Generate());
Assert.AreEqual(24, dep.Combinations.Count);
Assert.AreEqual(10, dep.Combinations[9].Position);
Assert.IsTrue(dep.Combinations[9].EquivalenceClasses.Contains(eq11));
Assert.IsTrue(dep.Combinations[9].EquivalenceClasses.Contains(eq24));
Assert.IsTrue(dep.Combinations[9].EquivalenceClasses.Contains(eq31));
ce.EndAllEdits();
ce.Undo();
Assert.IsTrue(dep.Combinations.Count == 0);
}
protected IUndoableEdit RemoveInvalidCombinations(IEnumerable <IList <EquivalenceClass> > patterns)
{
CompoundEdit ce = new CompoundEdit();
IPolicyFactory fact = new PolicyFactory();
//patterns.Equals()
List <Combination> combinations = new List <Combination>(parentDependency.Combinations);
foreach (IList <EquivalenceClass> list in patterns)
{
HashedSet <EquivalenceClass> eqSet = new HashedSet <EquivalenceClass>(list);
foreach (Combination combination in parentDependency.Combinations)
{
HashedSet <EquivalenceClass> combiEqSet = new HashedSet <EquivalenceClass>(combination.EquivalenceClasses);
if (eqSet.Equals(combiEqSet))
{
combinations.Remove(combination);
}
}
}
foreach (Combination combination in combinations)
{
ce.AddEdit(fact.DeleteCombinationPolicy(combination, parentDependency.ParentStructure));
parentDependency.RemoveCombination(combination);
}
return(ce);
}
public virtual IUndoableEdit Generate()
{
ValidateModel();
CompoundEdit ce = new CompoundEdit();
IPolicyFactory pfact = new PolicyFactory();
IList <TestCase> generatedTestCases = new List <TestCase>();
//generate the test cases
ce.AddEdit(FillTestCases(generatedTestCases));
//delete the common test cases from the structure
ce.AddEdit(pfact.DeleteCommonTestCasesPolicy(structure, genState, dependencies));
if (generatedTestCases.Count + structure.GetTestCases(genState).Count > maxTestCases)
{
ce.EndAllEdits();
ce.Undo();
throw new Exception("Maximal number of " + EntityWithEvents.GetDescription(genState) + " Test Cases reached");
}
//add the new generated test cases
foreach (TestCase tc in generatedTestCases)
{
//check if the structure has the same test cases before insert
if (!structure.ContainsSameTestCaseByRelations(tc))
{
ce.AddEdit(EditFactory.instance.CreateChangePropertyEdit(tc, "Position", structure.GetNewTestCasePosition()));
tc.Position = structure.GetNewTestCasePosition();
ce.AddEdit(EditFactory.instance.CreateAddTestCaseEdit(structure, tc));
structure.AddTestCase(tc);
}
}
return(ce);
}
/// <summary>
/// Create an <see cref="IUndoableEdit"/> for a <see cref="IDiagramModel.Changed"/> event.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <remarks>
/// This calls <see cref="SkipEvent"/> if for some reason we should ignore
/// the <paramref name="e"/>.
/// This then creates a <see cref="ModelChangedEventArgs"/> and adds it to the
/// <see cref="CurrentEdit"/>, a <see cref="UndoManager.CompoundEdit"/> which it allocates
/// if needed.
/// This method always ignores all Changed events while we are performing an
/// <see cref="Undo"/> or <see cref="Redo"/>.
/// </remarks>
public virtual void HandleModelChanged(Object sender, ModelChangedEventArgs e)
{
// changes caused by performing an undo or redo should be ignored!
if (this.IsUndoingRedoing)
{
return;
}
if (!SkipEvent(e))
{
CompoundEdit cedit = this.CurrentEdit;
//ModelHelper.Trace(this.TransactionLevel, e.ToString());
if (cedit == null)
{
cedit = new CompoundEdit();
this.CurrentEdit = cedit;
}
// make a copy of the event to save as an edit in the list
ModelChangedEventArgs edit = new ModelChangedEventArgs(e);
cedit.Edits.Add(edit);
if (this.ChecksTransactionLevel && this.TransactionLevel <= 0)
{
ModelHelper.Trace("Change not within a transaction: " + edit.ToString());
}
}
}
public IUndoableEdit DeleteCommonTestCases(State state, IList <Dependency> deps)
{
if (structure == null)
{
throw new NullReferenceException("The structure cannot be null");
}
CompoundEdit ce = new CompoundEdit();
IList <TestCase> deletedTestCases = new List <TestCase>();
foreach (TestCase testCase in structure.TestCases)
{
if (testCase.CurrentState == state)
{
if (hasCommonDependency(testCase, deps))
{
deletedTestCases.Add(testCase);
}
}
}
foreach (TestCase tc in deletedTestCases)
{
ce.AddEdit(EditFactory.instance.CreateRemoveTestCaseEdit(structure, tc));
structure.RemoveTestCase(tc);
}
return(ce);
}
public void GenerateOverwrite()
{
CompoundEdit ce = new CompoundEdit();
ICombinationsGenerator gen = new AllPairsCombinationsGenerator(dep, 80000, CombinationsGenerationOption.OVERWRITE);
ce.AddEdit(gen.Generate());
Assert.AreEqual(10, dep.Combinations.Count);
Assert.AreEqual(1, dep.Combinations[0].Position);
Assert.IsTrue(dep.Combinations[0].EquivalenceClasses.Contains(eq11));
Assert.IsTrue(dep.Combinations[0].EquivalenceClasses.Contains(eq21));
Assert.IsTrue(dep.Combinations[0].EquivalenceClasses.Contains(eq31));
Assert.AreEqual(2, dep.Combinations[1].Position);
Assert.IsTrue(dep.Combinations[1].EquivalenceClasses.Contains(eq11));
Assert.IsTrue(dep.Combinations[1].EquivalenceClasses.Contains(eq22));
Assert.IsTrue(dep.Combinations[1].EquivalenceClasses.Contains(eq32));
//Assert.AreEqual(3, dep.Combinations[2].Position);
//Assert.IsTrue(dep.Combinations[2].EquivalenceClasses.Contains(eq11));
//Assert.IsTrue(dep.Combinations[2].EquivalenceClasses.Contains(eq23));
//Assert.IsTrue(dep.Combinations[2].EquivalenceClasses.Contains(eq33));
//Assert.AreEqual(7, dep.Combinations[6].Position);
//Assert.IsTrue(dep.Combinations[6].EquivalenceClasses.Contains(eq12));
//Assert.IsTrue(dep.Combinations[6].EquivalenceClasses.Contains(eq22));
//Assert.IsTrue(dep.Combinations[6].EquivalenceClasses.Contains(eq33));
ce.EndAllEdits();
ce.Undo();
Assert.IsTrue(dep.Combinations.Count == 0);
}
//internal ModelChangedEventArgs FindPreviousChange(ModelChangedEventArgs edit) {
// ModelChangedEventArgs found = null;
// if (this.CurrentEdit != null) found = this.CurrentEdit.FindPreviousChange(edit);
// if (found != null) return found;
// for (int i = this.CompoundEdits.Count-1; i >= 0; i--) {
// CompoundEdit ce = this.CompoundEdits[i] as CompoundEdit;
// if (ce == null) continue;
// found = ce.FindPreviousChange(edit);
// if (found != null) return found;
// }
// return null;
//}
//internal void ReplaceReference(Object oldref, Object newref) {
// foreach (IUndoableEdit edit in this.CompoundEdits) {
// CompoundEdit ce = edit as CompoundEdit;
// if (ce == null) continue;
// ce.ReplaceReference(oldref, newref);
// }
//}
internal void CoalesceLastTransaction(String type)
{
int num = this.CompoundEdits.Count;
if (num < 2)
{
return;
}
CompoundEdit ult = this.CompoundEdits[num - 1] as CompoundEdit;
if (ult == null || ult.Name != type)
{
return;
}
CompoundEdit pen = this.CompoundEdits[num - 2] as CompoundEdit;
if (pen == null)
{
return;
}
//Diagram.Debug(" CoalesceLastTransaction " + ult.ToString() + " into " + pen.ToString());
foreach (IUndoableEdit edit in ult.Edits)
{
pen.Edits.Add(edit);
}
this.CompoundEdits.RemoveAt(num - 1);
this.UndoEditIndex--;
}
public void FindMergeableCombinationsTest()
{
//generate combinations
CompoundEdit ce = new CompoundEdit();
Dependency dep2 = new Dependency(structure);
foreach (Element element in structure.Elements)
{
dep2.AddElement(element);
foreach (EquivalenceClass equivalenceClass in element.EquivalenceClasses)
{
dep2.AddEquivalenceClass(equivalenceClass);
}
}
IGenerator gen = new PermutationCombinationsGenerator(dep2, 80000, CombinationsGenerationOption.OVERWRITE);
//this generates 27 combinations
ce.AddEdit(gen.Generate());
//select the combination 02
Assert.AreEqual(dep2.Combinations[1].Position, 2);
CombinationManager cm = new CombinationManager(dep2.Combinations[1]);
IList <Combination> combis = cm.FindMergeableCombinations(eq33);
Assert.AreEqual(1, combis.Count);
Assert.IsTrue(combis.Contains(dep2.Combinations[2]));
CombinationManager cm1 = new CombinationManager(dep2.Combinations[0]);
combis = cm1.FindMergeableCombinations(eq23);
Assert.AreEqual(1, combis.Count);
Assert.IsTrue(combis.Contains(dep2.Combinations[6]));
}
public IUndoableEdit ChangeRiskLevel(int newRiskLevel)
{
CompoundEdit ce = new CompoundEdit();
//check if is posible to assign the new risk level
if (riskLevelObject.GetParentRiskLevels() != null)
{
foreach (IRiskLevelObject parentRiskLevel in riskLevelObject.GetParentRiskLevels())
{
if (newRiskLevel < parentRiskLevel.RiskLevel)
{
throw new Exception("The risk level cannot change, contains a greater risk level as a parent");
}
}
}
//change the risk level of each children
if (riskLevelObject.GetChildrenRiskLevels() != null)
{
foreach (IRiskLevelObject o in riskLevelObject.GetChildrenRiskLevels())
{
RiskLevelManager rlm = new RiskLevelManager(o);
ce.AddEdit(rlm.ChangeRiskLevel(newRiskLevel));
}
}
ce.AddEdit(EditFactory.instance.CreateChangeRiskLevelEdit(riskLevelObject, newRiskLevel));
riskLevelObject.RiskLevel = newRiskLevel;
return(ce);
}
public void GenerateOverwrite()
{
CompoundEdit ce = new CompoundEdit();
IGenerator gen = new PermutationCombinationsGenerator(dep, 80000, CombinationsGenerationOption.OVERWRITE);
ce.AddEdit(gen.Generate());
Assert.AreEqual(27, dep.Combinations.Count);
Assert.AreEqual(1, dep.Combinations[0].Position);
Assert.IsTrue(dep.Combinations[0].EquivalenceClasses.Contains(eq11));
Assert.IsTrue(dep.Combinations[0].EquivalenceClasses.Contains(eq21));
Assert.IsTrue(dep.Combinations[0].EquivalenceClasses.Contains(eq31));
Assert.AreEqual(2, dep.Combinations[1].Position);
Assert.IsTrue(dep.Combinations[1].EquivalenceClasses.Contains(eq11));
Assert.IsTrue(dep.Combinations[1].EquivalenceClasses.Contains(eq21));
Assert.IsTrue(dep.Combinations[1].EquivalenceClasses.Contains(eq32));
Assert.AreEqual(19, dep.Combinations[18].Position);
Assert.IsTrue(dep.Combinations[18].EquivalenceClasses.Contains(eq13));
Assert.IsTrue(dep.Combinations[18].EquivalenceClasses.Contains(eq21));
Assert.IsTrue(dep.Combinations[18].EquivalenceClasses.Contains(eq31));
ce.EndAllEdits();
ce.Undo();
Assert.IsTrue(dep.Combinations.Count == 0);
}
private IUndoableEdit MergeEffects(IList <Combination> combinationsToMerge)
{
CompoundEdit ce = new CompoundEdit();
foreach (Combination combi in combinationsToMerge)
{
foreach (Effect effect in combi.Effects)
{
if (!combination.Effects.Contains(effect))
{
ce.AddEdit(EditFactory.instance.CreateAddEffectEdit(combination, effect));
combination.AddEffect(effect);
}
}
}
foreach (Combination combi in combinationsToMerge)
{
foreach (Effect effect in combi.Effects)
{
if (!combi.Effects.Contains(effect))
{
ce.AddEdit(EditFactory.instance.CreateAddEffectEdit(combi, effect));
combi.AddEffect(effect);
}
//update risk level
RiskLevelManager rlm = new RiskLevelManager(effect);
ce.AddEdit(rlm.ApplyRiskLevelToChildren());
//update state
StateObjectManager som = new StateObjectManager(effect);
ce.AddEdit(som.ApplyStateToChildren());
}
}
return(ce);
}
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 override IUndoableEdit FillTestCases(IList <TestCase> testCases)
{
CompoundEdit ce = new CompoundEdit();
ce.AddEdit(FillTestCasesFromNegativeEquivalenceClasses(testCases));
ce.AddEdit(FillTestCasesFromNegativeCombinations(testCases));
return(ce);
}
public void UnMergeCombinationsTest()
{
//generate a 3 x 3 permutation
CompoundEdit ce = new CompoundEdit();
Dependency dep2 = new Dependency(structure);
foreach (Element element in structure.Elements)
{
if (element.Position == 3)
{
continue;
}
dep2.AddElement(element);
foreach (EquivalenceClass equivalenceClass in element.EquivalenceClasses)
{
dep2.AddEquivalenceClass(equivalenceClass);
}
}
IGenerator gen = new PermutationCombinationsGenerator(dep2, 80000, CombinationsGenerationOption.OVERWRITE);
//this generates 10 combinations
ce.AddEdit(gen.Generate());
//select the combination 02
Assert.AreEqual(dep2.Combinations.Count, 9);
CombinationManager cm = new CombinationManager(dep2.Combinations[0]);
IList <Combination> combis = cm.FindMergeableCombinations(eq12);
cm.MergeCombinations(combis);
Assert.IsTrue(dep2.Combinations[0].Combinations.Contains(dep2.Combinations[3]));
combis = cm.FindMergeableCombinations(eq13);
cm.MergeCombinations(combis);
Assert.IsTrue(dep2.Combinations[0].Combinations.Contains(dep2.Combinations[6]));
combis = cm.FindMergeableCombinations(eq22);
cm.MergeCombinations(combis);
Assert.IsTrue(dep2.Combinations[0].Combinations.Contains(dep2.Combinations[4]));
Assert.IsTrue(dep2.Combinations[0].Combinations.Contains(dep2.Combinations[7]));
Assert.IsFalse(dep2.Combinations[0].Combinations.Contains(dep2.Combinations[8]));
combis = cm.FindMergeableCombinations(eq23);
cm.MergeCombinations(combis);
Assert.IsTrue(dep2.Combinations[0].Combinations.Contains(dep2.Combinations[2]));
Assert.IsTrue(dep2.Combinations[0].Combinations.Contains(dep2.Combinations[5]));
Assert.IsTrue(dep2.Combinations[0].Combinations.Contains(dep2.Combinations[8]));
//now the unmerge
cm.UnMergeCombinations(eq22);
Assert.IsFalse(dep2.Combinations[0].Combinations.Contains(dep2.Combinations[1]));
Assert.IsTrue(dep2.Combinations[1].Combinations.Contains(dep2.Combinations[4]));
Assert.IsTrue(dep2.Combinations[1].Combinations.Contains(dep2.Combinations[7]));
Assert.IsTrue(dep2.Combinations[0].Combinations.Contains(dep2.Combinations[3]));
//this thows an arg exception
cm.UnMergeCombinations(eq11);
cm.UnMergeCombinations(eq13);
Assert.IsFalse(dep2.Combinations[0].Combinations.Contains(dep2.Combinations[8]));
Assert.IsTrue(dep2.Combinations[8].Combinations.Contains(dep2.Combinations[5]));
}
public IUndoableEdit UnMergeCombinations(EquivalenceClass selectedEquivalenceClass)
{
if (combination.Origin != CombinationOrigin.PERMUTATION)
{
throw new InvalidOperationException("The Unmerge is available only for combinations generated by permutation");
}
if (!combination.GetChildrenCombinationEquivalenceClasses().Contains(selectedEquivalenceClass))
{
throw new ArgumentException("The combination does not contain any child combination containing this equivalence class");
}
if (combination.EquivalenceClasses.Contains(selectedEquivalenceClass))
{
throw new ArgumentException("The combination contains this equivalence class and cannot be separated");
}
CompoundEdit ce = new CompoundEdit();
//1-get all the combinations involved
ISet <Combination> allCombinations = new HashedSet <Combination>(combination.Combinations);
allCombinations.Add(combination);
//2-get all the combinations involved that directly contains the equivalence class
ISet <Combination> eqCombinations = new HashedSet <Combination>();
foreach (Combination eqCombination in allCombinations)
{
if (eqCombination.EquivalenceClasses.Contains(selectedEquivalenceClass))
{
eqCombinations.Add(eqCombination);
}
}
//3 remove any hierarchy
foreach (Combination allCombination in allCombinations)
{
if (allCombination.ParentCombination != null)
{
ce.AddEdit(
EditFactory.instance.CreateRemoveCombinationEdit(allCombination.ParentCombination,
allCombination));
allCombination.ParentCombination.RemoveCombination(allCombination);
}
}
//4 - merge the combinations that don't contain the equivalence class using the original root combination
if (allCombinations.Minus(eqCombinations).Count > 0)
{
ce.AddEdit(MergeCombinations(new List <Combination>(allCombinations.Minus(eqCombinations))));
}
//5- merge the combinations that contains the equivalence class using the first combination in the set
if (eqCombinations.Count > 1)
{
CombinationManager cm = new CombinationManager(FindRootCombination(eqCombinations));
ce.AddEdit(cm.MergeCombinations(new List <Combination>(eqCombinations)));
}
return(ce);
}
//Records edit used in scaling operation
void recordEdit(Transform transformEditing)
{
//Record edit for scaling
ScaleEdit scaleEdit = new ScaleEdit(transformEditing, initTransformEditingScale, transformEditing.localScale);
//Create compound edit to store transformEditing and transformTool translations
CompoundEdit compoundEdit = new CompoundEdit();
compoundEdit.addEdit(scaleEdit);
editTracker.trackEdit(compoundEdit); //Start tracking edit in edit tracker
}
public override IUndoableEdit Generate()
{
CompoundEdit ce = new CompoundEdit();
AbstractTestCaseGenerator gen = new PositiveTestCasesGenerator(dependencies, structure, maxTestCases);
ce.AddEdit(gen.Generate());
gen = new NegativeTestCasesGenerator(dependencies, structure, maxTestCases);
ce.AddEdit(gen.Generate());
gen = new FaultyTestCasesGenerator(dependencies, structure, maxTestCases);
ce.AddEdit(gen.Generate());
return(ce);
}
public IUndoableEdit DeleteAllCombinations()
{
CompoundEdit ce = new CompoundEdit();
List <Combination> combis = new List <Combination>(dependency.Combinations);
foreach (Combination combination in combis)
{
CombinationManager man = new CombinationManager(combination);
ce.AddEdit(man.DeleteCombination(dependency.ParentStructure));
}
return(ce);
}
public void DeleteCombination()
{
CombinationManager man = new CombinationManager(combi4);
CompoundEdit ce = (CompoundEdit)man.DeleteCombination(structure);
ce.EndAllEdits();
Assert.IsFalse(test1.Combinations.Contains(combi4));
Assert.IsFalse(test2.Combinations.Contains(combi4));
Assert.IsFalse(dep.Combinations.Contains(combi4));
ce.Undo();
Assert.IsTrue(test1.Combinations.Contains(combi4));
Assert.IsTrue(test2.Combinations.Contains(combi4));
Assert.IsTrue(dep.Combinations.Contains(combi4));
}
private static IUndoableEdit PropagateStateChangeInCombination(Combination target, EquivalenceClass parentEquivalenceClass)
{
CompoundEdit ce = new CompoundEdit();
if (target.ParentDependency != null)
{
ce.AddEdit(EditFactory.instance.CreateRemoveEquivalenceClassEdit(target.ParentDependency, parentEquivalenceClass));
target.ParentDependency.RemoveEquivalenceClass(parentEquivalenceClass);
CombinationManager cman = new CombinationManager(target);
ce.AddEdit(cman.DeleteCombination(target.ParentDependency.ParentStructure));
}
return(ce);
}
//Records edits used in translation operation
void recordEdits(Transform transformEditing)
{
//Record edits for translation
TranslationEdit translationEdit = new TranslationEdit(transformEditing, initTransformEditingEditVector, transformEditing.position);
TranslationEdit transformToolEdit = new TranslationEdit(transformTool.transform, initTransformToolEditVector, transformTool.transform.position);
//Create compound edit to store transformEditing and transformTool translations
CompoundEdit compoundEdit = new CompoundEdit();
compoundEdit.addEdit(translationEdit);
compoundEdit.addEdit(transformToolEdit);
editTracker.trackEdit(compoundEdit); //Start tracking edit in edit tracker
}
public void DeleteCommonTestCases()
{
StructureManager man = new StructureManager(structure);
List <Dependency> deps = new List <Dependency>();
deps.Add(dep3);
deps.Add(dep2);
CompoundEdit ce = (CompoundEdit)man.DeleteCommonTestCases(State.POSITIVE, deps);
Assert.IsTrue(structure.TestCases.Contains(test4));
Assert.AreEqual(structure.TestCases.Count, 1);
ce.EndAllEdits();
ce.Undo();
}
protected IUndoableEdit CreateCombinationsFromPatterns(IList <IList <EquivalenceClass> > patterns, CombinationOrigin origin)
{
//order the patterns based on equivalenceclasses
((List <IList <EquivalenceClass> >)patterns).Sort(new PatternComparer());
////create a combination for each pattern in the patterns
CompoundEdit ce = new CompoundEdit();
IPolicyFactory pfact = new PolicyFactory();
////delete all combinations from the dependency
if (generationOption == CombinationsGenerationOption.OVERWRITE)
{
ce.AddEdit(pfact.DeleteAllCombinationsPolicy(parentDependency));
}
else
{
ce.AddEdit(RemoveInvalidCombinations(patterns));
RemoveRepeatedPatterns(patterns);
}
////create the combinations from the pattern and remove the invalid ones
foreach (IList <EquivalenceClass> list in patterns)
{
Combination comb = new Combination();
ce.AddEdit(EditFactory.instance.CreateAddCombinationEdit(parentDependency, comb));
parentDependency.AddCombination(comb);
ce.AddEdit(EditFactory.instance.CreateChangePropertyEdit(comb, "Origin", origin));
comb.Origin = origin;
foreach (EquivalenceClass equivalenceClass in list)
{
ce.AddEdit(EditFactory.instance.CreateAddEquivalenceClassEdit(comb, equivalenceClass));
comb.AddEquivalenceClass(equivalenceClass);
}
}
////put the positions
int i = 1;
foreach (Combination combination in parentDependency.Combinations)
{
if (combination.Position != i)
{
ce.AddEdit(EditFactory.instance.CreateChangePropertyEdit(combination, "Position", i));
combination.Position = i;
}
i++;
}
return(ce);
}
//Records edits used in rotation operation
void recordEdits(Transform transformEditing)
{
//Record edits for rotation
RotationEdit rotationEdit = new RotationEdit(transformEditing, initTransformEditingEditVector, transformEditing.rotation.eulerAngles);
RotationEdit transformToolRotationEdit = new RotationEdit(transformTool.transform, initTransformToolEditVector, transformTool.transform.rotation.eulerAngles);
//TranslationEdit transformToolTranslationEdit = new TranslationEdit(transformTool.transform, transformTool.transform.position, transformTool.transform.position);
//Create compound edit to store transformEditing and transformTool rotations
CompoundEdit compoundEdit = new CompoundEdit();
compoundEdit.addEdit(rotationEdit);
compoundEdit.addEdit(transformToolRotationEdit);
//compoundEdit.addEdit(transformToolTranslationEdit);
editTracker.trackEdit(compoundEdit); //Start tracking edit in edit tracker
}
public IUndoableEdit MergeCombinations(IList <Combination> combinationsToMerge)
{
if (combinationsToMerge.Count < 1)
{
throw new ArgumentException("The list of combinations to merge is empty");
}
if (combination.Origin != CombinationOrigin.PERMUTATION)
{
throw new InvalidOperationException("The merge is available only for combinations generated by permutation");
}
CompoundEdit ce = new CompoundEdit();
//first merge the effects
ce.AddEdit(MergeEffects(combinationsToMerge));
foreach (Combination combi in combinationsToMerge)
{
if (!combination.Combinations.Contains(combi) && combination != combi)
{
ce.AddEdit(EditFactory.instance.CreateAddCombinationEdit(combination, combi));
combination.AddCombination(combi);
}
}
//remove all test cases referenced by the merged combinations (invalid testcases now)
if (combination.ParentDependency != null && combination.ParentDependency.ParentStructure != null)
{
ISet <Combination> combinationsMerged = new HashedSet <Combination>(combinationsToMerge);
IList <TestCase> deletedTCs = new List <TestCase>();
foreach (TestCase testCase in combination.ParentDependency.ParentStructure.TestCases)
{
ISet <Combination> tcCombinations = new HashedSet <Combination>(testCase.Combinations);
if (tcCombinations.Intersect(combinationsMerged).Count > 0)
{
//delete the referenced test case
deletedTCs.Add(testCase);
}
}
foreach (TestCase tc in deletedTCs)
{
ce.AddEdit(
EditFactory.instance.CreateRemoveTestCaseEdit(combination.ParentDependency.ParentStructure, tc));
combination.ParentDependency.ParentStructure.RemoveTestCase(tc);
}
}
return(ce);
}
public void Generate()
{
List <Dependency> deps = new List <Dependency>();
eq22.CurrentState = State.FAULTY;
combi2.CurrentState = State.FAULTY;
CompoundEdit ce = new CompoundEdit();
deps.Add(dep);
FaultyTestCasesGenerator generator = new FaultyTestCasesGenerator(deps, structure, 10000);
ce.AddEdit(generator.Generate());
Assert.IsTrue(structure.TestCases.Count == 2);
Assert.IsTrue(structure.TestCases[0].EquivalenceClasses.Contains(eq22));
Assert.IsTrue(structure.TestCases[1].Combinations.Contains(combi2));
//TODO add more complex tests here
}
public void Generate()
{
List <Dependency> deps = new List <Dependency>();
CompoundEdit ce = new CompoundEdit();
deps.Add(dep);
PositiveTestCasesGenerator generator = new PositiveTestCasesGenerator(deps, structure, 10000);
ce.AddEdit(generator.Generate());
Assert.IsTrue(structure.TestCases.Count == 5);
Assert.IsTrue(structure.TestCases[0].Combinations.Contains(combi1));
Assert.IsTrue(structure.TestCases[1].Combinations.Contains(combi2));
Assert.IsTrue(structure.TestCases[2].Combinations.Contains(combi3));
Assert.IsTrue(structure.TestCases[3].Combinations.Contains(combi4));
Assert.IsTrue(structure.TestCases[4].Combinations.Contains(combi5));
//TODO add more complex tests here
}
protected override IUndoableEdit FillTestCases(IList <TestCase> testCases)
{
CompoundEdit ce = new CompoundEdit();
//for each combination in the dependency a test case must be created in the same order of the combination
foreach (Dependency dependency in dependencies)
{
foreach (Combination combination in dependency.GetCombinations(genState))
{
TestCase testCase = new TestCase();
ce.AddEdit(EditFactory.instance.CreateChangePropertyEdit(testCase, "Origin", TestCaseOrigin.GENERATED));
testCase.Origin = TestCaseOrigin.GENERATED;
testCases.Add(testCase);
ce.AddEdit(PolicyFactory.instance.AddCombinationToTestCasePolicy(testCase, combination));
}
}
return(ce);
}
public IUndoableEdit ApplyStateToChildren()
{
if (stateObject == null)
{
return(null);
}
CompoundEdit ce = new CompoundEdit();
if (stateObject.GetChildrenObjectStates() == null)
{
return(ce);
}
foreach (IStateObject o in stateObject.GetChildrenObjectStates())
{
StateObjectManager rlc = new StateObjectManager(o);
ce.AddEdit(rlc.ChangeState(stateObject.CurrentState));
}
return(ce);
}
/// <summary>
/// This method is called by <see cref="EndTransaction"/> when committing a
/// compound edit.
/// </summary>
/// <param name="cedit">
/// the <see cref="CurrentEdit"/>;
/// this may be null if there had been no changes at commit time
/// </param>
/// <returns>By default, the unmodified <paramref name="cedit"/>.</returns>
/// <remarks>
/// You may wish to override this method in order to perform optimizations,
/// such as removing duplicate or unnecessary <see cref="ModelChangedEventArgs"/>s.
/// </remarks>
protected virtual CompoundEdit CommitCompoundEdit(CompoundEdit cedit) {
return cedit;
}
/// <summary>
/// Stop the current transaction, either rolling it back or committing it.
/// </summary>
/// <param name="commit">true to terminate the transaction normally;
/// false to abort it and rollback the existing edits</param>
/// <param name="tname">the internal locale-neutral name for the transaction</param>
/// <returns>true for a committed top-level transaction</returns>
/// <remarks>
/// <para>
/// If this call stops a top-level transaction, a value of false for
/// <paramref name="commit"/> just undoes and discards the information in the
/// <see cref="CurrentEdit"/>.
/// If <paramref name="commit"/> is true for a top-level transaction,
/// we mark the <see cref="CurrentEdit"/> complete,
/// call <see cref="CommitCompoundEdit"/>,
/// and add the resulting <see cref="UndoManager.CompoundEdit"/>
/// to the list of compound edits that this undo manager is recording.
/// </para>
/// <para>
/// Committing a transaction when there have been some undos without
/// corresponding redos will throw away the compound edits holding
/// changes that happened after the current state, before adding this
/// new compound edit to the undo manager's list of edits.
/// </para>
/// <para>
/// This method raises a <see cref="IDiagramModel.Changed"/> event
/// for each of this undo manager's <see cref="Models"/>,
/// with a hint of <see cref="ModelChange.CommittedTransaction"/>,
/// and with a <see cref="ModelChangedEventArgs.OldValue"/>
/// that is the <see cref="UndoManager.CompoundEdit"/>
/// that has been added to the list of <see cref="CompoundEdits"/>.
/// Similarly, if the transaction is aborted, either because <paramref name="commit"/>
/// is false or because there is no <see cref="CurrentEdit"/> to commit,
/// all of the <see cref="Models"/> get a <see cref="ModelChange.RolledBackTransaction"/>
/// Changed event. The values passed in the <see cref="ModelChangedEventArgs"/>
/// may all be null, however.
/// </para>
/// </remarks>
protected virtual bool EndTransaction(bool commit, String tname) {
if (this.IsUndoingRedoing) return false;
bool toplevel = (this.TransactionLevel == 1);
int start = 0;
// decrement the transaction level, but not below zero
if (this.TransactionLevel > 0) {
this.TransactionLevel--;
int numnames = this.NestedTransactionNames.Count;
if (numnames > 0) {
if (tname == null) tname = this.NestedTransactionNames[0];
this.NestedTransactionNames.RemoveAt(numnames-1);
}
int numstarts = this.NestedTransactionStarts.Count;
if (numstarts > 0) {
start = this.NestedTransactionStarts[numstarts-1];
this.NestedTransactionStarts.RemoveAt(numstarts-1);
}
}
if (tname == null) tname = "";
CompoundEdit current = this.CurrentEdit;
//Diagram.Debug(this.TransactionLevel, (commit ? "commit: " : "rollback: ") + (tname != "" ? tname : "(unknown)") + " " +
// (current != null ? current.Edits.Count.ToString() : "(no CEdit)") + " " + this.CompoundEdits.Count.ToString());
if (toplevel) {
if (commit) {
// finish the current edit
CompoundEdit cedit = CommitCompoundEdit(current);
if (cedit != null) {
cedit.IsComplete = true;
cedit.Name = tname;
// throw away any compound edits following the current index
for (int i = this.CompoundEdits.Count-1; i > this.UndoEditIndex; i--) {
this.CompoundEdits[i].Clear();
this.CompoundEdits.RemoveAt(i);
}
// if there is a limit, just throw away the oldest edit
int max = this.MaximumEditCount;
if (max == 0) max = 1;
if (max > 0) {
if (this.CompoundEdits.Count >= max) {
this.CompoundEdits[0].Clear();
this.CompoundEdits.RemoveAt(0);
this.UndoEditIndex--;
}
}
// add to CompoundEdits list
this.CompoundEdits.Add(cedit);
this.UndoEditIndex++;
}
// notify all models
foreach (IDiagramModel model in this.ModelsList) {
RaiseChanged(model, ModelChange.CommittedTransaction, tname, cedit, null);
}
} else { // !commit
// rollback the current compound edit by undoing all of its edits
if (current != null) {
try {
current.IsComplete = true;
this.IsUndoingRedoing = true;
current.Undo();
} finally {
this.IsUndoingRedoing = false;
}
}
foreach (IDiagramModel model in this.ModelsList) {
RaiseChanged(model, ModelChange.RolledBackTransaction, tname, current, null);
}
// now we can throw away all those undone edits
if (current != null) current.Clear();
}
this.CurrentEdit = null;
return true;
} else { // !toplevel
// rollback the current edit by undoing all of its edits, but not of parent edits
if (!commit && current != null) {
current.RollbackTo(start);
}
return false;
}
}
/// <summary>
/// Create an <see cref="IUndoableEdit"/> for a <see cref="IDiagramModel.Changed"/> event.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <remarks>
/// This calls <see cref="SkipEvent"/> if for some reason we should ignore
/// the <paramref name="e"/>.
/// This then creates a <see cref="ModelChangedEventArgs"/> and adds it to the
/// <see cref="CurrentEdit"/>, a <see cref="UndoManager.CompoundEdit"/> which it allocates
/// if needed.
/// This method always ignores all Changed events while we are performing an
/// <see cref="Undo"/> or <see cref="Redo"/>.
/// </remarks>
public virtual void HandleModelChanged(Object sender, ModelChangedEventArgs e) {
// changes caused by performing an undo or redo should be ignored!
if (this.IsUndoingRedoing) return;
if (!SkipEvent(e)) {
CompoundEdit cedit = this.CurrentEdit;
//ModelHelper.Trace(this.TransactionLevel, e.ToString());
if (cedit == null) {
cedit = new CompoundEdit();
this.CurrentEdit = cedit;
}
// make a copy of the event to save as an edit in the list
ModelChangedEventArgs edit = new ModelChangedEventArgs(e);
cedit.Edits.Add(edit);
if (this.ChecksTransactionLevel && this.TransactionLevel <= 0) {
ModelHelper.Trace("Change not within a transaction: " + edit.ToString());
}
}
}
