Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/DiscreteCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/DiscreteCrossover.cs	(revision 2935)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/DiscreteCrossover.cs	(revision 2936)
@@ -47,12 +47,15 @@
     public static DoubleArrayData Apply(IRandom random, ItemArray<DoubleArrayData> parents) {
       int length = parents[0].Length;
+      
+      for (int i = 0; i < parents.Length; i++) { 
+        if(parents[i].Length != length)
+          throw new ArgumentException("DiscreteCrossover: The parents' vectors are of different length.", "parents");
+      }
+      
       DoubleArrayData result = new DoubleArrayData(length);
-      try {
-        for (int i = 0; i < length; i++) {
-          result[i] = parents[random.Next(parents.Length)][i];
-        }
-      } catch (IndexOutOfRangeException) {
-        throw new ArgumentException("DiscreteCrossover: The parents' vectors are of different length.", "parents");
-      }
+      for (int i = 0; i < length; i++) {
+        result[i] = parents[random.Next(parents.Length)][i];
+      }        
+      
       return result;
     }
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/HeuristicCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/HeuristicCrossover.cs	(revision 2935)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/HeuristicCrossover.cs	(revision 2936)
@@ -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,5 +25,6 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Evolutionary;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.RealVector {
@@ -32,5 +33,23 @@
   /// of the two parents times a randomly chosen factor.
   /// </summary>
-  public class HeuristicCrossover : RealVectorCrossoverBase {
+  /// <remarks>
+  /// It is implemented as described in Wright, A.H. (1994), Genetic algorithms for real parameter optimization, Foundations of Genetic Algorithms, G.J.E. Rawlins (Ed.), Morgan Kaufmann, San Mateo, CA, 205-218.
+  /// </remarks>
+  [Item("HeuristicCrossover", "Heuristic crossover for real vectors: Takes for each position the better parent and adds the difference. It is implemented as described in Wright, A.H. (1994), Genetic algorithms for real parameter optimization, Foundations of Genetic Algorithms, G.J.E. Rawlins (Ed.), Morgan Kaufmann, San Mateo, CA, 205-218.")]
+  [EmptyStorableClass]
+  public class HeuristicCrossover : RealVectorCrossover {
+    /// <summary>
+    /// Whether the problem is a maximization or minimization problem.
+    /// </summary>
+    public ValueLookupParameter<BoolData> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolData>)Parameters["Maximization"]; }
+    }
+    /// <summary>
+    /// The quality of the parents.
+    /// </summary>
+    public SubScopesLookupParameter<DoubleData> QualityParameter {
+      get { return (SubScopesLookupParameter<DoubleData>)Parameters["Quality"]; }
+    }
+
     /// <summary>
     /// Initializes a new instance of <see cref="HeuristicCrossover"/> with two variable infos
