Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/GUIEventTaskComparisonRuleTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/GUIEventTaskComparisonRuleTest.java	(revision 1125)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/GUIEventTaskComparisonRuleTest.java	(revision 1146)
@@ -13,5 +13,5 @@
 //   limitations under the License.
 
-package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+package de.ugoe.cs.autoquest.tasktrees.taskequality;
 
 import static org.junit.Assert.*;
@@ -41,9 +41,10 @@
 import de.ugoe.cs.autoquest.eventcore.gui.ValueSelection;
 import de.ugoe.cs.autoquest.keyboardmaps.VirtualKey;
-import de.ugoe.cs.autoquest.tasktrees.nodeequality.GUIEventTaskComparisonRule;
-import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
-import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+import de.ugoe.cs.autoquest.tasktrees.taskequality.EventTaskComparisonRule;
+import de.ugoe.cs.autoquest.tasktrees.taskequality.GUIEventTaskComparisonRule;
+import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory;
 import de.ugoe.cs.autoquest.test.DummyGUIElement;
 
@@ -58,5 +59,5 @@
     @Test
     public void test_isApplicable_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -64,5 +65,5 @@
         IEventType eventType1 = new StringEventType("eventType1");
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         assertTrue(rule.isApplicable(task1, task1));
@@ -74,5 +75,5 @@
     @Test
     public void test_isApplicable_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -80,9 +81,9 @@
         IEventType eventType1 = new StringEventType("eventType1");
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new StringEventType("eventType2");
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
 
         assertTrue(rule.isApplicable(task1, task2));
@@ -95,5 +96,5 @@
     @Test
     public void test_isApplicable_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -101,9 +102,9 @@
         IEventType eventType1 = new KeyboardFocusChange();
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new KeyboardFocusChange();
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
 
         assertTrue(rule.isApplicable(task1, task2));
@@ -116,5 +117,5 @@
     @Test
     public void test_isApplicable_04() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -122,9 +123,9 @@
         IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new KeyReleased(VirtualKey.LETTER_B);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
 
         assertTrue(rule.isApplicable(task1, task2));
@@ -137,5 +138,5 @@
     @Test
     public void test_isApplicable_05() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -143,9 +144,9 @@
         IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_C);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new KeyTyped(VirtualKey.LETTER_D);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
 
         assertTrue(rule.isApplicable(task1, task2));
@@ -158,5 +159,5 @@
     @Test
     public void test_isApplicable_06() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -164,9 +165,9 @@
         IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 5, 6);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.MIDDLE, 3, 1);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
 
         assertTrue(rule.isApplicable(task1, task2));
@@ -179,5 +180,5 @@
     @Test
     public void test_isApplicable_07() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -185,9 +186,9 @@
         IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.RIGHT, 4, 7);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.X, 9, 12);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
 
         assertTrue(rule.isApplicable(task1, task2));
@@ -200,5 +201,5 @@
     @Test
     public void test_isApplicable_08() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -206,9 +207,9 @@
         IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new MouseDragAndDrop(5, 6, 7, 8);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
 
         assertTrue(rule.isApplicable(task1, task2));
