Ignore:
Timestamp:
08/17/12 08:33:29 (12 years ago)
Author:
pharms
Message:
  • adapted task tree creation stuff to more general event handling
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java

    r468 r557  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: DefaultIterationDetectionRuleTest.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: patrick $  $Date: 28.04.2012 $ 
    … …  
    54// Creation  : 2012 by patrick 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
    87package de.ugoe.cs.quest.tasktrees.temporalrelation; 
    98 
    109import org.junit.Test; 
    1110 
    12 import de.ugoe.cs.quest.eventcore.guimodel.GUIElement; 
    13 import de.ugoe.cs.quest.eventcore.userinteraction.Interaction; 
     11import de.ugoe.cs.quest.eventcore.IEventTarget; 
     12import de.ugoe.cs.quest.eventcore.IEventType; 
    1413import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; 
    1514import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; 
    1615import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; 
    1716 
    18 //------------------------------------------------------------------------------------------------- 
    1917/** 
    2018 * TODO comment 
    … …  
    2321 * @author 2012, last modified by $Author: patrick$ 
    2422 */ 
    25 //------------------------------------------------------------------------------------------------- 
    26 public class DefaultIterationDetectionRuleTest extends AbstractTemporalRelationshipTC 
    27 { 
    28  
    29   //----------------------------------------------------------------------------------------------- 
    30   /** 
    31    * 
    32    */ 
    33   //----------------------------------------------------------------------------------------------- 
    34   @Test 
    35   public void testInteractionIterationDetection() throws Exception 
    36   { 
    37     GUIElement element1 = new DummyGUIElement("elem1"); 
    38     Interaction interaction1 = new DummyInteraction("bla", 1); 
    39     simulateInteraction(element1, interaction1); 
    40     new TaskTreeChecker().assertTaskTree 
    41       ("Sequence sequence1 {" + 
    42        "  Interaction bla {}" + 
    43        "}", getTaskTree());     
    44  
    45     simulateInteraction(element1, interaction1); 
    46     new TaskTreeChecker().assertTaskTree 
    47       ("Sequence sequence1 {" + 
    48        "  Iteration iteration1 {" + 
    49        "    Interaction bla {}" + 
    50        "  }" + 
    51        "}", getTaskTree());     
    52  
    53     simulateInteraction(element1, interaction1); 
    54     new TaskTreeChecker().assertTaskTree 
    55       ("Sequence sequence1 {" + 
    56        "  Iteration iteration1 {" + 
    57        "    Interaction bla {}" + 
    58        "  }" + 
    59        "}", getTaskTree());     
    60  
    61     for (int i = 0; i < 10; i++) 
    62     { 
    63       simulateInteraction(element1, interaction1); 
     23public class DefaultIterationDetectionRuleTest extends AbstractTemporalRelationshipTC { 
     24 
     25    /** 
     26     * 
     27     */ 
     28    @Test 
     29    public void testInteractionIterationDetection() throws Exception { 
     30        IEventTarget element1 = new DummyGUIElement("elem1"); 
     31        IEventType event1 = new DummyInteraction("bla", 1); 
     32        simulateEvent(event1, element1); 
     33        new TaskTreeChecker().assertTaskTree 
     34            ("Sequence sequence1 {" + 
     35             "  Event bla {}" + 
     36             "}", getTaskTree()); 
     37 
     38        simulateEvent(event1, element1); 
     39        new TaskTreeChecker().assertTaskTree 
     40            ("Sequence sequence1 {" + 
     41             "  Iteration iteration1 {" + 
     42             "    Event bla {}" + 
     43             "  }" + 
     44             "}", getTaskTree()); 
     45 
     46        simulateEvent(event1, element1); 
     47        new TaskTreeChecker().assertTaskTree 
     48            ("Sequence sequence1 {" + 
     49             "  Iteration iteration1 {" + 
     50             "    Event bla {}" + 
     51             "  }" + 
     52             "}", getTaskTree()); 
     53 
     54        for (int i = 0; i < 10; i++) { 
     55            simulateEvent(event1, element1); 
     56        } 
     57 
     58        new TaskTreeChecker().assertTaskTree 
     59            ("Sequence sequence1 {" + 
     60             "  Iteration iteration1 {" + 
     61             "    Event bla {}" + 
     62             "  }" + 
     63             "}", getTaskTree()); 
     64 
     65        // now test with preceding and trailing other events 
     66        IEventType event2 = new DummyInteraction("bli", 1); 
     67        IEventType event3 = new DummyInteraction("blup", 1); 
     68 
     69        simulateEvent(event2, element1); 
     70        simulateEvent(event3, element1); 
     71        for (int i = 0; i < 10; i++) { 
     72            simulateEvent(event1, element1); 
     73        } 
     74        simulateEvent(event3, element1); 
     75        simulateEvent(event2, element1); 
     76 
     77        new TaskTreeChecker().assertTaskTree 
     78            ("Sequence sequence1 {" + 
     79             "  Iteration iteration1 {" + 
     80             "    Event bla {}" + 
     81             "  }" + 
     82             "  Event bli {}" + 
     83             "  Event blup {}" + 
     84             "  Iteration iteration2 {" + 
     85             "    Event bla {}" + 
     86             "  }" + 
     87             "  Event blup {}" + 
     88             "  Event bli {}" + 
     89             "}", getTaskTree()); 
     90 
     91        // now test with iterations of iterations 
     92 
     93        for (int i = 0; i < 10; i++) { 
     94            for (int j = 0; j < 5; j++) { 
     95                simulateEvent(event1, element1); 
     96            } 
     97            for (int j = 0; j < 5; j++) { 
     98                simulateEvent(event2, element1); 
     99            } 
     100            for (int j = 0; j < 5; j++) { 
     101                simulateEvent(event3, element1); 
     102            } 
     103        } 
     104 
     105        new TaskTreeChecker().assertTaskTree 
     106            ("Sequence sequence1 {" + 
     107             "  Iteration iteration1 {" + 
     108             "    Event bla {}" + 
     109             "  }" + 
     110             "  Event bli {}" + 
     111             "  Event blup {}" + 
     112             "  Iteration iteration2 {" + 
     113             "    Event bla {}" + 
     114             "  }" + 
     115             "  Event blup {}" + 
     116             "  Event bli {}" + 
     117             "  Iteration iteration3 {" + 
     118             "    Sequence sequence2 {" + 
     119             "      Iteration iteration4 {" + 
     120             "        Event bla {}" + 
     121             "      }" + 
     122             "      Iteration iteration5 {" + 
     123             "        Event bli {}" + 
     124             "      }" + 
     125             "      Iteration iteration6 {" + 
     126             "        Event blup {}" + 
     127             "      }" + 
     128             "    }" + 
     129             "  }" + 
     130             "}", getTaskTree()); 
     131 
    64132    } 
    65      
    66     new TaskTreeChecker().assertTaskTree 
    67       ("Sequence sequence1 {" + 
    68        "  Iteration iteration1 {" + 
    69        "    Interaction bla {}" + 
    70        "  }" + 
    71        "}", getTaskTree());     
    72      
    73     // now test with preceding and trailing other interactions 
    74     Interaction interaction2 = new DummyInteraction("bli", 1); 
    75     Interaction interaction3 = new DummyInteraction("blup", 1); 
    76  
    77     simulateInteraction(element1, interaction2); 
    78     simulateInteraction(element1, interaction3); 
    79     for (int i = 0; i < 10; i++) 
    80     { 
    81       simulateInteraction(element1, interaction1); 
     133 
     134    /** 
     135     * 
     136     */ 
     137    @Test 
     138    public void testSequenceIterationDetection() throws Exception { 
     139        IEventTarget element1 = new DummyGUIElement("elem1"); 
     140        IEventType event1 = new DummyInteraction("bla", 1); 
     141        IEventType event2 = new DummyInteraction("bli", 1); 
     142        IEventType event3 = new DummyInteraction("blup", 1); 
     143        simulateEvent(event1, element1); 
     144        simulateEvent(event2, element1); 
     145        simulateEvent(event3, element1); 
     146        new TaskTreeChecker().assertTaskTree 
     147            ("Sequence sequence1 {" + 
     148             "  Event bla {}" + 
     149             "  Event bli {}" + 
     150             "  Event blup {}" + 
     151             "}", getTaskTree()); 
     152 
     153        simulateEvent(event1, element1); 
     154        simulateEvent(event2, element1); 
     155        simulateEvent(event3, element1); 
     156        new TaskTreeChecker().assertTaskTree 
     157            ("Sequence sequence1 {" + 
     158             "  Iteration iteration1 {" + 
     159             "    Sequence sequence2 {" + 
     160             "      Event bla {}" + 
     161             "      Event bli {}" + 
     162             "      Event blup {}" + 
     163             "    }" + 
     164             "  }" + 
     165             "}", getTaskTree()); 
     166 
     167        simulateEvent(event1, element1); 
     168        simulateEvent(event2, element1); 
     169        simulateEvent(event3, element1); 
     170        new TaskTreeChecker().assertTaskTree 
     171            ("Sequence sequence1 {" + 
     172             "  Iteration iteration1 {" + 
     173             "    Sequence sequence2 {" + 
     174             "      Event bla {}" + 
     175             "      Event bli {}" + 
     176             "      Event blup {}" + 
     177             "    }" + 
     178             "  }" + 
     179             "}", getTaskTree()); 
     180 
     181        for (int i = 0; i < 10; i++) { 
     182            simulateEvent(event1, element1); 
     183            simulateEvent(event2, element1); 
     184            simulateEvent(event3, element1); 
     185        } 
     186 
     187        new TaskTreeChecker().assertTaskTree 
     188            ("Sequence sequence1 {" + 
     189             "  Iteration iteration1 {" + 
     190             "    Sequence sequence2 {" + 
     191             "      Event bla {}" + 
     192             "      Event bli {}" + 
     193             "      Event blup {}" + 
     194             "    }" + 
     195             "  }" + 
     196             "}", getTaskTree()); 
     197 
     198        // now test with preceding and trailing other events 
     199        IEventType event4 = new DummyInteraction("ble", 1); 
     200        IEventType event5 = new DummyInteraction("blo", 1); 
     201        IEventType event6 = new DummyInteraction("blu", 1); 
     202        simulateEvent(event4, element1); 
     203        simulateEvent(event5, element1); 
     204        simulateEvent(event6, element1); 
     205        for (int i = 0; i < 10; i++) { 
     206            simulateEvent(event1, element1); 
     207            simulateEvent(event2, element1); 
     208            simulateEvent(event3, element1); 
     209        } 
     210        simulateEvent(event6, element1); 
     211        simulateEvent(event5, element1); 
     212        simulateEvent(event4, element1); 
     213 
     214        new TaskTreeChecker().assertTaskTree 
     215            ("Sequence sequence1 {" + 
     216             "  Iteration iteration1 {" + 
     217             "    Sequence sequence2 {" + 
     218             "      Event bla {}" + 
     219             "      Event bli {}" + 
     220             "      Event blup {}" + 
     221             "    }" + 
     222             "  }" + 
     223             "  Event ble {}" + 
     224             "  Event blo {}" + 
     225             "  Event blu {}" + 
     226             "  Iteration iteration2 {" + 
     227             "    Sequence sequence3 {" + 
     228             "      Event bla {}" + 
     229             "      Event bli {}" + 
     230             "      Event blup {}" + 
     231             "    }" + 
     232             "  }" + 
     233             "  Event blu {}" + 
     234             "  Event blo {}" + 
     235             "  Event ble {}" + 
     236             "}", getTaskTree()); 
     237 
     238        // now test with iterations of iterations 
     239        for (int i = 0; i < 10; i++) { 
     240            for (int j = 0; j < 5; j++) { 
     241                simulateEvent(event1, element1); 
     242                simulateEvent(event2, element1); 
     243                simulateEvent(event3, element1); 
     244            } 
     245            for (int j = 0; j < 5; j++) { 
     246                simulateEvent(event2, element1); 
     247                simulateEvent(event1, element1); 
     248                simulateEvent(event3, element1); 
     249            } 
     250            for (int j = 0; j < 5; j++) { 
     251                simulateEvent(event1, element1); 
     252                simulateEvent(event2, element1); 
     253                simulateEvent(event3, element1); 
     254            } 
     255        } 
     256 
     257        new TaskTreeChecker().assertTaskTree 
     258            ("Sequence sequence1 {" + 
     259             "  Iteration iteration1 {" + 
     260             "    Sequence sequence2 {" + 
     261             "      Event bla {}" + 
     262             "      Event bli {}" + 
     263             "      Event blup {}" + 
     264             "    }" + 
     265             "  }" + 
     266             "  Event ble {}" + 
     267             "  Event blo {}" + 
     268             "  Event blu {}" + 
     269             "  Iteration iteration2 {" + 
     270             "    Sequence sequence3 {" + 
     271             "      Event bla {}" + 
     272             "      Event bli {}" + 
     273             "      Event blup {}" + 
     274             "    }" + 
     275             "  }" + 
     276             "  Event blu {}" + 
     277             "  Event blo {}" + 
     278             "  Event ble {}" + 
     279             "  Iteration iteration3 {" + 
     280             "    Sequence sequence4 {" + 
     281             "      Iteration iteration4 {" + 
     282             "        Sequence sequence4 {" + 
     283             "          Event bla {}" + 
     284             "          Event bli {}" + 
     285             "          Event blup {}" + 
     286             "        }" + 
     287             "      }" + 
     288             "      Iteration iteration5 {" + 
     289             "        Sequence sequence5 {" + 
     290             "          Event bli {}" + 
     291             "          Event bla {}" + 
     292             "          Event blup {}" + 
     293             "        }" + 
     294             "      }" + 
     295             "      Iteration iteration6 {" + 
     296             "        Sequence sequence6 {" + 
     297             "          Event bla {}" + 
     298             "          Event bli {}" + 
     299             "          Event blup {}" + 
     300             "        }" + 
     301             "      }" + 
     302             "    }" + 
     303             "  }" + 
     304             "}", getTaskTree()); 
    82305    } 
    83     simulateInteraction(element1, interaction3); 
    84     simulateInteraction(element1, interaction2); 
    85      
    86     new TaskTreeChecker().assertTaskTree 
    87       ("Sequence sequence1 {" + 
    88        "  Iteration iteration1 {" + 
    89        "    Interaction bla {}" + 
    90        "  }" + 
    91        "  Interaction bli {}" + 
    92        "  Interaction blup {}" + 
    93        "  Iteration iteration2 {" + 
    94        "    Interaction bla {}" + 
    95        "  }" + 
    96        "  Interaction blup {}" + 
    97        "  Interaction bli {}" + 
    98        "}", getTaskTree());     
    99    
    100     // now test with iterations of iterations 
    101  
    102     for (int i = 0; i < 10; i++) 
    103     { 
    104       for (int j = 0; j < 5; j++) 
    105       { 
    106         simulateInteraction(element1, interaction1); 
    107       } 
    108       for (int j = 0; j < 5; j++) 
    109       { 
    110         simulateInteraction(element1, interaction2); 
    111       } 
    112       for (int j = 0; j < 5; j++) 
    113       { 
    114         simulateInteraction(element1, interaction3); 
    115       } 
    116     } 
    117      
    118     new TaskTreeChecker().assertTaskTree 
    119       ("Sequence sequence1 {" + 
    120        "  Iteration iteration1 {" + 
    121        "    Interaction bla {}" + 
    122        "  }" + 
    123        "  Interaction bli {}" + 
    124        "  Interaction blup {}" + 
    125        "  Iteration iteration2 {" + 
    126        "    Interaction bla {}" + 
    127        "  }" + 
    128        "  Interaction blup {}" + 
    129        "  Interaction bli {}" + 
    130        "  Iteration iteration3 {" + 
    131        "    Sequence sequence2 {" + 
    132        "      Iteration iteration4 {" + 
    133        "        Interaction bla {}" + 
    134        "      }" + 
    135        "      Iteration iteration5 {" + 
    136        "        Interaction bli {}" + 
    137        "      }" + 
    138        "      Iteration iteration6 {" + 
    139        "        Interaction blup {}" + 
    140        "      }" + 
    141        "    }" + 
    142        "  }" + 
    143        "}", getTaskTree());     
    144    
    145   } 
    146    
    147   //----------------------------------------------------------------------------------------------- 
    148   /** 
    149    * 
    150    */ 
    151   //----------------------------------------------------------------------------------------------- 
    152   @Test 
    153   public void testSequenceIterationDetection() throws Exception 
    154   { 
    155     GUIElement element1 = new DummyGUIElement("elem1"); 
    156     Interaction interaction1 = new DummyInteraction("bla", 1); 
    157     Interaction interaction2 = new DummyInteraction("bli", 1); 
    158     Interaction interaction3 = new DummyInteraction("blup", 1); 
    159     simulateInteraction(element1, interaction1); 
    160     simulateInteraction(element1, interaction2); 
    161     simulateInteraction(element1, interaction3); 
    162     new TaskTreeChecker().assertTaskTree 
    163       ("Sequence sequence1 {" + 
    164        "  Interaction bla {}" + 
    165        "  Interaction bli {}" + 
    166        "  Interaction blup {}" + 
    167        "}", getTaskTree());     
    168  
    169     simulateInteraction(element1, interaction1); 
    170     simulateInteraction(element1, interaction2); 
    171     simulateInteraction(element1, interaction3); 
    172     new TaskTreeChecker().assertTaskTree 
    173       ("Sequence sequence1 {" + 
    174        "  Iteration iteration1 {" + 
    175        "    Sequence sequence2 {" + 
    176        "      Interaction bla {}" + 
    177        "      Interaction bli {}" + 
    178        "      Interaction blup {}" + 
    179        "    }" + 
    180        "  }" + 
    181        "}", getTaskTree());     
    182  
    183     simulateInteraction(element1, interaction1); 
    184     simulateInteraction(element1, interaction2); 
    185     simulateInteraction(element1, interaction3); 
    186     new TaskTreeChecker().assertTaskTree 
    187       ("Sequence sequence1 {" + 
    188        "  Iteration iteration1 {" + 
    189        "    Sequence sequence2 {" + 
    190        "      Interaction bla {}" + 
    191        "      Interaction bli {}" + 
    192        "      Interaction blup {}" + 
    193        "    }" + 
    194        "  }" + 
    195        "}", getTaskTree());     
    196  
    197     for (int i = 0; i < 10; i++) 
    198     { 
    199       simulateInteraction(element1, interaction1); 
    200       simulateInteraction(element1, interaction2); 
    201       simulateInteraction(element1, interaction3); 
    202     } 
    203      
    204     new TaskTreeChecker().assertTaskTree 
    205       ("Sequence sequence1 {" + 
    206        "  Iteration iteration1 {" + 
    207        "    Sequence sequence2 {" + 
    208        "      Interaction bla {}" + 
    209        "      Interaction bli {}" + 
    210        "      Interaction blup {}" + 
    211        "    }" + 
    212        "  }" + 
    213        "}", getTaskTree());     
    214      
    215     // now test with preceding and trailing other interactions 
    216     Interaction interaction4 = new DummyInteraction("ble", 1); 
    217     Interaction interaction5 = new DummyInteraction("blo", 1); 
    218     Interaction interaction6 = new DummyInteraction("blu", 1); 
    219     simulateInteraction(element1, interaction4); 
    220     simulateInteraction(element1, interaction5); 
    221     simulateInteraction(element1, interaction6); 
    222     for (int i = 0; i < 10; i++) 
    223     { 
    224       simulateInteraction(element1, interaction1); 
    225       simulateInteraction(element1, interaction2); 
    226       simulateInteraction(element1, interaction3); 
    227     } 
    228     simulateInteraction(element1, interaction6); 
    229     simulateInteraction(element1, interaction5); 
    230     simulateInteraction(element1, interaction4); 
    231      
    232     new TaskTreeChecker().assertTaskTree 
    233       ("Sequence sequence1 {" + 
    234        "  Iteration iteration1 {" + 
    235        "    Sequence sequence2 {" + 
    236        "      Interaction bla {}" + 
    237        "      Interaction bli {}" + 
    238        "      Interaction blup {}" + 
    239        "    }" + 
    240        "  }" + 
    241        "  Interaction ble {}" + 
    242        "  Interaction blo {}" + 
    243        "  Interaction blu {}" + 
    244        "  Iteration iteration2 {" + 
    245        "    Sequence sequence3 {" + 
    246        "      Interaction bla {}" + 
    247        "      Interaction bli {}" + 
    248        "      Interaction blup {}" + 
    249        "    }" + 
    250        "  }" + 
    251        "  Interaction blu {}" + 
    252        "  Interaction blo {}" + 
    253        "  Interaction ble {}" + 
    254        "}", getTaskTree());     
    255    
    256     // now test with iterations of iterations 
    257     for (int i = 0; i < 10; i++) 
    258     { 
    259       for (int j = 0; j < 5; j++) 
    260       { 
    261         simulateInteraction(element1, interaction1); 
    262         simulateInteraction(element1, interaction2); 
    263         simulateInteraction(element1, interaction3); 
    264       } 
    265       for (int j = 0; j < 5; j++) 
    266       { 
    267         simulateInteraction(element1, interaction2); 
    268         simulateInteraction(element1, interaction1); 
    269         simulateInteraction(element1, interaction3); 
    270       } 
    271       for (int j = 0; j < 5; j++) 
    272       { 
    273         simulateInteraction(element1, interaction1); 
    274         simulateInteraction(element1, interaction2); 
    275         simulateInteraction(element1, interaction3); 
    276       } 
    277     } 
    278      
    279     new TaskTreeChecker().assertTaskTree 
    280       ("Sequence sequence1 {" + 
    281        "  Iteration iteration1 {" + 
    282        "    Sequence sequence2 {" + 
    283        "      Interaction bla {}" + 
    284        "      Interaction bli {}" + 
    285        "      Interaction blup {}" + 
    286        "    }" + 
    287        "  }" + 
    288        "  Interaction ble {}" + 
    289        "  Interaction blo {}" + 
    290        "  Interaction blu {}" + 
    291        "  Iteration iteration2 {" + 
    292        "    Sequence sequence3 {" + 
    293        "      Interaction bla {}" + 
    294        "      Interaction bli {}" + 
    295        "      Interaction blup {}" + 
    296        "    }" + 
    297        "  }" + 
    298        "  Interaction blu {}" + 
    299        "  Interaction blo {}" + 
    300        "  Interaction ble {}" + 
    301        "  Iteration iteration3 {" + 
    302        "    Sequence sequence4 {" + 
    303        "      Iteration iteration4 {" + 
    304        "        Sequence sequence4 {" + 
    305        "          Interaction bla {}" + 
    306        "          Interaction bli {}" + 
    307        "          Interaction blup {}" + 
    308        "        }" + 
    309        "      }" + 
    310        "      Iteration iteration5 {" + 
    311        "        Sequence sequence5 {" + 
    312        "          Interaction bli {}" + 
    313        "          Interaction bla {}" + 
    314        "          Interaction blup {}" + 
    315        "        }" + 
    316        "      }" + 
    317        "      Iteration iteration6 {" + 
    318        "        Sequence sequence6 {" + 
    319        "          Interaction bla {}" + 
    320        "          Interaction bli {}" + 
    321        "          Interaction blup {}" + 
    322        "        }" + 
    323        "      }" + 
    324        "    }" + 
    325        "  }" + 
    326        "}", getTaskTree());     
    327   } 
    328    
     306 
    329307} 
Note: See TracChangeset for help on using the changeset viewer.