Ignore:
Timestamp:
08/14/13 17:04:42 (11 years ago)
Author:
pharms
Message:
  • rework of task model to move event instance stuff to task instances
  • introduction of sequence, selection, iteration and optional instances
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SequenceComparisonRuleTest.java

    r1190 r1294  
    2222import de.ugoe.cs.autoquest.eventcore.IEventType; 
    2323import de.ugoe.cs.autoquest.eventcore.StringEventType; 
    24 import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; 
    2524import de.ugoe.cs.autoquest.tasktrees.taskequality.SequenceComparisonRule; 
    26 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; 
    2725import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; 
    28 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; 
    2926import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    30 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; 
    31 import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskBuilder; 
    32 import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; 
    3327import de.ugoe.cs.autoquest.test.DummyGUIElement; 
    3428 
    … …  
    3630 * @author Patrick Harms 
    3731 */ 
    38 public class SequenceComparisonRuleTest { 
    39  
    40     /** 
    41      *  
    42      */ 
    43     @Test 
    44     public void test() { 
    45         ITaskFactory taskFactory = new TaskFactory(); 
    46         ITaskBuilder treeBuilder = new TaskBuilder(); 
    47          
     32public class SequenceComparisonRuleTest extends AbstractComparisonRuleTest { 
     33 
     34    /** 
     35     * 
     36     */ 
     37    @Test 
     38    public void test_isApplicable_01() { 
     39        SequenceComparisonRule rule = new SequenceComparisonRule(); 
     40         
     41        ITask task1 = createNewSequence(); 
     42         
     43        assertTrue(rule.isApplicable(task1, task1)); 
     44    } 
     45 
     46    /** 
     47     * 
     48     */ 
     49    @Test 
     50    public void test_isApplicable_02() { 
     51        SequenceComparisonRule rule = new SequenceComparisonRule(); 
     52 
     53        ITask task1 = createNewSequence(); 
     54        ITask task2 = createNewSequence(); 
     55         
     56        assertTrue(rule.isApplicable(task1, task2)); 
     57        assertTrue(rule.isApplicable(task2, task1)); 
     58    } 
     59 
     60    /** 
     61     * 
     62     */ 
     63    @Test 
     64    public void test_isApplicable_03() { 
     65        SequenceComparisonRule rule = new SequenceComparisonRule(); 
     66 
     67        ITask task1 = createNewSequence(); 
     68        ITask task2 = createNewSelection(); 
     69         
     70        assertFalse(rule.isApplicable(task1, task2)); 
     71        assertFalse(rule.isApplicable(task2, task1)); 
     72    } 
     73 
     74    /** 
     75     * 
     76     */ 
     77    @Test 
     78    public void test_isApplicable_04() { 
     79        SequenceComparisonRule rule = new SequenceComparisonRule(); 
     80 
     81        ITask task1 = createNewSequence(); 
     82        ITask task2 = createNewIteration(); 
     83         
     84        assertFalse(rule.isApplicable(task1, task2)); 
     85        assertFalse(rule.isApplicable(task2, task1)); 
     86    } 
     87 
     88    /** 
     89     * 
     90     */ 
     91    @Test 
     92    public void test_isApplicable_05() { 
     93        SequenceComparisonRule rule = new SequenceComparisonRule(); 
     94 
     95        ITask task1 = createNewSequence(); 
     96        ITask task2 = createNewOptional(); 
     97         
     98        assertFalse(rule.isApplicable(task1, task2)); 
     99        assertFalse(rule.isApplicable(task2, task1)); 
     100    } 
     101 
     102    /** 
     103     * 
     104     */ 
     105    @Test 
     106    public void test_isApplicable_06() { 
     107        SequenceComparisonRule rule = new SequenceComparisonRule(); 
     108         
     109        IEventType eventType1 = new StringEventType("eventType1"); 
     110        IEventTarget eventTarget1 = new DummyGUIElement("elem1"); 
     111 
     112        ITask task1 = createNewSequence(); 
     113        ITask task2 = createNewEventTask(eventType1, eventTarget1); 
     114         
     115        assertFalse(rule.isApplicable(task1, task2)); 
     116        assertFalse(rule.isApplicable(task2, task1)); 
     117    } 
     118 
     119    /** 
     120     *  
     121     */ 
     122    @Test 
     123    public void test_compare_01() { 
     124        SequenceComparisonRule rule = new SequenceComparisonRule(); 
     125         
     126        ISequence sequence1 = createNewSequence(); 
     127        assertLexicallyEqual(rule, sequence1, sequence1); 
     128    } 
     129 
     130    /** 
     131     *  
     132     */ 
     133    @Test 
     134    public void test_compare_02() { 
     135        SequenceComparisonRule rule = new SequenceComparisonRule(); 
     136         
     137        ISequence sequence1 = createNewSequence(); 
     138        ISequence sequence2 = createNewSequence(); 
     139         
     140        assertLexicallyEqual(rule, sequence1, sequence2); 
     141    } 
     142 
     143    /** 
     144     *  
     145     */ 
     146    @Test 
     147    public void test_compare_03() { 
     148        SequenceComparisonRule rule = new SequenceComparisonRule(); 
     149         
     150        IEventType eventType1 = new StringEventType("eventType1"); 
     151        IEventTarget eventTarget1 = new DummyGUIElement("elem1"); 
     152 
     153        ITask task1 = createNewEventTask(eventType1, eventTarget1); 
     154         
     155        ISequence sequence1 = createNewSequence(); 
     156        ISequence sequence2 = createNewSequence(); 
     157         
     158        addChild(sequence1, task1); 
     159         
     160        assertUnequal(rule, sequence1, sequence2); 
     161    } 
     162 
     163    /** 
     164     *  
     165     */ 
     166    @Test 
     167    public void test_compare_04() { 
     168        SequenceComparisonRule rule = new SequenceComparisonRule(); 
     169         
     170        IEventType eventType1 = new StringEventType("eventType1"); 
     171        IEventTarget eventTarget1 = new DummyGUIElement("elem1"); 
     172 
     173        ITask task1 = createNewEventTask(eventType1, eventTarget1); 
     174         
     175        ISequence sequence1 = createNewSequence(); 
     176        ISequence sequence2 = createNewSequence(); 
     177         
     178        addChild(sequence1, task1); 
     179        addChild(sequence2, task1); 
     180         
     181        assertLexicallyEqual(rule, sequence1, sequence2); 
     182    } 
     183 
     184    /** 
     185     *  
     186     */ 
     187    @Test 
     188    public void test_compare_05() { 
    48189        SequenceComparisonRule rule = new SequenceComparisonRule(); 
    49190         
    … …  
    54195        IEventTarget eventTarget2 = new DummyGUIElement("elem2"); 
    55196 
    56         ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); 
    57         ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); 
    58          
    59         assertFalse(rule.isApplicable(task1, task2)); 
    60          
    61         ISequence sequence1 = taskFactory.createNewSequence(); 
    62         assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence1)); 
    63  
    64         ISequence sequence2 = taskFactory.createNewSequence(); 
    65          
    66         assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2)); 
    67         assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1)); 
    68          
    69         treeBuilder.addChild(sequence1, task1); 
    70          
    71         assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence1, sequence2)); 
    72         assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence2, sequence1)); 
    73          
    74         treeBuilder.addChild(sequence2, task1); 
    75          
    76         assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2)); 
    77         assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1)); 
    78          
    79         treeBuilder.addChild(sequence1, task2); 
    80          
    81         assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence1, sequence2)); 
    82         assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence2, sequence1)); 
    83          
    84         treeBuilder.addChild(sequence2, task2); 
    85          
    86         assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2)); 
    87         assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1)); 
    88          
    89         ISequence sequence3 = taskFactory.createNewSequence(); 
    90         treeBuilder.addChild(sequence3, task2); 
    91         treeBuilder.addChild(sequence3, task1); 
    92          
    93         assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence1, sequence3)); 
    94         assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence3, sequence1)); 
    95         assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence2, sequence3)); 
    96         assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence3, sequence2)); 
    97  
    98         ISelection selection = taskFactory.createNewSelection(); 
    99         assertFalse(rule.isApplicable(sequence1, selection)); 
    100         assertFalse(rule.isApplicable(selection, sequence1)); 
    101         assertFalse(rule.isApplicable(sequence2, selection)); 
    102         assertFalse(rule.isApplicable(selection, sequence2)); 
    103         assertFalse(rule.isApplicable(sequence3, selection)); 
    104         assertFalse(rule.isApplicable(selection, sequence3)); 
     197        ITask task1 = createNewEventTask(eventType1, eventTarget1); 
     198        ITask task2 = createNewEventTask(eventType2, eventTarget2); 
     199         
     200        ISequence sequence1 = createNewSequence(); 
     201        ISequence sequence2 = createNewSequence(); 
     202         
     203        addChild(sequence1, task1); 
     204        addChild(sequence2, task1); 
     205         
     206        addChild(sequence1, task2); 
     207         
     208        assertUnequal(rule, sequence1, sequence2); 
     209    } 
     210 
     211    /** 
     212     *  
     213     */ 
     214    @Test 
     215    public void test_compare_06() { 
     216        SequenceComparisonRule rule = new SequenceComparisonRule(); 
     217         
     218        IEventType eventType1 = new StringEventType("eventType1"); 
     219        IEventTarget eventTarget1 = new DummyGUIElement("elem1"); 
     220 
     221        IEventType eventType2 = new StringEventType("eventType2"); 
     222        IEventTarget eventTarget2 = new DummyGUIElement("elem2"); 
     223 
     224        ITask task1 = createNewEventTask(eventType1, eventTarget1); 
     225        ITask task2 = createNewEventTask(eventType2, eventTarget2); 
     226         
     227        ISequence sequence1 = createNewSequence(); 
     228        ISequence sequence2 = createNewSequence(); 
     229         
     230        addChild(sequence1, task1); 
     231        addChild(sequence2, task1); 
     232         
     233        addChild(sequence1, task2); 
     234        addChild(sequence2, task2); 
     235         
     236        assertLexicallyEqual(rule, sequence1, sequence2); 
     237    } 
     238 
     239    /** 
     240     *  
     241     */ 
     242    @Test 
     243    public void test_compare_07() { 
     244        SequenceComparisonRule rule = new SequenceComparisonRule(); 
     245         
     246        IEventType eventType1 = new StringEventType("eventType1"); 
     247        IEventTarget eventTarget1 = new DummyGUIElement("elem1"); 
     248 
     249        IEventType eventType2 = new StringEventType("eventType2"); 
     250        IEventTarget eventTarget2 = new DummyGUIElement("elem2"); 
     251 
     252        ITask task1 = createNewEventTask(eventType1, eventTarget1); 
     253        ITask task2 = createNewEventTask(eventType2, eventTarget2); 
     254         
     255        ISequence sequence1 = createNewSequence(); 
     256        ISequence sequence2 = createNewSequence(); 
     257         
     258        addChild(sequence1, task1); 
     259        addChild(sequence1, task2); 
     260         
     261        addChild(sequence2, task2); 
     262        addChild(sequence2, task1); 
     263         
     264        assertUnequal(rule, sequence1, sequence2); 
    105265    } 
    106266 
Note: See TracChangeset for help on using the changeset viewer.