Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskSymbolBucketedMapTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskSymbolBucketedMapTest.java	(revision 1294)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskSymbolBucketedMapTest.java	(revision 1846)
@@ -34,5 +34,4 @@
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory;
 import de.ugoe.cs.autoquest.test.DummyGUIElement;
@@ -63,6 +62,6 @@
     @Test
     public void testSymbolMap_1() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
         
         assertNotNull(symbolMap);
@@ -73,13 +72,13 @@
     public void testSymbolMap_2() {
         TaskSymbolBucketedMap<String> symbolMap1 = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        ITaskInstance taskInstance = createTaskInstance("symbol");
-        symbolMap1.addSymbol(taskInstance, "value");
-        
-        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String>(symbolMap1);
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        ITask task = createTask("symbol");
+        symbolMap1.addSymbol(task, "value");
+        
+        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String>(symbolMap1);
         
         assertNotNull(symbolMap2);
-        assertSymbolMapEntries(symbolMap2, new ITaskInstance[] { taskInstance },
+        assertSymbolMapEntries(symbolMap2, new ITask[] { task },
                                new String[] { "value" });
     }
@@ -92,12 +91,12 @@
     @Test
     public void testAddSymbol_1() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        ITaskInstance taskInstance = createTaskInstance("symbol");
-        symbolMap.addSymbol(taskInstance, "value1");
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        ITask task = createTask("symbol");
+        symbolMap.addSymbol(task, "value1");
         
         assertNotNull(symbolMap);
-        assertSymbolMapEntries(symbolMap, new ITaskInstance[] { taskInstance },
+        assertSymbolMapEntries(symbolMap, new ITask[] { task },
                                new String[] { "value1" });
     }
@@ -105,14 +104,14 @@
     @Test
     public void testAddSymbol_2() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        ITaskInstance[] symbols = new ITaskInstance[entryCount];
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        ITask[] symbols = new ITask[entryCount];
         String[] values = new String[entryCount];
         
         for (int i = 0; i < entryCount; i++) {
-            symbols[i] = createTaskInstance("symbol" + i);
+            symbols[i] = createTask("symbol" + i);
             symbolMap.addSymbol(symbols[i], "value" + i);
             values[i] = "value" + i;
@@ -125,14 +124,14 @@
     @Test
     public void testAddSymbol_3() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        ITaskInstance[] symbols = new ITaskInstance[entryCount];
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        ITask[] symbols = new ITask[entryCount];
         String[] values = new String[entryCount];
         
         for (int i = 0; i < entryCount; i++) {
-            symbols[i] = createTaskInstance("symbol" + i);
+            symbols[i] = createTask("symbol" + i);
             if (i % 7 == 0) {
                 values[i] = "value" + i;
@@ -151,6 +150,6 @@
     @Test(expected = java.lang.IllegalArgumentException.class)
     public void testAddSymbol_4() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
             
         symbolMap.addSymbol(null, null);
@@ -159,6 +158,6 @@
     @Test
     public void testSize_1() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
             
         assertEquals(0, symbolMap.size());
@@ -167,8 +166,8 @@
     @Test
     public void testSize_2() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        symbolMap.addSymbol(createTask("symbol1"), "value1");
         
         assertEquals(1, symbolMap.size());
@@ -177,11 +176,11 @@
     @Test
     public void testSize_3() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
         }
         
@@ -191,15 +190,15 @@
     @Test
     public void testSize_4() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            if (i % 7 == 0) {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-            }
-            else {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            if (i % 7 == 0) {
+                symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+            }
+            else {
+                symbolMap.addSymbol(createTask("symbol" + i), null);
             }
         }
@@ -210,15 +209,15 @@
     @Test
     public void testSize_5() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-        }
-        
-        for (int i = 150; i < (entryCount - 150); i++) {
-            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+        }
+        
+        for (int i = 150; i < (entryCount - 150); i++) {
+            symbolMap.removeSymbol(createTask("symbol" + i));
         }
         
@@ -228,6 +227,6 @@
     @Test
     public void testIsEmpty_1() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
             
         assertTrue(symbolMap.isEmpty());
@@ -236,8 +235,8 @@
     @Test
     public void testIsEmpty_2() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        symbolMap.addSymbol(createTask("symbol1"), "value1");
         
         assertFalse(symbolMap.isEmpty());
@@ -246,11 +245,11 @@
     @Test
     public void testIsEmpty_3() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
         }
         
@@ -260,15 +259,15 @@
     @Test
     public void testIsEmpty_4() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            if (i % 7 == 0) {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-            }
-            else {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            if (i % 7 == 0) {
+                symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+            }
+            else {
+                symbolMap.addSymbol(createTask("symbol" + i), null);
             }
         }
@@ -279,15 +278,15 @@
     @Test
     public void testIsEmpty_5() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-        }
