Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskEqualityRuleManager.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeEqualityRuleManager.java	(revision 1125)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskEqualityRuleManager.java	(revision 1146)
@@ -13,18 +13,18 @@
 //   limitations under the License.
 
-package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+package de.ugoe.cs.autoquest.tasktrees.taskequality;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
 
 /**
  * <p>
- * The node equality rule manager is capable of comparing task tree nodes based on its internal list
- * of comparison rules. The current list of rules contains the {@link NodeIdentityRule}, the
+ * The task equality rule manager is capable of comparing tasks based on its internal list
+ * of comparison rules. The current list of rules contains the {@link TaskIdentityRule}, the
  * {@link IterationComparisonRule}, the {@link SequenceComparisonRule}, and
- * {@link SelectionComparisonRule}. These rules are asked for comparing the two provided task tree
- * nodes in the mentioned order. If a rule returns a node equality other than null, this equality is
+ * {@link SelectionComparisonRule}. These rules are asked for comparing the two provided tasks
+ * in the mentioned order. If a rule returns a task equality other than null, this equality is
  * returned. Otherwise the next rule is asked.
  * </p>
@@ -33,18 +33,18 @@
  * @author 2012, last modified by $Author: patrick$
  */
-public class NodeEqualityRuleManager {
+public class TaskEqualityRuleManager {
 
     /** */
-    private List<NodeComparisonRule> mRuleIndex = null;
-
-    /**
-     * <p>
-     * initializes the node equality rule manager by filling the internal list of comparison rules.
+    private List<TaskComparisonRule> mRuleIndex = null;
+
+    /**
+     * <p>
+     * initializes the task equality rule manager by filling the internal list of comparison rules.
      * This method must be called before any other method is called on the rule manager.
      * </p>
      */
     public void init() {
-        mRuleIndex = new ArrayList<NodeComparisonRule>();
-        mRuleIndex.add(new NodeIdentityRule());
+        mRuleIndex = new ArrayList<TaskComparisonRule>();
+        mRuleIndex.add(new TaskIdentityRule());
         mRuleIndex.add(new GUIEventTaskComparisonRule());
         mRuleIndex.add(new EventTaskComparisonRule());
@@ -52,18 +52,18 @@
         mRuleIndex.add(new SequenceComparisonRule(this));
         mRuleIndex.add(new SelectionComparisonRule(this));
-        mRuleIndex.add(new NodeAndIterationComparisonRule(this));
-        mRuleIndex.add(new NodeAndSelectionComparisonRule(this));
-    }
-
-    /**
-     * <p>
-     * this method performs a comparison of the two provided task tree nodes. It iterates its
-     * internal comparison rules. If the first rule returns a node equality other than null,
+        mRuleIndex.add(new TaskAndIterationComparisonRule(this));
+        mRuleIndex.add(new TaskAndSelectionComparisonRule(this));
+    }
+
+    /**
+     * <p>
+     * this method performs a comparison of the two provided tasks. It iterates its internal
+     * comparison rules. If the first rule returns a task equality other than null,
      * this equality is returned. Otherwise the next rule is tried. If no rule returns an equality
      * <code>NodeEquality.UNEQUAL</code> is returned.
      * </p>
      * 
-     * @param node1 the first task tree node to be compared
-     * @param node2 the second task tree node to be compared
+     * @param task1 the first task to be compared
+     * @param task2 the second task to be compared
      * 
      * @return as described
@@ -72,5 +72,5 @@
      *                               manager before a call to this method.
      */
-    public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2)
+    public TaskEquality compare(ITask task1, ITask task2)
         throws IllegalStateException
     {
@@ -79,20 +79,20 @@
         }
         
-        // LOG.info("checking for equality of " + node1 + " and " + node2);
-        NodeEquality nodeEquality = null;
-
-        for (NodeComparisonRule rule : mRuleIndex) {
-            if (rule.isApplicable(node1, node2)) {
-                nodeEquality = rule.compare(node1, node2);
-                if (nodeEquality != null) {
+        // LOG.info("checking for equality of " + task1 + " and " + task2);
+        TaskEquality taskEquality = null;
+
+        for (TaskComparisonRule rule : mRuleIndex) {
+            if (rule.isApplicable(task1, task2)) {
+                taskEquality = rule.compare(task1, task2);
+                if (taskEquality != null) {
                     // LOG.warning("used rule " + rule + " for equality check");
-                    return nodeEquality;
+                    return taskEquality;
                 }
             }
         }
 
-        // LOG.warning("no rule could be applied --> handling nodes as unequal");
-
-        return NodeEquality.UNEQUAL;
+        // LOG.warning("no rule could be applied --> handling tasks as unequal");
+
+        return TaskEquality.UNEQUAL;
     }
 
@@ -107,8 +107,5 @@
      * @return
      */
-    public boolean areAtLeastEqual(ITaskTreeNode node1,
-                                   ITaskTreeNode node2,
-                                   NodeEquality  equalityLevel)
-    {
+    public boolean areAtLeastEqual(ITask task1, ITask task2, TaskEquality equalityLevel) {
         if (equalityLevel == null) {
             throw new IllegalArgumentException("required equality level must not be null");
@@ -117,13 +114,13 @@
         switch (equalityLevel) {
             case IDENTICAL:
-                return areIdentical(node1, node2);
+                return areIdentical(task1, task2);
             case LEXICALLY_EQUAL:
-                return areLexicallyEqual(node1, node2);
+                return areLexicallyEqual(task1, task2);
             case SYNTACTICALLY_EQUAL:
-                return areSyntacticallyEqual(node1, node2);
+                return areSyntacticallyEqual(task1, task2);
             case SEMANTICALLY_EQUAL:
-                return areSemanticallyEqual(node1, node2);
+                return areSemanticallyEqual(task1, task2);
             case UNEQUAL:
-                return !areSemanticallyEqual(node1, node2);
+                return !areSemanticallyEqual(task1, task2);
             default:
                 throw new IllegalArgumentException("unknown required equality: " + equalityLevel);
@@ -140,80 +137,80 @@
      * @return
      */
-    public boolean areIdentical(ITaskTreeNode node1, ITaskTreeNode node2) {
-        if (mRuleIndex == null) {
-            throw new IllegalStateException("not initialized");
-        }
-        
-        for (NodeComparisonRule rule : mRuleIndex) {
-            if (rule.isApplicable(node1, node2) && rule.areLexicallyEqual(node1, node2)) {
-                 return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * <p>
-     * TODO: comment
-     * </p>
-     *
-     * @param child1
-     * @param child2
-     * @return
-     */
-    public boolean areLexicallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
-        if (mRuleIndex == null) {
-            throw new IllegalStateException("not initialized");
-        }
-        
-        for (NodeComparisonRule rule : mRuleIndex) {
-            if (rule.isApplicable(node1, node2) && rule.areLexicallyEqual(node1, node2)) {
-                 return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * <p>
-     * TODO: comment
-     * </p>
-     *
-     * @param child1
-     * @param child2
-     * @return
-     */
-    public boolean areSyntacticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
-        if (mRuleIndex == null) {
-            throw new IllegalStateException("not initialized");
-        }
-        
-        for (NodeComparisonRule rule : mRuleIndex) {
-            if (rule.isApplicable(node1, node2) && rule.areSyntacticallyEqual(node1, node2)) {
-                 return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * <p>
-     * TODO: comment
-     * </p>
-     *
-     * @param child1
-     * @param child2
-     * @return
-     */
-    public boolean areSemanticallyEqual(ITaskTreeNode node1, ITaskTreeNode node2) {
-        if (mRuleIndex == null) {
-            throw new IllegalStateException("not initialized");
-        }
-        
-        for (NodeComparisonRule rule : mRuleIndex) {
-            if (rule.isApplicable(node1, node2) && rule.areSemanticallyEqual(node1, node2)) {
+    public boolean areIdentical(ITask task1, ITask task2) {
+        if (mRuleIndex == null) {
+            throw new IllegalStateException("not initialized");
+        }
+        
+        for (TaskComparisonRule rule : mRuleIndex) {
+            if (rule.isApplicable(task1, task2) && rule.areLexicallyEqual(task1, task2)) {
+                 return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param child1
+     * @param child2
+     * @return
+     */
+    public boolean areLexicallyEqual(ITask task1, ITask task2) {
+        if (mRuleIndex == null) {
+            throw new IllegalStateException("not initialized");
+        }
+        
+        for (TaskComparisonRule rule : mRuleIndex) {
+            if (rule.isApplicable(task1, task2) && rule.areLexicallyEqual(task1, task2)) {
+                 return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param child1
+     * @param child2
+     * @return
+     */
+    public boolean areSyntacticallyEqual(ITask task1, ITask task2) {
+        if (mRuleIndex == null) {
+            throw new IllegalStateException("not initialized");
+        }
+        
+        for (TaskComparisonRule rule : mRuleIndex) {
+            if (rule.isApplicable(task1, task2) && rule.areSyntacticallyEqual(task1, task2)) {
+                 return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param child1
+     * @param child2
+     * @return
+     */
+    public boolean areSemanticallyEqual(ITask task1, ITask task2) {
+        if (mRuleIndex == null) {
+            throw new IllegalStateException("not initialized");
+        }
+        
+        for (TaskComparisonRule rule : mRuleIndex) {
+            if (rule.isApplicable(task1, task2) && rule.areSemanticallyEqual(task1, task2)) {
                  return true;
             }
