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
Location:
trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    r1294 r1846  
    2626import de.ugoe.cs.autoquest.tasktrees.TaskTreeDecoder; 
    2727import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; 
     28import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    2829import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; 
    2930import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; 
    30 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance; 
    3131import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession; 
    3232import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskBuilder; 
    … …  
    114114        fixture.trainSessions(Arrays.asList(session), 2); 
    115115         
    116         assertEquals(1, fixture.getCount(Arrays.asList(session.get(0)))); 
    117         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1)))); 
    118         assertEquals(1, fixture.getCount(Arrays.asList(session.get(2)))); 
     116        assertEquals(1, fixture.getCount(Arrays.asList(session.get(0).getTask()))); 
     117        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask()))); 
     118        assertEquals(1, fixture.getCount(Arrays.asList(session.get(2).getTask()))); 
    119119         
    120120        // subsequences of length 1 are not trained. So for the single item sequence of the last 
    121121        // task, the count must be 0 
    122         assertEquals(0, fixture.getCount(Arrays.asList(session.get(3)))); 
    123          
    124          
    125         assertEquals(1, fixture.getCount(Arrays.asList(session.get(0), session.get(1)))); 
    126         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1), session.get(2)))); 
    127         assertEquals(1, fixture.getCount(Arrays.asList(session.get(2), session.get(3)))); 
     122        assertEquals(0, fixture.getCount(Arrays.asList(session.get(3).getTask()))); 
     123         
     124         
     125        assertEquals(1, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     126                                                       session.get(1).getTask()))); 
     127        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask(), 
     128                                                       session.get(2).getTask()))); 
     129        assertEquals(1, fixture.getCount(Arrays.asList(session.get(2).getTask(), 
     130                                                       session.get(3).getTask()))); 
    128131         
    129132        // this must return 0 as we only trained shorter sequences 
    130         assertEquals(0, fixture.getCount(Arrays.asList(session.get(0), session.get(1), 
    131                                                        session.get(2)))); 
     133        assertEquals(0, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     134                                                       session.get(1).getTask(), 
     135                                                       session.get(2).getTask()))); 
    132136         
    133137        // subsequences of length 1 are not trained. So the single item sequence of the last 
    … …  
    153157            // subsequences of length 1 are not trained. So the single item sequence of the last 
    154158            // task is not counted. Therefore, the result must be 3 
    155             assertEquals(3, fixture.getCount(Arrays.asList(session.get(i)))); 
     159            assertEquals(3, fixture.getCount(Arrays.asList(session.get(i).getTask()))); 
    156160             
    157161            for (int j = 0; j < session.size(); j++) { 
    158                 assertEquals(3, fixture.getCount(Arrays.asList(session.get(i), session.get(j)))); 
     162                assertEquals(3, fixture.getCount(Arrays.asList(session.get(i).getTask(), 
     163                                                               session.get(j).getTask()))); 
    159164            } 
    160165        } 
    161166             
    162167        // this must return 0 as we only trained shorter sequences 
    163         assertEquals(0, fixture.getCount(Arrays.asList(session.get(0), session.get(1), 
    164                                                        session.get(2)))); 
     168        assertEquals(0, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     169                                                       session.get(1).getTask(), 
     170                                                       session.get(2).getTask()))); 
    165171         
    166172        assertEquals(1, fixture.getNumSymbols()); 
    … …  
    183189        // subsequences of length 1 are not trained. So the single item sequence of the last 
    184190        // task is not counted. Therefore, the result must be 3 
    185         assertEquals(2, fixture.getCount(Arrays.asList(session.get(0)))); 
    186         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1)))); 
    187         assertEquals(2, fixture.getCount(Arrays.asList(session.get(2)))); 
    188         assertEquals(1, fixture.getCount(Arrays.asList(session.get(3)))); 
    189          
    190         assertEquals(2, fixture.getCount(Arrays.asList(session.get(0), session.get(1)))); 
    191         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1), session.get(2)))); 
    192         assertEquals(2, fixture.getCount(Arrays.asList(session.get(2), session.get(3)))); 
     191        assertEquals(2, fixture.getCount(Arrays.asList(session.get(0).getTask()))); 
     192        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask()))); 
     193        assertEquals(2, fixture.getCount(Arrays.asList(session.get(2).getTask()))); 
     194        assertEquals(1, fixture.getCount(Arrays.asList(session.get(3).getTask()))); 
     195         
     196        assertEquals(2, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     197                                                       session.get(1).getTask()))); 
     198        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask(), 
     199                                                       session.get(2).getTask()))); 
     200        assertEquals(2, fixture.getCount(Arrays.asList(session.get(2).getTask(), 
     201                                                       session.get(3).getTask()))); 
    193202         
    194203        // this must return 0 as we only trained shorter sequences 
    195         assertEquals(0, fixture.getCount(Arrays.asList(session.get(0), session.get(1), 
    196                                                        session.get(2)))); 
     204        assertEquals(0, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     205                                                       session.get(1).getTask(), 
     206                                                       session.get(2).getTask()))); 
    197207         
    198208        assertEquals(2, fixture.getNumSymbols()); 
    … …  
    213223        fixture.trainSessions(Arrays.asList(session), 3); 
    214224         
    215         assertEquals(1, fixture.getCount(Arrays.asList(session.get(0)))); 
    216         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1)))); 
    217         assertEquals(1, fixture.getCount(Arrays.asList(session.get(2)))); 
     225        assertEquals(1, fixture.getCount(Arrays.asList(session.get(0).getTask()))); 
     226        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask()))); 
     227        assertEquals(1, fixture.getCount(Arrays.asList(session.get(2).getTask()))); 
    218228         
    219229        // subsequences of length 1 are not trained. So for the single item sequence of the last 
    220230        // task, the count must be 0 
    221         assertEquals(0, fixture.getCount(Arrays.asList(session.get(3)))); 
    222          
    223          
    224         assertEquals(1, fixture.getCount(Arrays.asList(session.get(0), session.get(1)))); 
    225         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1), session.get(2)))); 
    226         assertEquals(1, fixture.getCount(Arrays.asList(session.get(2), session.get(3)))); 
    227          
    228         assertEquals(1, fixture.getCount(Arrays.asList(session.get(0), session.get(1), 
    229                                                        session.get(2)))); 
    230         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1), session.get(2), 
    231                                                        session.get(3)))); 
     231        assertEquals(0, fixture.getCount(Arrays.asList(session.get(3).getTask()))); 
     232         
     233         
     234        assertEquals(1, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     235                                                       session.get(1).getTask()))); 
     236        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask(), 
     237                                                       session.get(2).getTask()))); 
     238        assertEquals(1, fixture.getCount(Arrays.asList(session.get(2).getTask(), 
     239                                                       session.get(3).getTask()))); 
     240         
     241        assertEquals(1, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     242                                                       session.get(1).getTask(), 
     243                                                       session.get(2).getTask()))); 
     244        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask(), 
     245                                                       session.get(2).getTask(), 
     246                                                       session.get(3).getTask()))); 
    232247         
    233248        // we only trained shorter sequences, so we expect a count of 0 for longer ones 
    234         assertEquals(0, fixture.getCount(Arrays.asList(session.get(0), session.get(1), 
    235                                                        session.get(2), session.get(3)))); 
     249        assertEquals(0, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     250                                                       session.get(1).getTask(), 
     251                                                       session.get(2).getTask(), 
     252                                                       session.get(3).getTask()))); 
    236253         
    237254        // subsequences of length 1 are not trained. So the single item sequence of the last 
    … …  
    257274            // subsequences of length 1 are not trained. So the single item sequence of the last 
    258275            // task is not counted. Therefore, the result must be 3 
    259             assertEquals(3, fixture.getCount(Arrays.asList(session.get(i)))); 
     276            assertEquals(3, fixture.getCount(Arrays.asList(session.get(i).getTask()))); 
    260277             
    261278            for (int j = 0; j < session.size(); j++) { 
    262                 assertEquals(3, fixture.getCount(Arrays.asList(session.get(i), session.get(j)))); 
     279                assertEquals(3, fixture.getCount(Arrays.asList(session.get(i).getTask(), 
     280                                                               session.get(j).getTask()))); 
    263281                 
    264282                for (int k = 0; k < session.size(); k++) { 
    265                     assertEquals(2, fixture.getCount(Arrays.asList(session.get(i), session.get(j), 
    266                                                                    session.get(k))));                     
     283                    assertEquals(2, fixture.getCount(Arrays.asList(session.get(i).getTask(), 
     284                                                                   session.get(j).getTask(), 
     285                                                                   session.get(k).getTask())));                     
    267286                } 
    268287            } 
    … …  
    270289             
    271290        // we only trained shorter sequences, so we expect a count of 0 for longer ones 
    272         assertEquals(0, fixture.getCount(Arrays.asList(session.get(0), session.get(1), 
    273                                                        session.get(2), session.get(3)))); 
     291        assertEquals(0, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     292                                                       session.get(1).getTask(), 
     293                                                       session.get(2).getTask(), 
     294                                                       session.get(3).getTask()))); 
    274295         
    275296        assertEquals(1, fixture.getNumSymbols()); 
    … …  
    292313        // subsequences of length 1 are not trained. So the single item sequence of the last 
    293314        // task is not counted. Therefore, the result must be 3 
    294         assertEquals(2, fixture.getCount(Arrays.asList(session.get(0)))); 
    295         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1)))); 
    296         assertEquals(2, fixture.getCount(Arrays.asList(session.get(2)))); 
    297         assertEquals(1, fixture.getCount(Arrays.asList(session.get(3)))); 
    298          
    299         assertEquals(2, fixture.getCount(Arrays.asList(session.get(0), session.get(1)))); 
    300         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1), session.get(2)))); 
    301         assertEquals(2, fixture.getCount(Arrays.asList(session.get(2), session.get(3)))); 
    302          
    303         assertEquals(1, fixture.getCount(Arrays.asList(session.get(0), session.get(1), 
    304                                                        session.get(2)))); 
    305         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1), session.get(2), 
    306                                                        session.get(3)))); 
     315        assertEquals(2, fixture.getCount(Arrays.asList(session.get(0).getTask()))); 
     316        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask()))); 
     317        assertEquals(2, fixture.getCount(Arrays.asList(session.get(2).getTask()))); 
     318        assertEquals(1, fixture.getCount(Arrays.asList(session.get(3).getTask()))); 
     319         
     320        assertEquals(2, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     321                                                       session.get(1).getTask()))); 
     322        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask(), 
     323                                                       session.get(2).getTask()))); 
     324        assertEquals(2, fixture.getCount(Arrays.asList(session.get(2).getTask(), 
     325                                                       session.get(3).getTask()))); 
     326         
     327        assertEquals(1, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     328                                                       session.get(1).getTask(), 
     329                                                       session.get(2).getTask()))); 
     330        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask(), 
     331                                                       session.get(2).getTask(), 
     332                                                       session.get(3).getTask()))); 
    307333         
    308334        // we only trained shorter sequences, so we expect a count of 0 for longer ones 
    309         assertEquals(0, fixture.getCount(Arrays.asList(session.get(0), session.get(1), 
    310                                                        session.get(2), session.get(3)))); 
     335        assertEquals(0, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     336                                                       session.get(1).getTask(), 
     337                                                       session.get(2).getTask(), 
     338                                                       session.get(3).getTask()))); 
    311339         
    312340        assertEquals(2, fixture.getNumSymbols()); 
    … …  
    327355        fixture.trainSessions(Arrays.asList(session), 4); 
    328356         
    329         assertEquals(1, fixture.getCount(Arrays.asList(session.get(0)))); 
    330         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1)))); 
    331         assertEquals(1, fixture.getCount(Arrays.asList(session.get(2)))); 
     357        assertEquals(1, fixture.getCount(Arrays.asList(session.get(0).getTask()))); 
     358        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask()))); 
     359        assertEquals(1, fixture.getCount(Arrays.asList(session.get(2).getTask()))); 
    332360         
    333361        // subsequences of length 1 are not trained. So for the single item sequence of the last 
    334362        // task, the count must be 0 
    335         assertEquals(0, fixture.getCount(Arrays.asList(session.get(3)))); 
    336          
    337          
    338         assertEquals(1, fixture.getCount(Arrays.asList(session.get(0), session.get(1)))); 
    339         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1), session.get(2)))); 
    340         assertEquals(1, fixture.getCount(Arrays.asList(session.get(2), session.get(3)))); 
    341          
    342         assertEquals(1, fixture.getCount(Arrays.asList(session.get(0), session.get(1), 
    343                                                        session.get(2)))); 
    344         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1), session.get(2), 
    345                                                        session.get(3)))); 
     363        assertEquals(0, fixture.getCount(Arrays.asList(session.get(3).getTask()))); 
     364         
     365         
     366        assertEquals(1, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     367                                                       session.get(1).getTask()))); 
     368        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask(), 
     369                                                       session.get(2).getTask()))); 
     370        assertEquals(1, fixture.getCount(Arrays.asList(session.get(2).getTask(), 
     371                                                       session.get(3).getTask()))); 
     372         
     373        assertEquals(1, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     374                                                       session.get(1).getTask(), 
     375                                                       session.get(2).getTask()))); 
     376        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask(), 
     377                                                       session.get(2).getTask(), 
     378                                                       session.get(3).getTask()))); 
    346379         
    347380        // we only trained shorter sequences, so we expect a count of 0 for longer ones 
    348         assertEquals(1, fixture.getCount(Arrays.asList(session.get(0), session.get(1), 
    349                                                        session.get(2), session.get(3)))); 
     381        assertEquals(1, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     382                                                       session.get(1).getTask(), 
     383                                                       session.get(2).getTask(), 
     384                                                       session.get(3).getTask()))); 
    350385         
    351386        // subsequences of length 1 are not trained. So the single item sequence of the last 
    … …  
    371406            // subsequences of length 1 are not trained. So the single item sequence of the last 
    372407            // task is not counted. Therefore, the result must be 3 
    373             assertEquals(3, fixture.getCount(Arrays.asList(session.get(i)))); 
     408            assertEquals(3, fixture.getCount(Arrays.asList(session.get(i).getTask()))); 
    374409             
    375410            for (int j = 0; j < session.size(); j++) { 
    376                 assertEquals(3, fixture.getCount(Arrays.asList(session.get(i), session.get(j)))); 
     411                assertEquals(3, fixture.getCount(Arrays.asList(session.get(i).getTask(), 
     412                                                               session.get(j).getTask()))); 
    377413                 
    378414                for (int k = 0; k < session.size(); k++) { 
    379                     assertEquals(2, fixture.getCount(Arrays.asList(session.get(i), session.get(j), 
    380                                                                    session.get(k))));                     
     415                    assertEquals(2, fixture.getCount(Arrays.asList(session.get(i).getTask(), 
     416                                                                   session.get(j).getTask(), 
     417                                                                   session.get(k).getTask())));                     
    381418                } 
    382419            } 
    … …  
    384421             
    385422        // we only trained shorter sequences, so we expect a count of 0 for longer ones 
    386         assertEquals(1, fixture.getCount(Arrays.asList(session.get(0), session.get(1), 
    387                                                        session.get(2), session.get(3)))); 
     423        assertEquals(1, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     424                                                       session.get(1).getTask(), 
     425                                                       session.get(2).getTask(), 
     426                                                       session.get(3).getTask()))); 
    388427         
    389428        assertEquals(1, fixture.getNumSymbols()); 
    … …  
    406445        // subsequences of length 1 are not trained. So the single item sequence of the last 
    407446        // task is not counted. Therefore, the result must be 3 
    408         assertEquals(2, fixture.getCount(Arrays.asList(session.get(0)))); 
    409         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1)))); 
    410         assertEquals(2, fixture.getCount(Arrays.asList(session.get(2)))); 
    411         assertEquals(1, fixture.getCount(Arrays.asList(session.get(3)))); 
    412          
    413         assertEquals(2, fixture.getCount(Arrays.asList(session.get(0), session.get(1)))); 
    414         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1), session.get(2)))); 
    415         assertEquals(2, fixture.getCount(Arrays.asList(session.get(2), session.get(3)))); 
    416          
    417         assertEquals(1, fixture.getCount(Arrays.asList(session.get(0), session.get(1), 
    418                                                        session.get(2)))); 
    419         assertEquals(1, fixture.getCount(Arrays.asList(session.get(1), session.get(2), 
    420                                                        session.get(3)))); 
     447        assertEquals(2, fixture.getCount(Arrays.asList(session.get(0).getTask()))); 
     448        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask()))); 
     449        assertEquals(2, fixture.getCount(Arrays.asList(session.get(2).getTask()))); 
     450        assertEquals(1, fixture.getCount(Arrays.asList(session.get(3).getTask()))); 
     451         
     452        assertEquals(2, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     453                                                       session.get(1).getTask()))); 
     454        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask(), 
     455                                                       session.get(2).getTask()))); 
     456        assertEquals(2, fixture.getCount(Arrays.asList(session.get(2).getTask(), 
     457                                                       session.get(3).getTask()))); 
     458         
     459        assertEquals(1, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     460                                                       session.get(1).getTask(), 
     461                                                       session.get(2).getTask()))); 
     462        assertEquals(1, fixture.getCount(Arrays.asList(session.get(1).getTask(), 
     463                                                       session.get(2).getTask(), 
     464                                                       session.get(3).getTask()))); 
    421465         
    422466        // we only trained shorter sequences, so we expect a count of 0 for longer ones 
    423         assertEquals(1, fixture.getCount(Arrays.asList(session.get(0), session.get(1), 
    424                                                        session.get(2), session.get(3)))); 
     467        assertEquals(1, fixture.getCount(Arrays.asList(session.get(0).getTask(), 
     468                                                       session.get(1).getTask(), 
     469                                                       session.get(2).getTask(), 
     470                                                       session.get(3).getTask()))); 
    425471         
    426472        assertEquals(2, fixture.getNumSymbols()); 
    … …  
    435481 
    436482        // get all sequences with a minimal length of one that occur most often 
    437         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(1, 0); 
     483        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(1, 0); 
    438484 
    439485        assertEquals(1, result.size()); 
    440486         
    441         List<ITaskInstance> expected = new ArrayList<ITaskInstance>(); 
    442         expected.add(session.get(0)); 
    443          
    444         assertContains((List<List<ITaskInstance>>) result, expected); 
     487        List<ITask> expected = new ArrayList<ITask>(); 
     488        expected.add(session.get(0).getTask()); 
     489         
     490        assertContains((List<List<ITask>>) result, expected); 
    445491    } 
    446492 
    … …  
    452498 
    453499        // get all sequences with a minimal length of one that occur exactly once 
    454         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(1, 1); 
     500        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(1, 1); 
    455501 
    456502        assertEquals(11, result.size()); 
    457503 
    458         List<ITaskInstance> expected = new ArrayList<ITaskInstance>(); 
    459         expected.add(session.get(2)); //r 
    460         expected.add(session.get(0)); //a 
    461         expected.add(session.get(4)); //c 
     504        List<ITask> expected = new ArrayList<ITask>(); 
     505        expected.add(session.get(2).getTask()); //r 
     506        expected.add(session.get(0).getTask()); //a 
     507        expected.add(session.get(4).getTask()); //c 
    462508        // rac 
    463         assertContains((List<List<ITaskInstance>>) result, expected); 
    464  
    465         expected.clear(); 
    466         expected.add(session.get(0)); //a 
    467         expected.add(session.get(4)); //c 
     509        assertContains((List<List<ITask>>) result, expected); 
     510 
     511        expected.clear(); 
     512        expected.add(session.get(0).getTask()); //a 
     513        expected.add(session.get(4).getTask()); //c 
    468514        // ac 
    469         assertContains((List<List<ITaskInstance>>) result, expected); 
    470  
    471         expected.add(session.get(0)); //a 
     515        assertContains((List<List<ITask>>) result, expected); 
     516 
     517        expected.add(session.get(0).getTask()); //a 
    472518        // aca 
    473         assertContains((List<List<ITaskInstance>>) result, expected); 
    474  
    475         expected.clear(); 
    476         expected.add(session.get(4)); //c 
     519        assertContains((List<List<ITask>>) result, expected); 
     520 
     521        expected.clear(); 
     522        expected.add(session.get(4).getTask()); //c 
    477523        // c 
    478         assertContains((List<List<ITaskInstance>>) result, expected); 
    479  
    480         expected.add(session.get(0)); //a 
     524        assertContains((List<List<ITask>>) result, expected); 
     525 
     526        expected.add(session.get(0).getTask()); //a 
    481527        // ca 
    482         assertContains((List<List<ITaskInstance>>) result, expected); 
    483  
    484         expected.add(session.get(6)); //d 
     528        assertContains((List<List<ITask>>) result, expected); 
     529 
     530        expected.add(session.get(6).getTask()); //d 
    485531        // cad 
    486         assertContains((List<List<ITaskInstance>>) result, expected); 
    487  
    488         expected.clear(); 
    489         expected.add(session.get(0)); //a 
    490         expected.add(session.get(6)); //d 
     532        assertContains((List<List<ITask>>) result, expected); 
     533 
     534        expected.clear(); 
     535        expected.add(session.get(0).getTask()); //a 
     536        expected.add(session.get(6).getTask()); //d 
    491537        // ad 
    492         assertContains((List<List<ITaskInstance>>) result, expected); 
    493  
    494         expected.add(session.get(0)); //a 
     538        assertContains((List<List<ITask>>) result, expected); 
     539 
     540        expected.add(session.get(0).getTask()); //a 
    495541        // ada 
    496         assertContains((List<List<ITaskInstance>>) result, expected); 
    497  
    498         expected.clear(); 
    499         expected.add(session.get(6)); //d 
     542        assertContains((List<List<ITask>>) result, expected); 
     543 
     544        expected.clear(); 
     545        expected.add(session.get(6).getTask()); //d 
    500546        // d 
    501         assertContains((List<List<ITaskInstance>>) result, expected); 
    502  
    503         expected.add(session.get(0)); //a 
     547        assertContains((List<List<ITask>>) result, expected); 
     548 
     549        expected.add(session.get(0).getTask()); //a 
    504550        // da 
    505         assertContains((List<List<ITaskInstance>>) result, expected); 
    506  
    507         expected.add(session.get(1)); //b 
     551        assertContains((List<List<ITask>>) result, expected); 
     552 
     553        expected.add(session.get(1).getTask()); //b 
    508554        // dab 
    509         assertContains((List<List<ITaskInstance>>) result, expected); 
     555        assertContains((List<List<ITask>>) result, expected); 
    510556    } 
    511557 
    … …  
    517563 
    518564        // get all sequences with a minimal length of one that occur exactly twice 
    519         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(1, 2); 
     565        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(1, 2); 
    520566 
    521567        assertEquals(7, result.size()); 
    522568 
    523         List<ITaskInstance> expected = new ArrayList<ITaskInstance>(); 
    524         expected.add(session.get(0)); //a 
    525         expected.add(session.get(1)); //b 
     569        List<ITask> expected = new ArrayList<ITask>(); 
     570        expected.add(session.get(0).getTask()); //a 
     571        expected.add(session.get(1).getTask()); //b 
    526572        // ab 
    527         assertContains((List<List<ITaskInstance>>) result, expected); 
    528  
    529         expected.add(session.get(2)); //r 
     573        assertContains((List<List<ITask>>) result, expected); 
     574 
     575        expected.add(session.get(2).getTask()); //r 
    530576        // abr 
    531         assertContains((List<List<ITaskInstance>>) result, expected); 
    532  
    533         expected.clear(); 
    534         expected.add(session.get(1)); //b 
     577        assertContains((List<List<ITask>>) result, expected); 
     578 
     579        expected.clear(); 
     580        expected.add(session.get(1).getTask()); //b 
    535581        // b 
    536         assertContains((List<List<ITaskInstance>>) result, expected); 
    537  
    538         expected.add(session.get(2)); //r 
     582        assertContains((List<List<ITask>>) result, expected); 
     583 
     584        expected.add(session.get(2).getTask()); //r 
    539585        // br 
    540         assertContains((List<List<ITaskInstance>>) result, expected); 
    541  
    542         expected.add(session.get(0)); //a 
     586        assertContains((List<List<ITask>>) result, expected); 
     587 
     588        expected.add(session.get(0).getTask()); //a 
    543589        // bra 
    544         assertContains((List<List<ITaskInstance>>) result, expected); 
    545  
    546         expected.clear(); 
    547         expected.add(session.get(2)); //r 
     590        assertContains((List<List<ITask>>) result, expected); 
     591 
     592        expected.clear(); 
     593        expected.add(session.get(2).getTask()); //r 
    548594        // r 
    549         assertContains((List<List<ITaskInstance>>) result, expected); 
    550  
    551         expected.add(session.get(0)); //a 
     595        assertContains((List<List<ITask>>) result, expected); 
     596 
     597        expected.add(session.get(0).getTask()); //a 
    552598        // ra 
    553         assertContains((List<List<ITaskInstance>>) result, expected); 
     599        assertContains((List<List<ITask>>) result, expected); 
    554600    } 
    555601 
    … …  
    561607 
    562608        // get all sequences with a minimal length of one that occur exactly three times 
    563         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(1, 3); 
     609        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(1, 3); 
    564610 
    565611        assertEquals(0, result.size()); 
    … …  
    573619 
    574620        // get all sequences with a minimal length of one that occur exactly four times 
    575         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(1, 4); 
     621        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(1, 4); 
    576622 
    577623        // as we did not train the last single action, we may expect the "a" action only 4 times 
    578624        assertEquals(1, result.size()); 
    579625 
    580         List<ITaskInstance> expected = new ArrayList<ITaskInstance>(); 
    581         expected.add(session.get(0)); //a 
    582         assertContains((List<List<ITaskInstance>>) result, expected); 
     626        List<ITask> expected = new ArrayList<ITask>(); 
     627        expected.add(session.get(0).getTask()); //a 
     628        assertContains((List<List<ITask>>) result, expected); 
    583629    } 
    584630 
    … …  
    590636 
    591637        // get all sequences with a minimal length of one that occur exactly five times 
    592         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(1, 5); 
     638        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(1, 5); 
    593639 
    594640        // as we did not train the last single action, we may expect the "a" action only 4 times 
    … …  
    603649 
    604650        // get all sequences with a minimal length of two that occur most often 
    605         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(2, 0); 
     651        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(2, 0); 
    606652 
    607653        assertEquals(5, result.size()); 
    608654 
    609         List<ITaskInstance> expected = new ArrayList<ITaskInstance>(); 
    610         expected.add(session.get(0)); //a 
    611         expected.add(session.get(1)); //b 
    612         assertContains((List<List<ITaskInstance>>) result, expected); 
    613  
    614         expected.add(session.get(2)); //r 
    615         assertContains((List<List<ITaskInstance>>) result, expected); 
    616  
    617         expected.clear(); 
    618         expected.add(session.get(1)); //b 
    619         expected.add(session.get(2)); //r 
    620         assertContains((List<List<ITaskInstance>>) result, expected); 
    621  
    622         expected.add(session.get(0)); //a 
    623         assertContains((List<List<ITaskInstance>>) result, expected); 
    624  
    625         expected.clear(); 
    626         expected.add(session.get(2)); //r 
    627         expected.add(session.get(0)); //a 
    628         assertContains((List<List<ITaskInstance>>) result, expected); 
     655        List<ITask> expected = new ArrayList<ITask>(); 
     656        expected.add(session.get(0).getTask()); //a 
     657        expected.add(session.get(1).getTask()); //b 
     658        assertContains((List<List<ITask>>) result, expected); 
     659 
     660        expected.add(session.get(2).getTask()); //r 
     661        assertContains((List<List<ITask>>) result, expected); 
     662 
     663        expected.clear(); 
     664        expected.add(session.get(1).getTask()); //b 
     665        expected.add(session.get(2).getTask()); //r 
     666        assertContains((List<List<ITask>>) result, expected); 
     667 
     668        expected.add(session.get(0).getTask()); //a 
     669        assertContains((List<List<ITask>>) result, expected); 
     670 
     671        expected.clear(); 
     672        expected.add(session.get(2).getTask()); //r 
     673        expected.add(session.get(0).getTask()); //a 
     674        assertContains((List<List<ITask>>) result, expected); 
    629675    } 
    630676 
    … …  
    636682 
    637683        // get all sequences with a minimal length of two that occur exactly once 
    638         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(2, 1); 
     684        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(2, 1); 
    639685 
    640686        assertEquals(9, result.size()); 
    641687 
    642         List<ITaskInstance> expected = new ArrayList<ITaskInstance>(); 
    643         expected.add(session.get(2)); //r 
    644         expected.add(session.get(0)); //a 
    645         expected.add(session.get(4)); //c 
     688        List<ITask> expected = new ArrayList<ITask>(); 
     689        expected.add(session.get(2).getTask()); //r 
     690        expected.add(session.get(0).getTask()); //a 
     691        expected.add(session.get(4).getTask()); //c 
    646692        // rac 
    647         assertContains((List<List<ITaskInstance>>) result, expected); 
    648  
    649         expected.clear(); 
    650         expected.add(session.get(0)); //a 
    651         expected.add(session.get(4)); //c 
     693        assertContains((List<List<ITask>>) result, expected); 
     694 
     695        expected.clear(); 
     696        expected.add(session.get(0).getTask()); //a 
     697        expected.add(session.get(4).getTask()); //c 
    652698        // ac 
    653         assertContains((List<List<ITaskInstance>>) result, expected); 
    654  
    655         expected.add(session.get(0)); //a 
     699        assertContains((List<List<ITask>>) result, expected); 
     700 
     701        expected.add(session.get(0).getTask()); //a 
    656702        // aca 
    657         assertContains((List<List<ITaskInstance>>) result, expected); 
    658  
    659         expected.clear(); 
    660         expected.add(session.get(4)); //c 
    661         expected.add(session.get(0)); //a 
     703        assertContains((List<List<ITask>>) result, expected); 
     704 
     705        expected.clear(); 
     706        expected.add(session.get(4).getTask()); //c 
     707        expected.add(session.get(0).getTask()); //a 
    662708        // ca 
    663         assertContains((List<List<ITaskInstance>>) result, expected); 
    664  
    665         expected.add(session.get(6)); //d 
     709        assertContains((List<List<ITask>>) result, expected); 
     710 
     711        expected.add(session.get(6).getTask()); //d 
    666712        // cad 
    667         assertContains((List<List<ITaskInstance>>) result, expected); 
    668  
    669         expected.clear(); 
    670         expected.add(session.get(0)); //a 
    671         expected.add(session.get(6)); //d 
     713        assertContains((List<List<ITask>>) result, expected); 
     714 
     715        expected.clear(); 
     716        expected.add(session.get(0).getTask()); //a 
     717        expected.add(session.get(6).getTask()); //d 
    672718        // ad 
    673         assertContains((List<List<ITaskInstance>>) result, expected); 
    674  
    675         expected.add(session.get(0)); //a 
     719        assertContains((List<List<ITask>>) result, expected); 
     720 
     721        expected.add(session.get(0).getTask()); //a 
    676722        // ada 
    677         assertContains((List<List<ITaskInstance>>) result, expected); 
    678  
    679         expected.clear(); 
    680         expected.add(session.get(6)); //d 
    681         expected.add(session.get(0)); //a 
     723        assertContains((List<List<ITask>>) result, expected); 
     724 
     725        expected.clear(); 
     726        expected.add(session.get(6).getTask()); //d 
     727        expected.add(session.get(0).getTask()); //a 
    682728        // da 
    683         assertContains((List<List<ITaskInstance>>) result, expected); 
    684  
    685         expected.add(session.get(1)); //b 
     729        assertContains((List<List<ITask>>) result, expected); 
     730 
     731        expected.add(session.get(1).getTask()); //b 
    686732        // dab 
    687         assertContains((List<List<ITaskInstance>>) result, expected); 
     733        assertContains((List<List<ITask>>) result, expected); 
    688734    } 
    689735 
    … …  
    695741 
    696742        // get all sequences with a minimal length of two that occur exactly twice 
    697         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(2, 2); 
     743        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(2, 2); 
    698744 
    699745        assertEquals(5, result.size()); 
    700746 
    701         List<ITaskInstance> expected = new ArrayList<ITaskInstance>(); 
    702         expected.add(session.get(0)); //a 
    703         expected.add(session.get(1)); //b 
     747        List<ITask> expected = new ArrayList<ITask>(); 
     748        expected.add(session.get(0).getTask()); //a 
     749        expected.add(session.get(1).getTask()); //b 
    704750        // ab 
    705         assertContains((List<List<ITaskInstance>>) result, expected); 
    706  
    707         expected.add(session.get(2)); //r 
     751        assertContains((List<List<ITask>>) result, expected); 
     752 
     753        expected.add(session.get(2).getTask()); //r 
    708754        // abr 
    709         assertContains((List<List<ITaskInstance>>) result, expected); 
    710  
    711         expected.clear(); 
    712         expected.add(session.get(1)); //b 
    713         expected.add(session.get(2)); //r 
     755        assertContains((List<List<ITask>>) result, expected); 
     756 
     757        expected.clear(); 
     758        expected.add(session.get(1).getTask()); //b 
     759        expected.add(session.get(2).getTask()); //r 
    714760        // br 
    715         assertContains((List<List<ITaskInstance>>) result, expected); 
    716  
    717         expected.add(session.get(0)); //a 
     761        assertContains((List<List<ITask>>) result, expected); 
     762 
     763        expected.add(session.get(0).getTask()); //a 
    718764        // bra 
    719         assertContains((List<List<ITaskInstance>>) result, expected); 
    720  
    721         expected.clear(); 
    722         expected.add(session.get(2)); //r 
    723         expected.add(session.get(0)); //a 
     765        assertContains((List<List<ITask>>) result, expected); 
     766 
     767        expected.clear(); 
     768        expected.add(session.get(2).getTask()); //r 
     769        expected.add(session.get(0).getTask()); //a 
    724770        // ra 
    725         assertContains((List<List<ITaskInstance>>) result, expected); 
     771        assertContains((List<List<ITask>>) result, expected); 
    726772    } 
    727773 
    … …  
    733779 
    734780        // get all sequences with a minimal length of two that occur exactly three times 
    735         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(2, 3); 
     781        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(2, 3); 
    736782 
    737783        assertEquals(0, result.size()); 
    … …  
    745791 
    746792        // get all sequences with a minimal length of three that occur most often 
    747         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(3, 0); 
     793        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(3, 0); 
    748794 
    749795        assertEquals(2, result.size()); 
    750796 
    751         List<ITaskInstance> expected = new ArrayList<ITaskInstance>(); 
    752         expected.add(session.get(0)); //a 
    753         expected.add(session.get(1)); //b 
    754         expected.add(session.get(2)); //r 
    755         assertContains((List<List<ITaskInstance>>) result, expected); 
    756  
    757         expected.clear(); 
    758         expected.add(session.get(1)); //b 
    759         expected.add(session.get(2)); //r 
    760         expected.add(session.get(0)); //a 
    761         assertContains((List<List<ITaskInstance>>) result, expected); 
     797        List<ITask> expected = new ArrayList<ITask>(); 
     798        expected.add(session.get(0).getTask()); //a 
     799        expected.add(session.get(1).getTask()); //b 
     800        expected.add(session.get(2).getTask()); //r 
     801        assertContains((List<List<ITask>>) result, expected); 
     802 
     803        expected.clear(); 
     804        expected.add(session.get(1).getTask()); //b 
     805        expected.add(session.get(2).getTask()); //r 
     806        expected.add(session.get(0).getTask()); //a 
     807        assertContains((List<List<ITask>>) result, expected); 
    762808    } 
    763809 
    … …  
    769815 
    770816        // get all sequences with a minimal length of three that occur exactly once 
    771         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(3, 1); 
     817        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(3, 1); 
    772818 
    773819        assertEquals(5, result.size()); 
    774820 
    775         List<ITaskInstance> expected = new ArrayList<ITaskInstance>(); 
    776         expected.add(session.get(2)); //r 
    777         expected.add(session.get(0)); //a 
    778         expected.add(session.get(4)); //c 
     821        List<ITask> expected = new ArrayList<ITask>(); 
     822        expected.add(session.get(2).getTask()); //r 
     823        expected.add(session.get(0).getTask()); //a 
     824        expected.add(session.get(4).getTask()); //c 
    779825        // rac 
    780         assertContains((List<List<ITaskInstance>>) result, expected); 
    781  
    782         expected.clear(); 
    783         expected.add(session.get(0)); //a 
    784         expected.add(session.get(4)); //c 
    785         expected.add(session.get(0)); //a 
     826        assertContains((List<List<ITask>>) result, expected); 
     827 
     828        expected.clear(); 
     829        expected.add(session.get(0).getTask()); //a 
     830        expected.add(session.get(4).getTask()); //c 
     831        expected.add(session.get(0).getTask()); //a 
    786832        // aca 
    787         assertContains((List<List<ITaskInstance>>) result, expected); 
    788  
    789         expected.clear(); 
    790         expected.add(session.get(4)); //c 
    791         expected.add(session.get(0)); //a 
    792         expected.add(session.get(6)); //d 
     833        assertContains((List<List<ITask>>) result, expected); 
     834 
     835        expected.clear(); 
     836        expected.add(session.get(4).getTask()); //c 
     837        expected.add(session.get(0).getTask()); //a 
     838        expected.add(session.get(6).getTask()); //d 
    793839        // cad 
    794         assertContains((List<List<ITaskInstance>>) result, expected); 
    795  
    796         expected.clear(); 
    797         expected.add(session.get(0)); //a 
    798         expected.add(session.get(6)); //d 
    799         expected.add(session.get(0)); //a 
     840        assertContains((List<List<ITask>>) result, expected); 
     841 
     842        expected.clear(); 
     843        expected.add(session.get(0).getTask()); //a 
     844        expected.add(session.get(6).getTask()); //d 
     845        expected.add(session.get(0).getTask()); //a 
    800846        // ada 
    801         assertContains((List<List<ITaskInstance>>) result, expected); 
    802  
    803         expected.clear(); 
    804         expected.add(session.get(6)); //d 
    805         expected.add(session.get(0)); //a 
    806         expected.add(session.get(1)); //b 
     847        assertContains((List<List<ITask>>) result, expected); 
     848 
     849        expected.clear(); 
     850        expected.add(session.get(6).getTask()); //d 
     851        expected.add(session.get(0).getTask()); //a 
     852        expected.add(session.get(1).getTask()); //b 
    807853        // dab 
    808         assertContains((List<List<ITaskInstance>>) result, expected); 
     854        assertContains((List<List<ITask>>) result, expected); 
    809855    } 
    810856 
    … …  
    816862 
    817863        // get all sequences with a minimal length of four that occur most often 
    818         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(4, 0); 
     864        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(4, 0); 
    819865 
    820866        // none of these exist, as the tree is only trained with sequences of length 3 
    … …  
    829875 
    830876        // get all sequences with a minimal length of four that occur exactly once 
    831         Collection<List<ITaskInstance>> result = fixture.getSequencesWithOccurrenceCount(4, 1); 
     877        Collection<List<ITask>> result = fixture.getSequencesWithOccurrenceCount(4, 1); 
    832878 
    833879        // none of these exist, as the tree is only trained with sequences of length 3 
    … …  
    841887        fixture.trainSessions(Arrays.asList(session), 3); 
    842888 
    843         List<ITaskInstance> subSequence = new ArrayList<ITaskInstance>(); 
    844         subSequence.add(session.get(0)); //a 
     889        List<ITask> subSequence = new ArrayList<ITask>(); 
     890        subSequence.add(session.get(0).getTask()); //a 
    845891 
    846892        int result = fixture.getCount(subSequence); 
    … …  
    856902        fixture.trainSessions(Arrays.asList(session), 3); 
    857903 
    858         List<ITaskInstance> subSequence = new ArrayList<ITaskInstance>(); 
    859         subSequence.add(session.get(0)); //a 
    860         subSequence.add(session.get(1)); //b 
     904        List<ITask> subSequence = new ArrayList<ITask>(); 
     905        subSequence.add(session.get(0).getTask()); //a 
     906        subSequence.add(session.get(1).getTask()); //b 
    861907 
    862908        int result = fixture.getCount(subSequence); 
    … …  
    871917        fixture.trainSessions(Arrays.asList(session), 3); 
    872918 
    873         List<ITaskInstance> subSequence = new ArrayList<ITaskInstance>(); 
    874         subSequence.add(taskFactory.createNewTaskInstance(taskFactory.createNewSequence())); 
     919        List<ITask> subSequence = new ArrayList<ITask>(); 
     920        subSequence.add(taskFactory.createNewSequence()); 
    875921 
    876922        int result = fixture.getCount(subSequence); 
    … …  
    885931        fixture.trainSessions(Arrays.asList(session), 3); 
    886932 
    887         List<ITaskInstance> subSequence = new ArrayList<ITaskInstance>(); 
    888  
    889         int result = fixture.getCount(subSequence, session.get(0)); //a 
     933        List<ITask> subSequence = new ArrayList<ITask>(); 
     934 
     935        int result = fixture.getCount(subSequence, session.get(0).getTask()); //a 
    890936 
    891937        // as we did not train the last single action, we may expect the "a" action only 4 times 
    … …  
    899945        fixture.trainSessions(Arrays.asList(session), 3); 
    900946 
    901         List<ITaskInstance> subSequence = new ArrayList<ITaskInstance>(); 
    902         subSequence.add(session.get(0)); //a 
    903         subSequence.add(session.get(1)); //b 
    904  
    905         int result = fixture.getCount(subSequence, session.get(2)); //r 
     947        List<ITask> subSequence = new ArrayList<ITask>(); 
     948        subSequence.add(session.get(0).getTask()); //a 
     949        subSequence.add(session.get(1).getTask()); //b 
     950 
     951        int result = fixture.getCount(subSequence, session.get(2).getTask()); //r 
    906952 
    907953        assertEquals(2, result); 
    … …  
    914960        fixture.trainSessions(Arrays.asList(session), 3); 
    915961 
    916         List<ITaskInstance> subSequence = new ArrayList<ITaskInstance>(); 
     962        List<ITask> subSequence = new ArrayList<ITask>(); 
    917963 
    918964        int result = fixture.getCount 
    919             (subSequence, taskFactory.createNewTaskInstance(taskFactory.createNewSequence())); 
     965            (subSequence, taskFactory.createNewSequence()); 
    920966 
    921967        assertEquals(0, result); 
    … …  
    928974        fixture.trainSessions(Arrays.asList(session), 3); 
    929975 
    930         List<ITaskInstance> subSequence = new ArrayList<ITaskInstance>(); 
    931         subSequence.add(session.get(0)); //a 
    932         Collection<ITaskInstance> expected = new ArrayList<ITaskInstance>(); 
    933         expected.add(session.get(1)); //b 
    934         expected.add(session.get(4)); //c 
    935         expected.add(session.get(6)); //d 
    936  
    937         Collection<ITaskInstance> result = fixture.getFollowingSymbols(subSequence); 
     976        List<ITask> subSequence = new ArrayList<ITask>(); 
     977        subSequence.add(session.get(0).getTask()); //a 
     978        Collection<ITask> expected = new ArrayList<ITask>(); 
     979        expected.add(session.get(1).getTask()); //b 
     980        expected.add(session.get(4).getTask()); //c 
     981        expected.add(session.get(6).getTask()); //d 
     982 
     983        Collection<ITask> result = fixture.getFollowingSymbols(subSequence); 
    938984 
    939985        assertCollectionContent(expected, result); 
    … …  
    946992        fixture.trainSessions(Arrays.asList(session), 3); 
    947993 
    948         List<ITaskInstance> subSequence = new ArrayList<ITaskInstance>(); 
    949         subSequence.add(session.get(0)); //a 
    950         subSequence.add(session.get(1)); //b 
    951         subSequence.add(session.get(2)); //r 
    952  
    953         Collection<ITaskInstance> result = fixture.getFollowingSymbols(subSequence); 
     994        List<ITask> subSequence = new ArrayList<ITask>(); 
     995        subSequence.add(session.get(0).getTask()); //a 
     996        subSequence.add(session.get(1).getTask()); //b 
     997        subSequence.add(session.get(2).getTask()); //r 
     998 
     999        Collection<ITask> result = fixture.getFollowingSymbols(subSequence); 
    9541000 
    9551001        assertEquals(0, result.size()); 
    … …  
    9621008        fixture.trainSessions(Arrays.asList(session), 3); 
    9631009 
    964         List<ITaskInstance> subSequence = new ArrayList<ITaskInstance>(); 
    965         subSequence.add(taskFactory.createNewTaskInstance(taskFactory.createNewSequence())); 
    966  
    967         Collection<ITaskInstance> result = fixture.getFollowingSymbols(subSequence); 
     1010        List<ITask> subSequence = new ArrayList<ITask>(); 
     1011        subSequence.add(taskFactory.createNewSequence()); 
     1012 
     1013        Collection<ITask> result = fixture.getFollowingSymbols(subSequence); 
    9681014 
    9691015        assertEquals(0, result.size()); 
    … …  
    10101056        int order = 2; 
    10111057         
    1012         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(3, 50, order); 
     1058        TaskTrieTester tester = new TaskTrieTester(3, 50, order); 
    10131059 
    10141060        long start = System.currentTimeMillis(); 
    … …  
    10301076        int order = 2; 
    10311077         
    1032         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(3, 10000, order); 
     1078        TaskTrieTester tester = new TaskTrieTester(3, 10000, order); 
    10331079 
    10341080        long start = System.currentTimeMillis(); 
    … …  
    10501096        int order = 2; 
    10511097         
    1052         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(30, 10000, order); 
     1098        TaskTrieTester tester = new TaskTrieTester(30, 10000, order); 
    10531099 
    10541100        long start = System.currentTimeMillis(); 
    … …  
    10701116        int order = 2; 
    10711117         
    1072         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(300, 10000, order); 
     1118        TaskTrieTester tester = new TaskTrieTester(300, 10000, order); 
    10731119 
    10741120        long start = System.currentTimeMillis(); 
    … …  
    10901136        int order = 2; 
    10911137         
    1092         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(1000, 10000, order); 
     1138        TaskTrieTester tester = new TaskTrieTester(1000, 10000, order); 
    10931139 
    10941140        long start = System.currentTimeMillis(); 
    … …  
    11101156        int order = 3; 
    11111157         
    1112         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(3, 50, order); 
     1158        TaskTrieTester tester = new TaskTrieTester(3, 50, order); 
    11131159 
    11141160        long start = System.currentTimeMillis(); 
    … …  
    11301176        int order = 3; 
    11311177         
    1132         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(3, 10000, order); 
     1178        TaskTrieTester tester = new TaskTrieTester(3, 10000, order); 
    11331179 
    11341180        long start = System.currentTimeMillis(); 
    … …  
    11501196        int order = 3; 
    11511197         
    1152         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(30, 10000, order); 
     1198        TaskTrieTester tester = new TaskTrieTester(30, 10000, order); 
    11531199 
    11541200        long start = System.currentTimeMillis(); 
    … …  
    11701216        int order = 3; 
    11711217         
    1172         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(300, 10000, order); 
     1218        TaskTrieTester tester = new TaskTrieTester(300, 10000, order); 
    11731219 
    11741220        long start = System.currentTimeMillis(); 
    … …  
    11901236        int order = 3; 
    11911237         
    1192         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(1000, 10000, order); 
     1238        TaskTrieTester tester = new TaskTrieTester(1000, 10000, order); 
    11931239 
    11941240        long start = System.currentTimeMillis(); 
    … …  
    12101256        int order = 4; 
    12111257         
    1212         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(3, 50, order); 
     1258        TaskTrieTester tester = new TaskTrieTester(3, 50, order); 
    12131259 
    12141260        long start = System.currentTimeMillis(); 
    … …  
    12301276        int order = 4; 
    12311277         
    1232         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(3, 10000, order); 
     1278        TaskTrieTester tester = new TaskTrieTester(3, 10000, order); 
    12331279 
    12341280        long start = System.currentTimeMillis(); 
    … …  
    12501296        int order = 4; 
    12511297         
    1252         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(30, 10000, order); 
     1298        TaskTrieTester tester = new TaskTrieTester(30, 10000, order); 
    12531299 
    12541300        long start = System.currentTimeMillis(); 
    … …  
    12701316        int order = 4; 
    12711317         
    1272         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(300, 10000, order); 
     1318        TaskTrieTester tester = new TaskTrieTester(300, 10000, order); 
    12731319 
    12741320        long start = System.currentTimeMillis(); 
    … …  
    12901336        int order = 4; 
    12911337         
    1292         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(1000, 10000, order); 
     1338        TaskTrieTester tester = new TaskTrieTester(1000, 10000, order); 
    12931339 
    12941340        long start = System.currentTimeMillis(); 
    … …  
    13101356        int order = 5; 
    13111357         
    1312         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(3, 50, order); 
     1358        TaskTrieTester tester = new TaskTrieTester(3, 50, order); 
    13131359 
    13141360        long start = System.currentTimeMillis(); 
    … …  
    13301376        int order = 5; 
    13311377         
    1332         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(3, 10000, order); 
     1378        TaskTrieTester tester = new TaskTrieTester(3, 10000, order); 
    13331379 
    13341380        long start = System.currentTimeMillis(); 
    … …  
    13501396        int order = 5; 
    13511397         
    1352         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(30, 10000, order); 
     1398        TaskTrieTester tester = new TaskTrieTester(30, 10000, order); 
    13531399 
    13541400        long start = System.currentTimeMillis(); 
    … …  
    13701416        int order = 5; 
    13711417         
    1372         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(300, 10000, order); 
     1418        TaskTrieTester tester = new TaskTrieTester(300, 10000, order); 
    13731419 
    13741420        long start = System.currentTimeMillis(); 
    … …  
    13901436        int order = 5; 
    13911437         
    1392         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(1000, 10000, order); 
     1438        TaskTrieTester tester = new TaskTrieTester(1000, 10000, order); 
    13931439 
    13941440        long start = System.currentTimeMillis(); 
    … …  
    14101456        int order = 6; 
    14111457         
    1412         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(3, 50, order); 
     1458        TaskTrieTester tester = new TaskTrieTester(3, 50, order); 
    14131459 
    14141460        long start = System.currentTimeMillis(); 
    … …  
    14301476        int order = 6; 
    14311477         
    1432         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(3, 10000, order); 
     1478        TaskTrieTester tester = new TaskTrieTester(3, 10000, order); 
    14331479 
    14341480        long start = System.currentTimeMillis(); 
    … …  
    14501496        int order = 6; 
    14511497         
    1452         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(30, 10000, order); 
     1498        TaskTrieTester tester = new TaskTrieTester(30, 10000, order); 
    14531499 
    14541500        long start = System.currentTimeMillis(); 
    … …  
    14701516        int order = 6; 
    14711517         
    1472         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(300, 10000, order); 
     1518        TaskTrieTester tester = new TaskTrieTester(300, 10000, order); 
    14731519 
    14741520        long start = System.currentTimeMillis(); 
    … …  
    14901536        int order = 6; 
    14911537         
    1492         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(1000, 10000, order); 
     1538        TaskTrieTester tester = new TaskTrieTester(1000, 10000, order); 
    14931539 
    14941540        long start = System.currentTimeMillis(); 
    … …  
    15101556        int order = 3; 
    15111557         
    1512         TaskInstanceTrieTester tester = new TaskInstanceTrieTester(1000, 100000, order); 
     1558        TaskTrieTester tester = new TaskTrieTester(1000, 100000, order); 
    15131559 
    15141560        long start = System.currentTimeMillis(); 
    … …  
    15271573     *  
    15281574     */ 
    1529     private void assertContains(List<List<ITaskInstance>> listOfList, 
    1530                                 List<ITaskInstance>       containedList) 
     1575    private void assertContains(List<List<ITask>> listOfList, 
     1576                                List<ITask>       containedList) 
    15311577    { 
    15321578        boolean found = false; 
    1533         for (List<ITaskInstance> candidate : listOfList) { 
     1579        for (List<ITask> candidate : listOfList) { 
    15341580            if (candidate.size() == containedList.size()) { 
    15351581                found = true; 
    … …  
    15611607     * @author Patrick Harms 
    15621608     */ 
    1563     private class TaskInstanceTrieTester implements TrieProcessor<ITaskInstance> { 
     1609    private class TaskTrieTester implements TrieProcessor<ITask> { 
    15641610         
    15651611        /** 
    15661612         * the symbols used for testing the trie 
    15671613         */ 
    1568         private Map<Integer, ITaskInstance> symbols = new HashMap<Integer, ITaskInstance>(); 
     1614        private Map<Integer, ITask> symbols = new HashMap<Integer, ITask>(); 
    15691615 
    15701616        /** 
    … …  
    15961642         * trie calculated the count correctly and if it did not create too many nodes. 
    15971643         */ 
    1598         public TaskInstanceTrieTester(int noOfSymbols, int sequenceLength, int maxOrder) { 
     1644        public TaskTrieTester(int noOfSymbols, int sequenceLength, int maxOrder) { 
    15991645            if (noOfSymbols > 1024) { 
    16001646                throw new IllegalArgumentException("too large number of symbols"); 
    … …  
    16161662             
    16171663            for (int i = 0; i < dummySession.size(); i++) { 
    1618                 this.symbols.put(i, dummySession.get(i)); 
     1664                this.symbols.put(i, dummySession.get(i).getTask()); 
    16191665            } 
    16201666             
    … …  
    16751721         */ 
    16761722        @Override 
    1677         public TrieProcessor.Result process(List<ITaskInstance> sequence, int count) { 
     1723        public TrieProcessor.Result process(List<ITask> sequence, int count) { 
    16781724            long key = 0; 
    16791725             
    1680             for (ITaskInstance symbol : sequence) { 
     1726            for (ITask symbol : sequence) { 
    16811727                int symbolIndex = -1; 
    16821728                 
    1683                 for (Map.Entry<Integer, ITaskInstance> entry : symbols.entrySet()) { 
     1729                for (Map.Entry<Integer, ITask> entry : symbols.entrySet()) { 
    16841730                    if (strategy.getTaskComparator().equals(entry.getValue(), symbol)) { 
    16851731                        symbolIndex = entry.getKey(); 

  • 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()); 

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

    r1294 r1846  
    3333import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    3434import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; 
    35 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance; 
    3635import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; 
    3736import de.ugoe.cs.autoquest.test.DummyGUIElement; 
    … …  
    6261    @Test 
    6362    public void testSymbolMap_1() { 
    64         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     63        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    6564         
    6665        assertNotNull(symbolMap); 
    … …  
    7271        TaskSymbolIdentityMap<String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
    7372         
    74         ITaskInstance taskInstance = createTaskInstance("symbol"); 
    75         symbolMap1.addSymbol(taskInstance, "value"); 
    76          
    77         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>(symbolMap1); 
     73        ITask task = createTask("symbol"); 
     74        symbolMap1.addSymbol(task, "value"); 
     75         
     76        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolIdentityMap<String>(symbolMap1); 
    7877         
    7978        assertNotNull(symbolMap2); 
    80         assertSymbolMapEntries(symbolMap2, new ITaskInstance[] { taskInstance }, 
     79        assertSymbolMapEntries(symbolMap2, new ITask[] { task }, 
    8180                               new String[] { "value" }); 
    8281    } 
    … …  
    8988    @Test 
    9089    public void testAddSymbol_1() { 
    91         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    92              
    93         ITaskInstance taskInstance = createTaskInstance("symbol"); 
    94         symbolMap.addSymbol(taskInstance, "value1"); 
     90        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     91             
     92        ITask task = createTask("symbol"); 
     93        symbolMap.addSymbol(task, "value1"); 
    9594         
    9695        assertNotNull(symbolMap); 
    97         assertSymbolMapEntries(symbolMap, new ITaskInstance[] { taskInstance }, 
     96        assertSymbolMapEntries(symbolMap, new ITask[] { task }, 
    9897                               new String[] { "value1" }); 
    9998    } 
    … …  
    101100    @Test 
    102101    public void testAddSymbol_2() { 
    103         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    104          
    105         int entryCount = 2000; 
    106          
    107         ITaskInstance[] symbols = new ITaskInstance[entryCount]; 
     102        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     103         
     104        int entryCount = 2000; 
     105         
     106        ITask[] symbols = new ITask[entryCount]; 
    108107        String[] values = new String[entryCount]; 
    109108         
    110109        for (int i = 0; i < entryCount; i++) { 
    111             symbols[i] = createTaskInstance("symbol" + i); 
     110            symbols[i] = createTask("symbol" + i); 
    112111            symbolMap.addSymbol(symbols[i], "value" + i); 
    113112            values[i] = "value" + i; 
    … …  
    120119    @Test 
    121120    public void testAddSymbol_3() { 
    122         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    123          
    124         int entryCount = 2000; 
    125          
    126         ITaskInstance[] symbols = new ITaskInstance[entryCount]; 
     121        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     122         
     123        int entryCount = 2000; 
     124         
     125        ITask[] symbols = new ITask[entryCount]; 
    127126        String[] values = new String[entryCount]; 
    128127         
    129128        for (int i = 0; i < entryCount; i++) { 
    130             symbols[i] = createTaskInstance("symbol" + i); 
     129            symbols[i] = createTask("symbol" + i); 
    131130            if (i % 7 == 0) { 
    132131                values[i] = "value" + i; 
    … …  
    145144    @Test(expected = java.lang.IllegalArgumentException.class) 
    146145    public void testAddSymbol_4() { 
    147         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     146        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    148147             
    149148        symbolMap.addSymbol(null, null); 
    … …  
    152151    @Test 
    153152    public void testSize_1() { 
    154         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     153        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    155154             
    156155        assertEquals(0, symbolMap.size()); 
    … …  
    159158    @Test 
    160159    public void testSize_2() { 
    161         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    162              
    163         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
     160        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     161             
     162        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
    164163         
    165164        assertEquals(1, symbolMap.size()); 
    … …  
    168167    @Test 
    169168    public void testSize_3() { 
    170         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    171          
    172         int entryCount = 2000; 
    173          
    174         for (int i = 0; i < entryCount; i++) { 
    175             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
     169        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     170         
     171        int entryCount = 2000; 
     172         
     173        for (int i = 0; i < entryCount; i++) { 
     174            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
    176175        } 
    177176         
    … …  
    181180    @Test 
    182181    public void testSize_4() { 
    183         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    184          
    185         int entryCount = 2000; 
    186          
    187         for (int i = 0; i < entryCount; i++) { 
    188             if (i % 7 == 0) { 
    189                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    190             } 
    191             else { 
    192                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
     182        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     183         
     184        int entryCount = 2000; 
     185         
     186        for (int i = 0; i < entryCount; i++) { 
     187            if (i % 7 == 0) { 
     188                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     189            } 
     190            else { 
     191                symbolMap.addSymbol(createTask("symbol" + i), null); 
    193192            } 
    194193        } 
    … …  
    199198    @Test 
    200199    public void testSize_5() { 
    201         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    202          
    203         int entryCount = 2000; 
    204          
    205         for (int i = 0; i < entryCount; i++) { 
    206             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    207         } 
    208          
    209         for (int i = 150; i < (entryCount - 150); i++) { 
    210             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     200        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     201         
     202        int entryCount = 2000; 
     203         
     204        for (int i = 0; i < entryCount; i++) { 
     205            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     206        } 
     207         
     208        for (int i = 150; i < (entryCount - 150); i++) { 
     209            symbolMap.removeSymbol(createTask("symbol" + i)); 
    211210        } 
    212211         
    … …  
    216215    @Test 
    217216    public void testIsEmpty_1() { 
    218         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     217        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    219218             
    220219        assertTrue(symbolMap.isEmpty()); 
    … …  
    223222    @Test 
    224223    public void testIsEmpty_2() { 
    225         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    226              
    227         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
     224        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     225             
     226        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
    228227         
    229228        assertFalse(symbolMap.isEmpty()); 
    … …  
    232231    @Test 
    233232    public void testIsEmpty_3() { 
    234         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    235          
    236         int entryCount = 2000; 
    237          
    238         for (int i = 0; i < entryCount; i++) { 
    239             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
     233        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     234         
     235        int entryCount = 2000; 
     236         
     237        for (int i = 0; i < entryCount; i++) { 
     238            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
    240239        } 
    241240         
    … …  
    245244    @Test 
    246245    public void testIsEmpty_4() { 
    247         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    248          
    249         int entryCount = 2000; 
    250          
    251         for (int i = 0; i < entryCount; i++) { 
    252             if (i % 7 == 0) { 
    253                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    254             } 
    255             else { 
    256                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
     246        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     247         
     248        int entryCount = 2000; 
     249         
     250        for (int i = 0; i < entryCount; i++) { 
     251            if (i % 7 == 0) { 
     252                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     253            } 
     254            else { 
     255                symbolMap.addSymbol(createTask("symbol" + i), null); 
    257256            } 
    258257        } 
    … …  
    263262    @Test 
    264263    public void testIsEmpty_5() { 
    265         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    266          
    267         int entryCount = 2000; 
    268          
    269         for (int i = 0; i < entryCount; i++) { 
    270             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    271         } 
    272          
    273         for (int i = 150; i < (entryCount - 150); i++) { 
    274             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     264        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     265         
     266        int entryCount = 2000; 
     267         
     268        for (int i = 0; i < entryCount; i++) { 
     269            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     270        } 
     271         
     272        for (int i = 150; i < (entryCount - 150); i++) { 
     273            symbolMap.removeSymbol(createTask("symbol" + i)); 
    275274        } 
    276275         
    … …  
    280279    @Test 
    281280    public void testContainsSymbol_1() { 
    282         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    283              
    284         assertFalse(symbolMap.containsSymbol(createTaskInstance("symbol"))); 
     281        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     282             
     283        assertFalse(symbolMap.containsSymbol(createTask("symbol"))); 
    285284    } 
    286285     
    287286    @Test 
    288287    public void testContainsSymbol_2() { 
    289         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    290              
    291         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
    292          
    293         assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol1"))); 
     288        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     289             
     290        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
     291         
     292        assertTrue(symbolMap.containsSymbol(createTask("symbol1"))); 
    294293    } 
    295294     
    296295    @Test 
    297296    public void testContainsSymbol_3() { 
    298         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    299          
    300         int entryCount = 2000; 
    301          
    302         for (int i = 0; i < entryCount; i++) { 
    303             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    304         } 
    305          
    306         for (int i = 0; i < entryCount; i++) { 
    307             assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i))); 
     297        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     298         
     299        int entryCount = 2000; 
     300         
     301        for (int i = 0; i < entryCount; i++) { 
     302            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     303        } 
     304         
     305        for (int i = 0; i < entryCount; i++) { 
     306            assertTrue(symbolMap.containsSymbol(createTask("symbol" + i))); 
    308307        } 
    309308    } 
    … …  
    311310    @Test 
    312311    public void testContainsSymbol_4() { 
    313         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    314          
    315         int entryCount = 2000; 
    316          
    317         for (int i = 0; i < entryCount; i++) { 
    318             if (i % 7 == 0) { 
    319                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    320             } 
    321             else { 
    322                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
    323             } 
    324         } 
    325          
    326         for (int i = 0; i < entryCount; i++) { 
    327             assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i))); 
     312        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     313         
     314        int entryCount = 2000; 
     315         
     316        for (int i = 0; i < entryCount; i++) { 
     317            if (i % 7 == 0) { 
     318                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     319            } 
     320            else { 
     321                symbolMap.addSymbol(createTask("symbol" + i), null); 
     322            } 
     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_5() { 
    333         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    334          
    335         int entryCount = 2000; 
    336          
    337         for (int i = 0; i < entryCount; i++) { 
    338             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    339         } 
    340          
    341         for (int i = 150; i < (entryCount - 150); i++) { 
    342             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     332        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     333         
     334        int entryCount = 2000; 
     335         
     336        for (int i = 0; i < entryCount; i++) { 
     337            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     338        } 
     339         
     340        for (int i = 150; i < (entryCount - 150); i++) { 
     341            symbolMap.removeSymbol(createTask("symbol" + i)); 
    343342        } 
    344343         
    345344        for (int i = 0; i < 150; i++) { 
    346             assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i))); 
    347         } 
    348          
    349         for (int i = 150; i < (entryCount - 150); i++) { 
    350             assertFalse(symbolMap.containsSymbol(createTaskInstance("symbol" + i))); 
     345            assertTrue(symbolMap.containsSymbol(createTask("symbol" + i))); 
     346        } 
     347         
     348        for (int i = 150; i < (entryCount - 150); i++) { 
     349            assertFalse(symbolMap.containsSymbol(createTask("symbol" + i))); 
    351350        } 
    352351         
    353352        for (int i = (entryCount - 150); i < entryCount; i++) { 
    354             assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i))); 
     353            assertTrue(symbolMap.containsSymbol(createTask("symbol" + i))); 
    355354        } 
    356355    } 
    … …  
    358357    @Test(expected = java.lang.IllegalArgumentException.class) 
    359358    public void testContainsSymbol_6() { 
    360         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     359        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    361360             
    362361        symbolMap.containsSymbol(null); 
    … …  
    365364    @Test 
    366365    public void testGetValue_1() { 
    367         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    368              
    369         assertNull(symbolMap.getValue(createTaskInstance("symbol"))); 
     366        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     367             
     368        assertNull(symbolMap.getValue(createTask("symbol"))); 
    370369    } 
    371370     
    372371    @Test 
    373372    public void testGetValue_2() { 
    374         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    375              
    376         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
    377          
    378         assertNotNull(symbolMap.getValue(createTaskInstance("symbol1"))); 
     373        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     374             
     375        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
     376         
     377        assertNotNull(symbolMap.getValue(createTask("symbol1"))); 
    379378    } 
    380379     
    381380    @Test 
    382381    public void testGetValue_3() { 
    383         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    384              
    385         symbolMap.addSymbol(createTaskInstance("symbol1"), null); 
    386          
    387         assertNull(symbolMap.getValue(createTaskInstance("symbol1"))); 
     382        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     383             
     384        symbolMap.addSymbol(createTask("symbol1"), null); 
     385         
     386        assertNull(symbolMap.getValue(createTask("symbol1"))); 
    388387    } 
    389388     
    390389    @Test 
    391390    public void testGetValue_4() { 
    392         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    393          
    394         int entryCount = 2000; 
    395          
    396         for (int i = 0; i < entryCount; i++) { 
    397             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    398         } 
    399          
    400         for (int i = 0; i < entryCount; i++) { 
    401             assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i))); 
     391        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     392         
     393        int entryCount = 2000; 
     394         
     395        for (int i = 0; i < entryCount; i++) { 
     396            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     397        } 
     398         
     399        for (int i = 0; i < entryCount; i++) { 
     400            assertNotNull(symbolMap.getValue(createTask("symbol" + i))); 
    402401        } 
    403402    } 
    … …  
    405404    @Test 
    406405    public void testGetValue_5() { 
    407         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    408          
    409         int entryCount = 2000; 
    410          
    411         for (int i = 0; i < entryCount; i++) { 
    412             if (i % 7 == 0) { 
    413                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    414             } 
    415             else { 
    416                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
    417             } 
    418         } 
    419          
    420         for (int i = 0; i < entryCount; i++) { 
    421             if (i % 7 == 0) { 
    422                 assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i))); 
    423             } 
    424             else { 
    425                 assertNull(symbolMap.getValue(createTaskInstance("symbol" + i))); 
     406        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     407         
     408        int entryCount = 2000; 
     409         
     410        for (int i = 0; i < entryCount; i++) { 
     411            if (i % 7 == 0) { 
     412                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     413            } 
     414            else { 
     415                symbolMap.addSymbol(createTask("symbol" + i), null); 
     416            } 
     417        } 
     418         
     419        for (int i = 0; i < entryCount; i++) { 
     420            if (i % 7 == 0) { 
     421                assertNotNull(symbolMap.getValue(createTask("symbol" + i))); 
     422            } 
     423            else { 
     424                assertNull(symbolMap.getValue(createTask("symbol" + i))); 
    426425            } 
    427426        } 
    … …  
    430429    @Test 
    431430    public void testGetValue_6() { 
    432         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    433          
    434         int entryCount = 2000; 
    435          
    436         for (int i = 0; i < entryCount; i++) { 
    437             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    438         } 
    439          
    440         for (int i = 150; i < (entryCount - 150); i++) { 
    441             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     431        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     432         
     433        int entryCount = 2000; 
     434         
     435        for (int i = 0; i < entryCount; i++) { 
     436            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     437        } 
     438         
     439        for (int i = 150; i < (entryCount - 150); i++) { 
     440            symbolMap.removeSymbol(createTask("symbol" + i)); 
    442441        } 
    443442         
    444443        for (int i = 0; i < 150; i++) { 
    445             assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i))); 
    446         } 
    447          
    448         for (int i = 150; i < (entryCount - 150); i++) { 
    449             assertNull(symbolMap.getValue(createTaskInstance("symbol" + i))); 
     444            assertNotNull(symbolMap.getValue(createTask("symbol" + i))); 
     445        } 
     446         
     447        for (int i = 150; i < (entryCount - 150); i++) { 
     448            assertNull(symbolMap.getValue(createTask("symbol" + i))); 
    450449        } 
    451450         
    452451        for (int i = (entryCount - 150); i < entryCount; i++) { 
    453             assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i))); 
     452            assertNotNull(symbolMap.getValue(createTask("symbol" + i))); 
    454453        } 
    455454    } 
    … …  
    457456    @Test(expected = java.lang.IllegalArgumentException.class) 
    458457    public void testGetValue_7() { 
    459         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     458        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    460459             
    461460        symbolMap.getValue(null); 
    … …  
    464463    @Test 
    465464    public void testRemoveSymbol_1() { 
    466         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    467              
    468         assertNull(symbolMap.removeSymbol(createTaskInstance("symbol"))); 
     465        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     466             
     467        assertNull(symbolMap.removeSymbol(createTask("symbol"))); 
    469468    } 
    470469     
    471470    @Test 
    472471    public void testRemoveSymbol_2() { 
    473         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    474              
    475         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
    476          
    477         assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol1"))); 
     472        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     473             
     474        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
     475         
     476        assertNotNull(symbolMap.removeSymbol(createTask("symbol1"))); 
    478477        assertEquals(0, symbolMap.size()); 
    479478    } 
    … …  
    481480    @Test 
    482481    public void testRemoveSymbol_3() { 
    483         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    484              
    485         symbolMap.addSymbol(createTaskInstance("symbol1"), null); 
    486          
    487         assertNull(symbolMap.removeSymbol(createTaskInstance("symbol1"))); 
     482        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     483             
     484        symbolMap.addSymbol(createTask("symbol1"), null); 
     485         
     486        assertNull(symbolMap.removeSymbol(createTask("symbol1"))); 
    488487        assertEquals(0, symbolMap.size()); 
    489488    } 
    … …  
    491490    @Test 
    492491    public void testRemoveSymbol_4() { 
    493         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    494          
    495         int entryCount = 2000; 
    496          
    497         for (int i = 0; i < entryCount; i++) { 
    498             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    499         } 
    500          
    501         for (int i = 0; i < entryCount; i++) { 
    502             assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i))); 
     492        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     493         
     494        int entryCount = 2000; 
     495         
     496        for (int i = 0; i < entryCount; i++) { 
     497            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     498        } 
     499         
     500        for (int i = 0; i < entryCount; i++) { 
     501            assertNotNull(symbolMap.removeSymbol(createTask("symbol" + i))); 
    503502        } 
    504503         
    … …  
    508507    @Test 
    509508    public void testRemoveSymbol_5() { 
    510         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    511          
    512         int entryCount = 2000; 
    513          
    514         for (int i = 0; i < entryCount; i++) { 
    515             if (i % 7 == 0) { 
    516                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    517             } 
    518             else { 
    519                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
    520             } 
    521         } 
    522          
    523         for (int i = 0; i < entryCount; i++) { 
    524             if (i % 7 == 0) { 
    525                 assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i))); 
    526             } 
    527             else { 
    528                 assertNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i))); 
     509        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     510         
     511        int entryCount = 2000; 
     512         
     513        for (int i = 0; i < entryCount; i++) { 
     514            if (i % 7 == 0) { 
     515                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     516            } 
     517            else { 
     518                symbolMap.addSymbol(createTask("symbol" + i), null); 
     519            } 
     520        } 
     521         
     522        for (int i = 0; i < entryCount; i++) { 
     523            if (i % 7 == 0) { 
     524                assertNotNull(symbolMap.removeSymbol(createTask("symbol" + i))); 
     525            } 
     526            else { 
     527                assertNull(symbolMap.removeSymbol(createTask("symbol" + i))); 
    529528            } 
    530529        } 
    … …  
    535534    @Test 
    536535    public void testRemoveSymbol_6() { 
    537         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    538          
    539         int entryCount = 2000; 
    540          
    541         for (int i = 0; i < entryCount; i++) { 
    542             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    543         } 
    544          
    545         for (int i = 150; i < (entryCount - 150); i++) { 
    546             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     536        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     537         
     538        int entryCount = 2000; 
     539         
     540        for (int i = 0; i < entryCount; i++) { 
     541            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     542        } 
     543         
     544        for (int i = 150; i < (entryCount - 150); i++) { 
     545            symbolMap.removeSymbol(createTask("symbol" + i)); 
    547546        } 
    548547         
    549548        for (int i = 0; i < 150; i++) { 
    550             assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i))); 
    551         } 
    552          
    553         for (int i = 150; i < (entryCount - 150); i++) { 
    554             assertNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i))); 
     549            assertNotNull(symbolMap.removeSymbol(createTask("symbol" + i))); 
     550        } 
     551         
     552        for (int i = 150; i < (entryCount - 150); i++) { 
     553            assertNull(symbolMap.removeSymbol(createTask("symbol" + i))); 
    555554        } 
    556555         
    557556        for (int i = (entryCount - 150); i < entryCount; i++) { 
    558             assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i))); 
     557            assertNotNull(symbolMap.removeSymbol(createTask("symbol" + i))); 
    559558        } 
    560559         
    … …  
    564563    @Test(expected = java.lang.IllegalArgumentException.class) 
    565564    public void testRemoveSymbol_7() { 
    566         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     565        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    567566             
    568567        symbolMap.removeSymbol(null); 
    … …  
    571570    @Test 
    572571    public void testGetSymbols_1() { 
    573         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     572        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    574573             
    575574        assertNotNull(symbolMap.getSymbols()); 
    … …  
    579578    @Test 
    580579    public void testGetSymbols_2() { 
    581         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     580        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    582581          
    583         ITaskInstance task = createTaskInstance("symbol1"); 
     582        ITask task = createTask("symbol1"); 
    584583        symbolMap.addSymbol(task, "value1"); 
    585584         
    … …  
    591590    @Test 
    592591    public void testGetSymbols_3() { 
    593         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    594              
    595         ITaskInstance task = createTaskInstance("symbol1"); 
     592        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     593             
     594        ITask task = createTask("symbol1"); 
    596595        symbolMap.addSymbol(task, null); 
    597596         
    … …  
    603602    @Test 
    604603    public void testGetSymbols_4() { 
    605         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    606         Set<ITaskInstance> expectedSymbols = new HashSet<ITaskInstance>(); 
    607          
    608         int entryCount = 2000; 
    609          
    610         for (int i = 0; i < entryCount; i++) { 
    611             ITaskInstance task = createTaskInstance("symbol" + i); 
     604        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     605        Set<ITask> expectedSymbols = new HashSet<ITask>(); 
     606         
     607        int entryCount = 2000; 
     608         
     609        for (int i = 0; i < entryCount; i++) { 
     610            ITask task = createTask("symbol" + i); 
    612611            symbolMap.addSymbol(task, "value" + i); 
    613612            expectedSymbols.add(task); 
    … …  
    617616        assertEquals(entryCount, symbolMap.getSymbols().size()); 
    618617         
    619         Iterator<ITaskInstance> iterator = symbolMap.getSymbols().iterator(); 
     618        Iterator<ITask> iterator = symbolMap.getSymbols().iterator(); 
    620619        for (int i = 0; i < entryCount; i++) { 
    621620            assertTrue(iterator.hasNext()); 
    … …  
    629628    @Test 
    630629    public void testGetSymbols_5() { 
    631         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    632         Set<ITaskInstance> expectedSymbols = new HashSet<ITaskInstance>(); 
    633          
    634         int entryCount = 2000; 
    635          
    636         for (int i = 0; i < entryCount; i++) { 
    637             ITaskInstance task = createTaskInstance("symbol" + i); 
     630        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     631        Set<ITask> expectedSymbols = new HashSet<ITask>(); 
     632         
     633        int entryCount = 2000; 
     634         
     635        for (int i = 0; i < entryCount; i++) { 
     636            ITask task = createTask("symbol" + i); 
    638637             
    639638            if (i % 7 == 0) { 
    … …  
    650649        assertEquals(entryCount, symbolMap.getSymbols().size()); 
    651650         
    652         Iterator<ITaskInstance> iterator = symbolMap.getSymbols().iterator(); 
     651        Iterator<ITask> iterator = symbolMap.getSymbols().iterator(); 
    653652        for (int i = 0; i < entryCount; i++) { 
    654653            assertTrue(iterator.hasNext()); 
    … …  
    662661    @Test 
    663662    public void testGetSymbols_6() { 
    664         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    665         List<ITaskInstance> expectedSymbols = new ArrayList<ITaskInstance>(); 
    666          
    667         int entryCount = 2000; 
    668          
    669         for (int i = 0; i < entryCount; i++) { 
    670             ITaskInstance task = createTaskInstance("symbol" + i); 
     663        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     664        List<ITask> expectedSymbols = new ArrayList<ITask>(); 
     665         
     666        int entryCount = 2000; 
     667         
     668        for (int i = 0; i < entryCount; i++) { 
     669            ITask task = createTask("symbol" + i); 
    671670            symbolMap.addSymbol(task, "value" + i); 
    672671            expectedSymbols.add(task); 
    … …  
    680679        assertEquals(2 * 150, symbolMap.getSymbols().size()); 
    681680         
    682         Iterator<ITaskInstance> iterator = symbolMap.getSymbols().iterator(); 
     681        Iterator<ITask> iterator = symbolMap.getSymbols().iterator(); 
    683682        for (int i = 0; i < 2 * 150; i++) { 
    684683            assertTrue(iterator.hasNext()); 
    … …  
    692691    @Test 
    693692    public void testGetValues_1() { 
    694         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     693        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    695694             
    696695        assertNotNull(symbolMap.getValues()); 
    … …  
    700699    @Test 
    701700    public void testGetValues_2() { 
    702         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    703              
    704         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
     701        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     702             
     703        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
    705704         
    706705        assertNotNull(symbolMap.getValues()); 
    … …  
    711710    @Test 
    712711    public void testGetValues_3() { 
    713         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    714              
    715         symbolMap.addSymbol(createTaskInstance("symbol1"), null); 
     712        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     713             
     714        symbolMap.addSymbol(createTask("symbol1"), null); 
    716715         
    717716        assertNotNull(symbolMap.getValues()); 
    … …  
    722721    @Test 
    723722    public void testGetValues_4() { 
    724         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     723        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    725724        Set<String> expectedValues = new HashSet<String>(); 
    726725         
    … …  
    728727         
    729728        for (int i = 0; i < entryCount; i++) { 
    730             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
     729            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
    731730            expectedValues.add("value" + i); 
    732731        } 
    … …  
    747746    @Test 
    748747    public void testGetValues_5() { 
    749         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     748        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    750749        Set<String> expectedValues = new HashSet<String>(); 
    751750         
    … …  
    754753        for (int i = 0; i < entryCount; i++) { 
    755754            if (i % 7 == 0) { 
    756                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
     755                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
    757756                expectedValues.add("value" + i); 
    758757            } 
    759758            else { 
    760                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
     759                symbolMap.addSymbol(createTask("symbol" + i), null); 
    761760                expectedValues.add(null); 
    762761            } 
    … …  
    778777    @Test 
    779778    public void testGetValues_6() { 
    780         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     779        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    781780        Set<String> expectedValues = new HashSet<String>(); 
    782781         
    … …  
    784783         
    785784        for (int i = 0; i < entryCount; i++) { 
    786             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
     785            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
    787786            expectedValues.add("value" + i); 
    788787        } 
    789788         
    790789        for (int i = 150; i < (entryCount - 150); i++) { 
    791             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     790            symbolMap.removeSymbol(createTask("symbol" + i)); 
    792791            expectedValues.remove("value" + i); 
    793792        } 
    … …  
    808807    @Test 
    809808    public void testClear_1() { 
    810         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     809        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    811810         
    812811        symbolMap.clear(); 
    … …  
    816815    @Test 
    817816    public void testClear_2() { 
    818         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    819              
    820         symbolMap.addSymbol(createTaskInstance("symbol1"), "value1"); 
     817        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     818             
     819        symbolMap.addSymbol(createTask("symbol1"), "value1"); 
    821820         
    822821        symbolMap.clear(); 
    … …  
    826825    @Test 
    827826    public void testClear_3() { 
    828         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    829              
    830         symbolMap.addSymbol(createTaskInstance("symbol1"), null); 
     827        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     828             
     829        symbolMap.addSymbol(createTask("symbol1"), null); 
    831830         
    832831        symbolMap.clear(); 
    … …  
    836835    @Test 
    837836    public void testClear_4() { 
    838         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    839          
    840         int entryCount = 2000; 
    841          
    842         for (int i = 0; i < entryCount; i++) { 
    843             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
     837        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     838         
     839        int entryCount = 2000; 
     840         
     841        for (int i = 0; i < entryCount; i++) { 
     842            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
    844843        } 
    845844         
    … …  
    850849    @Test 
    851850    public void testClear_5() { 
    852         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    853          
    854         int entryCount = 2000; 
    855          
    856         for (int i = 0; i < entryCount; i++) { 
    857             if (i % 7 == 0) { 
    858                 symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    859             } 
    860             else { 
    861                 symbolMap.addSymbol(createTaskInstance("symbol" + i), null); 
     851        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     852         
     853        int entryCount = 2000; 
     854         
     855        for (int i = 0; i < entryCount; i++) { 
     856            if (i % 7 == 0) { 
     857                symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     858            } 
     859            else { 
     860                symbolMap.addSymbol(createTask("symbol" + i), null); 
    862861            } 
    863862        } 
    … …  
    869868    @Test 
    870869    public void testClear_6() { 
    871         SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
    872          
    873         int entryCount = 2000; 
    874          
    875         for (int i = 0; i < entryCount; i++) { 
    876             symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i); 
    877         } 
    878          
    879         for (int i = 150; i < (entryCount - 150); i++) { 
    880             symbolMap.removeSymbol(createTaskInstance("symbol" + i)); 
     870        SymbolMap<ITask, String> symbolMap = new TaskSymbolIdentityMap<String>(); 
     871         
     872        int entryCount = 2000; 
     873         
     874        for (int i = 0; i < entryCount; i++) { 
     875            symbolMap.addSymbol(createTask("symbol" + i), "value" + i); 
     876        } 
     877         
     878        for (int i = 150; i < (entryCount - 150); i++) { 
     879            symbolMap.removeSymbol(createTask("symbol" + i)); 
    881880        } 
    882881         
    … …  
    887886    @Test 
    888887    public void testEquals_1() { 
    889         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
    890          
    891         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>(); 
     888        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
     889         
     890        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolIdentityMap<String>(); 
    892891         
    893892        assertTrue(symbolMap1.equals(symbolMap2)); 
    … …  
    896895    @Test 
    897896    public void testEquals_2() { 
    898         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
    899              
    900         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>(); 
    901              
    902         symbolMap1.addSymbol(createTaskInstance("symbol1"), "value1"); 
     897        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
     898             
     899        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolIdentityMap<String>(); 
     900             
     901        symbolMap1.addSymbol(createTask("symbol1"), "value1"); 
    903902         
    904903        assertFalse(symbolMap1.equals(symbolMap2)); 
    … …  
    907906    @Test 
    908907    public void testEquals_3() { 
    909         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
    910              
    911         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>(); 
    912          
    913         ITaskInstance task = createTaskInstance("symbol1"); 
     908        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
     909             
     910        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolIdentityMap<String>(); 
     911         
     912        ITask task = createTask("symbol1"); 
    914913        symbolMap1.addSymbol(task, "value1"); 
    915914        symbolMap2.addSymbol(task, "value1"); 
    … …  
    920919    @Test 
    921920    public void testEquals_4() { 
    922         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
     921        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
    923922                 
    924         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>(); 
     923        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolIdentityMap<String>(); 
    925924         
    926925        int entryCount = 1000; 
    927926         
    928927        for (int i = 0; i < entryCount; i++) { 
    929             ITaskInstance task = createTaskInstance("symbol1"); 
     928            ITask task = createTask("symbol1"); 
    930929            symbolMap1.addSymbol(task, "value" + i); 
    931930            assertFalse(symbolMap1.equals(symbolMap2)); 
    … …  
    937936    @Test 
    938937    public void testEquals_5() { 
    939         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
     938        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
    940939                
    941         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>(); 
     940        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolIdentityMap<String>(); 
    942941         
    943942        int entryCount = 1000; 
    944943         
    945944        for (int i = 0; i < entryCount; i++) { 
    946             ITaskInstance task = createTaskInstance("symbol" + i); 
     945            ITask task = createTask("symbol" + i); 
    947946            if (i % 7 == 0) { 
    948947                symbolMap1.addSymbol(task, "value" + i); 
    … …  
    962961    @Test 
    963962    public void testEquals_6() { 
    964         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
     963        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
    965964                 
    966         SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>(); 
     965        SymbolMap<ITask, String> symbolMap2 = new TaskSymbolIdentityMap<String>(); 
    967966         
    968967        int entryCount = 1000; 
    969968         
    970         ITaskInstance[] taskInstances = new ITaskInstance[entryCount]; 
    971          
    972         for (int i = 0; i < entryCount; i++) { 
    973             ITaskInstance task = createTaskInstance("symbol" + i); 
    974             taskInstances[i] = task; 
     969        ITask[] tasks = new ITask[entryCount]; 
     970         
     971        for (int i = 0; i < entryCount; i++) { 
     972            ITask task = createTask("symbol" + i); 
     973            tasks[i] = task; 
    975974            symbolMap1.addSymbol(task, "value" + i); 
    976975            assertFalse(symbolMap1.equals(symbolMap2)); 
    … …  
    980979         
    981980        for (int i = 150; i < (entryCount - 150); i++) { 
    982             symbolMap1.removeSymbol(taskInstances[i]); 
     981            symbolMap1.removeSymbol(tasks[i]); 
    983982            assertFalse(symbolMap1.equals(symbolMap2)); 
    984             symbolMap2.removeSymbol(taskInstances[i]); 
     983            symbolMap2.removeSymbol(tasks[i]); 
    985984            assertTrue(symbolMap1.equals(symbolMap2)); 
    986985        } 
    … …  
    989988    @Test 
    990989    public void testPerformance_Contains_1() { 
    991         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
     990        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
    992991        int mapSize = 100000; 
    993992        int noOfLookups = 1000000; 
    994993         
    995         ITaskInstance[] taskInstances = new ITaskInstance[mapSize]; 
     994        ITask[] tasks = new ITask[mapSize]; 
    996995         
    997996        for (int i = 0; i < mapSize; i++) { 
    998             ITaskInstance task = createTaskInstance("symbol" + i); 
    999             taskInstances[i] = task; 
     997            ITask task = createTask("symbol" + i); 
     998            tasks[i] = task; 
    1000999            symbolMap1.addSymbol(task, "value" + i); 
    10011000        } 
    … …  
    10031002        long start = System.currentTimeMillis(); 
    10041003        for (int i = 0; i < noOfLookups; i++) { 
    1005             symbolMap1.containsSymbol(taskInstances[noOfLookups % mapSize]); 
     1004            symbolMap1.containsSymbol(tasks[noOfLookups % mapSize]); 
    10061005        } 
    10071006         
    … …  
    10121011    @Test 
    10131012    public void testPerformance_GetValue_1() { 
    1014         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
     1013        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
    10151014        int mapSize = 100000; 
    10161015        int noOfLookups = 1000000; 
    10171016         
    1018         ITaskInstance[] taskInstances = new ITaskInstance[mapSize]; 
     1017        ITask[] tasks = new ITask[mapSize]; 
    10191018         
    10201019        for (int i = 0; i < mapSize; i++) { 
    1021             ITaskInstance task = createTaskInstance("symbol" + i); 
    1022             taskInstances[i] = task; 
     1020            ITask task = createTask("symbol" + i); 
     1021            tasks[i] = task; 
    10231022            symbolMap1.addSymbol(task, "value" + i); 
    10241023        } 
    … …  
    10261025        long start = System.currentTimeMillis(); 
    10271026        for (int i = 0; i < noOfLookups; i++) { 
    1028             symbolMap1.getValue(taskInstances[noOfLookups % mapSize]); 
     1027            symbolMap1.getValue(tasks[noOfLookups % mapSize]); 
    10291028        } 
    10301029         
    … …  
    10361035    @Test 
    10371036    public void testPerformance_AddRemove_1() { 
    1038         SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
     1037        SymbolMap<ITask, String> symbolMap1 = new TaskSymbolIdentityMap<String>(); 
    10391038        int mapSize = 100000; 
    10401039        int noOfLookups = 1000000; 
    10411040         
    1042         ITaskInstance[] taskInstances = new ITaskInstance[mapSize]; 
     1041        ITask[] tasks = new ITask[mapSize]; 
    10431042         
    10441043        for (int i = 0; i < mapSize; i++) { 
    1045             ITaskInstance task = createTaskInstance("symbol" + i); 
    1046             taskInstances[i] = task; 
     1044            ITask task = createTask("symbol" + i); 
     1045            tasks[i] = task; 
    10471046            symbolMap1.addSymbol(task, "value" + i); 
    10481047        } 
    … …  
    10501049        long start = System.currentTimeMillis(); 
    10511050        for (int i = 0; i < noOfLookups; i++) { 
    1052             ITaskInstance task = taskInstances[noOfLookups % mapSize]; 
     1051            ITask task = tasks[noOfLookups % mapSize]; 
    10531052            symbolMap1.addSymbol(task, symbolMap1.removeSymbol(task)); 
    10541053        } 
    … …  
    10611060     * 
    10621061     */ 
    1063     private ITaskInstance createTaskInstance(String id) { 
     1062    private ITask createTask(String id) { 
    10641063        ITask task = tasks.get(id); 
    10651064        Event event = null; 
    … …  
    10751074        } 
    10761075         
    1077         return taskFactory.createNewTaskInstance((IEventTask) task, event); 
    1078     } 
    1079  
    1080     private void assertSymbolMapEntries(SymbolMap<ITaskInstance, String> symbolMap, 
    1081                                         ITaskInstance[]                  symbols, 
    1082                                         String[]                         values) 
     1076        taskFactory.createNewTaskInstance((IEventTask) task, event); 
     1077         
     1078        return task; 
     1079    } 
     1080 
     1081    private void assertSymbolMapEntries(SymbolMap<ITask, String> symbolMap, 
     1082                                        ITask[]                  symbols, 
     1083                                        String[]                 values) 
    10831084    { 
    10841085        assertEquals(symbols.length, symbolMap.size()); 
Note: See TracChangeset for help on using the changeset viewer.