@@ -39,11 +58,6 @@
     public HeuristicCrossover()
       : base() {
-      AddVariableInfo(new VariableInfo("Maximization", "Maximization problem", typeof(BoolData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("Quality", "Quality value", typeof(DoubleData), VariableKind.In));
-    }
-
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return "Heuristic crossover for real vectors."; }
+      Parameters.Add(new ValueLookupParameter<BoolData>("Maximization", "Whether the problem is a maximization problem or not."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleData>("Quality", "The quality values of the parents."));
     }
 
@@ -51,23 +65,21 @@
     /// Perfomrs a heuristic crossover on the two given parents.
     /// </summary>
+    /// <exception cref="ArgumentException">Thrown when two parents are not of the same length.</exception>
     /// <param name="random">The random number generator.</param>
-    /// <param name="maximization">Boolean flag whether it is a maximization problem.</param>
-    /// <param name="parent1">The first parent for the crossover operation.</param>
-    /// <param name="quality1">The quality of the first parent.</param>
-    /// <param name="parent2">The second parent for the crossover operation.</param>
-    /// <param name="quality2">The quality of the second parent.</param>
+    /// <param name="betterParent">The first parent for the crossover operation.</param>
+    /// <param name="worseParent">The second parent for the crossover operation.</param>
     /// <returns>The newly created real vector, resulting from the heuristic crossover.</returns>
-    public static double[] Apply(IRandom random, bool maximization, double[] parent1, double quality1, double[] parent2, double quality2) {
-      int length = parent1.Length;
+    public static DoubleArrayData Apply(IRandom random, DoubleArrayData betterParent, DoubleArrayData worseParent) {
+      if (betterParent.Length != worseParent.Length)
+        throw new ArgumentException("ERROR in HeuristicCrossover: the two parents are not of the same length");
+      
+      int length = betterParent.Length;
       double[] result = new double[length];
       double factor = random.NextDouble();
 
       for (int i = 0; i < length; i++) {
-        if ((maximization && (quality1 > quality2)) || ((!maximization) && (quality1 < quality2)))
-          result[i] = parent1[i] + factor * (parent1[i] - parent2[i]);
-        else
-          result[i] = parent2[i] + factor * (parent2[i] - parent1[i]);
+        result[i] = betterParent[i] + factor * (betterParent[i] - worseParent[i]);
       }
-      return result;
+      return new DoubleArrayData(result);
     }
 
@@ -75,16 +87,28 @@
     /// Performs a heuristic crossover operation for two given parent real vectors.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
+    /// <exception cref="ArgumentException">Thrown when the number of parents is not equal to 2.</exception>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when either:<br/>
+    /// <list type="bullet">
+    /// <item><description>Maximization parameter could not be found.</description></item>
+    /// <item><description>Quality parameter could not be found or the number of quality values is not equal to the number of parents.</description></item>
+    /// </list>
+    /// </exception>
     /// <param name="random">A random number generator.</param>
     /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    protected override double[] Cross(IScope scope, IRandom random, double[][] parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("ERROR in HeuristicCrossover: The number of parents is not equal to 2");
-      bool maximization = GetVariableValue<BoolData>("Maximization", scope, true).Data;
-      double quality1 = scope.SubScopes[0].GetVariableValue<DoubleData>("Quality", false).Data;
-      double quality2 = scope.SubScopes[1].GetVariableValue<DoubleData>("Quality", false).Data;
+    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+      if (parents.Length != 2) throw new ArgumentException("ERROR in HeuristicCrossover: The number of parents is not equal to 2");
 
-      return Apply(random, maximization, parents[0], quality1, parents[1], quality2);
+      if (MaximizationParameter.ActualValue == null) throw new InvalidOperationException("HeuristicCrossover: Parameter " + MaximizationParameter.ActualName + " could not be found.");
+      if (QualityParameter.ActualValue == null || QualityParameter.ActualValue.Length != parents.Length) throw new InvalidOperationException("HeuristicCrossover: Parameter " + QualityParameter.ActualName + " could not be found, or not in the same quantity as there are parents.");
+
+      ItemArray<DoubleData> qualities = QualityParameter.ActualValue;
+      bool maximization = MaximizationParameter.ActualValue.Value;
+
+      if (maximization && qualities[0].Value >= qualities[1].Value || !maximization && qualities[0].Value <= qualities[1].Value)
+        return Apply(random, parents[0], parents[1]);
+      else
+        return Apply(random, parents[1], parents[0]);
     }
   }
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/LocalCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/LocalCrossover.cs	(revision 2935)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/LocalCrossover.cs	(revision 2936)
@@ -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.Encodings.RealVector {
@@ -31,18 +32,23 @@
   /// always newly created randomly chosen factor and adds the allele of the second parent times (1 - the randomly chosen factor).
   /// </summary>
-  public class LocalCrossover : RealVectorCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return "Local crossover for real vectors."; }
-    }
-
+  /// <remarks>
+  /// It is implemented as described in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL, p. 194.
+  /// </remarks>
+  [Item("LocalCrossover", "Local crossover for real vectors: Takes for each element the allele of the first parent times a always newly created randomly chosen factor and adds the allele of the second parent times (1 - the randomly chosen factor. " +
+    "It is implemented as described in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL., p. 194.")]
+  [EmptyStorableClass]
+  public class LocalCrossover : RealVectorCrossover {
     /// <summary>
     /// Performs a local crossover on the two given parent vectors.
     /// </summary>
+    /// <exception cref="ArgumentException">Thrown when two parents are not of the same length.</exception>
     /// <param name="random">The random number generator.</param>
     /// <param name="parent1">The first parent for the crossover operation.</param>
     /// <param name="parent2">The second parent for the crossover operation.</param>
     /// <returns>The newly created real vector, resulting from the local crossover.</returns>
-    public static double[] Apply(IRandom random, double[] parent1, double[] parent2) {
+    public static DoubleArrayData Apply(IRandom random, DoubleArrayData parent1, DoubleArrayData parent2) {
+      if (parent1.Length != parent2.Length)
+        throw new ArgumentException("ERROR in LocalCrossover: the two parents are not of the same length");
+      
       double factor;
       int length = parent1.Length;
@@ -53,5 +59,5 @@
         result[i] = (factor * parent1[i]) + ((1 - factor) * parent2[i]);
       }
-      return result;
+      return new DoubleArrayData(result);
     }
 
@@ -59,11 +65,10 @@
     /// Performs a local crossover operation for two given parent real vectors.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
+    /// <exception cref="ArgumentException">Thrown if there are not exactly two parents.</exception>
     /// <param name="random">A random number generator.</param>
     /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    protected override double[] Cross(IScope scope, IRandom random, double[][] parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("ERROR in LocalCrossover: The number of parents is not equal to 2");
+    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+      if (parents.Length != 2) throw new ArgumentException("ERROR in LocalCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
     }
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/RandomConvexCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/RandomConvexCrossover.cs	(revision 2935)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/RandomConvexCrossover.cs	(revision 2936)
@@ -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.Encodings.RealVector {
@@ -32,18 +33,23 @@
   /// (1 - the randomly chosen factor).
   /// </summary>
-  public class RandomConvexCrossover : RealVectorCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return "Random convex crossover for real vectors."; }
-    }
-
+  /// <remarks>
+  /// It is implemented as described in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL, pp. 193 - 194.
+  /// </remarks>
+  [Item("RandomConvexCrossover", "Random convex crossover for real vectors: Takes for each element the allele of the first parent times a once created randomly chosen factor and adds the allele of the second parent times (1 - the randomly chosen factor). " +
+    "It is implementes as described in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL, pp. 193 - 194.")]
+  [EmptyStorableClass]
+  public class RandomConvexCrossover : RealVectorCrossover {
     /// <summary>
     /// Performs a random convex crossover on the two given parents.
     /// </summary>
+    /// <exception cref="ArgumentException">Thrown when two parents are not of the same length.</exception>
     /// <param name="random">The random number generator.</param>
     /// <param name="parent1">The first parent vector for the crossover.</param>
     /// <param name="parent2">The second parent vector for the crossover.</param>
     /// <returns>The newly created real vector, resulting from the random convex crossover.</returns>
-    public static double[] Apply(IRandom random, double[] parent1, double[] parent2) {
+    public static DoubleArrayData Apply(IRandom random, DoubleArrayData parent1, DoubleArrayData parent2) {
+      if (parent1.Length != parent2.Length)
+        throw new ArgumentException("ERROR in RandomConvexCrossover: the two parents are not of the same length");
+      
       int length = parent1.Length;
       double[] result = new double[length];
@@ -52,5 +58,5 @@
       for (int i = 0; i < length; i++)
         result[i] = (factor * parent1[i]) + ((1 - factor) * parent2[i]);
-      return result;
+      return new DoubleArrayData(result);
     }
 
@@ -58,11 +64,10 @@
     /// Performs a random convex crossover operation for two given parent real vectors.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
+    /// <exception cref="ArgumentException">Thrown if there are not exactly two parents.</exception>
     /// <param name="random">A random number generator.</param>
     /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    protected override double[] Cross(IScope scope, IRandom random, double[][] parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("ERROR in RandomConvexCrossover: The number of parents is not equal to 2");
+    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+      if (parents.Length != 2) throw new ArgumentException("ERROR in RandomConvexCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
     }
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/SimulatedBinaryCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/SimulatedBinaryCrossover.cs	(revision 2935)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/SimulatedBinaryCrossover.cs	(revision 2936)
@@ -94,10 +94,10 @@
     /// Checks number of parents, availability of the parameters and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleArrayData, DoubleData)"/>.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown when there are not exactly 2 parents or when the contiguity parameter could not be found.</exception>
+    /// <exception cref="ArgumentException">Thrown when there are not exactly 2 parents or when the contiguity parameter could not be found.</exception>
     /// <param name="random">The random number generator.</param>
     /// <param name="parents">The collection of parents (must be of size 2).</param>
     /// <returns>The real vector resulting from the crossover.</returns>
     protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("SimulatedBinaryCrossover: The number of parents is not equal to 2");
+      if (parents.Length != 2) throw new ArgumentException("SimulatedBinaryCrossover: The number of parents is not equal to 2");
       if (ContiguityParameter.ActualValue == null) throw new InvalidOperationException("SimulatedBinaryCrossover: Parameter " + ContiguityParameter.ActualName + " could not be found.");
       return Apply(random, parents[0], parents[1], ContiguityParameter.ActualValue);
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/SinglePointCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/SinglePointCrossover.cs	(revision 2935)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/SinglePointCrossover.cs	(revision 2936)
@@ -62,10 +62,11 @@
     /// <summary>
     /// Checks number of parents and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleArrayData)"/>.
-    /// </summary>
+    /// </summary> 
+    /// <exception cref="ArgumentException">Thrown when the parents' vectors are of unequal length or when <paramref name="contiguity"/> is smaller than 0.</exception>
     /// <param name="random">The pseudo random number generator to use.</param>
     /// <param name="parents">The list of parents.</param>
     /// <returns>A new real vector.</returns>
     protected override HeuristicLab.Data.DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("SinglePointCrossover: The number of parents is not equal to 2");
+      if (parents.Length != 2) throw new ArgumentException("SinglePointCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
     }
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/HeuristicLab.Encodings.RealVector-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/HeuristicLab.Encodings.RealVector-3.3.csproj	(revision 2935)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/HeuristicLab.Encodings.RealVector-3.3.csproj	(revision 2936)
@@ -93,4 +93,7 @@
     <Compile Include="Crossovers\BlendAlphaCrossover.cs" />
     <Compile Include="Crossovers\DiscreteCrossover.cs" />
+    <Compile Include="Crossovers\HeuristicCrossover.cs" />
+    <Compile Include="Crossovers\LocalCrossover.cs" />
+    <Compile Include="Crossovers\RandomConvexCrossover.cs" />
     <Compile Include="Crossovers\SimulatedBinaryCrossover.cs" />
     <Compile Include="Crossovers\SinglePointCrossover.cs">
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/PolynomialAllPositionManipulator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/PolynomialAllPositionManipulator.cs	(revision 2935)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/PolynomialAllPositionManipulator.cs	(revision 2936)
@@ -26,5 +26,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.RealVector.Manipulators {
+namespace HeuristicLab.Encodings.RealVector {
   /// <summary>
   /// Performs the polynomial manipulation on all positions in the real vector.
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/PolynomialOnePositionManipulator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/PolynomialOnePositionManipulator.cs	(revision 2935)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/PolynomialOnePositionManipulator.cs	(revision 2936)
@@ -26,5 +26,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.RealVector.Manipulators {
+namespace HeuristicLab.Encodings.RealVector {
   /// <summary>
   /// Performs the polynomial manipulation on a randomly chosen single position in the real vector.
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/BlendAlphaBetaCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/BlendAlphaBetaCrossoverTest.cs	(revision 2936)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/BlendAlphaBetaCrossoverTest.cs	(revision 2936)
@@ -0,0 +1,153 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for BlendAlphaBetaCrossoverTest and is intended
+  ///to contain all BlendAlphaBetaCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class BlendAlphaBetaCrossoverTest {
+
+
+    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.Encodings.RealVector-3.3.dll")]
+    public void BlendAlphaBetaCrossoverCrossTest() {
+      BlendAlphaBetaCrossover_Accessor target = new BlendAlphaBetaCrossover_Accessor(new PrivateObject(typeof(BlendAlphaBetaCrossover)));
+      ItemArray<DoubleArrayData> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are more than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(5), new DoubleArrayData(6), new DoubleArrayData(4) });
+      exceptionFired = false;
+      try {
+        DoubleArrayData actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      exceptionFired = false;
+      try {
+        DoubleArrayData actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void BlendAlphaBetaCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArrayData parent1, parent2, expected, actual;
+      DoubleData alpha;
+      DoubleData beta;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.5, 0.5, 0.5, 0.5, 0.5 };
+      alpha = new DoubleData(0.5);
+      beta = new DoubleData(0.5);
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArrayData(new double[] { 0.3, 0.15, 0.3, 0.35, 0.45 });
+      actual = BlendAlphaBetaCrossover.Apply(random, parent1, parent2, alpha, beta);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.25, 0.75, 0.25, 0.75, 0.25 };
+      alpha = new DoubleData(-0.25); // negative values for alpha are not allowed
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = BlendAlphaBetaCrossover.Apply(random, parent1, parent2, alpha, beta);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.25, 0.75, 0.25, 0.75, 0.25, .75 };
+      alpha = new DoubleData(0.25);
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = BlendAlphaBetaCrossover.Apply(random, parent1, parent2, alpha, beta);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for BlendAlphaBetaCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void BlendAlphaBetaCrossoverConstructorTest() {
+      BlendAlphaBetaCrossover target = new BlendAlphaBetaCrossover();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/DiscreteCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/DiscreteCrossoverTest.cs	(revision 2936)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/DiscreteCrossoverTest.cs	(revision 2936)
@@ -0,0 +1,127 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for DiscreteCrossoverTest and is intended
+  ///to contain all DiscreteCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class DiscreteCrossoverTest {
+
+
+    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.Encodings.RealVector-3.3.dll")]
+    public void DiscreteCrossoverCrossTest() {
+      DiscreteCrossover_Accessor target = new DiscreteCrossover_Accessor(new PrivateObject(typeof(DiscreteCrossover)));
+      ItemArray<DoubleArrayData> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      exceptionFired = false;
+      try {
+        DoubleArrayData actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void DiscreteCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArrayData parent1, parent2, expected, actual;
+      ItemArray<DoubleArrayData> parents;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 0, 0, 1, 0, 1 };
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      parents = new ItemArray<DoubleArrayData>( new DoubleArrayData[] { parent1, parent2 } );
+      expected = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.8 });
+      actual = DiscreteCrossover.Apply(random, parents);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 0, 0, 1, 0, 1, 0 };
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { parent1, parent2 });
+      exceptionFired = false;
+      try {
+        actual = DiscreteCrossover.Apply(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for DiscreteCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void DiscreteCrossoverConstructorTest() {
+      DiscreteCrossover target = new DiscreteCrossover();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/HeuristicCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/HeuristicCrossoverTest.cs	(revision 2936)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/HeuristicCrossoverTest.cs	(revision 2936)
@@ -0,0 +1,136 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for HeuristicCrossoverTest and is intended
+  ///to contain all HeuristicCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class HeuristicCrossoverTest {
+
+
+    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.Encodings.RealVector-3.3.dll")]
+    public void HeuristicCrossoverCrossTest() {
+      HeuristicCrossover_Accessor target = new HeuristicCrossover_Accessor(new PrivateObject(typeof(HeuristicCrossover)));
+      ItemArray<DoubleArrayData> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are more than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(5), new DoubleArrayData(6), new DoubleArrayData(4) });
+      exceptionFired = false;
+      try {
+        DoubleArrayData actual;
+        actual = target.Cross(random, parents);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      exceptionFired = false;
+      try {
+        DoubleArrayData actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void HeuristicCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArrayData parent1, parent2, expected, actual;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3 };
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArrayData(new double[] { 0.14, 0.23, 0.3, 0.59, -0.11 });
+      actual = HeuristicCrossover.Apply(random, parent1, parent2);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3 };
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = HeuristicCrossover.Apply(random, parent1, parent2);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for HeuristicCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void HeuristicCrossoverConstructorTest() {
+      HeuristicCrossover target = new HeuristicCrossover();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/HeuristicLab.Encodings.RealVector-3.3.Tests.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/HeuristicLab.Encodings.RealVector-3.3.Tests.csproj	(revision 2935)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/HeuristicLab.Encodings.RealVector-3.3.Tests.csproj	(revision 2936)
@@ -76,5 +76,17 @@
     <Compile Include="Auxiliary.cs" />
     <Compile Include="BlendAlphaCrossoverTest.cs" />
+    <Compile Include="BlendAlphaBetaCrossoverTest.cs" />
+    <Compile Include="PolynomialOnePositionManipulatorTest.cs" />
+    <Compile Include="UniformOnePositionManipulatorTest.cs" />
+    <Compile Include="PolynomialAllPositionManipulatorTest.cs" />
+    <Compile Include="MichalewiczNonUniformOnePositionManipulatorTest.cs" />
+    <Compile Include="SinglePointCrossoverTest.cs" />
+    <Compile Include="SimulatedBinaryCrossoverTest.cs" />
+    <Compile Include="RandomConvexCrossoverTest.cs" />
+    <Compile Include="LocalCrossoverTest.cs" />
+    <Compile Include="HeuristicCrossoverTest.cs" />
+    <Compile Include="DiscreteCrossoverTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="MichalewiczNonUniformAllPositionsManipulatorTest.cs" />
     <Compile Include="TestRandom.cs" />
   </ItemGroup>
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/LocalCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/LocalCrossoverTest.cs	(revision 2936)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/LocalCrossoverTest.cs	(revision 2936)
@@ -0,0 +1,136 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for LocalCrossoverTest and is intended
+  ///to contain all LocalCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class LocalCrossoverTest {
+
+
+    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.Encodings.RealVector-3.3.dll")]
+    public void LocalCrossoverCrossTest() {
+      LocalCrossover_Accessor target = new LocalCrossover_Accessor(new PrivateObject(typeof(LocalCrossover)));
+      ItemArray<DoubleArrayData> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are more than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(5), new DoubleArrayData(6), new DoubleArrayData(4) });
+      exceptionFired = false;
+      try {
+        DoubleArrayData actual;
+        actual = target.Cross(random, parents);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      exceptionFired = false;
+      try {
+        DoubleArrayData actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void LocalCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArrayData parent1, parent2, expected, actual;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3, 0.1, 0.2, 0.4, 0.23 };
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArrayData(new double[] { 0.34, 0.11, 0.3, 0.32, 0.639 });
+      actual = LocalCrossover.Apply(random, parent1, parent2);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3, 0.1, 0.2, 0.4, 0.23, 0.5};
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = LocalCrossover.Apply(random, parent1, parent2);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for LocalCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void LocalCrossoverConstructorTest() {
+      LocalCrossover target = new LocalCrossover();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/MichalewiczNonUniformAllPositionsManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/MichalewiczNonUniformAllPositionsManipulatorTest.cs	(revision 2936)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/MichalewiczNonUniformAllPositionsManipulatorTest.cs	(revision 2936)
@@ -0,0 +1,130 @@
+﻿#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 Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Encodings.RealVector;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+  /// <summary>
+  ///This is a test class for MichalewiczNonUniformAllPositionsManipulator and is intended
+  ///to contain all MichalewiczNonUniformAllPositionsManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class MichalewiczNonUniformAllPositionsManipulatorTest {
+
+
+    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 MichalewiczNonUniformAllPositionsManipulatorApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArrayData parent, expected;
+      DoubleData min, max, generationsDependency;
+      IntData currentGeneration, maximumGenerations;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.2, 0.5, 0.7, 0.8, 0.9, 0.5, 0.2, 0.5, 0.7, 0.8 };
+      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArrayData(new double[] { 0.45, 0.22, 0.3, 0.6, 0.14 });
+      min = new DoubleData(0.3);
+      max = new DoubleData(0.7);
+      generationsDependency = new DoubleData(0.1);
+      currentGeneration = new IntData(1);
+      maximumGenerations = new IntData(4);
+      MichalewiczNonUniformAllPositionsManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
+      // The following test is not based on published examples
+      exceptionFired = false;
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.2, 0.5, 0.7, 0.8, 0.9, 0.5, 0.2, 0.5, 0.7, 0.8 };
+      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      min = new DoubleData(0.3);
+      max = new DoubleData(0.7);
+      generationsDependency = new DoubleData(0.1);
+      currentGeneration = new IntData(5); //current generation > max generation
+      maximumGenerations = new IntData(4);
+      try {
+        MichalewiczNonUniformAllPositionsManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for MichalewiczNonUniformAllPositionsManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void MichalewiczNonUniformAllPositionsManipulatorConstructorTest() {
+      MichalewiczNonUniformAllPositionsManipulator target = new MichalewiczNonUniformAllPositionsManipulator();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/MichalewiczNonUniformOnePositionManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/MichalewiczNonUniformOnePositionManipulatorTest.cs	(revision 2936)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/MichalewiczNonUniformOnePositionManipulatorTest.cs	(revision 2936)
@@ -0,0 +1,132 @@
+﻿#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 Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Encodings.RealVector;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+  /// <summary>
+  ///This is a test class for MichalewiczNonUniformOnePositionManipulator and is intended
+  ///to contain all MichalewiczNonUniformOnePositionManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class MichalewiczNonUniformOnePositionManipulatorTest {
+
+
+    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 MichalewiczNonUniformOnePositionManipulatorApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArrayData parent, expected;
+      DoubleData min, max, generationsDependency;
+      IntData currentGeneration, maximumGenerations;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 3 };
+      random.DoubleNumbers = new double[] { 0.2, 0.7 };
+      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.34, 0.1 });
+      min = new DoubleData(0.3);
+      max = new DoubleData(0.7);
+      generationsDependency = new DoubleData(0.1);
+      currentGeneration = new IntData(1);
+      maximumGenerations = new IntData(4);
+      MichalewiczNonUniformOnePositionManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
+      // The following test is not based on published examples
+      exceptionFired = false;
+      random.Reset();
+      random.IntNumbers = new int[] { 3 };
+      random.DoubleNumbers = new double[] { 0.2, 0.7 };
+      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      min = new DoubleData(0.3);
+      max = new DoubleData(0.7);
+      generationsDependency = new DoubleData(0.1);
+      currentGeneration = new IntData(5); //current generation > max generation
+      maximumGenerations = new IntData(4);
+      try {
+        MichalewiczNonUniformOnePositionManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for MichalewiczNonUniformOnePositionManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void MichalewiczNonUniformOnePositionManipulatorConstructorTest() {
+      MichalewiczNonUniformOnePositionManipulator target = new MichalewiczNonUniformOnePositionManipulator();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/PolynomialAllPositionManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/PolynomialAllPositionManipulatorTest.cs	(revision 2936)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/PolynomialAllPositionManipulatorTest.cs	(revision 2936)
@@ -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 Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Encodings.RealVector;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+  /// <summary>
+  ///This is a test class for PolynomialAllPositionManipulator and is intended
+  ///to contain all PolynomialAllPositionManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class PolynomialAllPositionManipulatorTest {
+
+
+    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 PolynomialAllPositionManipulatorApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArrayData parent, expected;
+      DoubleData contiguity, maxManipulation;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.2, 0.7, 0.8, 0.01, 0.1 };
+      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArrayData(new double[] { 0.120213215256006, 0.336631954950876, 0.474551336679454, 0.322759240811056, -0.0182075293954083 });
+      contiguity = new DoubleData(0.8);
+      maxManipulation = new DoubleData(0.2);
+      PolynomialAllPositionManipulator.Apply(random, parent, contiguity, maxManipulation);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
+      // The following test is not based on published examples
+      exceptionFired = false;
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.2, 0.7, 0.8, 0.01, 0.1 };
+      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      contiguity = new DoubleData(-1); //Contiguity value < 0
+      maxManipulation = new DoubleData(0.2);
+      try {
+        PolynomialAllPositionManipulator.Apply(random, parent, contiguity, maxManipulation);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for PolynomialAllPositionManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void PolynomialAllPositionManipulatorConstructorTest() {
+      PolynomialAllPositionManipulator target = new PolynomialAllPositionManipulator();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/PolynomialOnePositionManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/PolynomialOnePositionManipulatorTest.cs	(revision 2936)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/PolynomialOnePositionManipulatorTest.cs	(revision 2936)
@@ -0,0 +1,125 @@
+﻿#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 Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Encodings.RealVector;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+  /// <summary>
+  ///This is a test class for PolynomialOnePositionManipulator and is intended
+  ///to contain all PolynomialOnePositionManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class PolynomialOnePositionManipulatorTest {
+
+
+    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 PolynomialOnePositionManipulatorApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArrayData parent, expected;
+      DoubleData contiguity, maxManipulation;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 3 };
+      random.DoubleNumbers = new double[] { 0.2 };
+      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.1261980542102, 0.1 });
+      contiguity = new DoubleData(0.2);
+      maxManipulation = new DoubleData(0.7);
+      PolynomialOnePositionManipulator.Apply(random, parent, contiguity, maxManipulation);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
+      // The following test is not based on published examples
+      exceptionFired = false;
+      random.Reset();
+      random.IntNumbers = new int[] { 3 };
+      random.DoubleNumbers = new double[] { 0.2 };
+      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      contiguity = new DoubleData(-1); //Contiguity value < 0
+      maxManipulation = new DoubleData(0.2);
+      try {
+        PolynomialOnePositionManipulator.Apply(random, parent, contiguity, maxManipulation);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for PolynomialOnePositionManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void PolynomialOnePositionManipulatorConstructorTest() {
+      PolynomialOnePositionManipulator target = new PolynomialOnePositionManipulator();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/RandomConvexCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/RandomConvexCrossoverTest.cs	(revision 2936)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/RandomConvexCrossoverTest.cs	(revision 2936)
@@ -0,0 +1,136 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for RandomConvexCrossoverTest and is intended
+  ///to contain all RandomConvexCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class RandomConvexCrossoverTest {
+
+
+    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.Encodings.RealVector-3.3.dll")]
+    public void RandomConvexCrossoverCrossTest() {
+      RandomConvexCrossover_Accessor target = new RandomConvexCrossover_Accessor(new PrivateObject(typeof(RandomConvexCrossover)));
+      ItemArray<DoubleArrayData> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are more than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(5), new DoubleArrayData(6), new DoubleArrayData(4) });
+      exceptionFired = false;
+      try {
+        DoubleArrayData actual;
+        actual = target.Cross(random, parents);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      exceptionFired = false;
+      try {
+        DoubleArrayData actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void RandomConvexCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArrayData parent1, parent2, expected, actual;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3 };
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArrayData(new double[] { 0.34, 0.13, 0.3, 0.29, 0.59 });
+      actual = RandomConvexCrossover.Apply(random, parent1, parent2);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3 };
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = RandomConvexCrossover.Apply(random, parent1, parent2);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for RandomConvexCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void RandomConvexCrossoverConstructorTest() {
+      RandomConvexCrossover target = new RandomConvexCrossover();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/SimulatedBinaryCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/SimulatedBinaryCrossoverTest.cs	(revision 2936)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/SimulatedBinaryCrossoverTest.cs	(revision 2936)
@@ -0,0 +1,153 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for SimulatedBinaryCrossoverTest and is intended
+  ///to contain all SimulatedBinaryCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class SimulatedBinaryCrossoverTest {
+
+
+    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.Encodings.RealVector-3.3.dll")]
+    public void SimulatedBinaryCrossoverCrossTest() {
+      SimulatedBinaryCrossover_Accessor target = new SimulatedBinaryCrossover_Accessor(new PrivateObject(typeof(SimulatedBinaryCrossover)));
+      ItemArray<DoubleArrayData> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are more than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(5), new DoubleArrayData(6), new DoubleArrayData(4) });
+      exceptionFired = false;
+      try {
+        DoubleArrayData actual;
+        actual = target.Cross(random, parents);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      exceptionFired = false;
+      try {
+        DoubleArrayData actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void SimulatedBinaryCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArrayData parent1, parent2, expected, actual;
+      DoubleData contiguity;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3, 0.9, 0.7, 0.2, 0.8, 0.1, 0.2, 0.3, 0.4, 0.8, 0.7 };
+      contiguity = new DoubleData(0.3);
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArrayData(new double[] { 1.11032829834638, -0.0145477755417797, 0.3, 0.5, 0.1 });
+      actual = SimulatedBinaryCrossover.Apply(random, parent1, parent2, contiguity);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3, 0.9, 0.7, 0.2, 0.8, 0.1, 0.2, 0.3, 0.4, 0.8, 0.7 };
+      contiguity = new DoubleData(0.3);
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = SimulatedBinaryCrossover.Apply(random, parent1, parent2, contiguity);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3, 0.9, 0.7, 0.2, 0.8, 0.1, 0.2, 0.3, 0.4, 0.8, 0.7 };
+      contiguity = new DoubleData(-0.3);  //  contiguity < 0
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1}); 
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = SimulatedBinaryCrossover.Apply(random, parent1, parent2, contiguity);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for SimulatedBinaryCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void SimulatedBinaryCrossoverConstructorTest() {
+      SimulatedBinaryCrossover target = new SimulatedBinaryCrossover();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/SinglePointCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/SinglePointCrossoverTest.cs	(revision 2936)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/SinglePointCrossoverTest.cs	(revision 2936)
@@ -0,0 +1,136 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for SinglePointCrossoverTest and is intended
+  ///to contain all SinglePointCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class SinglePointCrossoverTest {
+
+
+    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.Encodings.RealVector-3.3.dll")]
+    public void SinglePointCrossoverCrossTest() {
+      SinglePointCrossover_Accessor target = new SinglePointCrossover_Accessor(new PrivateObject(typeof(SinglePointCrossover)));
+      ItemArray<DoubleArrayData> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are more than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(5), new DoubleArrayData(6), new DoubleArrayData(4) });
+      exceptionFired = false;
+      try {
+        DoubleArrayData actual;
+        actual = target.Cross(random, parents);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArrayData>(new DoubleArrayData[] { new DoubleArrayData(4) });
+      exceptionFired = false;
+      try {
+        DoubleArrayData actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void SinglePointCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArrayData parent1, parent2, expected, actual;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 3 };
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.2, 0.8 });
+      actual = SinglePointCrossover.Apply(random, parent1, parent2);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 2 };
+      parent1 = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArrayData(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = SinglePointCrossover.Apply(random, parent1, parent2);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for SinglePointCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void SinglePointCrossoverConstructorTest() {
+      SinglePointCrossover target = new SinglePointCrossover();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/UniformOnePositionManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 2936)
+++ /trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 2936)
@@ -0,0 +1,109 @@
+﻿#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 Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Encodings.RealVector;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+  /// <summary>
+  ///This is a test class for UniformOnePositionManipulator and is intended
+  ///to contain all UniformOnePositionManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class UniformOnePositionManipulatorTest {
+
+
+    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 UniformOnePositionManipulatorApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArrayData parent, expected;
+      DoubleData min, max;
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 3 };
+      random.DoubleNumbers = new double[] { 0.2 };
+      parent = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArrayData(new double[] { 0.2, 0.2, 0.3, 0.3, 0.1 });
+      min = new DoubleData(0.2);
+      max = new DoubleData(0.7);
+      UniformOnePositionManipulator.Apply(random, parent, min, max);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
+    }
+
+    /// <summary>
+    ///A test for UniformOnePositionManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void UniformOnePositionManipulatorConstructorTest() {
+      UniformOnePositionManipulator target = new UniformOnePositionManipulator();
+    }
+  }
+}
