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/contains
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

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

  • trunk/autoquest-core-usability-evaluation-test/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/contains/ContainsEventTest.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; 
    1918import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter.SELECTION; 
    2019import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter.SEQUENCE; 
    … …  
    2322import org.junit.Test; 
    2423 
    25 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree; 
     24import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
    2625import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePattern; 
    2726import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternBuilder; 
    28 import de.ugoe.cs.autoquest.usability.testutil.GenerateTaskTreeUtil; 
     27import de.ugoe.cs.autoquest.usability.testutil.GenerateTaskModelUtil; 
    2928 
    3029/** 
    … …  
    3736public class ContainsEventTest { 
    3837 
    39     @Test 
    40     public void sequence_ends_with_positive_1() { 
     38        @Test 
     39    public void contains_event_positive() { 
    4140        // Given 
    42         String spec = "Sequence {" +  
    43                       "  TextInput () {}" +  
     41        String spec = "UserSession {" + 
     42                      "  Sequence seq1 {" +  
     43                      "    TextInput t1 {}" + 
     44                      "  }" +  
    4445                      "}"; 
    45         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
     46        ITaskModel taskTree = GenerateTaskModelUtil.getTaskModelFromSpec(spec); 
    4647        UsagePattern pattern = new UsagePatternBuilder().concernedNode(SEQUENCE).contains(TEXT_INPUT).build(); 
    4748        // When 
    … …  
    5253     
    5354    @Test 
    54     public void sequence_ends_with_positive_2() { 
     55    public void contains_event_negative() { 
    5556        // 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).contains(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).contains(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).contains(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).contains(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).contains(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).contains(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 {}" + 
     57        String spec = "UserSession {" + 
     58                      "  Iteration it1 {" + 
     59                      "    Sequence seq1 {" + 
     60                      "      MouseClick t1 {}" + 
     61                      "      MouseClick t2 {}" + 
    18262                      "    }" + 
    18363                      "  }" + 
    18464                      "}"; 
    185         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    186         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).contains(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).contains(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).contains(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 {" + 
    234                       "      EventTask target2 {}" + 
    235                       "    }" + 
    236                       "  }" + 
    237                       "}"; 
    238         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    239         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).contains(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 {}" + 
    254                       "      EventTask target3 {}" + 
    255                       "    }" + 
    256                       "  }" + 
    257                       "}"; 
    258         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    259         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).contains(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).contains(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).contains(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 {}" + 
    324                       "      EventTask target6 {}" + 
    325                       "    }" + 
    326                       "  }" + 
    327                       "}"; 
    328         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    329         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SELECTION).contains(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).contains(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                       "      EventTask target3 {}" + 
    358                       "      EventTask target4 {}" + 
    359                       "    }" + 
    360                       "    Sequence {" + 
    361                       "      EventTask target5 {}" + 
    362                       "      EventTask target6 {}" + 
    363                       "    }" + 
    364                       "  }" + 
    365                       "}"; 
    366         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
     65        ITaskModel taskTree = GenerateTaskModelUtil.getTaskModelFromSpec(spec); 
    36766        UsagePattern pattern = new UsagePatternBuilder().concernedNode(SELECTION).contains(TEXT_INPUT).build(); 
    36867        // When 

  • trunk/autoquest-core-usability-evaluation-test/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/contains/ContainsPatternTest.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; 
    1918import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter.SELECTION; 
    2019import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter.SEQUENCE; 
    … …  
    2322import org.junit.Test; 
    2423 
    25 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree; 
     24import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
    2625import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePattern; 
    2726import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternBuilder; 
    28 import de.ugoe.cs.autoquest.usability.testutil.GenerateTaskTreeUtil; 
     27import de.ugoe.cs.autoquest.usability.testutil.GenerateTaskModelUtil; 
    2928 
    3029/** 
    … …  
    3736public class ContainsPatternTest { 
    3837 
    39     @Test 
    40     public void sequence_ends_with_positive_1() { 
     38        @Test 
     39    public void contains_pattern_positive() { 
    4140        // Given 
    42         String spec = "Sequence {" + 
    43                       "  Selection {" +  
    44                       "    TextInput () {}" + 
    45                       "    MouseClick () {}" + 
     41        String spec = "UserSession {" + 
     42                      "  Sequence seq1 {" + 
     43                          "    Selection sel1 {" +  
     44                      "      TextInput t1 {}" + 
     45                      "    }" + 
     46                      "    Selection sel1 {" + 
     47                      "      MouseClick t2 {}" + 
     48                      "    }" + 
    4649                      "  }" +  
    4750                      "}"; 
    48         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
     51        ITaskModel taskTree = GenerateTaskModelUtil.getTaskModelFromSpec(spec); 
    4952        UsagePatternBuilder patternBuilder = new UsagePatternBuilder(); 
    5053        UsagePattern containsPattern = patternBuilder.concernedNode(SELECTION).startsWith(TEXT_INPUT).endsWith(TEXT_INPUT).build(); 
    … …  
    5760     
    5861    @Test 
    59     public void sequence_ends_with_positive_2() { 
     62    public void contains_pattern_negative() { 
    6063        // Given 
    61         String spec = "Selection {" + 
    62                       "  EventTask target1 {}" + 
    63                       "  Sequence {" + 
    64                       "    EventTask target2 {}" + 
    65                       "    TextInput target3 {}" + 
    66                       "  }" + 
    67                       "}"; 
    68         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    69         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SEQUENCE).contains(TEXT_INPUT).build(); 
    70         // When 
    71         boolean patternContained = pattern.containedIn(taskTree); 
    72         // Then 
    73         assertThat(patternContained).isTrue(); 
    74     } 
    75      
    76     @Test 
    77     public void sequence_ends_with_positive_3() { 
    78         // Given 
    79         String spec =  "Sequence {" + 
    80                        "  Optional {" + 
    81                        "    Sequence {" + 
    82                        "      EventTask target4 {}" + 
    83                        "      EventTask target3 {}" + 
    84                        "    }" + 
    85                        "  }" + 
    86                        "  EventTask target1 {}" + 
    87                        "  EventTask target2 {}" + 
    88                        "  EventTask target3 {}" + 
    89                        "  EventTask target4 {}" + 
    90                        "  Selection {" + 
    91                        "    EventTask target5 {}" + 
    92                        "    Sequence {" + 
    93                        "      EventTask target4 {}" + 
    94                        "      EventTask target2 {}" + 
    95                        "    }" + 
    96                        "  }" + 
    97                        "  EventTask target6 {}" + 
    98                        "  TextInput target7 {}" + 
    99                        "}"; 
    100         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    101         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SEQUENCE).contains(TEXT_INPUT).build(); 
    102         // When 
    103         boolean patternContained = pattern.containedIn(taskTree); 
    104         // Then 
    105         assertThat(patternContained).isTrue(); 
    106     } 
    107     
    108     @Test 
    109     public void sequence_ends_with_negative_1() { 
    110         // Given 
    111         String spec = "Sequence {" +  
    112                       "  MouseClick () {}" +  
    113                       "}"; 
    114         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    115         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SEQUENCE).contains(TEXT_INPUT).build(); 
    116         // When 
    117         boolean patternContained = pattern.containedIn(taskTree); 
    118         // Then 
    119         assertThat(patternContained).isFalse(); 
    120     } 
    121      
    122     @Test 
    123     public void sequence_ends_with_negative_2() { 
    124         // Given 
    125         String spec = "Selection {" + 
    126                       "  Sequence {" + 
    127                       "    EventTask target1 {}" + 
    128                       "    EventTask target2 {}" + 
    129                       "  }" + 
    130                       "  Sequence {" + 
    131                       "    EventTask target3 {}" + 
    132                       "    EventTask target4 {}" + 
    133                       "  }" + 
    134                       "  Sequence {" + 
    135                       "    EventTask target5 {}" + 
    136                       "    EventTask target6 {}" + 
    137                       "  }" + 
    138                       "}"; 
    139         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    140         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SEQUENCE).contains(TEXT_INPUT).build(); 
    141         // When 
    142         boolean patternContained = pattern.containedIn(taskTree); 
    143         // Then 
    144         assertThat(patternContained).isFalse(); 
    145     } 
    146      
    147     @Test 
    148     public void sequence_ends_with_negative_3() { 
    149         // Given 
    150         String spec = "Iteration {" + 
    151                       "  Selection {" + 
    152                       "    EventTask target2 {}" + 
    153                       "    EventTask target3 {}" + 
    154                       "  }" + 
    155                       "}"; 
    156         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    157         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SEQUENCE).contains(TEXT_INPUT).build(); 
    158         // When 
    159         boolean patternContained = pattern.containedIn(taskTree); 
    160         // Then 
    161         assertThat(patternContained).isFalse(); 
    162     } 
    163      
    164     @Test 
    165     public void iteration_ends_with_positive_1() { 
    166         // Given 
    167         String spec = "Iteration {" +  
    168                       "  TextInput () {}" +  
    169                       "}"; 
    170         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    171         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).contains(TEXT_INPUT).build(); 
    172         // When 
    173         boolean patternContained = pattern.containedIn(taskTree); 
    174         // Then 
    175         assertThat(patternContained).isTrue(); 
    176     } 
    177      
    178     @Test 
    179     public void iteration_ends_with_positive_2() { 
    180         // Given 
    181         String spec = "Iteration {" + 
    182                       "  Sequence {" + 
    183                       "    EventTask target1 {}" + 
    184                       "    Selection {" + 
    185                       "      EventTask target2 {}" + 
    186                       "      TextInput target2 {}" + 
     64        String spec = "UserSession {" + 
     65                      "  Iteration it1 {" + 
     66                      "    Selection sel1 {" + 
     67                      "      Sequence seq1 {" + 
     68                      "        EventTask t1 {}" + 
     69                      "        EventTask t2 {}" + 
     70                      "      }" + 
     71                      "    }" + 
     72                      "    Selection sel1 {" + 
     73                      "      Sequence seq2 {" + 
     74                      "        EventTask t2 {}" + 
     75                      "        EventTask t1 {}" + 
     76                      "      }" + 
    18777                      "    }" + 
    18878                      "  }" + 
    18979                      "}"; 
    190         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    191         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).contains(TEXT_INPUT).build(); 
    192         // When 
    193         boolean patternContained = pattern.containedIn(taskTree); 
    194         // Then 
    195         assertThat(patternContained).isTrue(); 
    196     } 
    197      
    198     @Test 
    199     public void iteration_ends_with_positive_3() { 
    200         // Given 
    201         String spec = "Iteration {" + 
    202                       "  Selection {" + 
    203                       "    TextInput target1 {}" + 
    204                       "    Sequence {" + 
    205                       "      EventTask target2 {}" + 
    206                       "      EventTask target3 {}" + 
    207                       "    }" + 
    208                       "  }" + 
    209                       "}"; 
    210         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    211         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).contains(TEXT_INPUT).build(); 
    212         // When 
    213         boolean patternContained = pattern.containedIn(taskTree); 
    214         // Then 
    215         assertThat(patternContained).isTrue(); 
    216     } 
    217      
    218     @Test 
    219     public void iteration_ends_with_negative_1() { 
    220         // Given 
    221         String spec = "Iteration {" +  
    222                       "  MouseClick () {}" +  
    223                       "}"; 
    224         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    225         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).contains(TEXT_INPUT).build(); 
    226         // When 
    227         boolean patternContained = pattern.containedIn(taskTree); 
    228         // Then 
    229         assertThat(patternContained).isFalse(); 
    230     } 
    231      
    232     @Test 
    233     public void iteration_ends_with_negative_2() { 
    234         // Given 
    235         String spec = "Iteration {" + 
    236                       "  Sequence {" + 
    237                       "    EventTask target1 {}" + 
    238                       "    Optional {" + 
    239                       "      EventTask target2 {}" + 
    240                       "    }" + 
    241                       "  }" + 
    242                       "}"; 
    243         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    244         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).contains(TEXT_INPUT).build(); 
    245         // When 
    246         boolean patternContained = pattern.containedIn(taskTree); 
    247         // Then 
    248         assertThat(patternContained).isFalse(); 
    249     } 
    250      
    251     @Test 
    252     public void iteration_ends_with_negative_3() { 
    253         // Given 
    254         String spec = "Iteration {" + 
    255                       "  Selection {" + 
    256                       "    EventTask target1 {}" + 
    257                       "    Sequence {" + 
    258                       "      EventTask target2 {}" + 
    259                       "      EventTask target3 {}" + 
    260                       "    }" + 
    261                       "  }" + 
    262                       "}"; 
    263         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    264         UsagePattern pattern = new UsagePatternBuilder().concernedNode(ITERATION).contains(TEXT_INPUT).build(); 
    265         // When 
    266         boolean patternContained = pattern.containedIn(taskTree); 
    267         // Then 
    268         assertThat(patternContained).isFalse(); 
    269     } 
    270      
    271     @Test 
    272     public void selection_ends_with_positive_1() { 
    273         // Given 
    274         String spec = "Selection {" +  
    275                       "  MouseClick () {}" +  
    276                       "  TextInput () {}" +  
    277                       "}"; 
    278         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    279         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SELECTION).contains(TEXT_INPUT).build(); 
    280         // When 
    281         boolean patternContained = pattern.containedIn(taskTree); 
    282         // Then 
    283         assertThat(patternContained).isTrue(); 
    284     } 
    285      
    286     @Test 
    287     public void selection_ends_with_positive_2() { 
    288         // Given 
    289         String spec = "Sequence {" + 
    290                       "  Optional {" + 
    291                       "    Sequence {" + 
    292                       "      EventTask target4 {}" + 
    293                       "      EventTask target3 {}" + 
    294                       "    }" + 
    295                       "  }" + 
    296                       "  EventTask target1 {}" + 
    297                       "  EventTask target2 {}" + 
    298                       "  EventTask target3 {}" + 
    299                       "  EventTask target4 {}" + 
    300                       "  Selection {" + 
    301                       "    EventTask target5 {}" + 
    302                       "    Sequence {" + 
    303                       "      EventTask target4 {}" + 
    304                       "      TextInput target2 {}" + 
    305                       "    }" + 
    306                       "  }" + 
    307                       "  EventTask target6 {}" + 
    308                       "  EventTask target7 {}" + 
    309                       "}"; 
    310         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    311         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SELECTION).contains(TEXT_INPUT).build(); 
    312         // When 
    313         boolean patternContained = pattern.containedIn(taskTree); 
    314         // Then 
    315         assertThat(patternContained).isTrue(); 
    316     } 
    317      
    318     @Test 
    319     public void selection_ends_with_positive_3() { 
    320         // Given 
    321         String spec = "Iteration {" + 
    322                       "  Selection {" + 
    323                       "    Sequence {" + 
    324                       "      EventTask target3 {}" + 
    325                       "      TextInput target4 {}" + 
    326                       "    }" + 
    327                       "    Sequence {" + 
    328                       "      TextInput target5 {}" + 
    329                       "      EventTask target6 {}" + 
    330                       "    }" + 
    331                       "  }" + 
    332                       "}"; 
    333         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    334         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SELECTION).contains(TEXT_INPUT).build(); 
    335         // When 
    336         boolean patternContained = pattern.containedIn(taskTree); 
    337         // Then 
    338         assertThat(patternContained).isTrue(); 
    339     } 
    340      
    341     @Test 
    342     public void selection_ends_with_negative_1() { 
    343         // Given 
    344         String spec = "Selection {" +  
    345                       "  DragAndDrop () {}" +  
    346                       "  MouseClick () {}" +  
    347                       "}"; 
    348         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
    349         UsagePattern pattern = new UsagePatternBuilder().concernedNode(SELECTION).contains(TEXT_INPUT).build(); 
    350         // When 
    351         boolean patternContained = pattern.containedIn(taskTree); 
    352         // Then 
    353         assertThat(patternContained).isFalse(); 
    354     } 
    355      
    356     @Test 
    357     public void selection_ends_with_negative_2() { 
    358         // Given 
    359         String spec = "Iteration {" + 
    360                       "  Selection {" + 
    361                       "    Sequence {" + 
    362                       "      EventTask target3 {}" + 
    363                       "      EventTask target4 {}" + 
    364                       "    }" + 
    365                       "    Sequence {" + 
    366                       "      EventTask target5 {}" + 
    367                       "      EventTask target6 {}" + 
    368                       "    }" + 
    369                       "  }" + 
    370                       "}"; 
    371         ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec); 
     80        ITaskModel taskTree = GenerateTaskModelUtil.getTaskModelFromSpec(spec); 
    37281        UsagePattern pattern = new UsagePatternBuilder().concernedNode(SELECTION).contains(TEXT_INPUT).build(); 
    37382        // When 
Note: See TracChangeset for help on using the changeset viewer.