Index: trunk/sources/HeuristicLab.Permutation/3.3/AbsolutePositionTopologicalCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/AbsolutePositionTopologicalCrossover.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/AbsolutePositionTopologicalCrossover.cs	(revision 2854)
@@ -1,5 +1,5 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -25,4 +25,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Permutation {
@@ -32,13 +33,15 @@
   /// (minding already inserted values).
   /// </summary>
+  /// <remarks>It is implemented as described in Moraglio, A. and Poli, R. 2005. Topological crossover for the permutation representation. In Proceedings of the 2005 Workshops on Genetic and Evolutionary Computation.<br />
+  /// </remarks>
   /// <example>First take the value at position 0 from parent1 then take the value at position 0
   /// from parent2 if it has not already been inserted, afterwards take the value at position 1 from
   /// parent1 if it has not already been inserted, then from parent2 and so on.</example>
-  public class AbsolutePositionTopologicalCrossover : PermutationCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
-    }
-
+  [Item("AbsolutePositionTopologicalCrossover", @"An operator which performs a cross over permutation between two permutation arrays by taking the 
+entries with the same index (starting at position 0) from both parents 
+(minding already inserted values).")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public class AbsolutePositionTopologicalCrossover : PermutationCrossover {
     /// <summary>
     /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/>
@@ -48,9 +51,11 @@
     /// from parent2 if it has not already been inserted, afterwards take the value at position 1 from
     /// parent1 if it has not already been inserted, then from parent2 and so on.</example>
-    /// <param name="random">A random number generator.</param>
+    /// <exception cref="ArgumentException">Thrown when <paramref name="parent1"/> and <paramref name="parent2"/> are not of equal length.</exception>
+    /// <param name="random">The random number generator.</param>
     /// <param name="parent1">The parent scope 1 to cross over.</param>
     /// <param name="parent2">The parent scope 2 to cross over.</param>
     /// <returns>The created cross over permutation as int array.</returns>
-    public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
+    public static Permutation Apply(IRandom random, Permutation parent1, Permutation parent2) {
+      if (parent1.Length != parent2.Length) throw new ArgumentException("AbsolutePositionTopologicalCrossover: The parent permutations are of unequal length.");
       int length = parent1.Length;
       int[] result = new int[length];
@@ -71,5 +76,5 @@
         }
       }
-      return result;
+      return new Permutation(result);
     }
 