-        
-        for (int i = 150; i < (entryCount - 150); i++) {
-            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+        }
+        
+        for (int i = 150; i < (entryCount - 150); i++) {
+            symbolMap.removeSymbol(createTask("symbol" + i));
         }
         
@@ -297,33 +296,33 @@
     @Test
     public void testContainsSymbol_1() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        assertFalse(symbolMap.containsSymbol(createTaskInstance("symbol")));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        assertFalse(symbolMap.containsSymbol(createTask("symbol")));
     }
     
     @Test
     public void testContainsSymbol_2() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
-        
-        assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol1")));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        symbolMap.addSymbol(createTask("symbol1"), "value1");
+        
+        assertTrue(symbolMap.containsSymbol(createTask("symbol1")));
     }
     
     @Test
     public void testContainsSymbol_3() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-        }
-        
-        for (int i = 0; i < entryCount; i++) {
-            assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+        }
+        
+        for (int i = 0; i < entryCount; i++) {
+            assertTrue(symbolMap.containsSymbol(createTask("symbol" + i)));
         }
     }
@@ -331,20 +330,20 @@
     @Test
     public void testContainsSymbol_4() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            if (i % 7 == 0) {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-            }
-            else {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
-            }
-        }
-        
-        for (int i = 0; i < entryCount; i++) {
-            assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            if (i % 7 == 0) {
+                symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+            }
+            else {
+                symbolMap.addSymbol(createTask("symbol" + i), null);
+            }
+        }
+        
+        for (int i = 0; i < entryCount; i++) {
+            assertTrue(symbolMap.containsSymbol(createTask("symbol" + i)));
         }
     }
@@ -352,27 +351,27 @@
     @Test
     public void testContainsSymbol_5() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-        }
-        
-        for (int i = 150; i < (entryCount - 150); i++) {
-            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+        }
+        
+        for (int i = 150; i < (entryCount - 150); i++) {
+            symbolMap.removeSymbol(createTask("symbol" + i));
         }
         
         for (int i = 0; i < 150; i++) {
-            assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
-        }
-        
-        for (int i = 150; i < (entryCount - 150); i++) {
-            assertFalse(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
+            assertTrue(symbolMap.containsSymbol(createTask("symbol" + i)));
+        }
+        
+        for (int i = 150; i < (entryCount - 150); i++) {
+            assertFalse(symbolMap.containsSymbol(createTask("symbol" + i)));
         }
         
         for (int i = (entryCount - 150); i < entryCount; i++) {
-            assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
+            assertTrue(symbolMap.containsSymbol(createTask("symbol" + i)));
         }
     }
@@ -380,6 +379,6 @@
     @Test(expected = java.lang.IllegalArgumentException.class)
     public void testContainsSymbol_6() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
             
         symbolMap.containsSymbol(null);
@@ -388,43 +387,43 @@
     @Test
     public void testGetValue_1() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        assertNull(symbolMap.getValue(createTaskInstance("symbol")));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        assertNull(symbolMap.getValue(createTask("symbol")));
     }
     
     @Test
     public void testGetValue_2() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
-        
-        assertNotNull(symbolMap.getValue(createTaskInstance("symbol1")));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        symbolMap.addSymbol(createTask("symbol1"), "value1");
+        
+        assertNotNull(symbolMap.getValue(createTask("symbol1")));
     }
     
     @Test
     public void testGetValue_3() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        symbolMap.addSymbol(createTaskInstance("symbol1"), null);
