Ignore:
Timestamp:
04/04/13 16:06:07 (11 years ago)
Author:
pharms
Message:
  • complete refactoring of task tree model with a separation of task models and task instances
  • appropriate adaptation of task tree generation process
  • appropriate adaptation of commands and task tree visualization
Location:
trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation
Files:
6 deleted
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java

    r1132 r1146  
    2121import java.lang.reflect.Constructor; 
    2222import java.lang.reflect.InvocationTargetException; 
    23 import java.util.ArrayList; 
    2423import java.util.LinkedList; 
    2524import java.util.List; 
    … …  
    2928import org.junit.Before; 
    3029 
    31 import de.ugoe.cs.autoquest.eventcore.IEventTarget; 
    32 import de.ugoe.cs.autoquest.eventcore.IEventType; 
    33 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality; 
    34 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager; 
     30import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker; 
     31import de.ugoe.cs.autoquest.tasktrees.TaskTreeDecoder; 
     32import de.ugoe.cs.autoquest.tasktrees.TaskTreeEncoder; 
     33import de.ugoe.cs.autoquest.tasktrees.TaskTreeValidator; 
     34import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; 
     35import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEqualityRuleManager; 
    3536import de.ugoe.cs.autoquest.tasktrees.testutils.Utilities; 
    36 import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; 
    37 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; 
    38 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree; 
    39 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; 
    40 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; 
    41 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; 
    42 import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeBuilder; 
    43 import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory; 
     37import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList; 
     38import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; 
     39import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; 
     40import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession; 
     41import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskBuilder; 
     42import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; 
    4443import de.ugoe.cs.util.console.Console; 
    4544import de.ugoe.cs.util.console.TextConsole; 
    … …  
    5251 
    5352    /** */ 
    54     private List<IEventTask> events; 
    55  
    56     /** */ 
    57     private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder(); 
    58  
    59     /** */ 
    60     private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory(); 
    61  
    62     /** */ 
    63     private NodeEqualityRuleManager nodeEqualityRuleManager = 
    64         Utilities.getNodeEqualityRuleManagerForTests(); 
     53    private ITaskBuilder taskBuilder = new TaskBuilder(); 
     54 
     55    /** */ 
     56    private ITaskFactory taskFactory = new TaskFactory(); 
     57     
     58    /** */ 
     59    private TaskTreeDecoder decoder = null; 
     60 
     61    /** */ 
     62    private TaskTreeEncoder encoder = new TaskTreeEncoder(); 
     63     
     64    /** */ 
     65    private TaskEqualityRuleManager taskEqualityRuleManager = 
     66        Utilities.getTaskEqualityRuleManagerForTests(); 
    6567 
    6668    /** 
    … …  
    6971    @Before 
    7072    public void setUp() { 
     73        Console.reset(); 
    7174        new TextConsole(Level.FINEST); 
    72         events = new ArrayList<IEventTask>(); 
     75         
     76        decoder = new TaskTreeDecoder(taskFactory, taskBuilder); 
    7377    } 
    7478 
    … …  
    7680     * 
    7781     */ 
    78     protected void simulateEvent(IEventType eventType, IEventTarget eventTarget) { 
    79         events.add(taskTreeNodeFactory.createNewEventTask(eventType, eventTarget)); 
    80         Console.reset(); 
     82    protected void applyRule(Class<? extends ITaskInstanceListScopeRule> ruleClass, 
     83                             String                                      inputSpec, 
     84                             String                                      expectedOutputSpec) 
     85    { 
     86        ITaskInstanceListScopeRule rule = null; 
     87         
     88        CONSTRUCTOR_ITERATION: 
     89        for (Constructor<?> constructor : ruleClass.getDeclaredConstructors()) { 
     90            List<Object> parameters = new LinkedList<Object>(); 
     91             
     92            for (Class<?> type : constructor.getParameterTypes()) { 
     93                if (ITaskFactory.class.equals(type)) { 
     94                    parameters.add(taskFactory); 
     95                } 
     96                else if (ITaskBuilder.class.equals(type)) { 
     97                    parameters.add(taskBuilder); 
     98                } 
     99                else if (TaskEqualityRuleManager.class.equals(type)) { 
     100                    parameters.add(taskEqualityRuleManager); 
     101                } 
     102                else if (TaskEquality.class.equals(type)) { 
     103                    parameters.add(TaskEquality.LEXICALLY_EQUAL); 
     104                } 
     105                else { 
     106                    continue CONSTRUCTOR_ITERATION; 
     107                } 
     108            } 
     109             
     110            try { 
     111                rule = (ITaskInstanceListScopeRule) constructor.newInstance(parameters.toArray()); 
     112            } 
     113            catch (IllegalArgumentException e) { 
     114                e.printStackTrace(); 
     115                fail("could not invoke the constructor " + constructor); 
     116            } 
     117            catch (InstantiationException e) { 
     118                e.printStackTrace(); 
     119                fail("could not invoke the constructor " + constructor); 
     120            } 
     121            catch (IllegalAccessException e) { 
     122                e.printStackTrace(); 
     123                fail("could not invoke the constructor " + constructor); 
     124            } 
     125            catch (InvocationTargetException e) { 
     126                e.printStackTrace(); 
     127                fail("could not invoke the constructor " + constructor); 
     128            } 
     129        } 
     130         
     131        if (rule == null) { 
     132            fail("no matching constructor found to instantiate rule " + ruleClass); 
     133        } 
     134         
     135        RuleApplicationResult result; 
     136        RuleApplicationStatus status; 
     137         
     138        ITaskInstanceList inputList = decoder.decode(inputSpec); 
     139         
     140        Stack<ITaskInstanceList> toBeAppliedOn = new Stack<ITaskInstanceList>(); 
     141        toBeAppliedOn.push(inputList); 
     142         
     143        do { 
     144            result = rule.apply(toBeAppliedOn.peek()); 
     145             
     146            if (result != null) { 
     147                status = result.getRuleApplicationStatus(); 
     148                assertNotNull(status); 
     149            } 
     150            else { 
     151                status = RuleApplicationStatus.NOT_APPLIED; 
     152            } 
     153             
     154            assertTrue(status != RuleApplicationStatus.FEASIBLE); 
     155             
     156            if ((result != null) && (result.getNewlyCreatedTaskInstances() != null)) { 
     157                for (int i = result.getNewlyCreatedTaskInstances().size() - 1; i >= 0; i--) { 
     158                    toBeAppliedOn.push(result.getNewlyCreatedTaskInstances().get(i)); 
     159                } 
     160            } 
     161             
     162            if (status == RuleApplicationStatus.NOT_APPLIED) { 
     163                toBeAppliedOn.pop(); 
     164            } 
     165             
     166        } 
     167        while ((!toBeAppliedOn.isEmpty()) || (status == RuleApplicationStatus.FINISHED)); 
     168 
     169        ITaskInstanceList expectedList = decoder.decode(expectedOutputSpec); 
     170         
     171        new TaskTreeChecker().assertTaskInstanceListsEqual(expectedList, inputList); 
    81172    } 
    82173 
    … …  
    84175     * 
    85176     */ 
    86     protected ITaskTree getTaskTree() { 
    87         ISequence sequence = taskTreeNodeFactory.createNewSequence(); 
    88  
    89         for (IEventTask task : events) { 
    90             taskTreeBuilder.addChild(sequence, task); 
    91         } 
    92  
    93         TemporalRelationshipRuleManager ruleManager = new TemporalRelationshipRuleManager 
    94             (nodeEqualityRuleManager, taskTreeNodeFactory, taskTreeBuilder); 
    95  
    96         ruleManager.init(); 
    97         ruleManager.applyRules(sequence); 
    98  
    99         return taskTreeNodeFactory.createTaskTree(sequence); 
    100     } 
    101  
    102     /** 
    103      * 
    104      */ 
    105     protected ITaskTree getTaskTree(Class<? extends TemporalRelationshipRule> ruleClass, 
    106                                     NodeEquality                              nodeEquality) 
     177    protected void applySessionScopeRule(Class<? extends ISessionScopeRule> ruleClass, 
     178                                         String                             inputSpec, 
     179                                         String                             expectedOutputSpec) 
    107180    { 
    108         return getTaskTree(ruleClass, nodeEquality, false); 
    109     } 
    110      
    111     /** 
    112      * 
    113      */ 
    114     protected ITaskTree getTaskTree(Class<? extends TemporalRelationshipRule> ruleClass, 
    115                                     NodeEquality                              nodeEquality, 
    116                                     boolean                                   explicitSessionSeq) 
    117     { 
    118         ISequence sequence = taskTreeNodeFactory.createNewSequence(); 
    119  
    120         for (IEventTask task : events) { 
    121             taskTreeBuilder.addChild(sequence, task); 
    122         } 
    123  
    124         if (explicitSessionSeq) { 
    125             ISequence root = taskTreeNodeFactory.createNewSequence(); 
    126             taskTreeBuilder.addChild(root, sequence); 
    127             sequence = root; 
    128         } 
    129          
    130         TemporalRelationshipRule rule = null; 
     181        ISessionScopeRule rule = null; 
    131182         
    132183        CONSTRUCTOR_ITERATION: 
    … …  
    135186             
    136187            for (Class<?> type : constructor.getParameterTypes()) { 
    137                 if (ITaskTreeNodeFactory.class.equals(type)) { 
    138                     parameters.add(taskTreeNodeFactory); 
    139                 } 
    140                 else if (ITaskTreeBuilder.class.equals(type)) { 
    141                     parameters.add(taskTreeBuilder); 
    142                 } 
    143                 else if (NodeEqualityRuleManager.class.equals(type)) { 
    144                     parameters.add(nodeEqualityRuleManager); 
    145                 } 
    146                 else if (NodeEquality.class.equals(type)) { 
    147                     if (nodeEquality != null) { 
    148                         parameters.add(nodeEquality); 
    149                     } 
    150                     else { 
    151                         parameters.add(NodeEquality.LEXICALLY_EQUAL); 
    152                     } 
     188                if (ITaskFactory.class.equals(type)) { 
     189                    parameters.add(taskFactory); 
     190                } 
     191                else if (ITaskBuilder.class.equals(type)) { 
     192                    parameters.add(taskBuilder); 
     193                } 
     194                else if (TaskEqualityRuleManager.class.equals(type)) { 
     195                    parameters.add(taskEqualityRuleManager); 
     196                } 
     197                else if (TaskEquality.class.equals(type)) { 
     198                    parameters.add(TaskEquality.LEXICALLY_EQUAL); 
    153199                } 
    154200                else { 
    … …  
    158204             
    159205            try { 
    160                 rule = (TemporalRelationshipRule) constructor.newInstance(parameters.toArray()); 
     206                rule = (ISessionScopeRule) constructor.newInstance(parameters.toArray()); 
    161207            } 
    162208            catch (IllegalArgumentException e) { 
    … …  
    182228        } 
    183229         
    184         RuleApplicationResult result; 
    185         RuleApplicationStatus status; 
    186          
    187         Stack<ITaskTreeNode> toBeAppliedOn = new Stack<ITaskTreeNode>(); 
    188         toBeAppliedOn.push(sequence); 
    189          
    190         do { 
    191             result = rule.apply(toBeAppliedOn.peek(), true); 
    192              
    193             if (result != null) { 
    194                 status = result.getRuleApplicationStatus(); 
    195                 assertNotNull(status); 
    196             } 
    197             else { 
    198                 status = RuleApplicationStatus.NOT_APPLIED; 
    199             } 
    200              
    201             assertTrue(status != RuleApplicationStatus.FEASIBLE); 
    202              
    203             if ((result != null) && (result.getNewlyCreatedParentNodes() != null)) { 
    204                 for (int i = result.getNewlyCreatedParentNodes().size() - 1; i >= 0; i--) { 
    205                     toBeAppliedOn.push(result.getNewlyCreatedParentNodes().get(i)); 
    206                 } 
    207             } 
    208              
    209             if (status == RuleApplicationStatus.NOT_APPLIED) { 
    210                 toBeAppliedOn.pop(); 
    211             } 
    212              
    213         } 
    214         while ((!toBeAppliedOn.isEmpty()) || (status == RuleApplicationStatus.FINISHED)); 
    215  
    216         return taskTreeNodeFactory.createTaskTree(sequence); 
     230        ITaskInstanceList inputList = decoder.decode(inputSpec); 
     231         
     232        assertTrue(inputList instanceof IUserSession); 
     233         
     234        List<IUserSession> sessionList = new LinkedList<IUserSession>(); 
     235        sessionList.add((IUserSession) inputList); 
     236         
     237        System.out.println("Input:"); 
     238        encoder.encode(inputList, System.out); 
     239         
     240        RuleApplicationResult result = rule.apply(sessionList); 
     241         
     242        assertNotNull(result); 
     243        assertNotNull(result.getRuleApplicationStatus()); 
     244        assertTrue(result.getRuleApplicationStatus() != RuleApplicationStatus.FEASIBLE); 
     245             
     246        ITaskInstanceList expectedList = decoder.decode(expectedOutputSpec); 
     247         
     248        System.out.println("\nExpected Result:"); 
     249        encoder.encode(expectedList, System.out); 
     250        System.out.println("\nResult:"); 
     251        encoder.encode(inputList, System.out); 
     252 
     253        new TaskTreeChecker().assertTaskInstanceListsEqual(expectedList, inputList); 
     254        new TaskTreeValidator().validate(inputList); 
    217255    } 
    218256 

  • trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRuleTest.java

    r1132 r1146  
    1717import org.junit.Test; 
    1818 
    19 import de.ugoe.cs.autoquest.eventcore.IEventTarget; 
    20 import de.ugoe.cs.autoquest.eventcore.gui.IInteraction; 
    21 import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker; 
    22 import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality; 
    23 import de.ugoe.cs.autoquest.test.DummyGUIElement; 
    24 import de.ugoe.cs.autoquest.test.DummyInteraction; 
    25  
    2619/** 
    2720 * TODO comment 
    … …  
    3629     */ 
    3730    @Test 
    38     public void testTaskDetection() throws Exception { 
    39         IEventTarget element1 = new DummyGUIElement("elem1"); 
    40          
    41         IInteraction action1 = new DummyInteraction("action1", 1); 
    42         IInteraction action2 = new DummyInteraction("action2", 1); 
    43         IInteraction action3 = new DummyInteraction("action3", 1); 
    44         IInteraction action4 = new DummyInteraction("action4", 1); 
    45          
    46         simulateEvent(new DummyInteraction("noise0", 1), element1); 
    47         simulateEvent(action1, element1); 
    48         simulateEvent(action2, element1); 
    49         simulateEvent(action3, element1); 
    50         simulateEvent(action4, element1); 
    51         simulateEvent(new DummyInteraction("noise1", 1), element1); 
    52         simulateEvent(new DummyInteraction("noise2", 1), element1); 
    53         simulateEvent(action1, element1); 
    54         simulateEvent(action2, element1); 
    55         simulateEvent(action3, element1); 
    56         simulateEvent(action4, element1); 
    57         simulateEvent(new DummyInteraction("noise3", 1), element1); 
    58         simulateEvent(new DummyInteraction("noise4", 1), element1); 
    59         simulateEvent(new DummyInteraction("noise5", 1), element1); 
    60         simulateEvent(new DummyInteraction("noise6", 1), element1); 
    61         simulateEvent(action1, element1); 
    62         simulateEvent(action2, element1); 
    63         simulateEvent(action3, element1); 
    64         simulateEvent(action4, element1); 
    65         simulateEvent(new DummyInteraction("noise7", 1), element1); 
    66         simulateEvent(new DummyInteraction("noise8", 1), element1); 
    67          
    68         new TaskTreeChecker().assertTaskTree 
    69             ("Sequence root {" + 
    70              "  Sequence session1 {" + 
    71              "    Event noise0 {}" + 
    72              "    Sequence sequence2 {" + 
    73              "      Event action1 {}" + 
    74              "      Event action2 {}" + 
    75              "      Event action3 {}" + 
    76              "      Event action4 {}" + 
    77              "    }" + 
    78              "    Event noise1 {}" + 
    79              "    Event noise2 {}" + 
    80              "    Sequence sequence2 {" + 
    81              "      Event action1 {}" + 
    82              "      Event action2 {}" + 
    83              "      Event action3 {}" + 
    84              "      Event action4 {}" + 
    85              "    }" + 
    86              "    Event noise3 {}" + 
    87              "    Event noise4 {}" + 
    88              "    Event noise5 {}" + 
    89              "    Event noise6 {}" + 
    90              "    Sequence sequence2 {" + 
    91              "      Event action1 {}" + 
    92              "      Event action2 {}" + 
    93              "      Event action3 {}" + 
    94              "      Event action4 {}" + 
    95              "    }" + 
    96              "    Event noise7 {}" + 
    97              "    Event noise8 {}" + 
    98              "  }" + 
    99              "}", getTaskTree(SequenceForTaskDetectionRule.class, NodeEquality.LEXICALLY_EQUAL, true)); 
     31    public void test_TaskDetection_01() throws Exception { 
     32        String input = 
     33            "UserSession {" + 
     34            "  Event noise0 {}" + 
     35            "  Event action1 {}" + 
     36            "  Event action2 {}" + 
     37            "  Event action3 {}" + 
     38            "  Event action4 {}" + 
     39            "  Event noise1 {}" + 
     40            "  Event noise2 {}" + 
     41            "  Event action1 {}" + 
     42            "  Event action2 {}" + 
     43            "  Event action3 {}" + 
     44            "  Event action4 {}" + 
     45            "  Event noise3 {}" + 
     46            "  Event noise4 {}" + 
     47            "  Event noise5 {}" + 
     48            "  Event noise6 {}" + 
     49            "  Event action1 {}" + 
     50            "  Event action2 {}" + 
     51            "  Event action3 {}" + 
     52            "  Event action4 {}" + 
     53            "  Event action1 {}" + 
     54            "  Event action2 {}" + 
     55            "  Event action3 {}" + 
     56            "  Event action4 {}" + 
     57            "  Event noise7 {}" + 
     58            "}"; 
    10059 
     60        String output = 
     61            "UserSession {" + 
     62            "  Event noise0 {}" + 
     63            "  Iteration iteration1 {" + 
     64            "    Sequence sequence1 {" + 
     65            "      Event action1 {}" + 
     66            "      Event action2 {}" + 
     67            "      Event action3 {}" + 
     68            "      Event action4 {}" + 
     69            "    }" + 
     70            "  }" + 
     71            "  Event noise1 {}" + 
     72            "  Event noise2 {}" + 
     73            "  Iteration iteration1 {" + 
     74            "    Sequence sequence1 {" + 
     75            "      Event action1 {}" + 
     76            "      Event action2 {}" + 
     77            "      Event action3 {}" + 
     78            "      Event action4 {}" + 
     79            "    }" + 
     80            "  }" + 
     81            "  Event noise3 {}" + 
     82            "  Event noise4 {}" + 
     83            "  Event noise5 {}" + 
     84            "  Event noise6 {}" + 
     85            "  Iteration iteration1 {" + 
     86            "    Sequence sequence1 {" + 
     87            "      Event action1 {}" + 
     88            "      Event action2 {}" + 
     89            "      Event action3 {}" + 
     90            "      Event action4 {}" + 
     91            "    }" + 
     92            "    Sequence sequence1 {" + 
     93            "      Event action1 {}" + 
     94            "      Event action2 {}" + 
     95            "      Event action3 {}" + 
     96            "      Event action4 {}" + 
     97            "    }" + 
     98            "  }" + 
     99            "  Event noise7 {}" + 
     100            "}"; 
     101 
     102        applySessionScopeRule(SequenceForTaskDetectionRule.class, input, output); 
     103    } 
     104 
     105    /** 
     106     * 
     107     */ 
     108    @Test 
     109    public void test_TaskDetection_02() throws Exception { 
     110        String input = 
     111            "UserSession {" + 
     112            "  Event noise0 {}" + 
     113            "  Event action1 {}" + 
     114            "  Event action2 {}" + 
     115            "  Event noise1 {}" + 
     116            "  Event noise2 {}" + 
     117            "  Event action3 {}" + 
     118            "  Event action1 {}" + 
     119            "  Event action2 {}" + 
     120            "  Event action4 {}" + 
     121            "  Event noise3 {}" + 
     122            "  Event noise4 {}" + 
     123            "  Event noise5 {}" + 
     124            "  Event noise6 {}" + 
     125            "  Event action1 {}" + 
     126            "  Event action2 {}" + 
     127            "  Event action3 {}" + 
     128            "  Event action4 {}" + 
     129            "  Event action1 {}" + 
     130            "  Event action2 {}" + 
     131            "  Event action3 {}" + 
     132            "  Event action4 {}" + 
     133            "  Event noise7 {}" + 
     134            "}"; 
     135 
     136        String output = 
     137            "UserSession {" + 
     138            "  Event noise0 {}" + 
     139            "  Sequence sequence1 {" + 
     140            "    Event action1 {}" + 
     141            "    Event action2 {}" + 
     142            "  }" + 
     143            "  Event noise1 {}" + 
     144            "  Event noise2 {}" + 
     145            "  Event action3 {}" + 
     146            "  Sequence sequence1 {" + 
     147            "    Event action1 {}" + 
     148            "    Event action2 {}" + 
     149            "  }" + 
     150            "  Event action4 {}" + 
     151            "  Event noise3 {}" + 
     152            "  Event noise4 {}" + 
     153            "  Event noise5 {}" + 
     154            "  Event noise6 {}" + 
     155            "  Iteration iteration1 {" + 
     156            "    Sequence sequence3 {" + 
     157            "      Sequence sequence1 {" + 
     158            "        Event action1 {}" + 
     159            "        Event action2 {}" + 
     160            "      }" + 
     161            "      Event action3 {}" + 
     162            "      Event action4 {}" + 
     163            "    }" + 
     164            "    Sequence sequence3 {" + 
     165            "      Sequence sequence1 {" + 
     166            "        Event action1 {}" + 
     167            "        Event action2 {}" + 
     168            "      }" + 
     169            "      Event action3 {}" + 
     170            "      Event action4 {}" + 
     171            "    }" + 
     172            "  }" + 
     173            "  Event noise7 {}" + 
     174            "}"; 
     175 
     176        applySessionScopeRule(SequenceForTaskDetectionRule.class, input, output); 
    101177    } 
    102178 
Note: See TracChangeset for help on using the changeset viewer.