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

Last change on this file since 1151 was 1151, checked in by adeicke, 11 years ago

Added tests for usage pattern detection-
  • Property svn:mime-type set to text/plain
File size: 20.2 KB
Line 
1//   Copyright 2012 Georg-August-Universität Göttingen, Germany
2//
3//   Licensed under the Apache License, Version 2.0 (the "License");
4//   you may not use this file except in compliance with the License.
5//   You may obtain a copy of the License at
6//
7//       http://www.apache.org/licenses/LICENSE-2.0
8//
9//   Unless required by applicable law or agreed to in writing, software
10//   distributed under the License is distributed on an "AS IS" BASIS,
11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//   See the License for the specific language governing permissions and
13//   limitations under the License.
14
15package de.ugoe.cs.autoquest.usability.rules.patterns.visitors.endswith;
16
17import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.MOUSE_CLICK;
18import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.TEXT_INPUT;
19import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeNodeTypeFilter.ITERATION;
20import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeNodeTypeFilter.SELECTION;
21import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeNodeTypeFilter.SEQUENCE;
22import static org.fest.assertions.api.Assertions.assertThat;
23
24import org.junit.Test;
25
26import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
27import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePattern;
28import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternBuilder;
29import de.ugoe.cs.autoquest.usability.testutil.GenerateTaskTreeUtil;
30
31/**
32 * <p>
33 * TODO comment
34 * </p>
35 *
36 * @author Alexander Deicke
37 */
38public class EndsWithPatternTest {
39
40    @Test
41    public void sequence_starts_with_positive_1() {
42        // Given
43        String spec = "Sequence {" +
44                      "  EventTask target2 {}" +
45                      "  EventTask target3 {}" +
46                      "  Selection {" +
47                      "    Sequence {" +
48                      "      TextInput target4 {}" +
49                      "      MouseClick target2 {}" +
50                      "    }" +
51                      "    Sequence {" +
52                      "      TextInput target4 {}" +
53                      "      EventTask target2 {}" +
54                      "    }" +
55                      "  }" +
56                      "}";
57        ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec);
58        UsagePatternBuilder patternBuilder = new UsagePatternBuilder();
59        UsagePattern endsWithPattern = patternBuilder.concernedNode(SELECTION).startsWith(TEXT_INPUT).endsWith(MOUSE_CLICK).build();
60        UsagePattern pattern = patternBuilder.concernedNode(SEQUENCE).endsWith(endsWithPattern).build();
61        // When
62        boolean patternContained = pattern.containedIn(taskTree);
63        // Then
64        assertThat(patternContained).isTrue();
65    }
66   
67    @Test
68    public void sequence_starts_with_positive_2() {
69        // Given
70        String spec = "Selection {" +
71                      "  EventTask target1 {}" +
72                      "  Sequence {" +
73                      "    Iteration {" +
74                      "      Sequence {" +
75                      "        TextInput target4 {}" +
76                      "        MouseClick target2 {}" +
77                      "        TextInput target4 {}" +
78                      "      }" +
79                      "    }" +
80                      "  }" +
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 {}" +
153                      "    }" +
154                      "  }" +
155                      "  Sequence {" +
156                      "    EventTask target5 {}" +
157                      "    EventTask target6 {}" +
158                      "  }" +
159                      "}";
160        ITaskTree taskTree = GenerateTaskTreeUtil.getTaskTreeFromSpec(spec);
161        UsagePatternBuilder patternBuilder = new UsagePatternBuilder();
162        UsagePattern endsWithPattern = patternBuilder.concernedNode(ITERATION).startsWith(MOUSE_CLICK).contains(TEXT_INPUT).build();
163        UsagePattern pattern = patternBuilder.concernedNode(SEQUENCE).endsWith(endsWithPattern).build();
164        // When
165        boolean patternContained = pattern.containedIn(taskTree);
166        // Then
167        assertThat(patternContained).isFalse();
168    }
169   
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
452}
Note: See TracBrowser for help on using the repository browser.