-        
-        assertNull(symbolMap.getValue(createTaskInstance("symbol1")));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        symbolMap.addSymbol(createTask("symbol1"), null);
+        
+        assertNull(symbolMap.getValue(createTask("symbol1")));
     }
     
     @Test
     public void testGetValue_4() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-        }
-        
-        for (int i = 0; i < entryCount; i++) {
-            assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+        }
+        
+        for (int i = 0; i < entryCount; i++) {
+            assertNotNull(symbolMap.getValue(createTask("symbol" + i)));
         }
     }
@@ -432,24 +431,24 @@
     @Test
     public void testGetValue_5() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            if (i % 7 == 0) {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-            }
-            else {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
-            }
-        }
-        
-        for (int i = 0; i < entryCount; i++) {
-            if (i % 7 == 0) {
-                assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
-            }
-            else {
-                assertNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            if (i % 7 == 0) {
+                symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+            }
+            else {
+                symbolMap.addSymbol(createTask("symbol" + i), null);
+            }
+        }
+        
+        for (int i = 0; i < entryCount; i++) {
+            if (i % 7 == 0) {
+                assertNotNull(symbolMap.getValue(createTask("symbol" + i)));
+            }
+            else {
+                assertNull(symbolMap.getValue(createTask("symbol" + i)));
             }
         }
@@ -458,27 +457,27 @@
     @Test
     public void testGetValue_6() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-        }
-        
-        for (int i = 150; i < (entryCount - 150); i++) {
-            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+        }
+        
+        for (int i = 150; i < (entryCount - 150); i++) {
+            symbolMap.removeSymbol(createTask("symbol" + i));
         }
         
         for (int i = 0; i < 150; i++) {
-            assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
-        }
-        
-        for (int i = 150; i < (entryCount - 150); i++) {
-            assertNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
+            assertNotNull(symbolMap.getValue(createTask("symbol" + i)));
+        }
+        
+        for (int i = 150; i < (entryCount - 150); i++) {
+            assertNull(symbolMap.getValue(createTask("symbol" + i)));
         }
         
         for (int i = (entryCount - 150); i < entryCount; i++) {
-            assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
+            assertNotNull(symbolMap.getValue(createTask("symbol" + i)));
         }
     }
@@ -486,6 +485,6 @@
     @Test(expected = java.lang.IllegalArgumentException.class)
     public void testGetValue_7() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
             
         symbolMap.getValue(null);
@@ -494,18 +493,18 @@
     @Test
     public void testRemoveSymbol_1() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        assertNull(symbolMap.removeSymbol(createTaskInstance("symbol")));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        assertNull(symbolMap.removeSymbol(createTask("symbol")));
     }
     
     @Test
     public void testRemoveSymbol_2() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
-        
-        assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol1")));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        symbolMap.addSymbol(createTask("symbol1"), "value1");
+        
+        assertNotNull(symbolMap.removeSymbol(createTask("symbol1")));
         assertEquals(0, symbolMap.size());
     }
@@ -513,10 +512,10 @@
     @Test
     public void testRemoveSymbol_3() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        symbolMap.addSymbol(createTaskInstance("symbol1"), null);
-        
-        assertNull(symbolMap.removeSymbol(createTaskInstance("symbol1")));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        symbolMap.addSymbol(createTask("symbol1"), null);
+        
+        assertNull(symbolMap.removeSymbol(createTask("symbol1")));
         assertEquals(0, symbolMap.size());
     }
@@ -524,15 +523,15 @@
     @Test
     public void testRemoveSymbol_4() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-        }
-        
-        for (int i = 0; i < entryCount; i++) {
-            assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+        }
+        
+        for (int i = 0; i < entryCount; i++) {
+            assertNotNull(symbolMap.removeSymbol(createTask("symbol" + i)));
         }
         
