Ignore:
Timestamp:
12/23/14 10:55:46 (10 years ago)
Author:
pharms
Message:
  • rename of task instance comparator to task comparator as it actually compares tasks
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskSymbolBucketedMapTest.java

    r1294 r1846  
    3434import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    3535import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; 
    36 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance; 
    3736import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; 
    3837import de.ugoe.cs.autoquest.test.DummyGUIElement; 
    … …  
    6362    @Test 
    6463    public void testSymbolMap_1() { 
    65         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    66             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     64        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     65            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    6766         
    6867        assertNotNull(symbolMap); 
    … …  
    7372    public void testSymbolMap_2() { 
    7473        TaskSymbolBucketedMap<String> symbolMap1 = new TaskSymbolBucketedMap<String> 
    75             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    76          
    77         ITaskInstance taskInstance = createTaskInstance("symbol"); 
    78         symbolMap1.addSymbol(taskInstance, "value"); 
    79          
    80         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String>(symbolMap1); 
     74            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     75         
     76        ITask task = createTask("symbol"); 
     77        symbolMap1.addSymbol(task, "value"); 
     78         
     79        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String>(symbolMap1); 
    8180         
    8281        assertNotNull(symbolMap2); 
    83         assertSymbolMapEntries(symbolMap2, new ITaskInstance[] { taskInstance }, 
     82        assertSymbolMapEntries(symbolMap2, new ITask[] { task }, 
    8483                               new String[] { "value" }); 
    8584    } 
    … …  
    9291    @Test 
    9392    public void testAddSymbol_1() { 
    94         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    95             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    96              
    97         ITaskInstance taskInstance = createTaskInstance("symbol"); 
    98         symbolMap.addSymbol(taskInstance, "value1"); 
     93        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     94            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     95             
     96        ITask task = createTask("symbol"); 
     97        symbolMap.addSymbol(task, "value1"); 
    9998         
    10099        assertNotNull(symbolMap); 
    101         assertSymbolMapEntries(symbolMap, new ITaskInstance[] { taskInstance }, 
     100        assertSymbolMapEntries(symbolMap, new ITask[] { task }, 
    102101                               new String[] { "value1" }); 
    103102    } 
    … …  
    105104    @Test 
    106105    public void testAddSymbol_2() { 
    107         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    108             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    109          
    110         int entryCount = 2000; 
    111          
    112         ITaskInstance[] symbols = new ITaskInstance[entryCount]; 
     106        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     107            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     108         
     109        int entryCount = 2000; 
     110         
     111        ITask[] symbols = new ITask[entryCount]; 
    113112        String[] values = new String[entryCount]; 
    114113         
    115114        for (int i = 0; i < entryCount; i++) { 
    116             symbols[i] = createTaskInstance("symbol" + i); 
     115            symbols[i] = createTask("symbol" + i); 
    117116            symbolMap.addSymbol(symbols[i], "value" + i); 
    118117            values[i] = "value" + i; 
    … …  
    125124    @Test 
    126125    public void testAddSymbol_3() { 
    127         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    128             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    129          
    130         int entryCount = 2000; 
    131          
    132         ITaskInstance[] symbols = new ITaskInstance[entryCount]; 
     126        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     127            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     128         
     129        int entryCount = 2000; 
     130         
     131        ITask[] symbols = new ITask[entryCount]; 
    133132        String[] values = new String[entryCount]; 
    134133         
    135134        for (int i = 0; i < entryCount; i++) { 
    136             symbols[i] = createTaskInstance("symbol" + i); 
     135            symbols[i] = createTask("symbol" + i); 
    137136            if (i % 7 == 0) { 
    138137                values[i] = "value" + i; 
    … …  
    151150    @Test(expected = java.lang.IllegalArgumentException.class) 
    152151    public void testAddSymbol_4() { 
    153         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    154             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     152        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     153            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    155154             
    156155        symbolMap.addSymbol(null, null); 
    … …  
    159158    @Test 
    160159    public void testSize_1() { 
    161         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    162             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     160        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     161            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    163162             
    164163        assertEquals(0, symbolMap.size()); 
    … …  
    167166    @Test 
    168167    public void testSize_2() { 
    169         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    170             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    171              
    172         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
     168        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     169            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     170             
     171        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
    173172         
    174173        assertEquals(1, symbolMap.size()); 
    … …  
    177176    @Test 
    178177    public void testSize_3() { 
    179         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    180             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    181          
    182         int entryCount = 2000; 
    183          
    184         for (int i = 0; i < entryCount; i++) { 
    185             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
     178        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     179            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     180         
     181        int entryCount = 2000; 
     182         
     183        for (int i = 0; i < entryCount; i++) { 
     184            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
    186185        } 
    187186         
    … …  
    191190    @Test 
    192191    public void testSize_4() { 
    193         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    194             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    195          
    196         int entryCount = 2000; 
    197          
    198         for (int i = 0; i < entryCount; i++) { 
    199             if (i % 7 == 0) { 
    200                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    201             } 
    202             else { 
    203                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
     192        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     193            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     194         
     195        int entryCount = 2000; 
     196         
     197        for (int i = 0; i < entryCount; i++) { 
     198            if (i % 7 == 0) { 
     199                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     200            } 
     201            else { 
     202                symbolMap.addSymbol(createTask("symbol" + i), null); 
    204203            } 
    205204        } 
    … …  
    210209    @Test 
    211210    public void testSize_5() { 
    212         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    213             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    214          
    215         int entryCount = 2000; 
    216          
    217         for (int i = 0; i < entryCount; i++) { 
    218             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    219         } 
    220          
    221         for (int i = 150; i < (entryCount - 150); i++) { 
    222             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     211        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     212            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     213         
     214        int entryCount = 2000; 
     215         
     216        for (int i = 0; i < entryCount; i++) { 
     217            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     218        } 
     219         
     220        for (int i = 150; i < (entryCount - 150); i++) { 
     221            symbolMap.removeSymbol(createTask("symbol" + i)); 
    223222        } 
    224223         
    … …  
    228227    @Test 
    229228    public void testIsEmpty_1() { 
    230         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    231             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     229        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     230            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    232231             
    233232        assertTrue(symbolMap.isEmpty()); 
    … …  
    236235    @Test 
    237236    public void testIsEmpty_2() { 
    238         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    239             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    240              
    241         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
     237        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     238            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     239             
     240        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
    242241         
    243242        assertFalse(symbolMap.isEmpty()); 
    … …  
    246245    @Test 
    247246    public void testIsEmpty_3() { 
    248         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    249             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    250          
    251         int entryCount = 2000; 
    252          
    253         for (int i = 0; i < entryCount; i++) { 
    254             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
     247        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     248            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     249         
     250        int entryCount = 2000; 
     251         
     252        for (int i = 0; i < entryCount; i++) { 
     253            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
    255254        } 
    256255         
    … …  
    260259    @Test 
    261260    public void testIsEmpty_4() { 
    262         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    263             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    264          
    265         int entryCount = 2000; 
    266          
    267         for (int i = 0; i < entryCount; i++) { 
    268             if (i % 7 == 0) { 
    269                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    270             } 
    271             else { 
    272                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
     261        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     262            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     263         
     264        int entryCount = 2000; 
     265         
     266        for (int i = 0; i < entryCount; i++) { 
     267            if (i % 7 == 0) { 
     268                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     269            } 
     270            else { 
     271                symbolMap.addSymbol(createTask("symbol" + i), null); 
    273272            } 
    274273        } 
    … …  
    279278    @Test 
    280279    public void testIsEmpty_5() { 
    281         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    282             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    283          
    284         int entryCount = 2000; 
    285          
    286         for (int i = 0; i < entryCount; i++) { 
    287             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    288         } 
    289          
    290         for (int i = 150; i < (entryCount - 150); i++) { 
    291             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     280        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     281            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     282         
     283        int entryCount = 2000; 
     284         
     285        for (int i = 0; i < entryCount; i++) { 
     286            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     287        } 
     288         
     289        for (int i = 150; i < (entryCount - 150); i++) { 
     290            symbolMap.removeSymbol(createTask("symbol" + i)); 
    292291        } 
    293292         
    … …  
    297296    @Test 
    298297    public void testContainsSymbol_1() { 
    299         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    300             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    301              
    302         assertFalse(symbolMap.containsSymbol(createTaskInstance("symbol"))); 
     298        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     299            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     300             
     301        assertFalse(symbolMap.containsSymbol(createTask("symbol"))); 
    303302    } 
    304303     
    305304    @Test 
    306305    public void testContainsSymbol_2() { 
    307         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    308             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    309              
    310         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
    311          
    312         assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol1"))); 
     306        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     307            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     308             
     309        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
     310         
     311        assertTrue(symbolMap.containsSymbol(createTask("symbol1"))); 
    313312    } 
    314313     
    315314    @Test 
    316315    public void testContainsSymbol_3() { 
    317         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    318             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    319          
    320         int entryCount = 2000; 
    321          
    322         for (int i = 0; i < entryCount; i++) { 
    323             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    324         } 
    325          
    326         for (int i = 0; i < entryCount; i++) { 
    327             assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i))); 
     316        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     317            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     318         
     319        int entryCount = 2000; 
     320         
     321        for (int i = 0; i < entryCount; i++) { 
     322            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     323        } 
     324         
     325        for (int i = 0; i < entryCount; i++) { 
     326            assertTrue(symbolMap.containsSymbol(createTask("symbol" + i))); 
    328327        } 
    329328    } 
    … …  
    331330    @Test 
    332331    public void testContainsSymbol_4() { 
    333         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    334             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    335          
    336         int entryCount = 2000; 
    337          
    338         for (int i = 0; i < entryCount; i++) { 
    339             if (i % 7 == 0) { 
    340                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    341             } 
    342             else { 
    343                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
    344             } 
    345         } 
    346          
    347         for (int i = 0; i < entryCount; i++) { 
    348             assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i))); 
     332        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     333            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     334         
     335        int entryCount = 2000; 
     336         
     337        for (int i = 0; i < entryCount; i++) { 
     338            if (i % 7 == 0) { 
     339                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     340            } 
     341            else { 
     342                symbolMap.addSymbol(createTask("symbol" + i), null); 
     343            } 
     344        } 
     345         
     346        for (int i = 0; i < entryCount; i++) { 
     347            assertTrue(symbolMap.containsSymbol(createTask("symbol" + i))); 
    349348        } 
    350349    } 
    … …  
    352351    @Test 
    353352    public void testContainsSymbol_5() { 
    354         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    355             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    356          
    357         int entryCount = 2000; 
    358          
    359         for (int i = 0; i < entryCount; i++) { 
    360             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    361         } 
    362          
    363         for (int i = 150; i < (entryCount - 150); i++) { 
    364             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     353        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     354            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     355         
     356        int entryCount = 2000; 
     357         
     358        for (int i = 0; i < entryCount; i++) { 
     359            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     360        } 
     361         
     362        for (int i = 150; i < (entryCount - 150); i++) { 
     363            symbolMap.removeSymbol(createTask("symbol" + i)); 
    365364        } 
    366365         
    367366        for (int i = 0; i < 150; i++) { 
    368             assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i))); 
    369         } 
    370          
    371         for (int i = 150; i < (entryCount - 150); i++) { 
    372             assertFalse(symbolMap.containsSymbol(createTaskInstance("symbol" + i))); 
     367            assertTrue(symbolMap.containsSymbol(createTask("symbol" + i))); 
     368        } 
     369         
     370        for (int i = 150; i < (entryCount - 150); i++) { 
     371            assertFalse(symbolMap.containsSymbol(createTask("symbol" + i))); 
    373372        } 
    374373         
    375374        for (int i = (entryCount - 150); i < entryCount; i++) { 
    376             assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i))); 
     375            assertTrue(symbolMap.containsSymbol(createTask("symbol" + i))); 
    377376        } 
    378377    } 
    … …  
    380379    @Test(expected = java.lang.IllegalArgumentException.class) 
    381380    public void testContainsSymbol_6() { 
    382         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    383             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     381        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     382            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    384383             
    385384        symbolMap.containsSymbol(null); 
    … …  
    388387    @Test 
    389388    public void testGetValue_1() { 
    390         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    391             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    392              
    393         assertNull(symbolMap.getValue(createTaskInstance("symbol"))); 
     389        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     390            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     391             
     392        assertNull(symbolMap.getValue(createTask("symbol"))); 
    394393    } 
    395394     
    396395    @Test 
    397396    public void testGetValue_2() { 
    398         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    399             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    400              
    401         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
    402          
    403         assertNotNull(symbolMap.getValue(createTaskInstance("symbol1"))); 
     397        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     398            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     399             
     400        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
     401         
     402        assertNotNull(symbolMap.getValue(createTask("symbol1"))); 
    404403    } 
    405404     
    406405    @Test 
    407406    public void testGetValue_3() { 
    408         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    409             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    410              
    411         symbolMap.addSymbol(createTaskInstance("symbol1"), null); 
    412          
    413         assertNull(symbolMap.getValue(createTaskInstance("symbol1"))); 
     407        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     408            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     409             
     410        symbolMap.addSymbol(createTask("symbol1"), null); 
     411         
     412        assertNull(symbolMap.getValue(createTask("symbol1"))); 
    414413    } 
    415414     
    416415    @Test 
    417416    public void testGetValue_4() { 
    418         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    419             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    420          
    421         int entryCount = 2000; 
    422          
    423         for (int i = 0; i < entryCount; i++) { 
    424             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    425         } 
    426          
    427         for (int i = 0; i < entryCount; i++) { 
    428             assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i))); 
     417        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     418            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     419         
     420        int entryCount = 2000; 
     421         
     422        for (int i = 0; i < entryCount; i++) { 
     423            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     424        } 
     425         
     426        for (int i = 0; i < entryCount; i++) { 
     427            assertNotNull(symbolMap.getValue(createTask("symbol" + i))); 
    429428        } 
    430429    } 
    … …  
    432431    @Test 
    433432    public void testGetValue_5() { 
    434         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    435             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    436          
    437         int entryCount = 2000; 
    438          
    439         for (int i = 0; i < entryCount; i++) { 
    440             if (i % 7 == 0) { 
    441                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    442             } 
    443             else { 
    444                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
    445             } 
    446         } 
    447          
    448         for (int i = 0; i < entryCount; i++) { 
    449             if (i % 7 == 0) { 
    450                 assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i))); 
    451             } 
    452             else { 
    453                 assertNull(symbolMap.getValue(createTaskInstance("symbol" + i))); 
     433        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     434            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     435         
     436        int entryCount = 2000; 
     437         
     438        for (int i = 0; i < entryCount; i++) { 
     439            if (i % 7 == 0) { 
     440                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     441            } 
     442            else { 
     443                symbolMap.addSymbol(createTask("symbol" + i), null); 
     444            } 
     445        } 
     446         
     447        for (int i = 0; i < entryCount; i++) { 
     448            if (i % 7 == 0) { 
     449                assertNotNull(symbolMap.getValue(createTask("symbol" + i))); 
     450            } 
     451            else { 
     452                assertNull(symbolMap.getValue(createTask("symbol" + i))); 
    454453            } 
    455454        } 
    … …  
    458457    @Test 
    459458    public void testGetValue_6() { 
    460         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    461             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    462          
    463         int entryCount = 2000; 
    464          
    465         for (int i = 0; i < entryCount; i++) { 
    466             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    467         } 
    468          
    469         for (int i = 150; i < (entryCount - 150); i++) { 
    470             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     459        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     460            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     461         
     462        int entryCount = 2000; 
     463         
     464        for (int i = 0; i < entryCount; i++) { 
     465            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     466        } 
     467         
     468        for (int i = 150; i < (entryCount - 150); i++) { 
     469            symbolMap.removeSymbol(createTask("symbol" + i)); 
    471470        } 
    472471         
    473472        for (int i = 0; i < 150; i++) { 
    474             assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i))); 
    475         } 
    476          
    477         for (int i = 150; i < (entryCount - 150); i++) { 
    478             assertNull(symbolMap.getValue(createTaskInstance("symbol" + i))); 
     473            assertNotNull(symbolMap.getValue(createTask("symbol" + i))); 
     474        } 
     475         
     476        for (int i = 150; i < (entryCount - 150); i++) { 
     477            assertNull(symbolMap.getValue(createTask("symbol" + i))); 
    479478        } 
    480479         
    481480        for (int i = (entryCount - 150); i < entryCount; i++) { 
    482             assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i))); 
     481            assertNotNull(symbolMap.getValue(createTask("symbol" + i))); 
    483482        } 
    484483    } 
    … …  
    486485    @Test(expected = java.lang.IllegalArgumentException.class) 
    487486    public void testGetValue_7() { 
    488         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    489             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     487        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     488            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    490489             
    491490        symbolMap.getValue(null); 
    … …  
    494493    @Test 
    495494    public void testRemoveSymbol_1() { 
    496         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    497             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    498              
    499         assertNull(symbolMap.removeSymbol(createTaskInstance("symbol"))); 
     495        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     496            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     497             
     498        assertNull(symbolMap.removeSymbol(createTask("symbol"))); 
    500499    } 
    501500     
    502501    @Test 
    503502    public void testRemoveSymbol_2() { 
    504         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    505             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    506              
    507         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
    508          
    509         assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol1"))); 
     503        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     504            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     505             
     506        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
     507         
     508        assertNotNull(symbolMap.removeSymbol(createTask("symbol1"))); 
    510509        assertEquals(0, symbolMap.size()); 
    511510    } 
    … …  
    513512    @Test 
    514513    public void testRemoveSymbol_3() { 
    515         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    516             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    517              
    518         symbolMap.addSymbol(createTaskInstance("symbol1"), null); 
    519          
    520         assertNull(symbolMap.removeSymbol(createTaskInstance("symbol1"))); 
     514        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     515            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     516             
     517        symbolMap.addSymbol(createTask("symbol1"), null); 
     518         
     519        assertNull(symbolMap.removeSymbol(createTask("symbol1"))); 
    521520        assertEquals(0, symbolMap.size()); 
    522521    } 
    … …  
    524523    @Test 
    525524    public void testRemoveSymbol_4() { 
    526         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    527             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    528          
    529         int entryCount = 2000; 
    530          
    531         for (int i = 0; i < entryCount; i++) { 
    532             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    533         } 
    534          
    535         for (int i = 0; i < entryCount; i++) { 
    536             assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i))); 
     525        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     526            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     527         
     528        int entryCount = 2000; 
     529         
     530        for (int i = 0; i < entryCount; i++) { 
     531            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     532        } 
     533         
     534        for (int i = 0; i < entryCount; i++) { 
     535            assertNotNull(symbolMap.removeSymbol(createTask("symbol" + i))); 
    537536        } 
    538537         
    … …  
    542541    @Test 
    543542    public void testRemoveSymbol_5() { 
    544         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    545             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    546          
    547         int entryCount = 2000; 
    548          
    549         for (int i = 0; i < entryCount; i++) { 
    550             if (i % 7 == 0) { 
    551                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    552             } 
    553             else { 
    554                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
    555             } 
    556         } 
    557          
    558         for (int i = 0; i < entryCount; i++) { 
    559             if (i % 7 == 0) { 
    560                 assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i))); 
    561             } 
    562             else { 
    563                 assertNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i))); 
     543        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     544            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     545         
     546        int entryCount = 2000; 
     547         
     548        for (int i = 0; i < entryCount; i++) { 
     549            if (i % 7 == 0) { 
     550                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     551            } 
     552            else { 
     553                symbolMap.addSymbol(createTask("symbol" + i), null); 
     554            } 
     555        } 
     556         
     557        for (int i = 0; i < entryCount; i++) { 
     558            if (i % 7 == 0) { 
     559                assertNotNull(symbolMap.removeSymbol(createTask("symbol" + i))); 
     560            } 
     561            else { 
     562                assertNull(symbolMap.removeSymbol(createTask("symbol" + i))); 
    564563            } 
    565564        } 
    … …  
    570569    @Test 
    571570    public void testRemoveSymbol_6() { 
    572         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    573             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    574          
    575         int entryCount = 2000; 
    576          
    577         for (int i = 0; i < entryCount; i++) { 
    578             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    579         } 
    580          
    581         for (int i = 150; i < (entryCount - 150); i++) { 
    582             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     571        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     572            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     573         
     574        int entryCount = 2000; 
     575         
     576        for (int i = 0; i < entryCount; i++) { 
     577            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     578        } 
     579         
     580        for (int i = 150; i < (entryCount - 150); i++) { 
     581            symbolMap.removeSymbol(createTask("symbol" + i)); 
    583582        } 
    584583         
    585584        for (int i = 0; i < 150; i++) { 
    586             assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i))); 
    587         } 
    588          
    589         for (int i = 150; i < (entryCount - 150); i++) { 
    590             assertNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i))); 
     585            assertNotNull(symbolMap.removeSymbol(createTask("symbol" + i))); 
     586        } 
     587         
     588        for (int i = 150; i < (entryCount - 150); i++) { 
     589            assertNull(symbolMap.removeSymbol(createTask("symbol" + i))); 
    591590        } 
    592591         
    593592        for (int i = (entryCount - 150); i < entryCount; i++) { 
    594             assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i))); 
     593            assertNotNull(symbolMap.removeSymbol(createTask("symbol" + i))); 
    595594        } 
    596595         
    … …  
    600599    @Test(expected = java.lang.IllegalArgumentException.class) 
    601600    public void testRemoveSymbol_7() { 
    602         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    603             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     601        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     602            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    604603             
    605604        symbolMap.removeSymbol(null); 
    … …  
    608607    @Test 
    609608    public void testGetSymbols_1() { 
    610         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    611             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     609        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     610            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    612611             
    613612        assertNotNull(symbolMap.getSymbols()); 
    … …  
    617616    @Test 
    618617    public void testGetSymbols_2() { 
    619         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    620             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     618        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     619            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    621620          
    622         ITaskInstance task = createTaskInstance("symbol1"); 
     621        ITask task = createTask("symbol1"); 
    623622        symbolMap.addSymbol(task, "value1"); 
    624623         
    … …  
    630629    @Test 
    631630    public void testGetSymbols_3() { 
    632         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    633             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    634              
    635         ITaskInstance task = createTaskInstance("symbol1"); 
     631        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     632            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     633             
     634        ITask task = createTask("symbol1"); 
    636635        symbolMap.addSymbol(task, null); 
    637636         
    … …  
    643642    @Test 
    644643    public void testGetSymbols_4() { 
    645         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    646             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    647         Set<ITaskInstance> expectedSymbols = new HashSet<ITaskInstance>(); 
    648          
    649         int entryCount = 2000; 
    650          
    651         for (int i = 0; i < entryCount; i++) { 
    652             ITaskInstance task = createTaskInstance("symbol" + i); 
     644        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     645            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     646        Set<ITask> expectedSymbols = new HashSet<ITask>(); 
     647         
     648        int entryCount = 2000; 
     649         
     650        for (int i = 0; i < entryCount; i++) { 
     651            ITask task = createTask("symbol" + i); 
    653652            symbolMap.addSymbol(task, "value" + i); 
    654653            expectedSymbols.add(task); 
    … …  
    658657        assertEquals(entryCount, symbolMap.getSymbols().size()); 
    659658         
    660         Iterator<ITaskInstance> iterator = symbolMap.getSymbols().iterator(); 
     659        Iterator<ITask> iterator = symbolMap.getSymbols().iterator(); 
    661660        for (int i = 0; i < entryCount; i++) { 
    662661            assertTrue(iterator.hasNext()); 
    … …  
    670669    @Test 
    671670    public void testGetSymbols_5() { 
    672         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    673             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    674         Set<ITaskInstance> expectedSymbols = new HashSet<ITaskInstance>(); 
    675          
    676         int entryCount = 2000; 
    677          
    678         for (int i = 0; i < entryCount; i++) { 
    679             ITaskInstance task = createTaskInstance("symbol" + i); 
     671        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     672            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     673        Set<ITask> expectedSymbols = new HashSet<ITask>(); 
     674         
     675        int entryCount = 2000; 
     676         
     677        for (int i = 0; i < entryCount; i++) { 
     678            ITask task = createTask("symbol" + i); 
    680679             
    681680            if (i % 7 == 0) { 
    … …  
    692691        assertEquals(entryCount, symbolMap.getSymbols().size()); 
    693692         
    694         Iterator<ITaskInstance> iterator = symbolMap.getSymbols().iterator(); 
     693        Iterator<ITask> iterator = symbolMap.getSymbols().iterator(); 
    695694        for (int i = 0; i < entryCount; i++) { 
    696695            assertTrue(iterator.hasNext()); 
    … …  
    704703    @Test 
    705704    public void testGetSymbols_6() { 
    706         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    707             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    708         List<ITaskInstance> expectedSymbols = new ArrayList<ITaskInstance>(); 
    709          
    710         int entryCount = 2000; 
    711          
    712         for (int i = 0; i < entryCount; i++) { 
    713             ITaskInstance task = createTaskInstance("symbol" + i); 
     705        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     706            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     707        List<ITask> expectedSymbols = new ArrayList<ITask>(); 
     708         
     709        int entryCount = 2000; 
     710         
     711        for (int i = 0; i < entryCount; i++) { 
     712            ITask task = createTask("symbol" + i); 
    714713            symbolMap.addSymbol(task, "value" + i); 
    715714            expectedSymbols.add(task); 
    … …  
    723722        assertEquals(2 * 150, symbolMap.getSymbols().size()); 
    724723         
    725         Iterator<ITaskInstance> iterator = symbolMap.getSymbols().iterator(); 
     724        Iterator<ITask> iterator = symbolMap.getSymbols().iterator(); 
    726725        for (int i = 0; i < 2 * 150; i++) { 
    727726            assertTrue(iterator.hasNext()); 
    … …  
    735734    @Test 
    736735    public void testGetValues_1() { 
    737         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    738             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     736        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     737            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    739738             
    740739        assertNotNull(symbolMap.getValues()); 
    … …  
    744743    @Test 
    745744    public void testGetValues_2() { 
    746         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    747             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    748              
    749         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
     745        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     746            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     747             
     748        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
    750749         
    751750        assertNotNull(symbolMap.getValues()); 
    … …  
    756755    @Test 
    757756    public void testGetValues_3() { 
    758         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    759             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    760              
    761         symbolMap.addSymbol(createTaskInstance("symbol1"), null); 
     757        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     758            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     759             
     760        symbolMap.addSymbol(createTask("symbol1"), null); 
    762761         
    763762        assertNotNull(symbolMap.getValues()); 
    … …  
    768767    @Test 
    769768    public void testGetValues_4() { 
    770         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    771             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     769        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     770            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    772771        Set<String> expectedValues = new HashSet<String>(); 
    773772         
    … …  
    775774         
    776775        for (int i = 0; i < entryCount; i++) { 
    777             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
     776            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
    778777            expectedValues.add("value" + i); 
    779778        } 
    … …  
    794793    @Test 
    795794    public void testGetValues_5() { 
    796         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    797             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     795        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     796            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    798797        Set<String> expectedValues = new HashSet<String>(); 
    799798         
    … …  
    802801        for (int i = 0; i < entryCount; i++) { 
    803802            if (i % 7 == 0) { 
    804                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
     803                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
    805804                expectedValues.add("value" + i); 
    806805            } 
    807806            else { 
    808                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
     807                symbolMap.addSymbol(createTask("symbol" + i), null); 
    809808                expectedValues.add(null); 
    810809            } 
    … …  
    826825    @Test 
    827826    public void testGetValues_6() { 
    828         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    829             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     827        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     828            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    830829        Set<String> expectedValues = new HashSet<String>(); 
    831830         
    … …  
    833832         
    834833        for (int i = 0; i < entryCount; i++) { 
    835             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
     834            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
    836835            expectedValues.add("value" + i); 
    837836        } 
    838837         
    839838        for (int i = 150; i < (entryCount - 150); i++) { 
    840             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     839            symbolMap.removeSymbol(createTask("symbol" + i)); 
    841840            expectedValues.remove("value" + i); 
    842841        } 
    … …  
    857856    @Test 
    858857    public void testClear_1() { 
    859         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    860             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     858        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     859            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    861860         
    862861        symbolMap.clear(); 
    … …  
    866865    @Test 
    867866    public void testClear_2() { 
    868         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    869             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    870              
    871         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
     867        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     868            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     869             
     870        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
    872871         
    873872        symbolMap.clear(); 
    … …  
    877876    @Test 
    878877    public void testClear_3() { 
    879         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    880             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    881              
    882         symbolMap.addSymbol(createTaskInstance("symbol1"), null); 
     878        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     879            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     880             
     881        symbolMap.addSymbol(createTask("symbol1"), null); 
    883882         
    884883        symbolMap.clear(); 
    … …  
    888887    @Test 
    889888    public void testClear_4() { 
    890         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    891             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    892          
    893         int entryCount = 2000; 
    894          
    895         for (int i = 0; i < entryCount; i++) { 
    896             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
     889        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     890            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     891         
     892        int entryCount = 2000; 
     893         
     894        for (int i = 0; i < entryCount; i++) { 
     895            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
    897896        } 
    898897         
    … …  
    903902    @Test 
    904903    public void testClear_5() { 
    905         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    906             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    907          
    908         int entryCount = 2000; 
    909          
    910         for (int i = 0; i < entryCount; i++) { 
    911             if (i % 7 == 0) { 
    912                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    913             } 
    914             else { 
    915                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
     904        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     905            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     906         
     907        int entryCount = 2000; 
     908         
     909        for (int i = 0; i < entryCount; i++) { 
     910            if (i % 7 == 0) { 
     911                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     912            } 
     913            else { 
     914                symbolMap.addSymbol(createTask("symbol" + i), null); 
    916915            } 
    917916        } 
    … …  
    923922    @Test 
    924923    public void testClear_6() { 
    925         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolBucketedMap<String> 
    926             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    927          
    928         int entryCount = 2000; 
    929          
    930         for (int i = 0; i < entryCount; i++) { 
    931             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    932         } 
    933          
    934         for (int i = 150; i < (entryCount - 150); i++) { 
    935             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     924        SymbolMap<ITask, String> symbolMap = new TaskSymbolBucketedMap<String> 
     925            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     926         
     927        int entryCount = 2000; 
     928         
     929        for (int i = 0; i < entryCount; i++) { 
     930            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     931        } 
     932         
     933        for (int i = 150; i < (entryCount - 150); i++) { 
     934            symbolMap.removeSymbol(createTask("symbol" + i)); 
    936935        } 
    937936         
    … …  
    942941    @Test 
    943942    public void testEquals_1() { 
    944         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolBucketedMap<String> 
    945             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    946          
    947         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String> 
    948             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     943        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolBucketedMap<String> 
     944            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     945         
     946        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String> 
     947            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    949948         
    950949        assertTrue(symbolMap1.equals(symbolMap2)); 
    … …  
    953952    @Test 
    954953    public void testEquals_2() { 
    955         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolBucketedMap<String> 
    956             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    957              
    958         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String> 
    959             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    960              
    961         symbolMap1.addSymbol(createTaskInstance("symbol1"), "value1"); 
     954        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolBucketedMap<String> 
     955            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     956             
     957        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String> 
     958            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     959             
     960        symbolMap1.addSymbol(createTask("symbol1"), "value1"); 
    962961         
    963962        assertFalse(symbolMap1.equals(symbolMap2)); 
    … …  
    966965    @Test 
    967966    public void testEquals_3() { 
    968         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolBucketedMap<String> 
    969             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    970              
    971         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String> 
    972             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    973          
    974         ITaskInstance task = createTaskInstance("symbol1"); 
     967        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolBucketedMap<String> 
     968            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     969             
     970        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String> 
     971            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     972         
     973        ITask task = createTask("symbol1"); 
    975974        symbolMap1.addSymbol(task, "value1"); 
    976975        symbolMap2.addSymbol(task, "value1"); 
    … …  
    981980    @Test 
    982981    public void testEquals_4() { 
    983         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolBucketedMap<String> 
    984             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     982        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolBucketedMap<String> 
     983            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    985984                 
    986         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String> 
    987             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     985        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String> 
     986            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    988987         
    989988        int entryCount = 1000; 
    990989         
    991990        for (int i = 0; i < entryCount; i++) { 
    992             ITaskInstance task = createTaskInstance("symbol1"); 
     991            ITask task = createTask("symbol1"); 
    993992            symbolMap1.addSymbol(task, "value" + i); 
    994993            assertFalse(symbolMap1.equals(symbolMap2)); 
    … …  
    1000999    @Test 
    10011000    public void testEquals_5() { 
    1002         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolBucketedMap<String> 
    1003             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     1001        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolBucketedMap<String> 
     1002            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    10041003                
    1005         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String> 
    1006             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     1004        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String> 
     1005            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    10071006         
    10081007        int entryCount = 1000; 
    10091008         
    10101009        for (int i = 0; i < entryCount; i++) { 
    1011             ITaskInstance task = createTaskInstance("symbol" + i); 
     1010            ITask task = createTask("symbol" + i); 
    10121011            if (i % 7 == 0) { 
    10131012                symbolMap1.addSymbol(task, "value" + i); 
    … …  
    10271026    @Test 
    10281027    public void testEquals_6() { 
    1029         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolBucketedMap<String> 
    1030             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     1028        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolBucketedMap<String> 
     1029            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    10311030                 
    1032         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolBucketedMap<String> 
    1033             (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
     1031        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolBucketedMap<String> 
     1032            (new TaskComparator(TaskEquality.SEMANTICALLY_EQUAL)); 
    10341033         
    10351034        int entryCount = 1000; 
    10361035         
    1037         ITaskInstance[] taskInstances = new ITaskInstance[entryCount]; 
    1038          
    1039         for (int i = 0; i < entryCount; i++) { 
    1040             ITaskInstance task = createTaskInstance("symbol" + i); 
    1041             taskInstances[i] = task; 
     1036        ITask[] tasks = new ITask[entryCount]; 
     1037         
     1038        for (int i = 0; i < entryCount; i++) { 
     1039            ITask task = createTask("symbol" + i); 
     1040            tasks[i] = task; 
    10421041            symbolMap1.addSymbol(task, "value" + i); 
    10431042            assertFalse(symbolMap1.equals(symbolMap2)); 
    … …  
    10471046         
    10481047        for (int i = 150; i < (entryCount - 150); i++) { 
    1049             symbolMap1.removeSymbol(taskInstances[i]); 
     1048            symbolMap1.removeSymbol(tasks[i]); 
    10501049            assertFalse(symbolMap1.equals(symbolMap2)); 
    1051             symbolMap2.removeSymbol(taskInstances[i]); 
     1050            symbolMap2.removeSymbol(tasks[i]); 
    10521051            assertTrue(symbolMap1.equals(symbolMap2)); 
    10531052        } 
    … …  
    10571056     * 
    10581057     */ 
    1059     private ITaskInstance createTaskInstance(String id) { 
     1058    private ITask createTask(String id) { 
    10601059        ITask task = tasks.get(id); 
    10611060        Event event = null; 
    … …  
    10711070        } 
    10721071        
    1073         return taskFactory.createNewTaskInstance((IEventTask) task, event); 
    1074     } 
    1075  
    1076     private void assertSymbolMapEntries(SymbolMap<ITaskInstance, String> symbolMap, 
    1077                                         ITaskInstance[]                  symbols, 
    1078                                         String[]                         values) 
     1072        taskFactory.createNewTaskInstance((IEventTask) task, event); 
     1073         
     1074        return task; 
     1075    } 
     1076 
     1077    private void assertSymbolMapEntries(SymbolMap<ITask, String> symbolMap, 
     1078                                        ITask[]                  symbols, 
     1079                                        String[]                 values) 
    10791080    { 
    10801081        assertEquals(symbols.length, symbolMap.size()); 
Note: See TracChangeset for help on using the changeset viewer.