@@ -221,5 +222,5 @@
     @Test
     public void test_isApplicable_09() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -227,9 +228,9 @@
         IEventType eventType1 = new Scroll(1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new Scroll(3, 4);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
 
         assertTrue(rule.isApplicable(task1, task2));
@@ -242,5 +243,5 @@
     @Test
     public void test_isApplicable_10() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -249,9 +250,9 @@
         IEventType eventType1 = new TextInput("text1", inputEvents);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new TextInput("text2", inputEvents);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
 
         assertTrue(rule.isApplicable(task1, task2));
@@ -264,5 +265,5 @@
     @Test
     public void test_isApplicable_11() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -270,9 +271,9 @@
         IEventType eventType1 = new TextSelection();
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new ValueSelection<String>("value");
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
 
         assertTrue(rule.isApplicable(task1, task2));
@@ -285,5 +286,5 @@
     @Test
     public void test_isApplicable_12() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -291,7 +292,7 @@
         IEventType eventType1 = new StringEventType("eventType1");
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
-
-        ITaskTreeNode selection = treeNodeFactory.createNewSelection();
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
+
+        ITask selection = taskFactory.createNewSelection();
 
         assertFalse(rule.isApplicable(task1, selection));
@@ -304,5 +305,5 @@
     @Test
     public void test_isApplicable_13() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -310,7 +311,7 @@
         IEventType eventType1 = new StringEventType("eventType1");
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
-
-        ITaskTreeNode sequence = treeNodeFactory.createNewSequence();
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
+
+        ITask sequence = taskFactory.createNewSequence();
 
         assertFalse(rule.isApplicable(task1, sequence));
@@ -323,5 +324,5 @@
     @Test
     public void test_isApplicable_14() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -329,7 +330,7 @@
         IEventType eventType1 = new StringEventType("eventType1");
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
-
-        ITaskTreeNode iteration = treeNodeFactory.createNewIteration();
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
+
+        ITask iteration = taskFactory.createNewIteration();
 
         assertFalse(rule.isApplicable(task1, iteration));
@@ -342,5 +343,5 @@
     @Test
     public void test_isApplicable_15() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
 
         EventTaskComparisonRule rule = new EventTaskComparisonRule();
@@ -348,7 +349,7 @@
         IEventType eventType1 = new StringEventType("eventType1");
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
-
-        ITaskTreeNode optional = treeNodeFactory.createNewOptional();
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
+
+        ITask optional = taskFactory.createNewOptional();
 
         assertFalse(rule.isApplicable(task1, optional));
@@ -361,9 +362,9 @@
     @Test
     public void test_compare_KeyboardFocusChange_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyboardFocusChange();
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         assertLexicallyEqual(task1, task1);
@@ -375,12 +376,12 @@
     @Test
     public void test_compare_KeyboardFocusChange_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyboardFocusChange();
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new KeyboardFocusChange();
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertLexicallyEqual(task1, task2);
@@ -392,13 +393,13 @@
     @Test
     public void test_compare_KeyboardFocusChange_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyboardFocusChange();
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new KeyboardFocusChange();
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
         
         assertUnequal(task1, task2);
@@ -410,9 +411,9 @@
     @Test
     public void test_compare_KeyPressed_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         assertLexicallyEqual(task1, task1);
@@ -424,12 +425,12 @@
     @Test
     public void test_compare_KeyPressed_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new KeyPressed(VirtualKey.LETTER_A);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertLexicallyEqual(task1, task2);
@@ -441,12 +442,12 @@
     @Test
     public void test_compare_KeyPressed_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new KeyPressed(VirtualKey.LETTER_B);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -458,13 +459,13 @@
     @Test
     public void test_compare_KeyPressed_04() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new KeyPressed(VirtualKey.LETTER_A);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
         
         assertUnequal(task1, task2);
@@ -476,9 +477,9 @@
     @Test
     public void test_compare_KeyReleased_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyReleased(VirtualKey.LETTER_A);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         assertLexicallyEqual(task1, task1);
@@ -490,12 +491,12 @@
     @Test
     public void test_compare_KeyReleased_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyReleased(VirtualKey.LETTER_A);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new KeyReleased(VirtualKey.LETTER_A);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertLexicallyEqual(task1, task2);
@@ -507,12 +508,12 @@
     @Test
     public void test_compare_KeyReleased_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyReleased(VirtualKey.LETTER_A);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new KeyReleased(VirtualKey.LETTER_B);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -524,13 +525,13 @@
     @Test
     public void test_compare_KeyReleased_04() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyReleased(VirtualKey.LETTER_A);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new KeyReleased(VirtualKey.LETTER_A);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
         
         assertUnequal(task1, task2);
@@ -542,9 +543,9 @@
     @Test
     public void test_compare_KeyTyped_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_A);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         assertLexicallyEqual(task1, task1);
@@ -556,12 +557,12 @@
     @Test
     public void test_compare_KeyTyped_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_A);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new KeyTyped(VirtualKey.LETTER_A);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertLexicallyEqual(task1, task2);
@@ -573,12 +574,12 @@
     @Test
     public void test_compare_KeyTyped_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_A);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new KeyTyped(VirtualKey.LETTER_B);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -590,13 +591,13 @@
     @Test
     public void test_compare_KeyTyped_04() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_A);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new KeyTyped(VirtualKey.LETTER_A);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
         
         assertUnequal(task1, task2);
@@ -608,9 +609,9 @@
     @Test
     public void test_compare_MouseButtonDown_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         assertLexicallyEqual(task1, task1);
@@ -622,12 +623,12 @@
     @Test
     public void test_compare_MouseButtonDown_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertLexicallyEqual(task1, task2);
