Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/DataTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/DataTests.cs	(revision 14897)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/DataTests.cs	(revision 14897)
@@ -0,0 +1,249 @@
+﻿namespace HeuristicLab.Tests.Benchmark {
+  using System.Collections.Generic;
+  using System.Linq;
+
+  using HeuristicLab.BenchmarkSuite;
+  using HeuristicLab.BenchmarkSuite.Problems;
+
+  using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+  public class DataTests {
+    public void DataLoadedTest(BenchmarkSuiteDataDescriptor descriptor) {
+      var data = descriptor.CreateProblemData();
+
+      foreach (var example in data.Examples) {
+        Assert.AreEqual(example.InputArgs.Length + example.OutputArgs.Length, data.TotalArgumentCount);
+        var inputTypeCount = GetTypeCounterDict(data.InputArgumentTypes);
+        var outputTypeCount = GetTypeCounterDict(data.OutputArgumentTypes);
+
+        for (var i = 0; i < data.InputArgumentTypes.Length; i++)
+          TestPerArgumentType(i, example, data.InputArgumentTypes[i], inputTypeCount);
+
+        //for (var i = 0; i < data.OutputArgumentTypes.Length; i++)
+        //  TestPerArgumentType(example.OutputArgs[i], example, data.OutputArgumentTypes[i], outputTypeCount);
+      }
+    }
+
+    private IReadOnlyDictionary<ExampleArgumentType, ArgumentTypeCounter> GetTypeCounterDict(
+      ExampleArgumentType[] types) {
+      return types
+        .GroupBy(type => type)
+        .ToDictionary(group => group.Key, group => new ArgumentTypeCounter(group.Count()));
+    }
+
+    private void TestPerArgumentType(
+      int i,
+      Example example,
+      ExampleArgumentType type,
+      IReadOnlyDictionary<ExampleArgumentType, ArgumentTypeCounter> inputTypeCount) {
+
+      inputTypeCount[type].Counter++;
+      Assert.IsTrue(inputTypeCount[type].Counter < inputTypeCount[type].Total);
+    }
+
+    private class ArgumentTypeCounter {
+      public ArgumentTypeCounter(int total, int counter = 0) {
+        Total = total;
+        Counter = counter;
+      }
+      public int Total { get; set; }
+      public int Counter { get; set; }
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void Checksum() {
+      DataLoadedTest(new Checksum());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void CollatzNumbers() {
+      DataLoadedTest(new CollatzNumbers());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void CompareStringLengths() {
+      DataLoadedTest(new CompareStringLengths());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void CountOdds() {
+      DataLoadedTest(new CountOdds());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void Digits() {
+      DataLoadedTest(new Digits());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void DoubleLetters() {
+      DataLoadedTest(new DoubleLetters());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void EvenSquares() {
+      DataLoadedTest(new EvenSquares());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void ForLoopIndex() {
+      DataLoadedTest(new ForLoopIndex());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void Grades() {
+      DataLoadedTest(new Grades());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void LastIndexOfZero() {
+      DataLoadedTest(new LastIndexOfZero());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void Median() {
+      DataLoadedTest(new Median());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void MirrorImage() {
+      DataLoadedTest(new MirrorImage());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void NegativeToZero() {
+      DataLoadedTest(new NegativeToZero());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void NumberIo() {
+      DataLoadedTest(new NumberIO());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void PigLatin() {
+      DataLoadedTest(new PigLatin());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void ReplaceSpaceWithNewLine() {
+      DataLoadedTest(new ReplaceSpaceWithNewline());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void ScrabbleScore() {
+      DataLoadedTest(new ScrabbleScore());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void Smallest() {
+      DataLoadedTest(new Smallest());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void SmallOrLarge() {
+      DataLoadedTest(new SmallOrLarge());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void StringDifferences() {
+      DataLoadedTest(new StringDifferences());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void StringLengthsBackwards() {
+      DataLoadedTest(new StringLengthsBackwards());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void SumOfSquares() {
+      DataLoadedTest(new SumOfSquares());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void SuperAnagrams() {
+      DataLoadedTest(new SuperAnagrams());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void Syllables() {
+      DataLoadedTest(new Syllables());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void VectorAverage() {
+      DataLoadedTest(new VectorAverage());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void VectorSummed() {
+      DataLoadedTest(new VectorSummed());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void WallisPi() {
+      DataLoadedTest(new WallisPi());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void WordStats() {
+      DataLoadedTest(new WordStats());
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/ProblemTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/ProblemTests.cs	(revision 14875)
+++ 	(revision )
@@ -1,240 +1,0 @@
-﻿namespace HeuristicLab.Tests.Benchmark.Problem {
-  using System;
-  using System.Collections.Generic;
-  using System.Linq;
-  using System.Threading.Tasks;
-
-  using HeuristicLab.BenchmarkSuite;
-  using HeuristicLab.BenchmarkSuite.Problems;
-  using HeuristicLab.Problems.Instances;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Generators.CodeGenerator;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
-  using HeuristicLab.Random;
-
-  using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-  [TestClass]
-  public class ProblemTests {
-    [TestMethod]
-    [TestProperty("Time", "Medium")]
-    [TestCategory("ProblemTest")]
-    public void CountOdds() {
-      RandomWalk(new CountOdds());
-    }
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void Checksum() {
-    //  RandomWalk(new Checksum());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void CollatzNumbers() {
-    //  RandomWalk(new CollatzNumbers());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void CompareStringLengths() {
-    //  RandomWalk(new CompareStringLengths());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void Digits() {
-    //  RandomWalk(new Digits());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void DoubleLetters() {
-    //  RandomWalk(new DoubleLetters());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void EvenSquares() {
-    //  RandomWalk(new EvenSquares());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void ForLoopIndex() {
-    //  RandomWalk(new ForLoopIndex());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void Grades() {
-    //  RandomWalk(new Grades());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void LastIndexOfZero() {
-    //  RandomWalk(new LastIndexOfZero());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void Median() {
-    //  RandomWalk(new Median());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void MirrorImage() {
-    //  RandomWalk(new MirrorImage());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void NegativeToZero() {
-    //  RandomWalk(new NegativeToZero());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void NumberIo() {
-    //  RandomWalk(new NumberIo());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void PigLatin() {
-    //  RandomWalk(new PigLatin());
-    //}
-
-    //[TestMethod]
-    //[TestProperty("Time", "Medium")]
-    //[TestCategory("ProblemTest")]
-    //public void ReplaceSpaceWithNewLine() {
-    //  RandomWalk(new ReplaceSpaceWithNewline());
-    //}
-
-    private static void RandomWalk(IDataDescriptor descriptor) {
-      var maxProgramSizeLimit = 1024;
-      var iterations = 100;
-      var best = double.MaxValue;
-      var globalExecCounter = 0L;
-      var lockObj = new object();
-      var lockCount = new object();
-      var random = new FastRandom(1337);
-
-      Expression bestProgram = null;
-      var config = new PushConfiguration { EvalPushLimit = 4096 };
-      var pool = new PushInterpreterPool(config);
-
-      var instance = new BenchmarkSuiteInstanceProvider();
-      var data = instance.LoadData(descriptor);
-
-      Parallel.For(0u, iterations, i => {
-        var execCounter = 0L;
-        var results = new double[data.TrainingCount];
-        PushProgram program;
-
-        using (var interpreter = pool.Create(random)) {
-          program = RecursiveCodeGenerator.RandomProgram(maxProgramSizeLimit, random);
-
-          for (var j = 0; j < data.TrainingCount; j++) {
-            var example = data.Examples[i];
-
-            interpreter.BooleanStack.Push(example.InputBoolean);
-            interpreter.IntegerStack.Push(example.InputInteger);
-            interpreter.FloatStack.Push(example.InputFloat);
-
-            interpreter.Run(program);
-
-            var diff = GetDiff(example.OutputInteger, interpreter.IntegerStack)
-                       + GetDiff(example.OutputFloat, interpreter.FloatStack)
-                       + GetDiff(example.OutputBoolean, interpreter.BooleanStack);
-
-            results[j] = diff;
-
-            execCounter += interpreter.ExecCounter;
-            interpreter.Clear();
-          }
-        }
-
-        lock (lockCount) {
-          globalExecCounter += execCounter;
-        }
-
-        var avg = results.Average();
-
-        if (avg >= best) return;
-
-        lock (lockObj) {
-          if (avg < best) {
-            best = avg;
-            bestProgram = program;
-          }
-        }
-      });
-
-      var resultsTest = new double[data.TestCount];
-      Parallel.For(data.TestCount, data.TestCount, i => {
-        using (var interpreter = pool.Create()) {
-          var example = data.Examples[i];
-
-          interpreter.BooleanStack.Push(example.InputBoolean);
-          interpreter.IntegerStack.Push(example.InputInteger);
-          interpreter.FloatStack.Push(example.InputFloat);
-
-          interpreter.Run(bestProgram);
-
-          var diff = GetDiff(example.OutputInteger, interpreter.IntegerStack) +
-                     GetDiff(example.OutputFloat, interpreter.FloatStack) +
-                     GetDiff(example.OutputBoolean, interpreter.BooleanStack);
-
-          resultsTest[i] = diff;
-        }
-      });
-
-      var averageTestResult = resultsTest.Average();
-
-      Console.WriteLine("Best Training: {0}", best);
-      Console.WriteLine("Test: {0}", averageTestResult);
-      Console.WriteLine("Best trainig program: {0}", bestProgram);
-      Console.WriteLine("ExecCounter: {0}", globalExecCounter);
-    }
-
-    private static double GetDiff<T>(IReadOnlyList<T> estimated, IPushStack<T> resultStack)
-      where T : IComparable {
-      var count = Math.Min(estimated.Count, resultStack.Count);
-      var result = resultStack.Peek(count);
-      var comparableLength = Math.Min(estimated.Count, result.Length);
-      var diff = 0d;
-
-      for (var i = 0; i < comparableLength; i++) {
-        diff += Math.Abs(estimated[i].CompareTo(result[i]));
-      }
-
-      if (estimated.Count > result.Length) {
-        for (var i = comparableLength; i < estimated.Count; i++) {
-          diff += Math.Abs(estimated[i].CompareTo(default(T)));
-        }
-      }
-
-      return diff;
-    }
-  }
-}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/RandomWalkTests.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/RandomWalkTests.cs	(revision 14897)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/Benchmark/RandomWalkTests.cs	(revision 14897)
@@ -0,0 +1,266 @@
+﻿namespace HeuristicLab.Tests.Benchmark {
+  using System;
+  using System.Threading.Tasks;
+  using BenchmarkSuite;
+
+  using HeuristicLab.BenchmarkSuite.Problems;
+
+  using Microsoft.VisualStudio.TestTools.UnitTesting;
+  using Problems.ProgramSynthesis.Push.Configuration;
+  using Problems.ProgramSynthesis.Push.Expressions;
+  using Problems.ProgramSynthesis.Push.Generators.CodeGenerator;
+  using Problems.ProgramSynthesis.Push.Interpreter;
+  using Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite;
+  using Problems.ProgramSynthesis.Push.Simplifier;
+  using Problems.ProgramSynthesis.Push.Stack;
+  using Random;
+
+  [TestClass]
+  public class RandomWalkTests {
+    private static void RandomWalk(BenchmarkSuiteDataDescriptor descriptor) {
+      var iterations = 2;
+      var best = double.MaxValue;
+      var lockObj = new object();
+      var random = new MersenneTwister(1337);
+
+      var instance = new BenchmarkSuiteInstanceProvider();
+      var data = instance.LoadData(descriptor);
+      var evaluator = new PushBenchmarkSuiteEvaluator(data);
+
+      var config = new PushConfiguration {
+        EvalPushLimit = data.EvalLimit,
+        MaxPointsInProgram = data.MaxSize,
+        ErcOptions = data.ErcOptions,
+      };
+
+      config.SetEnabledStacks((StackTypes)data.EnabledDataTypes);
+
+      var pool = new PushInterpreterPool(config);
+      PushProgram bestProgram = null;
+
+      Parallel.For(0u, iterations, i => {
+        var program = RecursiveCodeGenerator.RandomProgram(data.MaxSize, random, config);
+        var avg = evaluator.EvaluateTraining(pool, program, random);
+
+        lock (lockObj) {
+          if (avg.TotalQuality < best) {
+            best = avg.TotalQuality;
+            bestProgram = program;
+          }
+        }
+      });
+
+      var averageTestResult = evaluator.EvaluateTest(pool, bestProgram, random);
+      var simplifiedProgram = Simplifier.Simplify(
+        bestProgram,
+        p => evaluator.EvaluateTraining(pool, p, random).TotalQuality);
+
+      Console.WriteLine("Training: {0}", best);
+      Console.WriteLine("RandomWalk: {0}", averageTestResult.TotalQuality);
+      Console.WriteLine("Best program (simplified): {0}", simplifiedProgram);
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void Checksum() {
+      RandomWalk(new Checksum());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void CollatzNumbers() {
+      RandomWalk(new CollatzNumbers());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void CompareStringLengths() {
+      RandomWalk(new CompareStringLengths());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void CountOdds() {
+      RandomWalk(new CountOdds());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void Digits() {
+      RandomWalk(new Digits());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void DoubleLetters() {
+      RandomWalk(new DoubleLetters());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void EvenSquares() {
+      RandomWalk(new EvenSquares());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void ForLoopIndex() {
+      RandomWalk(new ForLoopIndex());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void Grades() {
+      RandomWalk(new Grades());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void LastIndexOfZero() {
+      RandomWalk(new LastIndexOfZero());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void Median() {
+      RandomWalk(new Median());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void MirrorImage() {
+      RandomWalk(new MirrorImage());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void NegativeToZero() {
+      RandomWalk(new NegativeToZero());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void NumberIo() {
+      RandomWalk(new NumberIO());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void PigLatin() {
+      RandomWalk(new PigLatin());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void ReplaceSpaceWithNewLine() {
+      RandomWalk(new ReplaceSpaceWithNewline());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void ScrabbleScore() {
+      RandomWalk(new ScrabbleScore());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void Smallest() {
+      RandomWalk(new Smallest());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void SmallOrLarge() {
+      RandomWalk(new SmallOrLarge());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void StringDifferences() {
+      RandomWalk(new StringDifferences());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void StringLengthsBackwards() {
+      RandomWalk(new StringLengthsBackwards());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void SumOfSquares() {
+      RandomWalk(new SumOfSquares());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void SuperAnagrams() {
+      RandomWalk(new SuperAnagrams());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void Syllables() {
+      RandomWalk(new Syllables());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void VectorAverage() {
+      RandomWalk(new VectorAverage());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void VectorSummed() {
+      RandomWalk(new VectorSummed());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void WallisPi() {
+      RandomWalk(new WallisPi());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void WordStats() {
+      RandomWalk(new WordStats());
+    }
+
+    [TestMethod]
+    [TestProperty("Time", "Medium")]
+    [TestCategory("ProblemTest")]
+    public void XWordLines() {
+      RandomWalk(new XWordLines());
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/HeuristicLab.Tests.csproj
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 14875)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 14897)
@@ -71,5 +71,6 @@
   </Choose>
   <ItemGroup>
-    <Compile Include="Benchmark\ProblemTests.cs" />
+    <Compile Include="Benchmark\DataTests.cs" />
+    <Compile Include="Benchmark\RandomWalkTests.cs" />
     <Compile Include="Interpreter\Expressions\CommonTests.cs" />
     <Compile Include="Interpreter\Expressions\ExampleTests.cs" />
