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 void CanBeAssignedToTestCase()
{
test2.RemoveCombination(combi4);
CombinationManager man3 = new CombinationManager(combi3);
Assert.IsFalse(man3.CanBeAssignedToTestCase(test1));
CombinationManager man5 = new CombinationManager(combi5);
Assert.IsTrue(man5.CanBeAssignedToTestCase(test1));
CombinationManager man4 = new CombinationManager(combi4);
//combination already assigned
Assert.IsFalse(man4.CanBeAssignedToTestCase(test1));
//child combination
Assert.IsFalse(man4.CanBeAssignedToTestCase(test2));
//compatible combination
combi5.AddEquivalenceClass(eq13);
combi5.AddEquivalenceClass(eq23);
combi5.AddEquivalenceClass(eq31);
Assert.IsTrue(man5.CanBeAssignedToTestCase(test2));
//incompatible combination
combi5.RemoveEquivalenceClass(eq23);
combi5.AddEquivalenceClass(eq21);
Assert.IsFalse(man5.CanBeAssignedToTestCase(test2));
}
public void CheckWiningCombinationTest()
{
var combination = new MoveCombination(1, 2, 3);
var result = CombinationManager.CheckWiningCombinationChance(combination, 1, 5);
Assert.True(result == false);
}
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 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));
}
public AIManager(CombinationManager manager)
{
this.Manager = manager;
}
protected override IUndoableEdit FillTestCases(IList <TestCase> testCases)
{
CompoundEdit ce = new CompoundEdit();
TestCase testCase = null;
IList <Combination> rejectedCombinations = new List <Combination>();
int maxNumOfPositiveCombinations = 0;
//check wich dependency has the maximal number of positive combniations
foreach (Dependency dependency in dependencies)
{
int numOfPositiveCombinations = dependency.GetCombinations(State.POSITIVE).Count;
if (numOfPositiveCombinations > maxNumOfPositiveCombinations)
{
maxNumOfPositiveCombinations = numOfPositiveCombinations;
}
}
//create a test case for each of this maximal number
for (int i = 0; i < maxNumOfPositiveCombinations; i++)
{
//create the test case with his attributes
testCase = new TestCase();
ce.AddEdit(EditFactory.instance.CreateChangeStateEdit(testCase, State.POSITIVE));
testCase.CurrentState = State.POSITIVE;
ce.AddEdit(EditFactory.instance.CreateChangePropertyEdit(testCase, "Origin", TestCaseOrigin.GENERATED));
testCase.Origin = TestCaseOrigin.GENERATED;
testCases.Add(testCase);
//if( !existsTestCaseWithTheSameValues(testCase, generatedTestCases, p_Structure.getLnkElements())) {
//}
foreach (Dependency dependency in dependencies)
{
Combination combination = dependency.GetCombinationAt(i, State.POSITIVE);
CombinationManager cm = new CombinationManager(combination);
if (combination != null)
{
if (cm.CanBeAssignedToTestCase(testCase))
{
ce.AddEdit(PolicyFactory.instance.AddCombinationToTestCasePolicy(testCase, combination));
}
else
{
rejectedCombinations.Add(combination);
}
}
}
}
List <Combination> usedRejectedCombinations = new List <Combination>();
TestCase testCaseOfRejectedCombinations;
foreach (Combination rejectedCombination in rejectedCombinations)
{
bool combinationIsAssignedToATestCase = false;
foreach (TestCase tc in testCases)
{
if (!usedRejectedCombinations.Contains(rejectedCombination))
{
CombinationManager cm = new CombinationManager(rejectedCombination);
if (cm.CanBeAssignedToTestCase(tc))
{
ce.AddEdit(PolicyFactory.instance.AddCombinationToTestCasePolicy(tc, rejectedCombination));
combinationIsAssignedToATestCase = true;
usedRejectedCombinations.Add(rejectedCombination);
}
}
}
if (!combinationIsAssignedToATestCase)
{
if (!usedRejectedCombinations.Contains(rejectedCombination))
{
testCaseOfRejectedCombinations = new TestCase();
ce.AddEdit(EditFactory.instance.CreateChangeStateEdit(testCaseOfRejectedCombinations, State.POSITIVE));
testCaseOfRejectedCombinations.CurrentState = State.POSITIVE;
ce.AddEdit(EditFactory.instance.CreateChangePropertyEdit(testCaseOfRejectedCombinations, "Origin", TestCaseOrigin.GENERATED));
testCaseOfRejectedCombinations.Origin = TestCaseOrigin.GENERATED;
testCases.Add(testCaseOfRejectedCombinations);
ce.AddEdit(PolicyFactory.instance.AddCombinationToTestCasePolicy(testCaseOfRejectedCombinations, rejectedCombination));
usedRejectedCombinations.Add(rejectedCombination);
}
}
}
return(ce);
}
public void UnMergeCombinationsTest2()
{
//generate a 3 x 3 permutation
CompoundEdit ce = new CompoundEdit();
Dependency dep2 = new Dependency(structure);
dep = dep2;
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());
//Merge
//merge combination c3 with eq22
CombinationManager cm = new CombinationManager(dep2.Combinations[2]);
IList <Combination> combis = cm.FindMergeableCombinations(eq22);
cm.MergeCombinations(combis);
Assert.IsTrue(dep2.Combinations[2].Combinations.Contains(dep2.Combinations[1]));
//merge combination c3 with eq21
combis = cm.FindMergeableCombinations(eq21);
cm.MergeCombinations(combis);
Assert.IsTrue(dep.Combinations[2].Combinations.Contains(dep2.Combinations[1]));
//merge combination c6 with eq22
CombinationManager cm2 = new CombinationManager(dep2.Combinations[5]);
combis = cm2.FindMergeableCombinations(eq22);
cm2.MergeCombinations(combis);
Assert.IsTrue(dep2.Combinations[5].Combinations.Contains(dep2.Combinations[4]));
//merge combination c6 with eq21
combis = cm2.FindMergeableCombinations(eq21);
cm2.MergeCombinations(combis);
Assert.IsTrue(dep2.Combinations[5].Combinations.Contains(dep2.Combinations[3]));
//merge combination c9 with eq22
CombinationManager cm4 = new CombinationManager(dep.Combinations[8]);
combis = cm4.FindMergeableCombinations(eq22);
cm4.MergeCombinations(combis);
Assert.IsTrue(dep2.Combinations[8].Combinations.Contains(dep2.Combinations[7]));
//merge combination c9 with eq21
combis = cm4.FindMergeableCombinations(eq21);
cm4.MergeCombinations(combis);
Assert.IsTrue(dep2.Combinations[8].Combinations.Contains(dep2.Combinations[6]));
//merge combination c9 with eq12
combis = cm4.FindMergeableCombinations(eq12);
cm4.MergeCombinations(combis);
Assert.IsTrue(dep2.Combinations[8].Combinations.Contains(dep2.Combinations[5]));
//merge combination c9 with eq11
combis = cm4.FindMergeableCombinations(eq11);
cm4.MergeCombinations(combis);
Assert.IsTrue(dep2.Combinations[8].Combinations.Contains(dep2.Combinations[2]));
//unmerge from C9 eq11
cm4.UnMergeCombinations(eq11);
Assert.IsFalse(dep2.Combinations[0].Combinations.Contains(dep2.Combinations[0]));
cm4.UnMergeCombinations(eq21);
CombinationManager cm5 = new CombinationManager(dep.Combinations[2]);
//unmerge from C3 eq22
cm5.UnMergeCombinations(eq22);
}
