public void MaximalPreservativeCrossoverApplyTest() { TestRandom random = new TestRandom(); Permutation parent1, parent2, expected, actual; // The following test is based on an example from Larranaga, 1999. Genetic Algorithms for the Traveling Salesman Problem. random.Reset(); random.IntNumbers = new int[] { 3, 2 }; parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 }); Assert.IsTrue(parent1.Validate()); parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 }); Assert.IsTrue(parent2.Validate()); expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 0, 2, 3, 4, 5, 7, 6 }); Assert.IsTrue(expected.Validate()); actual = MaximalPreservativeCrossover.Apply(random, parent1, parent2); Assert.IsTrue(actual.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual)); // perform a test when the two permutations are of unequal length random.Reset(); bool exceptionFired = false; try { MaximalPreservativeCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6)); } catch (System.ArgumentException) { exceptionFired = true; } Assert.IsTrue(exceptionFired); }
public void TestPermutationReverse() { var permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Reverse(0, 0); Assert.IsTrue(permutation.Validate()); var expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Reverse(9, 1); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Reverse(0, 10); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Reverse(1, 4); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 4, 3, 2, 1, 5, 6, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); }
public void TestPermutationReplace() { var permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Replace(0, new int[0]); Assert.IsTrue(permutation.Validate()); var expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Replace(3, new [] { 3 }); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Replace(5, new [] { 8, 6, 5, 7 }); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 8, 6, 5, 7, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Replace(0, new [] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Replace(3, new[] { 5, 6, 7 }); Assert.IsFalse(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 5, 6, 7, 6, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); }
public void CyclicCrossover2ApplyTest() { TestRandom random = new TestRandom(); Permutation parent1, parent2, expected, actual; // The following test is based on an example from Affenzeller, M. et al. 2009. Genetic Algorithms and Genetic Programming - Modern Concepts and Practical Applications. CRC Press. pp. 134. random.Reset(); random.IntNumbers = new int[] { 0 }; parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); Assert.IsTrue(parent1.Validate()); parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 5, 6, 0, 7, 1, 3, 8, 4, 9 }); Assert.IsTrue(parent2.Validate()); expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 5, 2, 3, 7, 1, 6, 8, 4, 9 }); Assert.IsTrue(expected.Validate()); actual = CyclicCrossover2.Apply(random, parent1, parent2); Assert.IsTrue(actual.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual)); // perform a test when the two permutations are of unequal length random.Reset(); bool exceptionFired = false; try { CyclicCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6)); } catch (System.ArgumentException) { exceptionFired = true; } Assert.IsTrue(exceptionFired); }
public void CosaCrossoverApplyTest() { TestRandom random = new TestRandom(); Permutation parent1, parent2, expected, actual; // The following test is based on an example from Wendt, O. 1994. COSA: COoperative Simulated Annealing - Integration von Genetischen Algorithmen und Simulated Annealing am Beispiel der Tourenplanung. Dissertation Thesis. IWI Frankfurt. random.Reset(); random.IntNumbers = new int[] { 1 }; parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 5, 2, 4, 3 }); Assert.IsTrue(parent1.Validate()); parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 3, 0, 2, 1, 4, 5 }); Assert.IsTrue(parent2.Validate()); expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 4, 2, 5, 3 }); Assert.IsTrue(expected.Validate()); actual = CosaCrossover.Apply(random, parent1, parent2); Assert.IsTrue(actual.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual)); // The following test is not based on published examples random.Reset(); random.IntNumbers = new int[] { 4 }; parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 }); Assert.IsTrue(parent1.Validate()); parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 }); Assert.IsTrue(parent2.Validate()); expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 6, 5, 3, 4, 2, 1, 0 }); Assert.IsTrue(expected.Validate()); actual = CosaCrossover.Apply(random, parent1, parent2); Assert.IsTrue(actual.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual)); // The following test is not based on published examples random.Reset(); random.IntNumbers = new int[] { 5 }; parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); Assert.IsTrue(parent1.Validate()); parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 4, 3, 5, 1, 0, 9, 7, 2, 8, 6 }); Assert.IsTrue(parent2.Validate()); expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 6, 2, 3, 4, 5, 1, 0, 9, 8 }); Assert.IsTrue(expected.Validate()); actual = CosaCrossover.Apply(random, parent1, parent2); Assert.IsTrue(actual.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual)); // perform a test when the two permutations are of unequal length random.Reset(); bool exceptionFired = false; try { CosaCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6)); } catch (System.ArgumentException) { exceptionFired = true; } Assert.IsTrue(exceptionFired); }
public void ScrambleManipulatorApplyTest() { TestRandom random = new TestRandom(); Permutation parent, expected; // The following test is based on an example from Larranaga, P. et al. 1999. Genetic Algorithms for the Travelling Salesman Problem: A Review of Representations and Operators. Artificial Intelligence Review, 13 random.Reset(); random.IntNumbers = new int[] { 3, 6, 1, 1, 1, 0 }; parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 }); Assert.IsTrue(parent.Validate()); expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 4, 5, 6, 3, 7 }); Assert.IsTrue(expected.Validate()); ScrambleManipulator.Apply(random, parent); Assert.IsTrue(parent.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, parent)); }
public void InversionManipulatorApplyTest() { TestRandom random = new TestRandom(); Permutation parent, expected; // The following test is based on an example from Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg, pp. 46-47 random.Reset(); random.IntNumbers = new int[] { 1, 4 }; parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 }); Assert.IsTrue(parent.Validate()); expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 4, 3, 2, 1, 5, 6, 7, 8 }); Assert.IsTrue(expected.Validate()); InversionManipulator.Apply(random, parent); Assert.IsTrue(parent.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, parent)); }
public void Swap3ManipulatorApplyTest() { TestRandom random = new TestRandom(); Permutation parent, expected; // Test manipulator random.Reset(); random.IntNumbers = new int[] { 1, 3, 6 }; random.DoubleNumbers = new double[] { 0 }; parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 }); Assert.IsTrue(parent.Validate()); expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 3, 2, 6, 4, 5, 1, 7, 8 }); Assert.IsTrue(expected.Validate()); Swap3Manipulator.Apply(random, parent); Assert.IsTrue(parent.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, parent)); }
public void UniformLikeCrossoverApplyTest() { // test from the paper IRandom random = new TestRandom(new int[] { 0 }, new double[] { 0.2, 0.7, 0.2, 0.2 }); // TODO: Initialize to an appropriate value Permutation parent1 = new Permutation(PermutationTypes.Absolute, new int[] { 3, 2, 0, 7, 5, 4, 1, 6 }); Assert.IsTrue(parent1.Validate()); Permutation parent2 = new Permutation(PermutationTypes.Absolute, new int[] { 5, 0, 4, 7, 1, 3, 2, 6 }); Assert.IsTrue(parent2.Validate()); Permutation expected = new Permutation(PermutationTypes.Absolute, new int[] { 3, 0, 4, 7, 5, 2, 1, 6 }); Assert.IsTrue(expected.Validate()); Permutation actual; actual = UniformLikeCrossover.Apply(random, parent1, parent2); Assert.IsTrue(actual.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual)); }
public void TestPermutationSwap() { var permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Swap(0, 0); Assert.IsTrue(permutation.Validate()); var expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Swap(0, 9); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 9, 1, 2, 3, 4, 5, 6, 7, 8, 0 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Swap(1, 3); permutation.Swap(3, 5); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 3, 2, 5, 4, 1, 6, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); }
public void TestPermutationMove() { var permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Move(0, 0, 0); Assert.IsTrue(permutation.Validate()); var expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Move(0, 0, 1); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 1, 0, 2, 3, 4, 5, 6, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Move(0, 2, 3); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 3, 4, 5, 0, 1, 2, 6, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Move(3, 5, 0); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 3, 4, 5, 0, 1, 2, 6, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Move(3, 5, 2); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 3, 4, 5, 2, 6, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Move(5, 6, 8); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 7, 8, 9, 5, 6 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Move(5, 7, 7); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 8, 9, 5, 6, 7 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Move(2, 6, 5); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 7, 8, 9, 2, 3, 4, 5, 6 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); permutation.Move(3, 5, 4); Assert.IsTrue(permutation.Validate()); expected = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 6, 3, 4, 5, 7, 8, 9 }); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, permutation)); permutation = new Permutation(PermutationTypes.Absolute, new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); var exception = false; try { permutation.Move(0, 5, 7); } catch { exception = true; } Assert.IsTrue(exception); }
public void OrderCrossoverApplyTest() { TestRandom random = new TestRandom(); Permutation parent1, parent2, expected, actual; // The following test is based on an example from Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg, pp. 55-56 random.Reset(); random.IntNumbers = new int[] { 3, 6 }; parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 }); Assert.IsTrue(parent1.Validate()); parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 8, 2, 6, 7, 1, 5, 4, 0, 3 }); Assert.IsTrue(parent2.Validate()); expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 7, 1, 3, 4, 5, 6, 0, 8 }); Assert.IsTrue(expected.Validate()); actual = OrderCrossover.Apply(random, parent1, parent2); Assert.IsTrue(actual.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual)); // The following test is based on an example from Larranaga, P. et al. 1999. Genetic Algorithms for the Travelling Salesman Problem: A Review of Representations and Operators. Artificial Intelligence Review, 13, pp. 129-170. random.Reset(); random.IntNumbers = new int[] { 2, 4 }; parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 }); Assert.IsTrue(parent1.Validate()); parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 }); Assert.IsTrue(parent2.Validate()); expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 6, 2, 3, 4, 0, 1, 5 }); actual = OrderCrossover.Apply(random, parent1, parent2); Assert.IsTrue(actual.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual)); // The following test is based on an example from Talbi, E.G. 2009. Metaheuristics - From Design to Implementation. Wiley, p. 218. random.Reset(); random.IntNumbers = new int[] { 2, 5 }; parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 }); Assert.IsTrue(parent1.Validate()); parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 3, 0, 4, 8, 2, 5, 1, 6 }); Assert.IsTrue(parent2.Validate()); expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 8, 2, 3, 4, 5, 1, 6, 7 }); Assert.IsTrue(expected.Validate()); actual = OrderCrossover.Apply(random, parent1, parent2); Assert.IsTrue(actual.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual)); // The following test is not based on published examples random.Reset(); random.IntNumbers = new int[] { 0, 5 }; parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 }); Assert.IsTrue(parent1.Validate()); parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 5, 3, 4, 0, 9, 8, 2, 7, 1, 6 }); Assert.IsTrue(parent2.Validate()); expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 4, 3, 7, 8, 6, 5, 0, 9 }); Assert.IsTrue(expected.Validate()); actual = OrderCrossover.Apply(random, parent1, parent2); Assert.IsTrue(actual.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual)); // based on the previous with changed breakpoints random.Reset(); random.IntNumbers = new int[] { 6, 9 }; expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 3, 4, 8, 2, 7, 1, 6, 0, 5, 9 }); Assert.IsTrue(expected.Validate()); actual = OrderCrossover.Apply(random, parent1, parent2); Assert.IsTrue(actual.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual)); // another one based on the previous with changed breakpoints random.Reset(); random.IntNumbers = new int[] { 0, 9 }; expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 }); Assert.IsTrue(expected.Validate()); actual = OrderCrossover.Apply(random, parent1, parent2); Assert.IsTrue(actual.Validate()); Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual)); // perform a test when the two permutations are of unequal length random.Reset(); bool exceptionFired = false; try { OrderCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6)); } catch (System.ArgumentException) { exceptionFired = true; } Assert.IsTrue(exceptionFired); }