@@ -542,24 +541,24 @@
     @Test
     public void testRemoveSymbol_5() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            if (i % 7 == 0) {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-            }
-            else {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
-            }
-        }
-        
-        for (int i = 0; i < entryCount; i++) {
-            if (i % 7 == 0) {
-                assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
-            }
-            else {
-                assertNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            if (i % 7 == 0) {
+                symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+            }
+            else {
+                symbolMap.addSymbol(createTask("symbol" + i), null);
+            }
+        }
+        
+        for (int i = 0; i < entryCount; i++) {
+            if (i % 7 == 0) {
+                assertNotNull(symbolMap.removeSymbol(createTask("symbol" + i)));
+            }
+            else {
+                assertNull(symbolMap.removeSymbol(createTask("symbol" + i)));
             }
         }
@@ -570,27 +569,27 @@
     @Test
     public void testRemoveSymbol_6() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-        }
-        
-        for (int i = 150; i < (entryCount - 150); i++) {
-            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+        }
+        
+        for (int i = 150; i < (entryCount - 150); i++) {
+            symbolMap.removeSymbol(createTask("symbol" + i));
         }
         
         for (int i = 0; i < 150; i++) {
-            assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
-        }
-        
-        for (int i = 150; i < (entryCount - 150); i++) {
-            assertNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
+            assertNotNull(symbolMap.removeSymbol(createTask("symbol" + i)));
+        }
+        
+        for (int i = 150; i < (entryCount - 150); i++) {
+            assertNull(symbolMap.removeSymbol(createTask("symbol" + i)));
         }
         
         for (int i = (entryCount - 150); i < entryCount; i++) {
-            assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
+            assertNotNull(symbolMap.removeSymbol(createTask("symbol" + i)));
         }
         
@@ -600,6 +599,6 @@
     @Test(expected = java.lang.IllegalArgumentException.class)
     public void testRemoveSymbol_7() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
             
         symbolMap.removeSymbol(null);
@@ -608,6 +607,6 @@
     @Test
     public void testGetSymbols_1() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
             
         assertNotNull(symbolMap.getSymbols());
@@ -617,8 +616,8 @@
     @Test
     public void testGetSymbols_2() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
          
-        ITaskInstance task = createTaskInstance("symbol1");
+        ITask task = createTask("symbol1");
         symbolMap.addSymbol(task, "value1");
         
@@ -630,8 +629,8 @@
     @Test
     public void testGetSymbols_3() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        ITaskInstance task = createTaskInstance("symbol1");
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        ITask task = createTask("symbol1");
         symbolMap.addSymbol(task, null);
         
@@ -643,12 +642,12 @@
     @Test
     public void testGetSymbols_4() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        Set<ITaskInstance> expectedSymbols = new HashSet<ITaskInstance>();
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            ITaskInstance task = createTaskInstance("symbol" + i);
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        Set<ITask> expectedSymbols = new HashSet<ITask>();
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            ITask task = createTask("symbol" + i);
             symbolMap.addSymbol(task, "value" + i);
             expectedSymbols.add(task);
@@ -658,5 +657,5 @@
         assertEquals(entryCount, symbolMap.getSymbols().size());
         
