Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListSolution.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListSolution.cs	(revision 9475)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListSolution.cs	(revision 9494)
@@ -40,7 +40,11 @@
     private const string TrainingNumberOfAliveRulesName = "Number of alive rules (training)";
     private const string TrainingAliveRulesName = "Alive Rules (training)";
-    //private const string TestNumberOfAliveRules = "Number of alive rules (test)";
+    private const string TestNumberOfAliveRulesName = "Number of alive rules (test)";
+    private const string TestAliveRulesName = "Alive Rules (test)";
     private const string TrainingTheoryLengthName = "Theory Length (training)";
     private const string TrainingExceptionsLengthName = "Exceptions Length (training)";
+    private const string DefaultRuleName = "Default Rule Action";
+    private const string RulesName = "Rules";
+    private const string NumberOfRulesName = "Number of Rules";
 
     public double TrainingAccuracy {
@@ -67,4 +71,24 @@
       get { return ((DoubleValue)this[TrainingExceptionsLengthName].Value).Value; }
       private set { ((DoubleValue)this[TrainingExceptionsLengthName].Value).Value = value; }
+    }
+    public int TestNumberOfAliveRules {
+      get { return ((IntValue)this[TestNumberOfAliveRulesName].Value).Value; }
+      private set { ((IntValue)this[TestNumberOfAliveRulesName].Value).Value = value; }
+    }
+    public ItemSet<Rule> TestAliveRules {
+      get { return (ItemSet<Rule>)this[TestAliveRulesName].Value; }
+      private set { this[TestAliveRulesName].Value = value; }
+    }
+    public IAction DefaultRule {
+      get { return (IAction)this[DefaultRuleName].Value; }
+      private set { this[DefaultRuleName].Value = value; }
+    }
+    public ItemList<Rule> Rules {
+      get { return (ItemList<Rule>)this[RulesName].Value; }
+      private set { this[RulesName].Value = value; }
+    }
+    public int NumberOfRules {
+      get { return ((IntValue)this[NumberOfRulesName].Value).Value; }
+      private set { ((IntValue)this[NumberOfRulesName].Value).Value = value; }
     }
 
@@ -122,4 +146,9 @@
       Add(new Result(TrainingTheoryLengthName, "", new DoubleValue()));
       Add(new Result(TrainingExceptionsLengthName, "", new DoubleValue()));
+      Add(new Result(TestNumberOfAliveRulesName, "", new IntValue()));
+      Add(new Result(TestAliveRulesName, "", new ItemSet<Rule>()));
+      Add(new Result(DefaultRuleName, model.DefaultAction));
+      Add(new Result(RulesName, new ItemList<Rule>(model.Rules)));
+      Add(new Result(NumberOfRulesName, new IntValue(model.RuleSetSize)));
 
       problemData.Changed += new EventHandler(ProblemData_Changed);
@@ -132,13 +161,19 @@
 
     private void RecalculateResults() {
+      DefaultRule = Model.DefaultAction;
+      Rules = new ItemList<Rule>(Model.Rules);
+      NumberOfRules = Model.RuleSetSize;
       var originalTrainingCondition = ProblemData.FetchInput(ProblemData.TrainingIndices);
       var originalTestCondition = ProblemData.FetchInput(ProblemData.TestIndices);
-      ItemSet<Rule> aliveRules;
-      double theoryLength;
-      var estimatedTraining = Model.Evaluate(originalTrainingCondition, out aliveRules, out theoryLength);
-      TrainingNumberOfAliveRules = aliveRules.Count + (Model.DefaultAction != null ? 1 : 0);
-      TrainingAliveRules = aliveRules;
-      TrainingTheoryLength = theoryLength;
-      var estimatedTest = Model.Evaluate(originalTestCondition);
+      ItemSet<Rule> trainingAliveRules;
+      double trainingTheoryLength;
+      var estimatedTraining = Model.Evaluate(originalTrainingCondition, out trainingAliveRules, out trainingTheoryLength);
+      TrainingNumberOfAliveRules = trainingAliveRules.Count + (Model.DefaultAction != null ? 1 : 0);
+      TrainingAliveRules = trainingAliveRules;
+      TrainingTheoryLength = trainingTheoryLength;
+      ItemSet<Rule> testAliveRules;
+      var estimatedTest = Model.Evaluate(originalTestCondition, out testAliveRules);
+      TestNumberOfAliveRules = testAliveRules.Count + (Model.DefaultAction != null ? 1 : 0);
+      TestAliveRules = testAliveRules;
 
       var originalTrainingAction = ProblemData.FetchAction(ProblemData.TrainingIndices);