@@ -78,9 +83,8 @@
     /// </summary>
     /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
     /// <param name="parents">An array containing the two permutations that should be crossed.</param>
     /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+    protected override Permutation Cross(IRandom random, ItemArray<Permutation> parents) {
       if (parents.Length != 2) throw new InvalidOperationException("ERROR in AbsolutePositionTopologicalCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
Index: trunk/sources/HeuristicLab.Permutation/3.3/CosaCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/CosaCrossover.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/CosaCrossover.cs	(revision 2854)
@@ -1,5 +1,5 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -25,17 +25,16 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Permutation {
   /// <summary>
-  /// Performs a cross over permutation between two permutation arrays by taking randomly chosen 
+  /// Performs a crossover operation between two permutation arrays by taking randomly chosen 
   /// reverse and forward intervals from the first permutation array inserting 
   /// it in the child on different positions depending on the second permutation array.
   /// </summary>
-  public class CosaCrossover : PermutationCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
-    }
-
+  [Item("CosaCrossover", "An operator which performs a crossover operation between two permutation arrays by taking randomly chosen reverse and forward intervals from the first permutation array inserting it in the child on different positions depending on the second permutation array.")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public class CosaCrossover : PermutationCrossover {
     /// <summary>
     /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/>
@@ -44,9 +43,11 @@
     /// The remaining elements to be inserted are taken again from parent1 in the forward direction.
     /// </summary>
+    /// <exception cref="ArgumentException">Thrown when <paramref name="parent1"/> and <paramref name="parent2"/> are not of equal length.</exception>
     /// <param name="random">The random number generator.</param>
     /// <param name="parent1">The parent scope 1 to cross over.</param>
     /// <param name="parent2">The parent scope 2 to cross over.</param>
     /// <returns>The created cross over permutation as int array.</returns>
-    public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
+    public static Permutation Apply(IRandom random, Permutation parent1, Permutation parent2) {
+      if (parent1.Length != parent2.Length) throw new ArgumentException("CosaCrossover: The parent permutations are of unequal length.");
       int length = parent1.Length;
       int[] result = new int[length];
@@ -82,5 +83,5 @@
       }
       result[j] = parent1[crossPoint];  // last station: crosspoint
-      return result;
+      return new Permutation(result);
     }
 
@@ -89,9 +90,8 @@
     /// </summary>
     /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
     /// <param name="parents">An array containing the two permutations that should be crossed.</param>
     /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+    protected override Permutation Cross(IRandom random, ItemArray<Permutation> parents) {
       if (parents.Length != 2) throw new InvalidOperationException("ERROR in CosaCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
Index: trunk/sources/HeuristicLab.Permutation/3.3/CyclicCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/CyclicCrossover.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/CyclicCrossover.cs	(revision 2854)
@@ -31,5 +31,5 @@
   /// The operator first determines all cycles in the permutation and then composes the offspring by alternating between the cycles of the two parents.
   /// </remarks>
-  [Item("CyclicCrossover", "An operator which performs the cyclic crossover on two permutations as described in Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg.")]
+  [Item("CyclicCrossover", "An operator which performs the cyclic crossover on two permutations.")]
   [EmptyStorableClass]
   [Creatable("Test")]
@@ -47,4 +47,5 @@
     /// The stochasticity of this operator is rather low. There are only two possible outcomes for a given pair of parents.
     /// </remarks>
+    /// <exception cref="ArgumentException">Thrown if the two parents are not of equal length.</exception>
     /// <param name="random">The random number generator.</param>
     /// <param name="parent1">The parent scope 1 to cross over.</param>
@@ -77,10 +78,11 @@
           if (copyFromParent1) {
             result[j] = parent1[j]; // copy number at position j from parent1
+            indexCopied[j] = true;
             j = invParent2[result[j]]; // set position j to the position of the copied number in parent2
           } else {
             result[j] = parent2[j]; // copy number at position j from parent2
+            indexCopied[j] = true;
             j = invParent1[result[j]]; // set position j to the position of the copied number in parent1
           }
-          indexCopied[j] = true;
         } while (!indexCopied[j]);
         copyFromParent1 = !copyFromParent1;
@@ -96,5 +98,4 @@
     /// </summary>
     /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
     /// <param name="parents">An array containing the two permutations that should be crossed.</param>
Index: trunk/sources/HeuristicLab.Permutation/3.3/EdgeRecombinationCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/EdgeRecombinationCrossover.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/EdgeRecombinationCrossover.cs	(revision 2854)
@@ -1,5 +1,5 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -25,4 +25,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Permutation {
@@ -32,10 +33,11 @@
   /// number of neighbours, the next again a neighbour and so on.
   /// </summary>
-  public class EdgeRecombinationCrossover : PermutationCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
-    }
-
+  ///   /// <remarks>It is implemented as described in Whitley et.al. 1991, The Traveling Salesman and Sequence Scheduling, in Davis, L. (Ed.), Handbook ov Genetic Algorithms, New York, pp. 350-372<br />
+  /// The operator first determines all cycles in the permutation and then composes the offspring by alternating between the cycles of the two parents.
+  /// </remarks>
+  [Item("EdgeRecombinationCrossover", "An operator which performs the edge recombination crossover on two permutations.")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public class EdgeRecombinationCrossover : PermutationCrossover {
     /// <summary>
     /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="2"/>
@@ -44,4 +46,5 @@
     /// number of neighbours, the next again a neighbour and so on.
     /// </summary>
+    /// <exception cref="ArgumentException">Thrown when <paramref name="parent1"/> and <paramref name="parent2"/> are not of equal length.</exception>
     /// <exception cref="InvalidOperationException">Thrown when the permutation lacks a number.
     /// </exception>
@@ -50,5 +53,6 @@
     /// <param name="parent2">The parent scope 2 to cross over.</param>
     /// <returns>The created cross over permutation as int array.</returns>
-    public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
+    public static Permutation Apply(IRandom random, Permutation parent1, Permutation parent2) {
+      if (parent1.Length != parent2.Length) throw new ArgumentException("EdgeRecombinationCrossover: The parent permutations are of unequal length.");
       int length = parent1.Length;
       int[] result = new int[length];
@@ -135,5 +139,5 @@
         }
       }
-      return result;
+      return new Permutation(result);
     }
 
@@ -142,9 +146,8 @@
     /// </summary>
     /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
     /// <param name="parents">An array containing the two permutations that should be crossed.</param>
     /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+    protected override Permutation Cross(IRandom random, ItemArray<Permutation> parents) {
       if (parents.Length != 2) throw new InvalidOperationException("ERROR in EdgeRecombinationCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
Index: trunk/sources/HeuristicLab.Permutation/3.3/HeuristicLab.Permutation-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/HeuristicLab.Permutation-3.3.csproj	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/HeuristicLab.Permutation-3.3.csproj	(revision 2854)
@@ -82,9 +82,14 @@
   <ItemGroup>
     <None Include="HeuristicLabPermutationPlugin.cs.frame" />
+    <Compile Include="AbsolutePositionTopologicalCrossover.cs" />
+    <Compile Include="CosaCrossover.cs" />
     <Compile Include="CyclicCrossover.cs" />
+    <Compile Include="EdgeRecombinationCrossover.cs" />
+    <Compile Include="InsertionManipulator.cs" />
     <Compile Include="InversionManipulator.cs">
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="MaximalPreservativeCrossover.cs" />
+    <Compile Include="OrderBasedCrossover.cs" />
     <Compile Include="PartiallyMatchedCrossover.cs" />
     <Compile Include="PermutationManipulator.cs" />
@@ -93,6 +98,12 @@
     <Compile Include="PermutationCrossover.cs" />
     <Compile Include="Permutation.cs" />
+    <Compile Include="PositionBasedCrossover.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="RandomPermutationCreator.cs" />
+    <Compile Include="ScrambleManipulator.cs" />
+    <Compile Include="Swap2Manipulator.cs" />
+    <Compile Include="Swap3Manipulator.cs" />
+    <Compile Include="TranslocationInversionManipulator.cs" />
+    <Compile Include="TranslocationManipulator.cs" />
   </ItemGroup>
   <ItemGroup>
Index: trunk/sources/HeuristicLab.Permutation/3.3/InsertionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/InsertionManipulator.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/InsertionManipulator.cs	(revision 2854)
@@ -1,5 +1,5 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -24,15 +24,17 @@
 using System.Text;
 using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Permutation {
   /// <summary>
   /// Manipulates a permutation array by moving randomly one element to another position in the array.
-  /// </summary>
-  public class InsertionManipulator : PermutationManipulatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
-    }
-
+  /// </summary> 
+  /// <remarks>
+  /// It is implemented as described in Fogel, D.B. (1988). An Evolutionary Approach to the Traveling Salesman Problem, Biological Cybernetics, 60, pp. 139-144
+  /// </remarks>
+  [Item("InsertionManipulator", "An operator which moves randomly one element to another position in the permutation.")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public class InsertionManipulator : PermutationManipulator {
     /// <summary>
     /// Moves an randomly chosen element in the specified <paramref name="permutation"/> array 
@@ -40,31 +42,29 @@
     /// </summary>
     /// <param name="random">The random number generator.</param>
-    /// <param name="permutation">The array to manipulate.</param>
-    /// <returns>The new permuation array with the manipulated data.</returns>
-    public static int[] Apply(IRandom random, int[] permutation) {
-      int[] result = (int[])permutation.Clone();
+    /// <param name="permutation">The permutation to manipulate.</param>
+    public static void Apply(IRandom random, Permutation permutation) {
+      Permutation original = (Permutation)permutation.Clone();
       int cutIndex, insertIndex, number;
 
-      cutIndex = random.Next(permutation.Length);
-      insertIndex = random.Next(permutation.Length);
-      number = permutation[cutIndex];
+      cutIndex = random.Next(original.Length);
+      insertIndex = random.Next(original.Length);
+      number = original[cutIndex];
 
       int i = 0;  // index in new permutation
       int j = 0;  // index in old permutation
-      while (i < permutation.Length) {
+      while (i < original.Length) {
         if (j == cutIndex) {
           j++;
         }
         if (i == insertIndex) {
-          result[i] = number;
+          permutation[i] = number;
           i++;
         }
-        if ((i < permutation.Length) && (j < permutation.Length)) {
-          result[i] = permutation[j];
+        if ((i < original.Length) && (j < original.Length)) {
+          permutation[i] = original[j];
           i++;
           j++;
         }
       }
-      return result;
     }
 
@@ -74,10 +74,8 @@
     /// </summary>
     /// <remarks>Calls <see cref="Apply"/>.</remarks>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="permutation">The array to manipulate.</param>
-    /// <returns>The new permuation array with the manipulated data.</returns>
-    protected override int[] Manipulate(IScope scope, IRandom random, int[] permutation) {
-      return Apply(random, permutation);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="permutation">The permutation to manipulate.</param>
+    protected override void Manipulate(IRandom random, Permutation permutation) {
+      Apply(random, permutation);
     }
   }
Index: trunk/sources/HeuristicLab.Permutation/3.3/InversionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/InversionManipulator.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/InversionManipulator.cs	(revision 2854)
@@ -27,4 +27,7 @@
   /// An operator which inverts a randomly chosen part of a permutation.
   /// </summary>
+  /// <remarks>
+  /// It is implemented as described in Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg.<br />
+  /// </remarks>
   [Item("InversionManipulator", "An operator which inverts a randomly chosen part of a permutation.")]
   [EmptyStorableClass]
@@ -36,5 +39,4 @@
     /// <param name="random">A random number generator.</param>
     /// <param name="permutation">The permutation to manipulate.</param>
-    /// <returns>The new manipulated permutation.</returns>
     public static void Apply(IRandom random, Permutation permutation) {
       int breakPoint1, breakPoint2;
@@ -58,5 +60,4 @@
     /// <param name="random">A random number generator.</param>
     /// <param name="permutation">The permutation to manipulate.</param>
-    /// <returns>The new manipulated permuation.</returns>
     protected override void Manipulate(IRandom random, Permutation permutation) {
       Apply(random, permutation);
Index: trunk/sources/HeuristicLab.Permutation/3.3/MaximalPreservativeCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/MaximalPreservativeCrossover.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/MaximalPreservativeCrossover.cs	(revision 2854)
@@ -34,5 +34,5 @@
   /// If the length of the permutation is smaller than 15, the size of the segment is always equal to 3.
   /// </remarks>
-  [Item("MaximalPreservativeCrossover", "An operator which performs the maximal preservative crossover on two permutations as described in Mühlenbein, H. 1991. Evolution in time and space - the parallel genetic algorithm. FOUNDATIONS OF GENETIC ALGORITHMS, pp. 316-337. Morgan Kaufmann.")]
+  [Item("MaximalPreservativeCrossover", "An operator which performs the maximal preservative crossover on two permutations.")]
   [EmptyStorableClass]
   [Creatable("Test")]
@@ -131,5 +131,4 @@
     /// </summary>
     /// <exception cref="InvalidOperationException">Thrown if there are not exactly two permutations in <paramref name="parents"/>.</exception>
-    /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
     /// <param name="parents">An array containing the two permutations that should be crossed.</param>
Index: trunk/sources/HeuristicLab.Permutation/3.3/OrderBasedCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/OrderBasedCrossover.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/OrderBasedCrossover.cs	(revision 2854)
@@ -1,5 +1,5 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -25,4 +25,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Permutation {
@@ -32,10 +33,12 @@
   /// the missing entries with the elements from the second permutation, also in the right order.
   /// </summary>
-  public class OrderBasedCrossover : PermutationCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
-    }
-
+  /// <remarks>
+  /// Implemented as described in Syswerda, G. (1991). Schedule Optimization Using Genetic Algorithms,
+  /// in Davis, L. (Ed.) Handbook of Genetic Algorithms, Van Nostrand Reinhold, New York, pp 332-349.
+  /// </remarks>
+  [Item("OrderBasedCrossover", "An operator which performs an order based crossover of two permutations.")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public class OrderBasedCrossover : PermutationCrossover {
     /// <summary>
     /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/> by
@@ -43,9 +46,11 @@
     /// other; the missing ones are picked in the correct order from the second permutation.
     /// </summary>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The parent scope 1 to cross over.</param>
-    /// <param name="parent2">The parent scope 2 to cross over.</param>
-    /// <returns>The created cross over permutation as int array.</returns>
-    public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
+    /// <exception cref="ArgumentException">Thrown when <paramref name="parent1"/> and <paramref name="parent2"/> are not of equal length.</exception>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parent1">The first parent permutation to cross.</param>
+    /// <param name="parent2">The second parent permutation to cross.</param>
+    /// <returns>The new permutation resulting from the crossover.</returns>
+    public static Permutation Apply(IRandom random, Permutation parent1, Permutation parent2) {
+      if (parent1.Length != parent2.Length) throw new ArgumentException("OrderBasedCrossover: The parent permutations are of unequal length.");
       int length = parent1.Length;
       int[] result = new int[length];
@@ -88,5 +93,5 @@
         }
       }
-      return result;
+      return new Permutation(result);
     }
 
@@ -95,10 +100,9 @@
     /// </summary>
     /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
     /// <param name="parents">An array containing the two permutations that should be crossed.</param>
-    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("ERROR in OrderBasedCrossover: The number of parents is not equal to 2");
+    /// <returns>The new permutation resulting from the crossover.</returns>
+    protected override Permutation Cross(IRandom random, ItemArray<Permutation> parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("OrderCrossover: Number of parents is not equal to 2.");
       return Apply(random, parents[0], parents[1]);
     }
Index: trunk/sources/HeuristicLab.Permutation/3.3/OrderCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/OrderCrossover.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/OrderCrossover.cs	(revision 2854)
@@ -34,5 +34,5 @@
   /// in the order they occur.
   /// </remarks>
-  [Item("OrderCrossover", "An operator which performs an order crossover of two permutations as described in Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg.")]
+  [Item("OrderCrossover", "An operator which performs an order crossover of two permutations.")]
   [EmptyStorableClass]
   [Creatable("Test")]
Index: trunk/sources/HeuristicLab.Permutation/3.3/PartiallyMatchedCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/PartiallyMatchedCrossover.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/PartiallyMatchedCrossover.cs	(revision 2854)
@@ -33,5 +33,5 @@
   /// as the original source of the operator.
   /// </remarks>
-  [Item("PartiallyMatchedCrossover", "An operator which performs the partially matched crossover on two permutations as described in Fogel, D.B. 1988. An Evolutionary Approach to the Traveling Salesman Problem. Biological Cybernetics, 60, pp. 139-144, Springer-Verlag.")]
+  [Item("PartiallyMatchedCrossover", "An operator which performs the partially matched crossover on two permutations.")]
   [EmptyStorableClass]
   [Creatable("Test")]
@@ -92,5 +92,4 @@
     /// </summary>
     /// <exception cref="InvalidOperationException">Thrown if there are not exactly two permutations in <paramref name="parents"/>.</exception>
-    /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
     /// <param name="parents">An array containing the two permutations that should be crossed.</param>
Index: trunk/sources/HeuristicLab.Permutation/3.3/PositionBasedCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/PositionBasedCrossover.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/PositionBasedCrossover.cs	(revision 2854)
@@ -1,5 +1,5 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -25,4 +25,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Permutation {
@@ -30,19 +31,23 @@
   /// Performs a cross over permutation between two permutation arrays based on randomly chosen positions.
   /// </summary>
-  public class PositionBasedCrossover : PermutationCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
-    }
-
+  /// <remarks>
+  /// Implemented as described in Syswerda, G. (1991). Schedule Optimization Using Genetic Algorithms,
+  /// in Davis, L. (Ed.) Handbook of Genetic Algorithms, Van Nostrand Reinhold, New York, pp 332-349.
+  /// </remarks>
+  [Item("PositionBasedCrossover", "An operator which performs the position based crossover on two permutations.")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public class PositionBasedCrossover : PermutationCrossover {
     /// <summary>
     /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/>
     /// based on randomly chosen positions to define which position to take from where.
     /// </summary>
+    /// <exception cref="ArgumentException">Thrown when <paramref name="parent1"/> and <paramref name="parent2"/> are not of equal length.</exception>
     /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The permutation array of parent 1.</param>
-    /// <param name="parent2">The permutation array of parent 2.</param>
-    /// <returns>The created cross over permutation as int array.</returns>
-    public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
+    /// <param name="parent1">First parent</param>
+    /// <param name="parent2">Second Parent</param>
+    /// <returns>Child</returns>
+    public static Permutation Apply(IRandom random, Permutation parent1, Permutation parent2) {
+      if (parent1.Length != parent2.Length) throw new ArgumentException("PositionBasedCrossover: The parent permutations are of unequal length.");
       int length = parent1.Length;
       int[] result = new int[length];
@@ -74,5 +79,6 @@
         }
       }
-      return result;
+
+      return new Permutation(result);
     }
 
@@ -81,9 +87,8 @@
     /// </summary>
     /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
     /// <param name="parents">An array containing the two permutations that should be crossed.</param>
     /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+    protected override Permutation Cross(IRandom random, ItemArray<Permutation> parents) {
       if (parents.Length != 2) throw new InvalidOperationException("ERROR in PositionBasedCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
Index: trunk/sources/HeuristicLab.Permutation/3.3/ScrambleManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/ScrambleManipulator.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/ScrambleManipulator.cs	(revision 2854)
@@ -1,5 +1,5 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -24,4 +24,5 @@
 using System.Text;
 using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Permutation {
@@ -29,10 +30,12 @@
   /// Manipulates a permutation array by randomly scrambling the elements in a randomly chosen interval.
   /// </summary>
-  public class ScrambleManipulator : PermutationManipulatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
-    }
-
+  /// <remarks>
+  /// Implemented as described in Syswerda, G. (1991). Schedule Optimization Using Genetic Algorithms,
+  /// in Davis, L. (Ed.) Handbook of Genetic Algorithms, Van Nostrand Reinhold, New York, pp 332-349.
+  /// </remarks>
+  [Item("ScrambleManipulator", "An operator which manipulates a permutation array by randomly scrambling the elements in a randomly chosen interval.")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public class ScrambleManipulator : PermutationManipulator {
     /// <summary>
     /// Mixes the elements of the given <paramref name="permutation"/> randomly 
@@ -40,14 +43,14 @@
     /// </summary>
     /// <param name="random">The random number generator.</param>
-    /// <param name="permutation">The permutation array to manipulate.</param>
-    /// <returns>The new permuation array with the manipulated data.</returns>
-    public static int[] Apply(IRandom random, int[] permutation) {
-      int[] result = (int[])permutation.Clone();
+    /// <param name="permutation">The permutation to manipulate.</param>
+    public static void Apply(IRandom random, Permutation permutation) {
+      Permutation original = (Permutation)permutation.Clone();
+
       int breakPoint1, breakPoint2;
       int[] scrambledIndices, remainingIndices, temp;
       int selectedIndex, index;
 
-      breakPoint1 = random.Next(permutation.Length - 1);
-      breakPoint2 = random.Next(breakPoint1 + 1, permutation.Length);
+      breakPoint1 = random.Next(original.Length - 1);
+      breakPoint2 = random.Next(breakPoint1 + 1, original.Length);
 
       scrambledIndices = new int[breakPoint2 - breakPoint1 + 1];
@@ -73,7 +76,6 @@
 
       for (int i = 0; i <= (breakPoint2 - breakPoint1); i++) {  // scramble permutation between breakpoints
-        result[breakPoint1 + i] = permutation[breakPoint1 + scrambledIndices[i]];
+        permutation[breakPoint1 + i] = original[breakPoint1 + scrambledIndices[i]];
       }
-      return result;
     }
 
@@ -83,10 +85,8 @@
     /// </summary>
     /// <remarks>Calls <see cref="Apply"/>.</remarks>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="permutation">The permutation array to manipulate.</param>
-    /// <returns>The new permuation array with the manipulated data.</returns>
-    protected override int[] Manipulate(IScope scope, IRandom random, int[] permutation) {
-      return Apply(random, permutation);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="permutation">The permutation to manipulate.</param>
+    protected override void Manipulate(IRandom random, Permutation permutation) {
+      Apply(random, permutation);
     }
   }
Index: trunk/sources/HeuristicLab.Permutation/3.3/Swap2Manipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Swap2Manipulator.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Swap2Manipulator.cs	(revision 2854)
@@ -1,5 +1,5 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -24,4 +24,5 @@
 using System.Text;
 using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Permutation {
@@ -29,28 +30,25 @@
   /// Manipulates a permutation array by swapping to randomly chosen elements.
   /// </summary>
-  public class Swap2Manipulator : PermutationManipulatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
-    }
-
+  ///   /// <remarks>
+  /// It is implemented as described in Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg.<br />
+  /// </remarks>
+  [Item("Swap2Manipulator", "An operator which manipulates a permutation array by swapping to randomly chosen elements.")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public class Swap2Manipulator : PermutationManipulator {
     /// <summary>
-    /// Swaps two randomly chosen elements in the given <paramref name="permutation"/> array.
+    /// Swaps two randomly chosen elements in the given <paramref name="permutation"/> permutation.
     /// </summary>
     /// <param name="random">The random number generator.</param>
-    /// <param name="permutation">The permutation array to manipulate.</param>
-    /// <returns>The new permuation array with the manipulated data.</returns>
-    public static int[] Apply(IRandom random, int[] permutation) {
-      int[] result = (int[])permutation.Clone();
+    /// <param name="permutation">The permutation to manipulate.</param>
+    public static void Apply(IRandom random, Permutation permutation) {
       int index1, index2, temp;
 
-      index1 = random.Next(result.Length);
-      index2 = random.Next(result.Length);
+      index1 = random.Next(permutation.Length);
+      index2 = random.Next(permutation.Length);
 
-      temp = result[index1];
-      result[index1] = result[index2];
-      result[index2] = temp;
-
-      return result;
+      temp = permutation[index1];
+      permutation[index1] = permutation[index2];
+      permutation[index2] = temp;
     }
 
@@ -59,10 +57,8 @@
     /// </summary>
     /// <remarks>Calls <see cref="Apply"/>.</remarks>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="permutation">The permutation array to manipulate.</param>
-    /// <returns>The new permuation array with the manipulated data.</returns>
-    protected override int[] Manipulate(IScope scope, IRandom random, int[] permutation) {
-      return Apply(random, permutation);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="permutation">The permutation to manipulate.</param>
+    protected override void Manipulate(IRandom random, Permutation permutation) {
+      Apply(random, permutation);
     }
   }
Index: trunk/sources/HeuristicLab.Permutation/3.3/Swap3Manipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Swap3Manipulator.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Swap3Manipulator.cs	(revision 2854)
@@ -1,5 +1,5 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -24,4 +24,5 @@
 using System.Text;
 using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Permutation {
@@ -29,44 +30,39 @@
   /// Manipulates a permutation array by swaping three randomly chosen elements.
   /// </summary>
-  public class Swap3Manipulator : PermutationManipulatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
-    }
-
+  [Item("Swap3Manipulator", "An operator which manipulates a permutation array by swaping three randomly chosen elements.")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public class Swap3Manipulator : PermutationManipulator {
     /// <summary>
     /// Swaps three randomly chosen elements of the given <paramref name="permutation"/> array.
     /// </summary>
     /// <param name="random">The random number generator.</param>
-    /// <param name="permutation">The permutation array to manipulate.</param>
-    /// <returns>The new permuation array with the manipulated data.</returns>
-    public static int[] Apply(IRandom random, int[] permutation) {
-      int[] result = (int[])permutation.Clone();
+    /// <param name="permutation">The permutation to manipulate.</param>
+    public static void Apply(IRandom random, Permutation permutation) {
       int index1, index2, index3, temp;
 
-      index1 = random.Next(result.Length);
-      index2 = random.Next(result.Length);
-      index3 = random.Next(result.Length);
+      index1 = random.Next(permutation.Length);
+      index2 = random.Next(permutation.Length);
+      index3 = random.Next(permutation.Length);
 
       if (random.NextDouble() < 0.5) {
         // swap edges 1 and 2
-        temp = result[index1];
-        result[index1] = result[index2];
-        result[index2] = temp;
+        temp = permutation[index1];
+        permutation[index1] = permutation[index2];
+        permutation[index2] = temp;
         // swap edges 2 and 3
-        temp = result[index2];
-        result[index2] = result[index3];
-        result[index3] = temp;
+        temp = permutation[index2];
+        permutation[index2] = permutation[index3];
+        permutation[index3] = temp;
       } else {
         // swap edges 1 and 3
-        temp = result[index1];
-        result[index1] = result[index3];
-        result[index3] = temp;
+        temp = permutation[index1];
+        permutation[index1] = permutation[index3];
+        permutation[index3] = temp;
         // swap edges 2 and 3
-        temp = result[index2];
-        result[index2] = result[index3];
-        result[index3] = temp;
+        temp = permutation[index2];
+        permutation[index2] = permutation[index3];
+        permutation[index3] = temp;
       }
-      return result;
     }
 
@@ -75,10 +71,8 @@
     /// </summary>
     /// <remarks>Calls <see cref="Apply"/>.</remarks>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="permutation">The permutation array to manipulate.</param>
-    /// <returns>The new permuation array with the manipulated data.</returns>
-    protected override int[] Manipulate(IScope scope, IRandom random, int[] permutation) {
-      return Apply(random, permutation);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="permutation">The permutation to manipulate.</param>
+    protected override void Manipulate(IRandom random, Permutation permutation) {
+      Apply(random, permutation);
     }
   }
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/AbsolutePositionTopologicalCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/AbsolutePositionTopologicalCrossoverTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/AbsolutePositionTopologicalCrossoverTest.cs	(revision 2854)
@@ -0,0 +1,142 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests
+{
+    
+    
+    /// <summary>
+    ///This is a test class for AbsolutePositionTopologicalCrossoverTest and is intended
+    ///to contain all AbsolutePositionTopologicalCrossoverTest Unit Tests
+    ///</summary>
+  [TestClass()]
+  public class AbsolutePositionTopologicalCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Permutation-3.3.dll")]
+    public void AbsolutePositionTopologicalCrossoverCrossTest() {
+      TestRandom random = new TestRandom();
+      AbsolutePositionTopologicalCrossover_Accessor target = 
+        new AbsolutePositionTopologicalCrossover_Accessor(new PrivateObject(typeof(AbsolutePositionTopologicalCrossover)));
+      // perform a test with more than two parents
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
+          new Permutation(4), new Permutation(4), new Permutation(4)}));
+      } catch (System.InvalidOperationException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void AbsolutePositionTopologicalCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      Permutation parent1, parent2, expected, actual;
+      random.Reset();
+      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      Assert.IsTrue(parent1.Validate());
+      parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
+      Assert.IsTrue(parent2.Validate());
+      expected = new Permutation(new int[] { 0, 1, 3, 2, 5, 7, 4, 6 });
+      Assert.IsTrue(expected.Validate());
+      actual = AbsolutePositionTopologicalCrossover.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 {
+        AbsolutePositionTopologicalCrossover.Apply(random, new Permutation(8), new Permutation(6));
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for AbsolutePositionTopologicalCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void AbsolutePositionTopologicalCrossoverConstructorTest() {
+      AbsolutePositionTopologicalCrossover target = new AbsolutePositionTopologicalCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/Auxiliary.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/Auxiliary.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/Auxiliary.cs	(revision 2854)
@@ -1,3 +1,24 @@
-﻿using System;
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
 using System.Collections.Generic;
 using System.Linq;
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/CosaCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/CosaCrossoverTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/CosaCrossoverTest.cs	(revision 2854)
@@ -0,0 +1,143 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests
+{
+    
+    
+    /// <summary>
+    ///This is a test class for CosaCrossoverTest and is intended
+    ///to contain all CosaCrossoverTest Unit Tests
+    ///</summary>
+  [TestClass()]
+  public class CosaCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Permutation-3.3.dll")]
+    public void CosaCrossoverCrossTest() {
+      TestRandom random = new TestRandom();
+      CosaCrossover_Accessor target = 
+        new CosaCrossover_Accessor(new PrivateObject(typeof(CosaCrossover)));
+      // perform a test with more than two parents
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
+          new Permutation(4), new Permutation(4), new Permutation(4)}));
+      } catch (System.InvalidOperationException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void CosaCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      Permutation parent1, parent2, expected, actual;
+      random.Reset();
+      random.IntNumbers = new int[] { 4 };
+      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      Assert.IsTrue(parent1.Validate());
+      parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
+      Assert.IsTrue(parent2.Validate());
+      expected = new Permutation(new int[] { 6, 5, 7, 0, 1, 2, 3, 4 });
+      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(8), new Permutation(6));
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for CosaCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void CosaCrossoverConstructorTest() {
+      CosaCrossover target = new CosaCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/CyclicCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/CyclicCrossoverTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/CyclicCrossoverTest.cs	(revision 2854)
@@ -0,0 +1,145 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests {
+
+
+  /// <summary>
+  ///This is a test class for CyclicCrossover and is intended
+  ///to contain all CyclicCrossover Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class CyclicCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Permutation-3.3.dll")]
+    public void CyclicCrossoverCrossTest() {
+      TestRandom random = new TestRandom();
+      CyclicCrossover_Accessor target =
+        new CyclicCrossover_Accessor(new PrivateObject(typeof(CyclicCrossover)));
+      // perform a test with more than two parents
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
+          new Permutation(4), new Permutation(4), new Permutation(4)}));
+      }
+      catch (System.InvalidOperationException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void CyclicCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      Permutation parent1, parent2, 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
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.9 };
+      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      Assert.IsTrue(parent1.Validate());
+      parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
+      Assert.IsTrue(parent2.Validate());
+      expected = new Permutation(new int[] { 0, 1, 5, 3, 6, 4, 2, 7 });
+      Assert.IsTrue(expected.Validate());
+      actual = CyclicCrossover.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(8), new Permutation(6));
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for OrderCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void CyclicCrossoverConstructorTest() {
+      CyclicCrossover target = new CyclicCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/EdgeRecombinationCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/EdgeRecombinationCrossoverTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/EdgeRecombinationCrossoverTest.cs	(revision 2854)
@@ -0,0 +1,146 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests {
+
+
+  /// <summary>
+  ///This is a test class for EdgeRecombinationCrossover and is intended
+  ///to contain all EdgeRecombinationCrossover Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class EdgeRecombinationCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Permutation-3.3.dll")]
+    public void EdgeRecombinationCrossoverCrossoverCrossTest() {
+      TestRandom random = new TestRandom();
+      EdgeRecombinationCrossover_Accessor target =
+        new EdgeRecombinationCrossover_Accessor(new PrivateObject(typeof(EdgeRecombinationCrossover)));
+      // perform a test with more than two parents
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
+          new Permutation(4), new Permutation(4), new Permutation(4)}));
+      }
+      catch (System.InvalidOperationException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void EdgeRecombinationCrossoverApplyTest() {
+      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. 54-55
+      random.Reset();
+      random.IntNumbers = new int[] { 0 };
+      random.DoubleNumbers = new double[] { 0.5, 0, 0, 0 };
+      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
+      Assert.IsTrue(parent1.Validate());
+      parent2 = new Permutation(new int[] { 8, 2, 6, 7, 1, 5, 4, 0, 3 });
+      Assert.IsTrue(parent2.Validate());
+      expected = new Permutation(new int[] { 0, 4, 5, 1, 7, 6, 2, 8, 3 });
+      Assert.IsTrue(expected.Validate());
+      actual = EdgeRecombinationCrossover.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 {
+        EdgeRecombinationCrossover.Apply(random, new Permutation(8), new Permutation(6));
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for EdgeRecombinationCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void EdgeRecombinationCrossoverConstructorTest() {
+      EdgeRecombinationCrossover target = new EdgeRecombinationCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/HeuristicLab.Permutation-3.3.Tests.csproj
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/HeuristicLab.Permutation-3.3.Tests.csproj	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/HeuristicLab.Permutation-3.3.Tests.csproj	(revision 2854)
@@ -42,8 +42,23 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AbsolutePositionTopologicalCrossoverTest.cs" />
     <Compile Include="Auxiliary.cs" />
+    <Compile Include="CosaCrossoverTest.cs" />
+    <Compile Include="CyclicCrossoverTest.cs" />
+    <Compile Include="EdgeRecombinationCrossoverTest.cs" />
+    <Compile Include="InsertionManipulatorTest.cs" />
+    <Compile Include="InversionManipulatorTest.cs" />
+    <Compile Include="MaximalPreservativeCrossoverTest.cs" />
+    <Compile Include="OrderBasedCrossoverTest.cs" />
     <Compile Include="OrderCrossoverTest.cs" />
+    <Compile Include="PartiallyMatchedCrossoverTest.cs" />
+    <Compile Include="PositionBasedCrossoverTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Random.cs" />
+    <Compile Include="ScrambleManipulatorTest.cs" />
+    <Compile Include="Swap2ManipulatorTest.cs" />
+    <Compile Include="Swap3ManipulatorTest.cs" />
+    <Compile Include="TranslocationInversionManipulatorTest.cs" />
+    <Compile Include="TranslocationManipulatorTest.cs" />
   </ItemGroup>
   <ItemGroup>
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/InsertionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/InsertionManipulatorTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/InsertionManipulatorTest.cs	(revision 2854)
@@ -0,0 +1,122 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests {
+
+
+  /// <summary>
+  ///This is a test class for InsertionManipulator and is intended
+  ///to contain all InsertionManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class InsertionManipulatorTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void InsertionManipulatorApplyTest() {
+      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 };
+      parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      Assert.IsTrue(parent.Validate());
+      
+      expected = new Permutation(new int[] { 0, 1, 2, 4, 5, 6, 3, 7 });
+      Assert.IsTrue(expected.Validate());
+      InsertionManipulator.Apply(random, parent);
+      Assert.IsTrue(parent.Validate());
+      Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, parent));
+     
+      // perform a test when the two permutations are of unequal length
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        CyclicCrossover.Apply(random, new Permutation(8), new Permutation(6));
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for InsertionManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void InsertionManipulatorConstructorTest() {
+      InsertionManipulator target = new InsertionManipulator();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/InversionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/InversionManipulatorTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/InversionManipulatorTest.cs	(revision 2854)
@@ -0,0 +1,122 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests {
+
+
+  /// <summary>
+  ///This is a test class for InversionManipulator and is intended
+  ///to contain all InversionManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class InversionManipulatorTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    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(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
+      Assert.IsTrue(parent.Validate());
+      
+      expected = new Permutation(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));
+     
+      // perform a test when the two permutations are of unequal length
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        CyclicCrossover.Apply(random, new Permutation(8), new Permutation(6));
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for InversionManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void InversionManipulatorConstructorTest() {
+      InversionManipulator target = new InversionManipulator();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/MaximalPreservativeCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/MaximalPreservativeCrossoverTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/MaximalPreservativeCrossoverTest.cs	(revision 2854)
@@ -0,0 +1,145 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests {
+
+
+  /// <summary>
+  ///This is a test class for MaximalPreservativeCrossover and is intended
+  ///to contain all MaximalPreservativeCrossover Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class MaximalPreservativeCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Permutation-3.3.dll")]
+    public void CyclicCrossoverCrossTest() {
+      TestRandom random = new TestRandom();
+      MaximalPreservativeCrossover_Accessor target =
+        new MaximalPreservativeCrossover_Accessor(new PrivateObject(typeof(MaximalPreservativeCrossover)));
+      // perform a test with more than two parents
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
+          new Permutation(4), new Permutation(4), new Permutation(4)}));
+      }
+      catch (System.InvalidOperationException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    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(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      Assert.IsTrue(parent1.Validate());
+      parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
+      Assert.IsTrue(parent2.Validate());
+      expected = new Permutation(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(8), new Permutation(6));
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for OrderCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void MaximalPreservativeCrossoverConstructorTest() {
+      MaximalPreservativeCrossover target = new MaximalPreservativeCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/OrderBasedCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/OrderBasedCrossoverTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/OrderBasedCrossoverTest.cs	(revision 2854)
@@ -0,0 +1,142 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests
+{
+    
+    
+    /// <summary>
+    ///This is a test class for OrderBasedCrossoverTest and is intended
+    ///to contain all OrderBasedCrossoverTest Unit Tests
+    ///</summary>
+  [TestClass()]
+  public class OrderBasedCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Permutation-3.3.dll")]
+    public void OrderBasedCrossoverCrossTest() {
+      TestRandom random = new TestRandom();
+      OrderBasedCrossover_Accessor target = 
+        new OrderBasedCrossover_Accessor(new PrivateObject(typeof(OrderBasedCrossover)));
+      // perform a test with more than two parents
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
+          new Permutation(4), new Permutation(4), new Permutation(4)}));
+      } catch (System.InvalidOperationException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void OrderBasedCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      Permutation parent1, parent2, 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
+      random.Reset();
+      random.IntNumbers = new int[] { 3, 5, 2, 1 };
+      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      Assert.IsTrue(parent1.Validate());
+      parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
+      Assert.IsTrue(parent2.Validate());
+      expected = new Permutation(new int[] { 1, 3, 2, 7, 6, 4, 5, 0 });
+      actual = OrderBasedCrossover.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 {
+        OrderBasedCrossover.Apply(random, new Permutation(8), new Permutation(6));
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for OrderBasedCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void OrderBasedCrossoverConstructorTest() {
+      OrderBasedCrossover target = new OrderBasedCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/OrderCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/OrderCrossoverTest.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/OrderCrossoverTest.cs	(revision 2854)
@@ -1,3 +1,24 @@
-﻿using HeuristicLab.Permutation;
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using HeuristicLab.Core;
@@ -68,89 +89,13 @@
     public void OrderCrossoverCrossTest() {
       TestRandom random = new TestRandom();
-      Permutation parent1, parent2, expected, actual;
-      ItemArray<Permutation> parents;
-      OrderCrossover_Accessor target = new OrderCrossover_Accessor(new PrivateObject(typeof(OrderCrossover)));
-      // 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(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
-      Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 8, 2, 6, 7, 1, 5, 4, 0, 3 });
-      Assert.IsTrue(parent2.Validate());
-      parents = new ItemArray<Permutation>(new Permutation[] { parent1, parent2 });
-      expected = new Permutation(new int[] { 2, 7, 1, 3, 4, 5, 6, 0, 8 });
-      Assert.IsTrue(expected.Validate());
-      actual = target.Cross(random, parents);
-      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(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
-      Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
-      Assert.IsTrue(parent2.Validate());
-      parents = new ItemArray<Permutation>(new Permutation[] { parent1, parent2 });
-      expected = new Permutation(new int[] { 7, 6, 2, 3, 4, 0, 1, 5 });
-      actual = target.Cross(random, parents);
-      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(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
-      Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 7, 3, 0, 4, 8, 2, 5, 1, 6 });
-      Assert.IsTrue(parent2.Validate());
-      parents = new ItemArray<Permutation>(new Permutation[] { parent1, parent2 });
-      expected = new Permutation(new int[] { 0, 8, 2, 3, 4, 5, 1, 6, 7 });
-      Assert.IsTrue(expected.Validate());
-      actual = target.Cross(random, parents);
-      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(new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 });
-      Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 5, 3, 4, 0, 9, 8, 2, 7, 1, 6 });
-      Assert.IsTrue(parent2.Validate());
-      parents = new ItemArray<Permutation>(new Permutation[] { parent1, parent2 });
-      expected = new Permutation(new int[] { 2, 1, 4, 3, 7, 8, 6, 5, 0, 9 });
-      Assert.IsTrue(expected.Validate());
-      actual = target.Cross(random, parents);
-      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(new int[] { 3, 4, 8, 2, 7, 1, 6, 0, 5, 9 });
-      Assert.IsTrue(expected.Validate());
-      actual = target.Cross(random, parents);
-      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(new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 });
-      Assert.IsTrue(expected.Validate());
-      actual = target.Cross(random, parents);
-      Assert.IsTrue(actual.Validate());
-      Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
+      OrderCrossover_Accessor target = 
+        new OrderCrossover_Accessor(new PrivateObject(typeof(OrderCrossover)));
       // perform a test with more than two parents
       random.Reset();
       bool exceptionFired = false;
       try {
-        target.Cross(random, new ItemArray<Permutation>(new Permutation[] { new Permutation(4), new Permutation(4), new Permutation(4)}));
+        target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
+          new Permutation(4), new Permutation(4), new Permutation(4)}));
       } catch (System.InvalidOperationException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-      // perform a test when two permutations are of unequal length
-      random.Reset();
-      exceptionFired = false;
-      try {
-        target.Cross(random, new ItemArray<Permutation>(new Permutation[] { new Permutation(8), new Permutation(6) }));
-      } catch (System.ArgumentException) {
         exceptionFired = true;
       }
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/PartiallyMatchedCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/PartiallyMatchedCrossoverTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/PartiallyMatchedCrossoverTest.cs	(revision 2854)
@@ -0,0 +1,145 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests {
+
+
+  /// <summary>
+  ///This is a test class for PartiallyMatchedCrossover and is intended
+  ///to contain all PartiallyMatchedCrossover Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class PartiallyMatchedCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Permutation-3.3.dll")]
+    public void PartiallyMatchedCrossTest() {
+      TestRandom random = new TestRandom();
+      PartiallyMatchedCrossover_Accessor target =
+        new PartiallyMatchedCrossover_Accessor(new PrivateObject(typeof(PartiallyMatchedCrossover)));
+      // perform a test with more than two parents
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
+          new Permutation(4), new Permutation(4), new Permutation(4)}));
+      }
+      catch (System.InvalidOperationException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void PartiallyMatchedCrossoverApplyTest() {
+      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, 5 };
+      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      Assert.IsTrue(parent1.Validate());
+      parent2 = new Permutation(new int[] { 2, 6, 4, 0, 5, 7, 1, 3 });
+      Assert.IsTrue(parent2.Validate());
+      expected = new Permutation(new int[] { 2, 6, 7, 3, 4, 5, 1, 0 });
+      Assert.IsTrue(expected.Validate());
+      actual = PartiallyMatchedCrossover.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 {
+        PartiallyMatchedCrossover.Apply(random, new Permutation(8), new Permutation(6));
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for PartiallyMatchedCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void PartiallyMatchedCrossoverConstructorTest() {
+      PartiallyMatchedCrossover target = new PartiallyMatchedCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/PositionBasedCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/PositionBasedCrossoverTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/PositionBasedCrossoverTest.cs	(revision 2854)
@@ -0,0 +1,147 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests {
+  /// <summary>
+  ///This is a test class for PositionBasedCrossover and is intended
+  ///to contain all PositionBasedCrossover Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class PositionBasedCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Permutation-3.3.dll")]
+    public void PositionBasedCrossoverCrossTest() {
+      TestRandom random = new TestRandom();
+      PositionBasedCrossover_Accessor target = new PositionBasedCrossover_Accessor(
+        new PrivateObject(typeof(PositionBasedCrossover)));
+     
+      // perform a test with more than two parents
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
+          new Permutation(4), new Permutation(4), new Permutation(4) }));
+      }
+      catch (System.InvalidOperationException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Permutation-3.3.dll")]
+    public void PositionBasedCrossoverApplyTest() {
+      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, 1, 2, 5 };
+      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      Assert.IsTrue(parent1.Validate());
+      parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
+      Assert.IsTrue(parent2.Validate());
+
+      expected = new Permutation(new int[] { 0, 3, 5, 1, 2, 4, 6, 7 });
+      Assert.IsTrue(expected.Validate());
+      actual = PositionBasedCrossover.Apply(random, parent1, parent2);
+      Assert.IsTrue(actual.Validate());
+      Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
+
+      // perform a test when two permutations are of unequal length
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        PositionBasedCrossover.Apply(random, new Permutation(8), new Permutation(6));
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for PositionBasedCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void PositionBasedCrossoverConstructorTest() {
+      PositionBasedCrossover target = new PositionBasedCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/Random.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/Random.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/Random.cs	(revision 2854)
@@ -1,3 +1,24 @@
-﻿using System;
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
 using System.Collections.Generic;
 using System.Linq;
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/ScrambleManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/ScrambleManipulatorTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/ScrambleManipulatorTest.cs	(revision 2854)
@@ -0,0 +1,122 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests {
+
+
+  /// <summary>
+  ///This is a test class for ScrambleManipulator and is intended
+  ///to contain all ScrambleManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class ScrambleManipulatorTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    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(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      Assert.IsTrue(parent.Validate());
+      
+      expected = new Permutation(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));
+     
+      // perform a test when the two permutations are of unequal length
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        CyclicCrossover.Apply(random, new Permutation(8), new Permutation(6));
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for ScrambleManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void ScrambleManipulatorConstructorTest() {
+      ScrambleManipulator target = new ScrambleManipulator();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/Swap2ManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/Swap2ManipulatorTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/Swap2ManipulatorTest.cs	(revision 2854)
@@ -0,0 +1,122 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests {
+
+
+  /// <summary>
+  ///This is a test class for Swap2Manipulator and is intended
+  ///to contain all Swap2Manipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class Swap2ManipulatorTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void Swap2ManipulatorApplyTest() {
+      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, p. 45
+      random.Reset();
+      random.IntNumbers = new int[] { 1, 4 };
+      parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
+      Assert.IsTrue(parent.Validate());
+
+      expected = new Permutation(new int[] { 0, 4, 2, 3, 1, 5, 6, 7, 8 });
+      Assert.IsTrue(expected.Validate());
+      Swap2Manipulator.Apply(random, parent);
+      Assert.IsTrue(parent.Validate());
+      Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, parent));
+     
+      // perform a test when the two permutations are of unequal length
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        CyclicCrossover.Apply(random, new Permutation(8), new Permutation(6));
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Swap2Manipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void Swap2ManipulatorConstructorTest() {
+      Swap2Manipulator target = new Swap2Manipulator();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/Swap3ManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/Swap3ManipulatorTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/Swap3ManipulatorTest.cs	(revision 2854)
@@ -0,0 +1,123 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests {
+
+
+  /// <summary>
+  ///This is a test class for Swap3Manipulator and is intended
+  ///to contain all Swap3Manipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class Swap3ManipulatorTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    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(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
+      Assert.IsTrue(parent.Validate());
+
+      expected = new Permutation(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));
+     
+      // perform a test when the two permutations are of unequal length
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        CyclicCrossover.Apply(random, new Permutation(8), new Permutation(6));
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Swap3Manipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void Swap3ManipulatorConstructorTest() {
+      Swap3Manipulator target = new Swap3Manipulator();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/TranslocationInversionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/TranslocationInversionManipulatorTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/TranslocationInversionManipulatorTest.cs	(revision 2854)
@@ -0,0 +1,122 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests {
+
+
+  /// <summary>
+  ///This is a test class for TranslocationInversionManipulator and is intended
+  ///to contain all TranslocationInversionManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class TranslocationInversionManipulatorTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void TranslocationInversionManipulatorApplyTest() {
+      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[] { 2, 4, 4 };
+      parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      Assert.IsTrue(parent.Validate());
+      
+      expected = new Permutation(new int[] { 0, 1, 5, 6, 4, 3, 2, 7 });
+      Assert.IsTrue(expected.Validate());
+      TranslocationInversionManipulator.Apply(random, parent);
+      Assert.IsTrue(parent.Validate());
+      Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, parent));
+     
+      // perform a test when the two permutations are of unequal length
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        CyclicCrossover.Apply(random, new Permutation(8), new Permutation(6));
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for InversionManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void InversionManipulatorConstructorTest() {
+      TranslocationInversionManipulator target = new TranslocationInversionManipulator();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Tests/TranslocationManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Tests/TranslocationManipulatorTest.cs	(revision 2854)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Tests/TranslocationManipulatorTest.cs	(revision 2854)
@@ -0,0 +1,122 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Permutation;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Permutation.Tests {
+
+
+  /// <summary>
+  ///This is a test class for TranslocationManipulator and is intended
+  ///to contain all TranslocationManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class TranslocationManipulatorTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void TranslocationManipulatorApplyTest() {
+      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, p. 24
+      random.Reset();
+      random.IntNumbers = new int[] { 2, 4, 4 };
+      parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      Assert.IsTrue(parent.Validate());
+      
+      expected = new Permutation(new int[] { 0, 1, 5, 6, 2, 3, 4, 7 });
+      Assert.IsTrue(expected.Validate());
+      TranslocationManipulator.Apply(random, parent);
+      Assert.IsTrue(parent.Validate());
+      Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, parent));
+     
+      // perform a test when the two permutations are of unequal length
+      random.Reset();
+      bool exceptionFired = false;
+      try {
+        CyclicCrossover.Apply(random, new Permutation(8), new Permutation(6));
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for InversionManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void InversionManipulatorConstructorTest() {
+      TranslocationManipulator target = new TranslocationManipulator();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/TranslocationInversionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/TranslocationInversionManipulator.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/TranslocationInversionManipulator.cs	(revision 2854)
@@ -1,5 +1,5 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -24,4 +24,6 @@
 using System.Text;
 using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Permutation {
@@ -30,10 +32,12 @@
   /// (randomly chosen) position in the array.
   /// </summary>
-  public class TranslocationInversionManipulator : PermutationManipulatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
-    }
-
+  /// <remarks>
+  /// It is implemented as described in Fogel, D.B. (1993). Applying Evolutionary Programming to Selected TSP Problems, 
+  /// Cybernetics and Systems, 22, pp 27-36.<br />
+  /// </remarks>
+  [Item("TranslocationInversionManipulator", "An operator which inverts a randomly chosen part of a permutation and inserts it at a random position.")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public class TranslocationInversionManipulator : PermutationManipulator {
     /// <summary>
     /// Moves a randomly chosen interval of elements to another (randomly chosen) position in the given
@@ -42,12 +46,11 @@
     /// <param name="random">The random number generator.</param>
     /// <param name="permutation">The permutation array to manipulate.</param>
-    /// <returns>The new permuation array with the manipulated data.</returns>
-    public static int[] Apply(IRandom random, int[] permutation) {
-      int[] result = (int[])permutation.Clone();
+    public static void Apply(IRandom random, Permutation permutation) {
+      Permutation original = (Permutation)permutation.Clone();
       int breakPoint1, breakPoint2, insertPoint, insertPointLimit;
 
-      breakPoint1 = random.Next(permutation.Length - 1);
-      breakPoint2 = random.Next(breakPoint1 + 1, permutation.Length);
-      insertPointLimit = permutation.Length - breakPoint2 + breakPoint1 - 1;  // get insertion point in remaining part
+      breakPoint1 = random.Next(original.Length - 1);
+      breakPoint2 = random.Next(breakPoint1 + 1, original.Length);
+      insertPointLimit = original.Length - breakPoint2 + breakPoint1 - 1;  // get insertion point in remaining part
       if (insertPointLimit > 0)
         insertPoint = random.Next(insertPointLimit);
@@ -57,8 +60,8 @@
       int i = 0;  // index in new permutation
       int j = 0;  // index in old permutation
-      while (i < permutation.Length) {
+      while (i < original.Length) {
         if (i == insertPoint) {  // copy translocated area
           for (int k = breakPoint2; k >= breakPoint1; k--) {
-            result[i] = permutation[k];
+            permutation[i] = original[k];
             i++;
           }
@@ -67,11 +70,10 @@
           j = breakPoint2 + 1;
         }
-        if ((i < permutation.Length) && (j < permutation.Length)) {
-          result[i] = permutation[j];
+        if ((i < original.Length) && (j < original.Length)) {
+          permutation[i] = original[j];
           i++;
           j++;
         }
       }
-      return result;
     }
 
@@ -81,10 +83,8 @@
     /// </summary>
     /// <remarks>Calls <see cref="Apply"/>.</remarks>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="permutation">The permutation array to manipulate.</param>
-    /// <returns>The new permuation array with the manipulated data.</returns>
-    protected override int[] Manipulate(IScope scope, IRandom random, int[] permutation) {
-      return Apply(random, permutation);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="permutation">The permutation to manipulate.</param>
+    protected override void Manipulate(IRandom random, Permutation permutation) {
+      Apply(random, permutation);
     }
   }
Index: trunk/sources/HeuristicLab.Permutation/3.3/TranslocationManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/TranslocationManipulator.cs	(revision 2852)
+++ trunk/sources/HeuristicLab.Permutation/3.3/TranslocationManipulator.cs	(revision 2854)
@@ -1,5 +1,5 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -24,4 +24,5 @@
 using System.Text;
 using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Permutation {
@@ -30,10 +31,11 @@
   /// (randomly chosen) position in the array.
   /// </summary>
-  public class TranslocationManipulator : PermutationManipulatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
-    }
-
+  /// <remarks>
+  /// It is implemented as described in Michalewicz, Z. (1992), Genetic Algorithms ü Data Structures = Evolution Programs, Springer Verlag, Berlin Heidelberg.<br />
+  /// </remarks>
+  [Item("TranslocationManipulator", "An operator which Manipulates a permutation array by moving a randomly chosen interval of elements to another (randomly chosen) position in the array.")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public class TranslocationManipulator : PermutationManipulator {
     /// <summary>
     /// Moves a randomly chosen interval of elements to another (randomly chosen) position in the given
@@ -42,7 +44,6 @@
     /// <param name="random">The random number generator.</param>
     /// <param name="permutation">The permutation array to manipulate.</param>
-    /// <returns>The new permuation array with the manipulated data.</returns>
-    public static int[] Apply(IRandom random, int[] permutation) {
-      int[] result = (int[])permutation.Clone();
+    public static void Apply(IRandom random, Permutation permutation) {
+      Permutation original = (Permutation)permutation.Clone();
       int breakPoint1, breakPoint2, insertPoint, insertPointLimit;
 
@@ -57,8 +58,8 @@
       int i = 0;  // index in new permutation
       int j = 0;  // index in old permutation
-      while (i < permutation.Length) {
+      while (i < original.Length) {
         if (i == insertPoint) {  // copy translocated area
           for (int k = breakPoint1; k <= breakPoint2; k++) {
-            result[i] = permutation[k];
+            permutation[i] = original[k];
             i++;
           }
@@ -67,11 +68,10 @@
           j = breakPoint2 + 1;
         }
-        if ((i < permutation.Length) && (j < permutation.Length)) {
-          result[i] = permutation[j];
+        if ((i < original.Length) && (j < original.Length)) {
+          permutation[i] = original[j];
           i++;
           j++;
         }
       }
-      return result;
     }
 
@@ -81,10 +81,8 @@
     /// </summary>
     /// <remarks>Calls <see cref="Apply"/>.</remarks>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="permutation">The permutation array to manipulate.</param>
-    /// <returns>The new permuation array with the manipulated data.</returns>
-    protected override int[] Manipulate(IScope scope, IRandom random, int[] permutation) {
-      return Apply(random, permutation);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="permutation">The permutation to manipulate.</param>
+    protected override void Manipulate(IRandom random, Permutation permutation) {
+      Apply(random, permutation);
     }
   }
