Ignore:
Timestamp:
04/20/13 21:33:32 (11 years ago)
Author:
adeicke
Message:

Fixed test cases.

Location:
trunk/autoquest-core-usability-evaluation-test/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/endswith
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/autoquest-core-usability-evaluation-test/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/endswith/EndsWithEventTest.java

    r1152 r1171  
    1616 
    1717import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.TEXT_INPUT; 
    18 import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter.ITERATION; 
    19 import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter.SELECTION; 
    2018import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter.SEQUENCE; 
    2119import static org.fest.assertions.api.Assertions.assertThat; 
    … …  
    2321import org.junit.Test; 
    2422 
    25 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree; 
     23import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
    2624import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePattern; 
    2725import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternBuilder; 
    28 import de.ugoe.cs.autoquest.usability.testutil.GenerateTaskTreeUtil; 
     26import de.ugoe.cs.autoquest.usability.testutil.GenerateTaskModelUtil; 
    2927 
    3028/** 
    … …  
    3634 */ 
    3735public class EndsWithEventTest { 
    38  
     36     
    3937    @Test 
    40     public void sequence_ends_with_positive_1() { 
     38    public void ends_with_event_positive() { 
    4139        // Given 
    42         String spec = "Sequence {" +  
    43                       "  TextInput () {}" +  
     40        String spec = "UserSession {" + 
     41                              "  Selection sel1 {" + 
     42                              "    Sequence seq1 {" + 
     43                      "      EventTask target1 {}" + 
     44                      "    }" + 
     45                      "  }" + 
     46                      "  Selection sel1 {" + 
     47                      "    Sequence seq2 {" + 
     48                      "      EventTask target2 {}" + 
     49                      "      TextInput target3 {}" + 
     50                      "    }" + 
     51                      "  }" + 
    4452                      "}"; 
    45         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
     53        ITaskModel taskTree = GenerateTaskModelUtil.getTaskModelFromSpec(spec); 
    4654        UsagePattern pattern = new UsagePatternBuilder().concernedNode(SEQUENCE).endsWith(TEXT_INPUT).build(); 
    4755        // When 
    … …  
    5260     
    5361    @Test 
    54     public void sequence_ends_with_positive_2() { 
     62    public void ends_with_event_negative() { 
    5563        // Given 
    56         String spec = "Selection {" + 
    57                       "  EventTask target1 {}" + 
    58                       "  Sequence {" + 
    59                       "    EventTask target2 {}" + 
    60                       "    TextInput target3 {}" + 
    61                       "  }" + 
    62                       "}"; 
    63         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    64         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SEQUENCE).endsWith(TEXT_INPUT).build(); 
    65         // When 
    66         boolean patternContained = pattern.containedIn(taskTree); 
    67         // Then 
    68         assertThat(patternContained).isTrue(); 
    69     } 
    70      
    71     @Test 
    72     public void sequence_ends_with_positive_3() { 
    73         // Given 
    74         String spec =  "Sequence {" + 
    75                        "  Optional {" + 
    76                        "    Sequence {" + 
    77                        "      EventTask target4 {}" + 
    78                        "      EventTask target3 {}" + 
    79                        "    }" + 
    80                        "  }" + 
    81                        "  EventTask target1 {}" + 
    82                        "  EventTask target2 {}" + 
    83                        "  EventTask target3 {}" + 
    84                        "  EventTask target4 {}" + 
    85                        "  Selection {" + 
    86                        "    EventTask target5 {}" + 
    87                        "    Sequence {" + 
    88                        "      EventTask target4 {}" + 
    89                        "      EventTask target2 {}" + 
    90                        "    }" + 
    91                        "  }" + 
    92                        "  EventTask target6 {}" + 
    93                        "  TextInput target7 {}" + 
    94                        "}"; 
    95         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    96         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SEQUENCE).endsWith(TEXT_INPUT).build(); 
    97         // When 
    98         boolean patternContained = pattern.containedIn(taskTree); 
    99         // Then 
    100         assertThat(patternContained).isTrue(); 
    101     } 
    102     
    103     @Test 
    104     public void sequence_ends_with_negative_1() { 
    105         // Given 
    106         String spec = "Sequence {" +  
    107                       "  MouseClick () {}" +  
    108                       "}"; 
    109         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    110         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SEQUENCE).endsWith(TEXT_INPUT).build(); 
    111         // When 
    112         boolean patternContained = pattern.containedIn(taskTree); 
    113         // Then 
    114         assertThat(patternContained).isFalse(); 
    115     } 
    116      
    117     @Test 
    118     public void sequence_ends_with_negative_2() { 
    119         // Given 
    120         String spec = "Selection {" + 
    121                       "  Sequence {" + 
    122                       "    EventTask target1 {}" + 
    123                       "    EventTask target2 {}" + 
    124                       "  }" + 
    125                       "  Sequence {" + 
    126                       "    EventTask target3 {}" + 
    127                       "    EventTask target4 {}" + 
    128                       "  }" + 
    129                       "  Sequence {" + 
    130                       "    EventTask target5 {}" + 
    131                       "    EventTask target6 {}" + 
    132                       "  }" + 
    133                       "}"; 
    134         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    135         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SEQUENCE).endsWith(TEXT_INPUT).build(); 
    136         // When 
    137         boolean patternContained = pattern.containedIn(taskTree); 
    138         // Then 
    139         assertThat(patternContained).isFalse(); 
    140     } 
    141      
    142     @Test 
    143     public void sequence_ends_with_negative_3() { 
    144         // Given 
    145         String spec = "Iteration {" + 
    146                       "  Selection {" + 
    147                       "    EventTask target2 {}" + 
    148                       "    EventTask target3 {}" + 
    149                       "  }" + 
    150                       "}"; 
    151         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    152         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SEQUENCE).endsWith(TEXT_INPUT).build(); 
    153         // When 
    154         boolean patternContained = pattern.containedIn(taskTree); 
    155         // Then 
    156         assertThat(patternContained).isFalse(); 
    157     } 
    158      
    159     @Test 
    160     public void iteration_ends_with_positive_1() { 
    161         // Given 
    162         String spec = "Iteration {" +  
    163                       "  TextInput () {}" +  
    164                       "}"; 
    165         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    166         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).endsWith(TEXT_INPUT).build(); 
    167         // When 
    168         boolean patternContained = pattern.containedIn(taskTree); 
    169         // Then 
    170         assertThat(patternContained).isTrue(); 
    171     } 
    172      
    173     @Test 
    174     public void iteration_ends_with_positive_2() { 
    175         // Given 
    176         String spec = "Iteration {" + 
    177                       "  Sequence {" + 
    178                       "    EventTask target1 {}" + 
    179                       "    Selection {" + 
    180                       "      EventTask target2 {}" + 
    181                       "      TextInput target2 {}" + 
    182                       "    }" + 
    183                       "  }" + 
    184                       "}"; 
    185         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    186         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).endsWith(TEXT_INPUT).build(); 
    187         // When 
    188         boolean patternContained = pattern.containedIn(taskTree); 
    189         // Then 
    190         assertThat(patternContained).isTrue(); 
    191     } 
    192      
    193     @Test 
    194     public void iteration_ends_with_positive_3() { 
    195         // Given 
    196         String spec = "Iteration {" + 
    197                       "  Selection {" + 
    198                       "    TextInput target1 {}" + 
    199                       "    Sequence {" + 
    200                       "      EventTask target2 {}" + 
    201                       "      EventTask target3 {}" + 
    202                       "    }" + 
    203                       "  }" + 
    204                       "}"; 
    205         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    206         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).endsWith(TEXT_INPUT).build(); 
    207         // When 
    208         boolean patternContained = pattern.containedIn(taskTree); 
    209         // Then 
    210         assertThat(patternContained).isTrue(); 
    211     } 
    212      
    213     @Test 
    214     public void iteration_ends_with_negative_1() { 
    215         // Given 
    216         String spec = "Iteration {" +  
    217                       "  MouseClick () {}" +  
    218                       "}"; 
    219         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    220         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).endsWith(TEXT_INPUT).build(); 
    221         // When 
    222         boolean patternContained = pattern.containedIn(taskTree); 
    223         // Then 
    224         assertThat(patternContained).isFalse(); 
    225     } 
    226      
    227     @Test 
    228     public void iteration_ends_with_negative_2() { 
    229         // Given 
    230         String spec = "Iteration {" + 
    231                       "  Sequence {" + 
    232                       "    EventTask target1 {}" + 
    233                       "    Optional {" + 
     64        String spec = "UserSession {" + 
     65                              "  Selection sel1 {" + 
     66                      "    Sequence seq1 {" + 
     67                      "      EventTask target1 {}" + 
    23468                      "      EventTask target2 {}" + 
    23569                      "    }" + 
    23670                      "  }" + 
    237                       "}"; 
    238         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    239         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).endsWith(TEXT_INPUT).build(); 
    240         // When 
    241         boolean patternContained = pattern.containedIn(taskTree); 
    242         // Then 
    243         assertThat(patternContained).isFalse(); 
    244     } 
    245      
    246     @Test 
    247     public void iteration_ends_with_negative_3() { 
    248         // Given 
    249         String spec = "Iteration {" + 
    250                       "  Selection {" + 
    251                       "    EventTask target1 {}" + 
    252                       "    Sequence {" + 
    253                       "      EventTask target2 {}" + 
     71                      "  Selection sel1 {" + 
     72                      "    Sequence seq2 {" + 
    25473                      "      EventTask target3 {}" + 
     74                      "      EventTask target4 {}" + 
    25575                      "    }" + 
    25676                      "  }" + 
    257                       "}"; 
    258         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    259         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).endsWith(TEXT_INPUT).build(); 
    260         // When 
    261         boolean patternContained = pattern.containedIn(taskTree); 
    262         // Then 
    263         assertThat(patternContained).isFalse(); 
    264     } 
    265      
    266     @Test 
    267     public void selection_ends_with_positive_1() { 
    268         // Given 
    269         String spec = "Selection {" +  
    270                       "  MouseClick () {}" +  
    271                       "  TextInput () {}" +  
    272                       "}"; 
    273         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    274         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SELECTION).endsWith(TEXT_INPUT).build(); 
    275         // When 
    276         boolean patternContained = pattern.containedIn(taskTree); 
    277         // Then 
    278         assertThat(patternContained).isTrue(); 
    279     } 
    280      
    281     @Test 
    282     public void selection_ends_with_positive_2() { 
    283         // Given 
    284         String spec = "Sequence {" + 
    285                       "  Optional {" + 
    286                       "    Sequence {" + 
    287                       "      EventTask target4 {}" + 
    288                       "      EventTask target3 {}" + 
    289                       "    }" + 
    290                       "  }" + 
    291                       "  EventTask target1 {}" + 
    292                       "  EventTask target2 {}" + 
    293                       "  EventTask target3 {}" + 
    294                       "  EventTask target4 {}" + 
    295                       "  Selection {" + 
    296                       "    EventTask target5 {}" + 
    297                       "    Sequence {" + 
    298                       "      EventTask target4 {}" + 
    299                       "      TextInput target2 {}" + 
    300                       "    }" + 
    301                       "  }" + 
    302                       "  EventTask target6 {}" + 
    303                       "  EventTask target7 {}" + 
    304                       "}"; 
    305         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    306         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SELECTION).endsWith(TEXT_INPUT).build(); 
    307         // When 
    308         boolean patternContained = pattern.containedIn(taskTree); 
    309         // Then 
    310         assertThat(patternContained).isTrue(); 
    311     } 
    312      
    313     @Test 
    314     public void selection_ends_with_positive_3() { 
    315         // Given 
    316         String spec = "Iteration {" + 
    317                       "  Selection {" + 
    318                       "    Sequence {" + 
    319                       "      EventTask target3 {}" + 
    320                       "      TextInput target4 {}" + 
    321                       "    }" + 
    322                       "    Sequence {" + 
    323                       "      TextInput target5 {}" + 
     77                      "  Selection sel1 {" + 
     78                      "    Sequence seq3 {" + 
     79                      "      EventTask target5 {}" + 
    32480                      "      EventTask target6 {}" + 
    32581                      "    }" + 
    32682                      "  }" + 
    32783                      "}"; 
    328         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    329         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SELECTION).endsWith(TEXT_INPUT).build(); 
    330         // When 
    331         boolean patternContained = pattern.containedIn(taskTree); 
    332         // Then 
    333         assertThat(patternContained).isTrue(); 
    334     } 
    335      
    336     @Test 
    337     public void selection_ends_with_negative_1() { 
    338         // Given 
    339         String spec = "Selection {" +  
    340                       "  DragAndDrop () {}" +  
    341                       "  MouseClick () {}" +  
    342                       "}"; 
    343         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    344         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SELECTION).endsWith(TEXT_INPUT).build(); 
    345         // When 
    346         boolean patternContained = pattern.containedIn(taskTree); 
    347         // Then 
    348         assertThat(patternContained).isFalse(); 
    349     } 
    350      
    351     @Test 
    352     public void selection_ends_with_negative_2() { 
    353         // Given 
    354         String spec = "Iteration {" + 
    355                       "  Selection {" + 
    356                       "    Sequence {" + 
    357                       "      TextInput target3 {}" + 
    358                       "      EventTask target4 {}" + 
    359                       "    }" + 
    360                       "    Sequence {" + 
    361                       "      TextInput target5 {}" + 
    362                       "      EventTask target6 {}" + 
    363                       "    }" + 
    364                       "  }" + 
    365                       "}"; 
    366         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    367         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SELECTION).endsWith(TEXT_INPUT).build(); 
     84        ITaskModel taskTree = GenerateTaskModelUtil.getTaskModelFromSpec(spec); 
     85        UsagePattern pattern = new UsagePatternBuilder().concernedNode(SEQUENCE).endsWith(TEXT_INPUT).build(); 
    36886        // When 
    36987        boolean patternContained = pattern.containedIn(taskTree); 

  • trunk/autoquest-core-usability-evaluation-test/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/endswith/EndsWithPatternTest.java

    r1152 r1171  
    2424import org.junit.Test; 
    2525 
    26 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree; 
     26import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
    2727import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePattern; 
    2828import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternBuilder; 
    29 import de.ugoe.cs.autoquest.usability.testutil.GenerateTaskTreeUtil; 
     29import de.ugoe.cs.autoquest.usability.testutil.GenerateTaskModelUtil; 
    3030 
    3131/** 
    … …  
    3939 
    4040    @Test 
    41     public void sequence_starts_with_positive_1() { 
     41    public void starts_with_pattern_positive() { 
    4242        // Given 
    43         String spec = "Sequence {" + 
    44                       "  EventTask target2 {}" + 
    45                       "  EventTask target3 {}" + 
    46                       "  Selection {" + 
    47                       "    Sequence {" + 
    48                       "      TextInput target4 {}" + 
    49                       "      MouseClick target2 {}" + 
     43        String spec = "UserSession {" + 
     44                              "  Sequence seq1 {" + 
     45                      "    EventTask target2 {}" + 
     46                      "    EventTask target3 {}" + 
     47                      "    Selection sel1 {" + 
     48                      "      Sequence seq2 {" + 
     49                      "        TextInput target4 {}" + 
     50                      "        MouseClick target2 {}" + 
     51                      "      }" + 
    5052                      "    }" + 
    51                       "    Sequence {" + 
    52                       "      TextInput target4 {}" + 
    53                       "      EventTask target2 {}" + 
     53                      "    Selection sel1 {" + 
     54                      "      Sequence seq3 {" + 
     55                      "        TextInput target4 {}" + 
     56                      "        EventTask target2 {}" + 
     57                      "      }" + 
    5458                      "    }" + 
    5559                      "  }" + 
    5660                      "}"; 
    57         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
     61        ITaskModel taskTree = GenerateTaskModelUtil.getTaskModelFromSpec(spec); 
    5862        UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    5963        UsagePattern endsWithPattern = patternBuilder.concernedNode(SELECTION).startsWith(TEXT_INPUT).endsWith(MOUSE_CLICK).build(); 
    … …  
    6670     
    6771    @Test 
    68     public void sequence_starts_with_positive_2() { 
     72    public void starts_with_pattern_negative() { 
    6973        // Given 
    70         String spec = "Selection {" + 
    71                       "  EventTask target1 {}" + 
    72                       "  Sequence {" + 
    73                       "    Iteration {" + 
    74                       "      Sequence {" + 
    75                       "        TextInput target4 {}" + 
    76                       "        MouseClick target2 {}" + 
    77                       "        TextInput target4 {}" + 
     74        String spec = "UserSession {" + 
     75                              "  Selection sel1 {" + 
     76                      "    Sequence seq1 {" + 
     77                      "      EventTask target1 {}" + 
     78                      "      EventTask target2 {}" + 
     79                      "    }" + 
     80                      "  }" + 
     81                      "  Selection sel1 {" + 
     82                      "    Iteration it1 {" + 
     83                      "      Sequence seq2 {" + 
     84                      "        MouseClick target5 {}" + 
     85                      "        EventTask target4 {}" + 
     86                      "        EventTask target2 {}" + 
    7887                      "      }" + 
    7988                      "    }" + 
    8089                      "  }" + 
    81                       "}"; 
    82         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    83         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    84         UsagePattern endsWithPattern = patternBuilder.concernedNode(ITERATION).startsWith(TEXT_INPUT).contains(MOUSE_CLICK).build(); 
    85         UsagePattern pattern = patternBuilder.concernedNode(SEQUENCE).endsWith(endsWithPattern).build(); 
    86         // When 
    87         boolean patternContained = pattern.containedIn(taskTree); 
    88         // Then 
    89         assertThat(patternContained).isTrue(); 
    90     } 
    91      
    92     @Test 
    93     public void sequence_starts_with_positive_3() { 
    94         // Given 
    95         String spec =  "Sequence {" + 
    96                        "  Optional {" + 
    97                        "    Sequence {" + 
    98                        "      EventTask target4 {}" + 
    99                        "      EventTask target3 {}" + 
    100                        "    }" + 
    101                        "  }" + 
    102                        "  EventTask target1 {}" + 
    103                        "  EventTask target2 {}" + 
    104                        "  EventTask target3 {}" + 
    105                        "  EventTask target4 {}" + 
    106                        "  EventTask target6 {}" + 
    107                        "  EventTask target7 {}" + 
    108                        "  Sequence {" + 
    109                        "    MouseClick target5 {}" + 
    110                        "    TextInput target4 {}" + 
    111                        "    MouseClick target2 {}" + 
    112                        "  }" + 
    113                        "}"; 
    114         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec);  
    115         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    116         UsagePattern startsWithPattern = patternBuilder.concernedNode(SEQUENCE).startsWith(MOUSE_CLICK).endsWith(MOUSE_CLICK).build(); 
    117         UsagePattern pattern = patternBuilder.concernedNode(SEQUENCE).startsWith(startsWithPattern).build(); 
    118         // When 
    119         boolean patternContained = pattern.containedIn(taskTree); 
    120         // Then 
    121         assertThat(patternContained).isTrue(); 
    122     } 
    123     
    124     @Test 
    125     public void sequence_starts_with_negative_1() { 
    126         // Given 
    127         String spec = "Sequence {" +  
    128                       "  MouseClick () {}" +  
    129                       "}"; 
    130         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    131         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    132         UsagePattern endsWithPattern = patternBuilder.concernedNode(SELECTION).startsWith(MOUSE_CLICK).endsWith(MOUSE_CLICK).build(); 
    133         UsagePattern pattern = patternBuilder.concernedNode(SEQUENCE).endsWith(endsWithPattern).build(); 
    134         // When 
    135         boolean patternContained = pattern.containedIn(taskTree); 
    136         // Then 
    137         assertThat(patternContained).isFalse(); 
    138     } 
    139      
    140     @Test 
    141     public void sequence_starts_with_negative_2() { 
    142         // Given 
    143         String spec = "Selection {" + 
    144                       "  Sequence {" + 
    145                       "    EventTask target1 {}" + 
    146                       "    EventTask target2 {}" + 
    147                       "  }" + 
    148                       "  Iteration {" + 
    149                       "    Sequence {" + 
    150                       "      MouseClick target5 {}" + 
    151                       "      EventTask target4 {}" + 
    152                       "      EventTask target2 {}" + 
     90                      "  Selection sel1 {" + 
     91                      "    Sequence seq3 {" + 
     92                      "      EventTask target5 {}" + 
     93                      "      EventTask target6 {}" + 
    15394                      "    }" + 
    15495                      "  }" + 
    155                       "  Sequence {" + 
    156                       "    EventTask target5 {}" + 
    157                       "    EventTask target6 {}" + 
    158                       "  }" + 
    15996                      "}"; 
    160         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
     97        ITaskModel taskTree = GenerateTaskModelUtil.getTaskModelFromSpec(spec); 
    16198        UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    16299        UsagePattern endsWithPattern = patternBuilder.concernedNode(ITERATION).startsWith(MOUSE_CLICK).contains(TEXT_INPUT).build(); 
    … …  
    168105    } 
    169106     
    170     @Test 
    171     public void sequence_starts_with_negative_3() { 
    172         // Given 
    173         String spec = "Sequence {" + 
    174                       "  Selection {" + 
    175                       "    Sequence {" + 
    176                       "      MouseClick target4 {}" + 
    177                       "      EventTask target2 {}" + 
    178                       "    }" + 
    179                       "    Sequence {" + 
    180                       "      TextInput target4 {}" + 
    181                       "      TextInput target2 {}" + 
    182                       "    }" + 
    183                       "  }" + 
    184                       "}"; 
    185         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    186         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    187         UsagePattern endsWithPattern = patternBuilder.concernedNode(SEQUENCE).startsWith(MOUSE_CLICK).endsWith(TEXT_INPUT).build(); 
    188         UsagePattern pattern = patternBuilder.concernedNode(SEQUENCE).endsWith(endsWithPattern).build(); 
    189         // When 
    190         boolean patternContained = pattern.containedIn(taskTree); 
    191         // Then 
    192         assertThat(patternContained).isFalse(); 
    193     } 
    194      
    195     @Test 
    196     public void iteration_starts_with_positive_1() { 
    197         // Given 
    198         String spec = "Iteration {" + 
    199                       "  Sequence {" +  
    200                       "    MouseClick () {}" + 
    201                       "    TextInput () {}" + 
    202                       "  }" +  
    203                       "}"; 
    204         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    205         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    206         UsagePattern endsWithPattern = patternBuilder.concernedNode(SEQUENCE).startsWith(MOUSE_CLICK).endsWith(TEXT_INPUT).build(); 
    207         UsagePattern pattern = patternBuilder.concernedNode(ITERATION).endsWith(endsWithPattern).build(); 
    208         // When 
    209         boolean patternContained = pattern.containedIn(taskTree); 
    210         // Then 
    211         assertThat(patternContained).isTrue(); 
    212     } 
    213      
    214     @Test 
    215     public void iteration_starts_with_positive_2() { 
    216         // Given 
    217         String spec = "Iteration {" + 
    218                       "  Selection {" + 
    219                       "    Sequence {" + 
    220                       "      MouseClick target4 {}" + 
    221                       "      TextInput target2 {}" + 
    222                       "      MouseClick target 4 {}" + 
    223                       "    }" + 
    224                       "    Sequence {" + 
    225                       "      TextInput target4 {}" + 
    226                       "      TextInput target2 {}" + 
    227                       "    }" + 
    228                       "  }" + 
    229                       "}"; 
    230         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    231         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    232         UsagePattern endsWithPattern = patternBuilder.concernedNode(SELECTION).startsWith(MOUSE_CLICK).contains(TEXT_INPUT).build(); 
    233         UsagePattern pattern = patternBuilder.concernedNode(ITERATION).endsWith(endsWithPattern).build(); 
    234         // When 
    235         boolean patternContained = pattern.containedIn(taskTree); 
    236         // Then 
    237         assertThat(patternContained).isTrue(); 
    238     } 
    239      
    240     @Test 
    241     public void iteration_starts_with_positive_3() { 
    242         // Given 
    243         String spec = "Iteration {" + 
    244                       "  Selection {" + 
    245                       "    EventTask target1 {}" + 
    246                       "    Sequence {" + 
    247                       "      MouseClick target2 {}" + 
    248                       "      MouseClick target3 {}" + 
    249                       "    }" + 
    250                       "  }" + 
    251                       "}"; 
    252         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    253         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    254         UsagePattern endsWithPattern = patternBuilder.concernedNode(SEQUENCE).startsWith(MOUSE_CLICK).endsWith(MOUSE_CLICK).build(); 
    255         UsagePattern pattern = patternBuilder.concernedNode(ITERATION).endsWith(endsWithPattern).build(); 
    256         // When 
    257         boolean patternContained = pattern.containedIn(taskTree); 
    258         // Then 
    259         assertThat(patternContained).isTrue(); 
    260     } 
    261      
    262     @Test 
    263     public void iteration_starts_with_negative_1() { 
    264         // Given 
    265         String spec = "Iteration {" +  
    266                       "  MouseClick () {}" +  
    267                       "}"; 
    268         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    269         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    270         UsagePattern endsWithPattern = patternBuilder.concernedNode(SEQUENCE).startsWith(MOUSE_CLICK).endsWith(MOUSE_CLICK).build(); 
    271         UsagePattern pattern = patternBuilder.concernedNode(ITERATION).endsWith(endsWithPattern).build(); 
    272         // When 
    273         boolean patternContained = pattern.containedIn(taskTree); 
    274         // Then 
    275         assertThat(patternContained).isFalse(); 
    276     } 
    277      
    278     @Test 
    279     public void iteration_starts_with_negative_2() { 
    280         // Given 
    281         String spec = "Iteration {" + 
    282                       "  Selection {" + 
    283                       "    Sequence {" + 
    284                       "      MouseClick target2 {}" + 
    285                       "      MouseClick target3 {}" + 
    286                       "      TextInput target4 {}" +  
    287                       "    }" + 
    288                       "    Optional {" + 
    289                       "      EventTask target2 {}" + 
    290                       "    }" + 
    291                       "  }" + 
    292                       "}"; 
    293         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    294         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    295         UsagePattern endsWithPattern = patternBuilder.concernedNode(SELECTION).startsWith(MOUSE_CLICK).endsWith(MOUSE_CLICK).build(); 
    296         UsagePattern pattern = patternBuilder.concernedNode(ITERATION).endsWith(endsWithPattern).build(); 
    297         // When 
    298         boolean patternContained = pattern.containedIn(taskTree); 
    299         // Then 
    300         assertThat(patternContained).isFalse(); 
    301     } 
    302      
    303     @Test 
    304     public void iteration_starts_with_negative_3() { 
    305         // Given 
    306         String spec = "Iteration {" + 
    307                       "  Selection {" + 
    308                       "    EventTask target1 {}" + 
    309                       "    Sequence {" + 
    310                       "      EventTask target2 {}" + 
    311                       "      EventTask target3 {}" + 
    312                       "    }" + 
    313                       "  }" + 
    314                       "}"; 
    315         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    316         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    317         UsagePattern endsWithPattern = patternBuilder.concernedNode(SEQUENCE).startsWith(MOUSE_CLICK).endsWith(MOUSE_CLICK).build(); 
    318         UsagePattern pattern = patternBuilder.concernedNode(ITERATION).endsWith(endsWithPattern).build(); 
    319         // When 
    320         boolean patternContained = pattern.containedIn(taskTree); 
    321         // Then 
    322         assertThat(patternContained).isFalse(); 
    323     } 
    324      
    325     @Test 
    326     public void selection_starts_with_positive_1() { 
    327         // Given 
    328         String spec = "Selection {" +  
    329                       "  Sequence {" + 
    330                       "    MouseClick target2 {}" + 
    331                       "    MouseClick target3 {}" + 
    332                       "  }" + 
    333                       "  MouseClick () {}" +  
    334                       "}"; 
    335         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    336         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    337         UsagePattern endsWithPattern = patternBuilder.concernedNode(SEQUENCE).startsWith(MOUSE_CLICK).endsWith(MOUSE_CLICK).build(); 
    338         UsagePattern pattern = patternBuilder.concernedNode(SELECTION).endsWith(endsWithPattern).build(); 
    339         // When 
    340         boolean patternContained = pattern.containedIn(taskTree); 
    341         // Then 
    342         assertThat(patternContained).isTrue(); 
    343     } 
    344      
    345     @Test 
    346     public void selection_starts_with_positive_2() { 
    347         // Given 
    348         String spec = "Sequence {" + 
    349                       "  Optional {" + 
    350                       "    Sequence {" + 
    351                       "      EventTask target4 {}" + 
    352                       "      EventTask target3 {}" + 
    353                       "    }" + 
    354                       "  }" + 
    355                       "  EventTask target1 {}" + 
    356                       "  EventTask target2 {}" + 
    357                       "  EventTask target3 {}" + 
    358                       "  EventTask target4 {}" + 
    359                       "  Selection {" + 
    360                       "    TextInput target5 {}" + 
    361                       "    Selection {" + 
    362                       "      MouseClick target4 {}" + 
    363                       "      MouseClick target2 {}" + 
    364                       "    }" + 
    365                       "  }" + 
    366                       "  EventTask target6 {}" + 
    367                       "  EventTask target7 {}" + 
    368                       "}"; 
    369         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    370         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    371         UsagePattern endsWithPattern = patternBuilder.concernedNode(SELECTION).startsWith(MOUSE_CLICK).endsWith(MOUSE_CLICK).build(); 
    372         UsagePattern pattern = patternBuilder.concernedNode(SELECTION).endsWith(endsWithPattern).build(); 
    373         // When 
    374         boolean patternContained = pattern.containedIn(taskTree); 
    375         // Then 
    376         assertThat(patternContained).isTrue(); 
    377     } 
    378      
    379     @Test 
    380     public void selection_starts_with_positive_3() { 
    381         // Given 
    382         String spec = "Iteration {" + 
    383                       "  Selection {" + 
    384                       "    Iteration {" + 
    385                       "      Sequence {" + 
    386                       "        TextInput target3 {}" + 
    387                       "        MouseClick target4 {}" + 
    388                       "      }" + 
    389                       "    }" + 
    390                       "    Sequence {" + 
    391                       "      TextInput target5 {}" + 
    392                       "      EventTask target6 {}" + 
    393                       "    }" + 
    394                       "  }" + 
    395                       "}"; 
    396         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    397         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    398         UsagePattern endsWithPattern = patternBuilder.concernedNode(ITERATION).startsWith(TEXT_INPUT).contains(MOUSE_CLICK).build(); 
    399         UsagePattern pattern = patternBuilder.concernedNode(SELECTION).endsWith(endsWithPattern).build(); 
    400         // When 
    401         boolean patternContained = pattern.containedIn(taskTree); 
    402         // Then 
    403         assertThat(patternContained).isTrue(); 
    404     } 
    405      
    406     @Test 
    407     public void selection_starts_with_negative_1() { 
    408         // Given 
    409         String spec = "Selection {" +  
    410                       "  DragAndDrop () {}" +  
    411                       "  MouseClick () {}" +  
    412                       "}"; 
    413         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    414         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    415         UsagePattern endsWithPattern = patternBuilder.concernedNode(SEQUENCE).startsWith(TEXT_INPUT).contains(MOUSE_CLICK).build(); 
    416         UsagePattern pattern = patternBuilder.concernedNode(SELECTION).endsWith(endsWithPattern).build(); 
    417         // When 
    418         boolean patternContained = pattern.containedIn(taskTree); 
    419         // Then 
    420         assertThat(patternContained).isFalse(); 
    421     } 
    422      
    423     @Test 
    424     public void selection_starts_with_negative_2() { 
    425         // Given 
    426         String spec = "Iteration {" + 
    427                       "  Selection {" + 
    428                       "    Iteration {" + 
    429                       "      Sequence {"+ 
    430                       "        TextInput target3 {}" + 
    431                       "        TextInput target4 {}" + 
    432                       "      }" + 
    433                       "    }" + 
    434                       "    Iteration {" + 
    435                       "      Sequence {"+ 
    436                       "        MouseClick target5 {}" + 
    437                       "        TextInput target6 {}" + 
    438                       "      }" + 
    439                       "    }" + 
    440                       "  }" + 
    441                       "}"; 
    442         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    443         UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    444         UsagePattern endsWithPattern = patternBuilder.concernedNode(ITERATION).startsWith(TEXT_INPUT).endsWith(MOUSE_CLICK).build(); 
    445         UsagePattern pattern = patternBuilder.concernedNode(SELECTION).endsWith(endsWithPattern).build(); 
    446         // When 
    447         boolean patternContained = pattern.containedIn(taskTree); 
    448         // Then 
    449         assertThat(patternContained).isFalse(); 
    450     } 
    451  
    452107} 
Note: See TracChangeset for help on using the changeset viewer.