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 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());
        }