public void Start_UsingAllConfigurationCombinationsAvailable_AllRun()
        {
            var selections   = SelectionService.GetSelectionNames();
            var crossovers   = CrossoverService.GetCrossoverNames();
            var mutations    = MutationService.GetMutationNames().Where(m => !m.Equals("Flip Bit"));
            var reinsertions = ReinsertionService.GetReinsertionNames();
            var chromosome   = new OrderedChromosomeStub();

            foreach (var s in selections)
            {
                foreach (var c in crossovers)
                {
                    foreach (var m in mutations)
                    {
                        foreach (var r in reinsertions)
                        {
                            var selection   = SelectionService.CreateSelectionByName(s);
                            var crossover   = CrossoverService.CreateCrossoverByName(c);
                            var mutation    = MutationService.CreateMutationByName(m);
                            var reinsertion = ReinsertionService.CreateReinsertionByName(r);

                            if (crossover.IsOrdered ^ mutation.IsOrdered)
                            {
                                continue;
                            }

                            if (crossover.ParentsNumber > crossover.ChildrenNumber && !reinsertion.CanExpand)
                            {
                                continue;
                            }

                            if (mutation is UniformMutation)
                            {
                                mutation = new UniformMutation(1);
                            }

                            var target = new GeneticAlgorithm(
                                new Population(50, 50, chromosome.Clone())
                            {
                                GenerationStrategy = new TrackingGenerationStrategy()
                            },
                                new FitnessStub()
                            {
                                SupportsParallel = false
                            },
                                selection,
                                crossover,
                                mutation);

                            target.Reinsertion          = reinsertion;
                            target.Termination          = new GenerationNumberTermination(25);
                            target.CrossoverProbability = reinsertion.CanExpand ? 0.75f : 1f;

                            target.Start();
                            Assert.AreEqual(25, target.Population.Generations.Count);
                        }
                    }
                }
            }
        }
        public void GetCrossoverNames_NoArgs_AllAvailableCrossoversNames()
        {
            var actual = CrossoverService.GetCrossoverNames();

            Assert.AreEqual(8, actual.Count);
            Assert.AreEqual("Cut and Splice", actual[0]);
            Assert.AreEqual("Cycle (CX)", actual[1]);
            Assert.AreEqual("One-Point", actual [2]);
            Assert.AreEqual("Ordered (OX1)", actual [3]);
            Assert.AreEqual("Partially Mapped (PMX)", actual [4]);
            Assert.AreEqual("Three Parent", actual[5]);
            Assert.AreEqual("Two-Point", actual [6]);
            Assert.AreEqual("Uniform", actual [7]);
        }
        public void GetCrossoverNames_NoArgs_AllAvailableCrossoversNames()
        {
            var actual = CrossoverService.GetCrossoverNames();

            Assert.AreEqual(12, actual.Count);
            var index = -1;

            Assert.AreEqual("Alternating-position (AP)", actual[++index]);
            Assert.AreEqual("Cut and Splice", actual[++index]);
            Assert.AreEqual("Cycle (CX)", actual[++index]);
            Assert.AreEqual("One-Point", actual[++index]);
            Assert.AreEqual("Order-based (OX2)", actual[++index]);
            Assert.AreEqual("Ordered (OX1)", actual[++index]);
            Assert.AreEqual("Partially Mapped (PMX)", actual[++index]);
            Assert.AreEqual("Position-based (POS)", actual[++index]);
            Assert.AreEqual("Three Parent", actual[++index]);
            Assert.AreEqual("Two-Point", actual[++index]);
            Assert.AreEqual("Uniform", actual[++index]);
            Assert.AreEqual("Voting Recombination (VR)", actual[++index]);
        }