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

Legend:

Unmodified
Added
Removed

  • trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/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(); 
Note: See TracChangeset for help on using the changeset viewer.