-        Iterator<ITaskInstance> iterator = symbolMap.getSymbols().iterator();
+        Iterator<ITask> iterator = symbolMap.getSymbols().iterator();
         for (int i = 0; i < entryCount; i++) {
             assertTrue(iterator.hasNext());
@@ -670,12 +669,12 @@
     @Test
     public void testGetSymbols_5() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        Set<ITaskInstance> expectedSymbols = new HashSet<ITaskInstance>();
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            ITaskInstance task = createTaskInstance("symbol" + i);
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        Set<ITask> expectedSymbols = new HashSet<ITask>();
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            ITask task = createTask("symbol" + i);
             
             if (i % 7 == 0) {
@@ -692,5 +691,5 @@
         assertEquals(entryCount, symbolMap.getSymbols().size());
         
-        Iterator<ITaskInstance> iterator = symbolMap.getSymbols().iterator();
+        Iterator<ITask> iterator = symbolMap.getSymbols().iterator();
         for (int i = 0; i < entryCount; i++) {
             assertTrue(iterator.hasNext());
@@ -704,12 +703,12 @@
     @Test
     public void testGetSymbols_6() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        List<ITaskInstance> expectedSymbols = new ArrayList<ITaskInstance>();
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            ITaskInstance task = createTaskInstance("symbol" + i);
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        List<ITask> expectedSymbols = new ArrayList<ITask>();
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            ITask task = createTask("symbol" + i);
             symbolMap.addSymbol(task, "value" + i);
             expectedSymbols.add(task);
@@ -723,5 +722,5 @@
         assertEquals(2 * 150, symbolMap.getSymbols().size());
         
-        Iterator<ITaskInstance> iterator = symbolMap.getSymbols().iterator();
+        Iterator<ITask> iterator = symbolMap.getSymbols().iterator();
         for (int i = 0; i < 2 * 150; i++) {
             assertTrue(iterator.hasNext());
@@ -735,6 +734,6 @@
     @Test
     public void testGetValues_1() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
             
         assertNotNull(symbolMap.getValues());
@@ -744,8 +743,8 @@
     @Test
     public void testGetValues_2() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        symbolMap.addSymbol(createTask("symbol1"), "value1");
         
         assertNotNull(symbolMap.getValues());
@@ -756,8 +755,8 @@
     @Test
     public void testGetValues_3() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        symbolMap.addSymbol(createTaskInstance("symbol1"), null);
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        symbolMap.addSymbol(createTask("symbol1"), null);
         
         assertNotNull(symbolMap.getValues());
@@ -768,6 +767,6 @@
     @Test
     public void testGetValues_4() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
         Set<String> expectedValues = new HashSet<String>();
         
@@ -775,5 +774,5 @@
         
         for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
             expectedValues.add("value" + i);
         }
@@ -794,6 +793,6 @@
     @Test
     public void testGetValues_5() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
         Set<String> expectedValues = new HashSet<String>();
         
@@ -802,9 +801,9 @@
         for (int i = 0; i < entryCount; i++) {
             if (i % 7 == 0) {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+                symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
                 expectedValues.add("value" + i);
             }
             else {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
+                symbolMap.addSymbol(createTask("symbol" + i), null);
                 expectedValues.add(null);
             }
@@ -826,6 +825,6 @@
     @Test
     public void testGetValues_6() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
         Set<String> expectedValues = new HashSet<String>();
         
@@ -833,10 +832,10 @@
         
         for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
             expectedValues.add("value" + i);
         }
         
         for (int i = 150; i < (entryCount - 150); i++) {
-            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
+            symbolMap.removeSymbol(createTask("symbol" + i));
             expectedValues.remove("value" + i);
         }
@@ -857,6 +856,6 @@
     @Test
     public void testClear_1() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
         
         symbolMap.clear();
@@ -866,8 +865,8 @@
     @Test
     public void testClear_2() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        symbolMap.addSymbol(createTask("symbol1"), "value1");
         
         symbolMap.clear();
@@ -877,8 +876,8 @@
     @Test
     public void testClear_3() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        symbolMap.addSymbol(createTaskInstance("symbol1"), null);
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        symbolMap.addSymbol(createTask("symbol1"), null);
         
         symbolMap.clear();
@@ -888,11 +887,11 @@
     @Test
     public void testClear_4() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
         }
         
@@ -903,15 +902,15 @@
     @Test
     public void testClear_5() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            if (i % 7 == 0) {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-            }
-            else {
-                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            if (i % 7 == 0) {
+                symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+            }
+            else {
+                symbolMap.addSymbol(createTask("symbol" + i), null);
             }
         }
@@ -923,15 +922,15 @@
     @Test
     public void testClear_6() {
-        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        int entryCount = 2000;
-        
-        for (int i = 0; i < entryCount; i++) {
-            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
-        }
-        
-        for (int i = 150; i < (entryCount - 150); i++) {
-            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
+        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        int entryCount = 2000;
+        
+        for (int i = 0; i < entryCount; i++) {
+            symbolMap.addSymbol(createTask("symbol" + i), "value" + i);
+        }
+        
+        for (int i = 150; i < (entryCount - 150); i++) {
+            symbolMap.removeSymbol(createTask("symbol" + i));
         }
         
@@ -942,9 +941,9 @@
     @Test
     public void testEquals_1() {
-        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
         
         assertTrue(symbolMap1.equals(symbolMap2));
@@ -953,11 +952,11 @@
     @Test
     public void testEquals_2() {
-        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        symbolMap1.addSymbol(createTaskInstance("symbol1"), "value1");
+        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        symbolMap1.addSymbol(createTask("symbol1"), "value1");
         
         assertFalse(symbolMap1.equals(symbolMap2));
@@ -966,11 +965,11 @@
     @Test
     public void testEquals_3() {
-        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-            
-        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
-        
-        ITaskInstance task = createTaskInstance("symbol1");
+        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+            
+        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        
+        ITask task = createTask("symbol1");
         symbolMap1.addSymbol(task, "value1");
         symbolMap2.addSymbol(task, "value1");
@@ -981,14 +980,14 @@
     @Test
     public void testEquals_4() {
-        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
                 
-        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
         
         int entryCount = 1000;
         
         for (int i = 0; i < entryCount; i++) {
-            ITaskInstance task = createTaskInstance("symbol1");
+            ITask task = createTask("symbol1");
             symbolMap1.addSymbol(task, "value" + i);
             assertFalse(symbolMap1.equals(symbolMap2));
@@ -1000,14 +999,14 @@
     @Test
     public void testEquals_5() {
-        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
                
-        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
         
         int entryCount = 1000;
         
         for (int i = 0; i < entryCount; i++) {
-            ITaskInstance task = createTaskInstance("symbol" + i);
+            ITask task = createTask("symbol" + i);
             if (i % 7 == 0) {
                 symbolMap1.addSymbol(task, "value" + i);
@@ -1027,17 +1026,17 @@
     @Test
     public void testEquals_6() {
-        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
                 
-        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String>
-            (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String>
+            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL));
         
         int entryCount = 1000;
         
-        ITaskInstance[] taskInstances = new ITaskInstance[entryCount];
-        
-        for (int i = 0; i < entryCount; i++) {
-            ITaskInstance task = createTaskInstance("symbol" + i);
-            taskInstances[i] = task;
+        ITask[] tasks = new ITask[entryCount];
+        
+        for (int i = 0; i < entryCount; i++) {
+            ITask task = createTask("symbol" + i);
+            tasks[i] = task;
             symbolMap1.addSymbol(task, "value" + i);
             assertFalse(symbolMap1.equals(symbolMap2));
@@ -1047,7 +1046,7 @@
         
         for (int i = 150; i < (entryCount - 150); i++) {
-            symbolMap1.removeSymbol(taskInstances[i]);
+            symbolMap1.removeSymbol(tasks[i]);
             assertFalse(symbolMap1.equals(symbolMap2));
-            symbolMap2.removeSymbol(taskInstances[i]);
+            symbolMap2.removeSymbol(tasks[i]);
             assertTrue(symbolMap1.equals(symbolMap2));
         }
@@ -1057,5 +1056,5 @@
      *
      */
-    private ITaskInstance createTaskInstance(String id) {
+    private ITask createTask(String id) {
         ITask task = tasks.get(id);
         Event event = null;
@@ -1071,10 +1070,12 @@
         }
        
-        return taskFactory.createNewTaskInstance((IEventTask) task, event);
-    }
-
-    private void assertSymbolMapEntries(SymbolMap<ITaskInstance, String> symbolMap,
-                                        ITaskInstance[]                  symbols,
-                                        String[]                         values)
+        taskFactory.createNewTaskInstance((IEventTask) task, event);
+        
+        return task;
+    }
+
+    private void assertSymbolMapEntries(SymbolMap<ITask, String> symbolMap,
+                                        ITask[]                  symbols,
+                                        String[]                 values)
     {
         assertEquals(symbols.length, symbolMap.size());