@@ -639,12 +640,12 @@
     @Test
     public void test_compare_MouseButtonDown_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 3);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -656,12 +657,12 @@
     @Test
     public void test_compare_MouseButtonDown_04() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 3, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -673,12 +674,12 @@
     @Test
     public void test_compare_MouseButtonDown_05() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.RIGHT, 1, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertUnequal(task1, task2);
@@ -690,13 +691,13 @@
     @Test
     public void test_compare_MouseButtonDown_06() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
         
         assertUnequal(task1, task2);
@@ -708,9 +709,9 @@
     @Test
     public void test_compare_MouseButtonUp_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         assertLexicallyEqual(task1, task1);
@@ -722,12 +723,12 @@
     @Test
     public void test_compare_MouseButtonUp_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertLexicallyEqual(task1, task2);
@@ -739,12 +740,12 @@
     @Test
     public void test_compare_MouseButtonUp_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 3);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -756,12 +757,12 @@
     @Test
     public void test_compare_MouseButtonUp_04() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 3, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -773,12 +774,12 @@
     @Test
     public void test_compare_MouseButtonUp_05() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.RIGHT, 1, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertUnequal(task1, task2);
@@ -790,13 +791,13 @@
     @Test
     public void test_compare_MouseButtonUp_06() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
         
         assertUnequal(task1, task2);
@@ -808,9 +809,9 @@
     @Test
     public void test_compare_MouseClick_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         assertLexicallyEqual(task1, task1);
@@ -822,12 +823,12 @@
     @Test
     public void test_compare_MouseClick_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertLexicallyEqual(task1, task2);
@@ -839,12 +840,12 @@
     @Test
     public void test_compare_MouseClick_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 3);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -856,12 +857,12 @@
     @Test
     public void test_compare_MouseClick_04() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.LEFT, 3, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -873,12 +874,12 @@
     @Test
     public void test_compare_MouseClick_05() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.RIGHT, 1, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertUnequal(task1, task2);
@@ -890,13 +891,13 @@
     @Test
     public void test_compare_MouseClick_06() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
         
         assertUnequal(task1, task2);
@@ -908,9 +909,9 @@
     @Test
     public void test_compare_MouseDoubleClick_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         assertLexicallyEqual(task1, task1);
@@ -922,12 +923,12 @@
     @Test
     public void test_compare_MouseDoubleClick_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertLexicallyEqual(task1, task2);
@@ -939,12 +940,12 @@
     @Test
     public void test_compare_MouseDoubleClick_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 3);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -956,12 +957,12 @@
     @Test
     public void test_compare_MouseDoubleClick_04() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 3, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -973,12 +974,12 @@
     @Test
     public void test_compare_MouseDoubleClick_05() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.RIGHT, 1, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertUnequal(task1, task2);
@@ -990,13 +991,13 @@
     @Test
     public void test_compare_MouseDoubleClick_06() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
         
         assertUnequal(task1, task2);
@@ -1008,9 +1009,9 @@
     @Test
     public void test_compare_MouseDragAndDrop_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         assertLexicallyEqual(task1, task1);
@@ -1022,12 +1023,12 @@
     @Test
     public void test_compare_MouseDragAndDrop_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseDragAndDrop(1, 2, 3, 4);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertLexicallyEqual(task1, task2);
@@ -1039,12 +1040,12 @@
     @Test
     public void test_compare_MouseDragAndDrop_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseDragAndDrop(5, 2, 3, 4);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -1056,12 +1057,12 @@
     @Test
     public void test_compare_MouseDragAndDrop_04() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseDragAndDrop(1, 5, 3, 4);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -1073,12 +1074,12 @@
     @Test
     public void test_compare_MouseDragAndDrop_05() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseDragAndDrop(1, 2, 5, 4);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -1090,12 +1091,12 @@
     @Test
     public void test_compare_MouseDragAndDrop_06() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseDragAndDrop(1, 2, 3, 5);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -1107,13 +1108,13 @@
     @Test
     public void test_compare_MouseDragAndDrop_07() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new MouseDragAndDrop(1, 2, 3, 4);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
         
         assertUnequal(task1, task2);
@@ -1125,9 +1126,9 @@
     @Test
     public void test_compare_Scroll_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new Scroll(1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         assertLexicallyEqual(task1, task1);
@@ -1139,12 +1140,12 @@
     @Test
     public void test_compare_Scroll_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new Scroll(1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new Scroll(1, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertLexicallyEqual(task1, task2);
@@ -1156,12 +1157,12 @@
     @Test
     public void test_compare_Scroll_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new Scroll(1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new Scroll(3, 2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -1173,12 +1174,12 @@
     @Test
     public void test_compare_Scroll_04() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new Scroll(1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new Scroll(1, 3);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -1190,13 +1191,13 @@
     @Test
     public void test_compare_Scroll_05() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new Scroll(1, 2);
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new Scroll(1, 2);
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
         
         assertUnequal(task1, task2);
@@ -1208,5 +1209,5 @@
     @Test
     public void test_compare_TextInput_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new StringEventType("eventType1");
@@ -1215,5 +1216,5 @@
         textInputEvents1.add(new Event(eventType1, eventTarget1));
         eventType1 = new TextInput("enteredText1", textInputEvents1);
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         assertLexicallyEqual(task1, task1);
@@ -1225,5 +1226,5 @@
     @Test
     public void test_compare_TextInput_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new StringEventType("eventType1");
@@ -1232,8 +1233,8 @@
         textInputEvents1.add(new Event(eventType1, eventTarget1));
         eventType1 = new TextInput("enteredText1", textInputEvents1);
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new TextInput("enteredText1", textInputEvents1);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
 
         assertLexicallyEqual(task1, task2);
@@ -1245,5 +1246,5 @@
     @Test
     public void test_compare_TextInput_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new StringEventType("eventType1");
@@ -1252,5 +1253,5 @@
         textInputEvents1.add(new Event(eventType1, eventTarget1));
         eventType1 = new TextInput("enteredText1", textInputEvents1);
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new StringEventType("eventType2");
@@ -1258,5 +1259,5 @@
         textInputEvents2.add(new Event(eventType2, eventTarget1));
         eventType2 = new TextInput("enteredText1", textInputEvents2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
 
         assertSyntacticallyEqual(task1, task2);
@@ -1268,5 +1269,5 @@
     @Test
     public void test_compare_TextInput_04() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new StringEventType("eventType1");
@@ -1275,5 +1276,5 @@
         textInputEvents1.add(new Event(eventType1, eventTarget1));
         eventType1 = new TextInput("enteredText1", textInputEvents1);
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new StringEventType("eventType2");
@@ -1281,5 +1282,5 @@
         textInputEvents2.add(new Event(eventType2, eventTarget1));
         eventType2 = new TextInput("enteredText2", textInputEvents2);
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
 
         assertSemanticallyEqual(task1, task2);
@@ -1291,5 +1292,5 @@
     @Test
     public void test_compare_TextInput_05() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new StringEventType("eventType1");
@@ -1298,8 +1299,8 @@
         textInputEvents1.add(new Event(eventType1, eventTarget1));
         eventType1 = new TextInput("enteredText1", textInputEvents1);
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
-        
-        IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType1, eventTarget2);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
+        
+        IEventTarget eventTarget2 = new DummyGUIElement("elem2");
+        ITask task2 = taskFactory.createNewEventTask(eventType1, eventTarget2);
 
         assertUnequal(task1, task2);
@@ -1311,9 +1312,9 @@
     @Test
     public void test_compare_TextSelection_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new TextSelection();
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         assertLexicallyEqual(task1, task1);
@@ -1325,12 +1326,12 @@
     @Test
     public void test_compare_TextSelection_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new TextSelection();
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new TextSelection();
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertLexicallyEqual(task1, task2);
@@ -1342,13 +1343,13 @@
     @Test
     public void test_compare_TextSelection_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new TextSelection();
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
 
         IEventType eventType2 = new TextSelection();
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
         
         assertUnequal(task1, task2);
@@ -1360,9 +1361,9 @@
     @Test
     public void test_compare_ValueSelection_01() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new ValueSelection<String>("value1");
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         assertLexicallyEqual(task1, task1);
@@ -1374,12 +1375,12 @@
     @Test
     public void test_compare_ValueSelection_02() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new ValueSelection<String>("value1");
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new ValueSelection<String>("value1");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertLexicallyEqual(task1, task2);
@@ -1391,12 +1392,12 @@
     @Test
     public void test_compare_ValueSelection_03() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new ValueSelection<String>("value1");
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new ValueSelection<String>("value2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1);
         
         assertSemanticallyEqual(task1, task2);
@@ -1408,29 +1409,29 @@
     @Test
     public void test_compare_ValueSelection_04() {
-        ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+        ITaskFactory taskFactory = new TaskFactory();
         
         IEventType eventType1 = new ValueSelection<String>("value1");
         IEventTarget eventTarget1 = new DummyGUIElement("elem1");
-        ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+        ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1);
         
         IEventType eventType2 = new ValueSelection<String>("value1");
         IEventTarget eventTarget2 = new DummyGUIElement("elem2");
-        ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
-        
-        assertUnequal(task1, task2);
-    }
-    
-    /**
-     *
-     */
-    private void assertLexicallyEqual(ITaskTreeNode task1, ITaskTreeNode task2) {
+        ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2);
+        
+        assertUnequal(task1, task2);
+    }
+    
+    /**
+     *
+     */
+    private void assertLexicallyEqual(ITask task1, ITask task2) {
         GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule();
         
-        assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, task2));
+        assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(task1, task2));
         assertTrue(rule.areLexicallyEqual(task1, task2));
         assertTrue(rule.areSyntacticallyEqual(task1, task2));
         assertTrue(rule.areSemanticallyEqual(task1, task2));
 
-        assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task2, task1));
+        assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(task2, task1));
         assertTrue(rule.areLexicallyEqual(task2, task1));
         assertTrue(rule.areSyntacticallyEqual(task2, task1));
@@ -1441,13 +1442,13 @@
      *
      */
-    private void assertSyntacticallyEqual(ITaskTreeNode task1, ITaskTreeNode task2) {
+    private void assertSyntacticallyEqual(ITask task1, ITask task2) {
         GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule();
         
-        assertEquals(NodeEquality.SYNTACTICALLY_EQUAL, rule.compare(task1, task2));
+        assertEquals(TaskEquality.SYNTACTICALLY_EQUAL, rule.compare(task1, task2));
         assertFalse(rule.areLexicallyEqual(task1, task2));
         assertTrue(rule.areSyntacticallyEqual(task1, task2));
         assertTrue(rule.areSemanticallyEqual(task1, task2));
 
-        assertEquals(NodeEquality.SYNTACTICALLY_EQUAL, rule.compare(task2, task1));
+        assertEquals(TaskEquality.SYNTACTICALLY_EQUAL, rule.compare(task2, task1));
         assertFalse(rule.areLexicallyEqual(task2, task1));
         assertTrue(rule.areSyntacticallyEqual(task2, task1));
@@ -1458,13 +1459,13 @@
      *
      */
-    private void assertSemanticallyEqual(ITaskTreeNode task1, ITaskTreeNode task2) {
+    private void assertSemanticallyEqual(ITask task1, ITask task2) {
         GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule();
         
-        assertEquals(NodeEquality.SEMANTICALLY_EQUAL, rule.compare(task1, task2));
+        assertEquals(TaskEquality.SEMANTICALLY_EQUAL, rule.compare(task1, task2));
         assertFalse(rule.areLexicallyEqual(task1, task2));
         assertFalse(rule.areSyntacticallyEqual(task1, task2));
         assertTrue(rule.areSemanticallyEqual(task1, task2));
 
-        assertEquals(NodeEquality.SEMANTICALLY_EQUAL, rule.compare(task2, task1));
+        assertEquals(TaskEquality.SEMANTICALLY_EQUAL, rule.compare(task2, task1));
         assertFalse(rule.areLexicallyEqual(task2, task1));
         assertFalse(rule.areSyntacticallyEqual(task2, task1));
@@ -1475,13 +1476,13 @@
      *
      */
-    private void assertUnequal(ITaskTreeNode task1, ITaskTreeNode task2) {
+    private void assertUnequal(ITask task1, ITask task2) {
         GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule();
         
-        assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2));
+        assertEquals(TaskEquality.UNEQUAL, rule.compare(task1, task2));
         assertFalse(rule.areLexicallyEqual(task1, task2));
         assertFalse(rule.areSyntacticallyEqual(task1, task2));
         assertFalse(rule.areSemanticallyEqual(task1, task2));
 
-        assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1));
+        assertEquals(TaskEquality.UNEQUAL, rule.compare(task2, task1));
         assertFalse(rule.areLexicallyEqual(task2, task1));
         assertFalse(rule.areSyntacticallyEqual(task2, task1));
