Changeset 557 for trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation
- Timestamp:
- 08/17/12 08:33:29 (12 years ago)
- Location:
- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation
- Files:
-
- 5 edited
- 1 moved
Legend:
- Unmodified
- Added
- Removed
-
trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java
r452 r557 1 //-------------------------------------------------------------------------------------------------2 1 // Module : $RCSfile: AbstractTemporalRelationshipTC.java,v $ 3 2 // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 28.04.2012 $ … … 5 4 // Creation : 2012 by patrick 6 5 // Copyright : Patrick Harms, 2012 7 //------------------------------------------------------------------------------------------------- 6 8 7 package de.ugoe.cs.quest.tasktrees.temporalrelation; 9 8 … … 14 13 import org.junit.Before; 15 14 16 import de.ugoe.cs.quest.eventcore. guimodel.GUIElement;17 import de.ugoe.cs.quest.eventcore. userinteraction.Interaction;15 import de.ugoe.cs.quest.eventcore.IEventTarget; 16 import de.ugoe.cs.quest.eventcore.IEventType; 18 17 import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; 19 18 import de.ugoe.cs.quest.tasktrees.testutils.SimpleLogFormatter; 20 19 import de.ugoe.cs.quest.tasktrees.testutils.Utilities; 21 import de.ugoe.cs.quest.tasktrees.treeifc.I nteractionTask;22 import de.ugoe.cs.quest.tasktrees.treeifc. Sequence;23 import de.ugoe.cs.quest.tasktrees.treeifc. TaskTree;24 import de.ugoe.cs.quest.tasktrees.treeifc. TaskTreeBuilder;25 import de.ugoe.cs.quest.tasktrees.treeifc. TaskTreeNodeFactory;26 import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilder Impl;27 import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory Impl;20 import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; 21 import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; 22 import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; 23 import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; 24 import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; 25 import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilder; 26 import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; 28 27 29 //-------------------------------------------------------------------------------------------------30 28 /** 31 29 * TODO comment … … 34 32 * @author 2012, last modified by $Author: patrick$ 35 33 */ 36 //------------------------------------------------------------------------------------------------- 37 public class AbstractTemporalRelationshipTC 38 { 34 public class AbstractTemporalRelationshipTC { 39 35 40 /** */ 41 private List<InteractionTask> mInteractions; 42 43 /** */ 44 private TaskTreeBuilder mTaskTreeBuilder = new TaskTreeBuilderImpl(); 36 /** */ 37 private List<IEventTask> events; 45 38 46 /** */ 47 private TaskTreeNodeFactory mTaskTreeNodeFactory = new TaskTreeNodeFactoryImpl(); 48 49 /** */ 50 private NodeEqualityRuleManager mNodeEqualityRuleManager = 51 Utilities.getNodeEqualityRuleManagerForTests(); 39 /** */ 40 private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder(); 52 41 53 //----------------------------------------------------------------------------------------------- 54 /** 42 /** */ 43 private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory(); 44 45 /** */ 46 private NodeEqualityRuleManager nodeEqualityRuleManager = 47 Utilities.getNodeEqualityRuleManagerForTests(); 48 49 /** 55 50 * 56 51 */ 57 //----------------------------------------------------------------------------------------------- 58 @Before 59 public void setUp() 60 { 61 Logger.getLogger("").getHandlers()[0].setFormatter(new SimpleLogFormatter()); 62 mInteractions = new ArrayList<InteractionTask>(); 63 } 52 @Before 53 public void setUp() { 54 Logger.getLogger("").getHandlers()[0].setFormatter(new SimpleLogFormatter()); 55 events = new ArrayList<IEventTask>(); 56 } 64 57 65 //----------------------------------------------------------------------------------------------- 66 /** 67 * @param interactionsDoNotOverwriteElement 68 */ 69 //----------------------------------------------------------------------------------------------- 70 protected void simulateInteraction(GUIElement GUIElement, Interaction interaction) 71 { 72 mInteractions.add 73 (mTaskTreeNodeFactory.createNewInteractionTask(GUIElement, interaction)); 74 } 58 /** 59 * 60 */ 61 protected void simulateEvent(IEventType eventType, IEventTarget eventTarget) { 62 events.add(taskTreeNodeFactory.createNewEventTask(eventType, eventTarget)); 63 } 75 64 76 //----------------------------------------------------------------------------------------------- 77 /** 78 * @param interactionsDoNotOverwriteElement 79 * @return 80 */ 81 //----------------------------------------------------------------------------------------------- 82 protected TaskTree getTaskTree() 83 { 84 Sequence sequence = mTaskTreeNodeFactory.createNewSequence(); 85 86 for (InteractionTask task : mInteractions) 87 { 88 mTaskTreeBuilder.addChild(sequence, task); 65 /** 66 * 67 * @return 68 */ 69 protected ITaskTree getTaskTree() { 70 ISequence sequence = taskTreeNodeFactory.createNewSequence(); 71 72 for (IEventTask task : events) { 73 taskTreeBuilder.addChild(sequence, task); 74 } 75 76 TemporalRelationshipRuleManager ruleManager = 77 new TemporalRelationshipRuleManager(nodeEqualityRuleManager); 78 79 ruleManager.init(); 80 ruleManager.applyRules(sequence, taskTreeBuilder, taskTreeNodeFactory, true); 81 82 return taskTreeNodeFactory.createTaskTree(sequence); 89 83 } 90 91 TemporalRelationshipRuleManager ruleManager =92 new TemporalRelationshipRuleManager(mNodeEqualityRuleManager);93 94 ruleManager.init();95 ruleManager.applyRules(sequence, mTaskTreeBuilder, mTaskTreeNodeFactory, true);96 97 return mTaskTreeNodeFactory.createTaskTree(sequence);98 }99 84 100 85 } -
trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRuleTest.java
r468 r557 1 //-------------------------------------------------------------------------------------------------2 1 // Module : $RCSfile: TaskTreeManagerTest.java,v $ 3 2 // Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 08.11.2011 21:32:36 $ … … 5 4 // Creation : 2011 by Patrick 6 5 // Copyright : Patrick Harms, 2011 7 //-------------------------------------------------------------------------------------------------8 6 9 7 package de.ugoe.cs.quest.tasktrees.temporalrelation; … … 11 9 import org.junit.Test; 12 10 13 import de.ugoe.cs.quest.eventcore.guimodel.GUIElement; 14 import de.ugoe.cs.quest.eventcore.userinteraction.Interaction; 11 import de.ugoe.cs.quest.eventcore.IEventTarget; 15 12 import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; 16 13 import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; 17 14 import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; 18 15 19 //-------------------------------------------------------------------------------------------------20 16 /** 21 17 * TODO comment 22 * 18 * 23 19 * @version $Revision: $ $Date: $ 24 * @author 20 * @author 2011, last modified by $Author: $ 25 21 */ 26 //------------------------------------------------------------------------------------------------- 27 public class DefaultGUIElementSequenceDetectionRuleTest extends AbstractTemporalRelationshipTC 28 { 29 //----------------------------------------------------------------------------------------------- 30 /** 31 * 32 */ 33 //----------------------------------------------------------------------------------------------- 34 @Test 35 public void testOneInteractionOnOneElement() 36 { 37 simulateInteraction(new DummyGUIElement("elem1"), new DummyInteraction("bla", 1)); 22 public class DefaultGuiEventSequenceDetectionRuleTest extends AbstractTemporalRelationshipTC { 38 23 39 new TaskTreeChecker().assertTaskTree 40 ("Sequence sequence {" + 41 " Interaction bla {}" + 42 "}", getTaskTree()); 43 } 44 45 //----------------------------------------------------------------------------------------------- 46 /** 47 * 48 */ 49 //----------------------------------------------------------------------------------------------- 50 @Test 51 public void testManyInteractionsOnOneElement() 52 { 53 GUIElement element = new DummyGUIElement("elem1"); 54 simulateInteraction(element, new DummyInteraction("bla", 1)); 55 simulateInteraction(element, new DummyInteraction("bli", 1)); 56 simulateInteraction(element, new DummyInteraction("blo", 1)); 57 simulateInteraction(element, new DummyInteraction("blu", 1)); 58 simulateInteraction(element, new DummyInteraction("bla", 1)); 59 60 new TaskTreeChecker().assertTaskTree 61 ("Sequence sequence {" + 62 " Interaction bla {}" + 63 " Interaction bli {}" + 64 " Interaction blo {}" + 65 " Interaction blu {}" + 66 " Interaction bla {}" + 67 "}", getTaskTree()); 68 } 69 70 //----------------------------------------------------------------------------------------------- 71 /** 72 * 73 */ 74 //----------------------------------------------------------------------------------------------- 75 @Test 76 public void testOneInteractionOnManyElements() 77 { 78 GUIElement element1 = new DummyGUIElement("elem1"); 79 GUIElement element2 = new DummyGUIElement("elem2"); 80 GUIElement element3 = new DummyGUIElement("elem3"); 81 GUIElement element4 = new DummyGUIElement("elem4"); 82 GUIElement element5 = new DummyGUIElement("elem5"); 83 GUIElement element6 = new DummyGUIElement("elem6"); 84 simulateInteraction(element1, new DummyInteraction("bla", 1)); 85 simulateInteraction(element2, new DummyInteraction("bli", 1)); 86 simulateInteraction(element3, new DummyInteraction("bla", 1)); 87 simulateInteraction(element4, new DummyInteraction("bli", 1)); 88 simulateInteraction(element5, new DummyInteraction("blo", 1)); 89 simulateInteraction(element6, new DummyInteraction("bla", 1)); 24 /** 25 * 26 */ 27 @Test 28 public void testOneInteractionOnOneElement() { 29 simulateEvent(new DummyInteraction("bla", 1), new DummyGUIElement("elem1")); 90 30 91 new TaskTreeChecker().assertTaskTree 92 ("Sequence sequence0 {" + 93 " Sequence sequence1 {" + 94 " Interaction bla {}" + 95 " }" + 96 " Sequence sequence2 {" + 97 " Interaction bli {}" + 98 " }" + 99 " Sequence sequence3 {" + 100 " Interaction bla {}" + 101 " }" + 102 " Sequence sequence4 {" + 103 " Interaction bli {}" + 104 " }" + 105 " Sequence sequence5 {" + 106 " Interaction blo {}" + 107 " }" + 108 " Sequence sequence6 {" + 109 " Interaction bla {}" + 110 " }" + 111 "}", getTaskTree()); 112 } 31 new TaskTreeChecker().assertTaskTree 32 ("Sequence sequence {" + 33 " Event bla {}" + 34 "}", getTaskTree()); 35 } 113 36 114 //----------------------------------------------------------------------------------------------- 115 /** 116 * 117 */ 118 //----------------------------------------------------------------------------------------------- 119 @Test 120 public void testManyInteractionsOnManyElements() 121 { 122 GUIElement element1 = new DummyGUIElement("elem1"); 123 GUIElement element2 = new DummyGUIElement("elem2"); 124 GUIElement element3 = new DummyGUIElement("elem3"); 125 GUIElement element4 = new DummyGUIElement("elem4"); 126 GUIElement element5 = new DummyGUIElement("elem5"); 127 GUIElement element6 = new DummyGUIElement("elem6"); 128 simulateInteraction(element1, new DummyInteraction("bla", 1)); 129 simulateInteraction(element1, new DummyInteraction("bli", 1)); 130 simulateInteraction(element1, new DummyInteraction("bla", 1)); 131 simulateInteraction(element2, new DummyInteraction("bli", 1)); 132 simulateInteraction(element2, new DummyInteraction("blo", 1)); 133 simulateInteraction(element3, new DummyInteraction("bla", 1)); 134 simulateInteraction(element4, new DummyInteraction("bli", 1)); 135 simulateInteraction(element4, new DummyInteraction("bla", 1)); 136 simulateInteraction(element4, new DummyInteraction("bli", 1)); 137 simulateInteraction(element4, new DummyInteraction("blo", 1)); 138 simulateInteraction(element5, new DummyInteraction("bla", 1)); 139 simulateInteraction(element6, new DummyInteraction("bli", 1)); 140 simulateInteraction(element6, new DummyInteraction("bla", 1)); 141 simulateInteraction(element6, new DummyInteraction("bli", 1)); 142 simulateInteraction(element6, new DummyInteraction("blo", 1)); 143 144 new TaskTreeChecker().assertTaskTree 145 ("Sequence sequence0 {" + 146 " Sequence sequence1 {" + 147 " Interaction bla {}" + 148 " Interaction bli {}" + 149 " Interaction bla {}" + 150 " }" + 151 " Sequence sequence2 {" + 152 " Interaction bli {}" + 153 " Interaction blo {}" + 154 " }" + 155 " Sequence sequence3 {" + 156 " Interaction bla {}" + 157 " }" + 158 " Sequence sequence4 {" + 159 " Interaction bli {}" + 160 " Interaction bla {}" + 161 " Interaction bli {}" + 162 " Interaction blo {}" + 163 " }" + 164 " Sequence sequence5 {" + 165 " Interaction bla {}" + 166 " }" + 167 " Sequence sequence6 {" + 168 " Interaction bli {}" + 169 " Interaction bla {}" + 170 " Interaction bli {}" + 171 " Interaction blo {}" + 172 " }" + 173 "}", getTaskTree()); 174 } 37 /** 38 * 39 */ 40 @Test 41 public void testManyInteractionsOnOneElement() { 42 IEventTarget eventTarget = new DummyGUIElement("elem1"); 43 simulateEvent(new DummyInteraction("bla", 1), eventTarget); 44 simulateEvent(new DummyInteraction("bli", 1), eventTarget); 45 simulateEvent(new DummyInteraction("blo", 1), eventTarget); 46 simulateEvent(new DummyInteraction("blu", 1), eventTarget); 47 simulateEvent(new DummyInteraction("bla", 1), eventTarget); 175 48 176 //----------------------------------------------------------------------------------------------- 177 /** 178 * 179 */ 180 //----------------------------------------------------------------------------------------------- 181 @Test 182 public void testGUIElementHierarchyChanges() throws Exception 183 { 184 GUIElement element1 = new DummyGUIElement("elem1"); 185 GUIElement element2 = new DummyGUIElement("elem2"); 186 GUIElement element3 = new DummyGUIElement("elem3"); 187 GUIElement parent1 = new DummyGUIElement("parent1"); 188 GUIElement parent2 = new DummyGUIElement("parent2"); 189 GUIElement parent3 = new DummyGUIElement("parent3"); 190 191 element1.setParent(parent1); 192 element2.setParent(parent2); 193 element3.setParent(parent3); 194 195 parent1.setParent(parent2); 196 parent2.setParent(parent3); 197 198 Interaction interaction1 = new DummyInteraction("bla", 1); 199 simulateInteraction(element1, interaction1); 200 simulateInteraction(element2, interaction1); 201 simulateInteraction(element3, interaction1); 202 simulateInteraction(element2, interaction1); 203 simulateInteraction(element3, interaction1); 204 simulateInteraction(element2, interaction1); 205 simulateInteraction(element1, interaction1); 206 207 new TaskTreeChecker().assertTaskTree 208 ("Sequence sequence0 {" + 209 " Sequence sequence1 {" + 210 " Interaction bla {}" + 211 " }" + 212 " Sequence sequence2 {" + 213 " Interaction bla {}" + 214 " }" + 215 " Iteration iteration0 {" + 216 " Sequence sequence3 {" + 217 " Sequence sequence4 {" + 218 " Interaction bla {}" + 219 " }" + 220 " Sequence sequence5 {" + 221 " Interaction bla {}" + 222 " }" + 223 " }" + 224 " }" + 225 " Sequence sequence6 {" + 226 " Interaction bla {}" + 227 " }" + 228 "}", getTaskTree()); 49 new TaskTreeChecker().assertTaskTree 50 ("Sequence sequence {" + 51 " Event bla {}" + 52 " Event bli {}" + 53 " Event blo {}" + 54 " Event blu {}" + 55 " Event bla {}" + 56 "}", getTaskTree()); 57 } 229 58 230 } 231 59 /** 60 * 61 */ 62 @Test 63 public void testOneInteractionOnManyElements() { 64 IEventTarget eventTarget1 = new DummyGUIElement("elem1"); 65 IEventTarget eventTarget2 = new DummyGUIElement("elem2"); 66 IEventTarget eventTarget3 = new DummyGUIElement("elem3"); 67 IEventTarget eventTarget4 = new DummyGUIElement("elem4"); 68 IEventTarget eventTarget5 = new DummyGUIElement("elem5"); 69 IEventTarget eventTarget6 = new DummyGUIElement("elem6"); 70 simulateEvent(new DummyInteraction("bla", 1), eventTarget1); 71 simulateEvent(new DummyInteraction("bli", 1), eventTarget2); 72 simulateEvent(new DummyInteraction("bla", 1), eventTarget3); 73 simulateEvent(new DummyInteraction("bli", 1), eventTarget4); 74 simulateEvent(new DummyInteraction("blo", 1), eventTarget5); 75 simulateEvent(new DummyInteraction("bla", 1), eventTarget6); 76 77 new TaskTreeChecker().assertTaskTree 78 ("Sequence sequence0 {" + 79 " Sequence sequence1 {" + 80 " Event bla {}" + 81 " }" + 82 " Sequence sequence2 {" + 83 " Event bli {}" + 84 " }" + 85 " Sequence sequence3 {" + 86 " Event bla {}" + 87 " }" + 88 " Sequence sequence4 {" + 89 " Event bli {}" + 90 " }" + 91 " Sequence sequence5 {" + 92 " Event blo {}" + 93 " }" + 94 " Sequence sequence6 {" + 95 " Event bla {}" + 96 " }" + 97 "}", getTaskTree()); 98 } 99 100 /** 101 * 102 */ 103 @Test 104 public void testManyInteractionsOnManyElements() { 105 IEventTarget eventTarget1 = new DummyGUIElement("elem1"); 106 IEventTarget eventTarget2 = new DummyGUIElement("elem2"); 107 IEventTarget eventTarget3 = new DummyGUIElement("elem3"); 108 IEventTarget eventTarget4 = new DummyGUIElement("elem4"); 109 IEventTarget eventTarget5 = new DummyGUIElement("elem5"); 110 IEventTarget eventTarget6 = new DummyGUIElement("elem6"); 111 simulateEvent(new DummyInteraction("bla", 1), eventTarget1); 112 simulateEvent(new DummyInteraction("bli", 1), eventTarget1); 113 simulateEvent(new DummyInteraction("bla", 1), eventTarget1); 114 simulateEvent(new DummyInteraction("bli", 1), eventTarget2); 115 simulateEvent(new DummyInteraction("blo", 1), eventTarget2); 116 simulateEvent(new DummyInteraction("bla", 1), eventTarget3); 117 simulateEvent(new DummyInteraction("bli", 1), eventTarget4); 118 simulateEvent(new DummyInteraction("bla", 1), eventTarget4); 119 simulateEvent(new DummyInteraction("bli", 1), eventTarget4); 120 simulateEvent(new DummyInteraction("blo", 1), eventTarget4); 121 simulateEvent(new DummyInteraction("bla", 1), eventTarget5); 122 simulateEvent(new DummyInteraction("bli", 1), eventTarget6); 123 simulateEvent(new DummyInteraction("bla", 1), eventTarget6); 124 simulateEvent(new DummyInteraction("bli", 1), eventTarget6); 125 simulateEvent(new DummyInteraction("blo", 1), eventTarget6); 126 127 new TaskTreeChecker().assertTaskTree 128 ("Sequence sequence0 {" + 129 " Sequence sequence1 {" + 130 " Event bla {}" + 131 " Event bli {}" + 132 " Event bla {}" + 133 " }" + 134 " Sequence sequence2 {" + 135 " Event bli {}" + 136 " Event blo {}" + 137 " }" + 138 " Sequence sequence3 {" + 139 " Event bla {}" + 140 " }" + 141 " Sequence sequence4 {" + 142 " Event bli {}" + 143 " Event bla {}" + 144 " Event bli {}" + 145 " Event blo {}" + 146 " }" + 147 " Sequence sequence5 {" + 148 " Event bla {}" + 149 " }" + 150 " Sequence sequence6 {" + 151 " Event bli {}" + 152 " Event bla {}" + 153 " Event bli {}" + 154 " Event blo {}" + 155 " }" + 156 "}", getTaskTree()); 157 } 158 232 159 } -
trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java
r468 r557 1 //-------------------------------------------------------------------------------------------------2 1 // Module : $RCSfile: DefaultIterationDetectionRuleTest.java,v $ 3 2 // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 28.04.2012 $ … … 5 4 // Creation : 2012 by patrick 6 5 // Copyright : Patrick Harms, 2012 7 //------------------------------------------------------------------------------------------------- 6 8 7 package de.ugoe.cs.quest.tasktrees.temporalrelation; 9 8 10 9 import org.junit.Test; 11 10 12 import de.ugoe.cs.quest.eventcore. guimodel.GUIElement;13 import de.ugoe.cs.quest.eventcore. userinteraction.Interaction;11 import de.ugoe.cs.quest.eventcore.IEventTarget; 12 import de.ugoe.cs.quest.eventcore.IEventType; 14 13 import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; 15 14 import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; 16 15 import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; 17 16 18 //-------------------------------------------------------------------------------------------------19 17 /** 20 18 * TODO comment … … 23 21 * @author 2012, last modified by $Author: patrick$ 24 22 */ 25 //------------------------------------------------------------------------------------------------- 26 public class DefaultIterationDetectionRuleTest extends AbstractTemporalRelationshipTC 27 { 28 29 //----------------------------------------------------------------------------------------------- 30 /** 31 * 32 */ 33 //----------------------------------------------------------------------------------------------- 34 @Test 35 public void testInteractionIterationDetection() throws Exception 36 { 37 GUIElement element1 = new DummyGUIElement("elem1"); 38 Interaction interaction1 = new DummyInteraction("bla", 1); 39 simulateInteraction(element1, interaction1); 40 new TaskTreeChecker().assertTaskTree 41 ("Sequence sequence1 {" + 42 " Interaction bla {}" + 43 "}", getTaskTree()); 44 45 simulateInteraction(element1, interaction1); 46 new TaskTreeChecker().assertTaskTree 47 ("Sequence sequence1 {" + 48 " Iteration iteration1 {" + 49 " Interaction bla {}" + 50 " }" + 51 "}", getTaskTree()); 52 53 simulateInteraction(element1, interaction1); 54 new TaskTreeChecker().assertTaskTree 55 ("Sequence sequence1 {" + 56 " Iteration iteration1 {" + 57 " Interaction bla {}" + 58 " }" + 59 "}", getTaskTree()); 60 61 for (int i = 0; i < 10; i++) 62 { 63 simulateInteraction(element1, interaction1); 23 public class DefaultIterationDetectionRuleTest extends AbstractTemporalRelationshipTC { 24 25 /** 26 * 27 */ 28 @Test 29 public void testInteractionIterationDetection() throws Exception { 30 IEventTarget element1 = new DummyGUIElement("elem1"); 31 IEventType event1 = new DummyInteraction("bla", 1); 32 simulateEvent(event1, element1); 33 new TaskTreeChecker().assertTaskTree 34 ("Sequence sequence1 {" + 35 " Event bla {}" + 36 "}", getTaskTree()); 37 38 simulateEvent(event1, element1); 39 new TaskTreeChecker().assertTaskTree 40 ("Sequence sequence1 {" + 41 " Iteration iteration1 {" + 42 " Event bla {}" + 43 " }" + 44 "}", getTaskTree()); 45 46 simulateEvent(event1, element1); 47 new TaskTreeChecker().assertTaskTree 48 ("Sequence sequence1 {" + 49 " Iteration iteration1 {" + 50 " Event bla {}" + 51 " }" + 52 "}", getTaskTree()); 53 54 for (int i = 0; i < 10; i++) { 55 simulateEvent(event1, element1); 56 } 57 58 new TaskTreeChecker().assertTaskTree 59 ("Sequence sequence1 {" + 60 " Iteration iteration1 {" + 61 " Event bla {}" + 62 " }" + 63 "}", getTaskTree()); 64 65 // now test with preceding and trailing other events 66 IEventType event2 = new DummyInteraction("bli", 1); 67 IEventType event3 = new DummyInteraction("blup", 1); 68 69 simulateEvent(event2, element1); 70 simulateEvent(event3, element1); 71 for (int i = 0; i < 10; i++) { 72 simulateEvent(event1, element1); 73 } 74 simulateEvent(event3, element1); 75 simulateEvent(event2, element1); 76 77 new TaskTreeChecker().assertTaskTree 78 ("Sequence sequence1 {" + 79 " Iteration iteration1 {" + 80 " Event bla {}" + 81 " }" + 82 " Event bli {}" + 83 " Event blup {}" + 84 " Iteration iteration2 {" + 85 " Event bla {}" + 86 " }" + 87 " Event blup {}" + 88 " Event bli {}" + 89 "}", getTaskTree()); 90 91 // now test with iterations of iterations 92 93 for (int i = 0; i < 10; i++) { 94 for (int j = 0; j < 5; j++) { 95 simulateEvent(event1, element1); 96 } 97 for (int j = 0; j < 5; j++) { 98 simulateEvent(event2, element1); 99 } 100 for (int j = 0; j < 5; j++) { 101 simulateEvent(event3, element1); 102 } 103 } 104 105 new TaskTreeChecker().assertTaskTree 106 ("Sequence sequence1 {" + 107 " Iteration iteration1 {" + 108 " Event bla {}" + 109 " }" + 110 " Event bli {}" + 111 " Event blup {}" + 112 " Iteration iteration2 {" + 113 " Event bla {}" + 114 " }" + 115 " Event blup {}" + 116 " Event bli {}" + 117 " Iteration iteration3 {" + 118 " Sequence sequence2 {" + 119 " Iteration iteration4 {" + 120 " Event bla {}" + 121 " }" + 122 " Iteration iteration5 {" + 123 " Event bli {}" + 124 " }" + 125 " Iteration iteration6 {" + 126 " Event blup {}" + 127 " }" + 128 " }" + 129 " }" + 130 "}", getTaskTree()); 131 64 132 } 65 66 new TaskTreeChecker().assertTaskTree 67 ("Sequence sequence1 {" + 68 " Iteration iteration1 {" + 69 " Interaction bla {}" + 70 " }" + 71 "}", getTaskTree()); 72 73 // now test with preceding and trailing other interactions 74 Interaction interaction2 = new DummyInteraction("bli", 1); 75 Interaction interaction3 = new DummyInteraction("blup", 1); 76 77 simulateInteraction(element1, interaction2); 78 simulateInteraction(element1, interaction3); 79 for (int i = 0; i < 10; i++) 80 { 81 simulateInteraction(element1, interaction1); 133 134 /** 135 * 136 */ 137 @Test 138 public void testSequenceIterationDetection() throws Exception { 139 IEventTarget element1 = new DummyGUIElement("elem1"); 140 IEventType event1 = new DummyInteraction("bla", 1); 141 IEventType event2 = new DummyInteraction("bli", 1); 142 IEventType event3 = new DummyInteraction("blup", 1); 143 simulateEvent(event1, element1); 144 simulateEvent(event2, element1); 145 simulateEvent(event3, element1); 146 new TaskTreeChecker().assertTaskTree 147 ("Sequence sequence1 {" + 148 " Event bla {}" + 149 " Event bli {}" + 150 " Event blup {}" + 151 "}", getTaskTree()); 152 153 simulateEvent(event1, element1); 154 simulateEvent(event2, element1); 155 simulateEvent(event3, element1); 156 new TaskTreeChecker().assertTaskTree 157 ("Sequence sequence1 {" + 158 " Iteration iteration1 {" + 159 " Sequence sequence2 {" + 160 " Event bla {}" + 161 " Event bli {}" + 162 " Event blup {}" + 163 " }" + 164 " }" + 165 "}", getTaskTree()); 166 167 simulateEvent(event1, element1); 168 simulateEvent(event2, element1); 169 simulateEvent(event3, element1); 170 new TaskTreeChecker().assertTaskTree 171 ("Sequence sequence1 {" + 172 " Iteration iteration1 {" + 173 " Sequence sequence2 {" + 174 " Event bla {}" + 175 " Event bli {}" + 176 " Event blup {}" + 177 " }" + 178 " }" + 179 "}", getTaskTree()); 180 181 for (int i = 0; i < 10; i++) { 182 simulateEvent(event1, element1); 183 simulateEvent(event2, element1); 184 simulateEvent(event3, element1); 185 } 186 187 new TaskTreeChecker().assertTaskTree 188 ("Sequence sequence1 {" + 189 " Iteration iteration1 {" + 190 " Sequence sequence2 {" + 191 " Event bla {}" + 192 " Event bli {}" + 193 " Event blup {}" + 194 " }" + 195 " }" + 196 "}", getTaskTree()); 197 198 // now test with preceding and trailing other events 199 IEventType event4 = new DummyInteraction("ble", 1); 200 IEventType event5 = new DummyInteraction("blo", 1); 201 IEventType event6 = new DummyInteraction("blu", 1); 202 simulateEvent(event4, element1); 203 simulateEvent(event5, element1); 204 simulateEvent(event6, element1); 205 for (int i = 0; i < 10; i++) { 206 simulateEvent(event1, element1); 207 simulateEvent(event2, element1); 208 simulateEvent(event3, element1); 209 } 210 simulateEvent(event6, element1); 211 simulateEvent(event5, element1); 212 simulateEvent(event4, element1); 213 214 new TaskTreeChecker().assertTaskTree 215 ("Sequence sequence1 {" + 216 " Iteration iteration1 {" + 217 " Sequence sequence2 {" + 218 " Event bla {}" + 219 " Event bli {}" + 220 " Event blup {}" + 221 " }" + 222 " }" + 223 " Event ble {}" + 224 " Event blo {}" + 225 " Event blu {}" + 226 " Iteration iteration2 {" + 227 " Sequence sequence3 {" + 228 " Event bla {}" + 229 " Event bli {}" + 230 " Event blup {}" + 231 " }" + 232 " }" + 233 " Event blu {}" + 234 " Event blo {}" + 235 " Event ble {}" + 236 "}", getTaskTree()); 237 238 // now test with iterations of iterations 239 for (int i = 0; i < 10; i++) { 240 for (int j = 0; j < 5; j++) { 241 simulateEvent(event1, element1); 242 simulateEvent(event2, element1); 243 simulateEvent(event3, element1); 244 } 245 for (int j = 0; j < 5; j++) { 246 simulateEvent(event2, element1); 247 simulateEvent(event1, element1); 248 simulateEvent(event3, element1); 249 } 250 for (int j = 0; j < 5; j++) { 251 simulateEvent(event1, element1); 252 simulateEvent(event2, element1); 253 simulateEvent(event3, element1); 254 } 255 } 256 257 new TaskTreeChecker().assertTaskTree 258 ("Sequence sequence1 {" + 259 " Iteration iteration1 {" + 260 " Sequence sequence2 {" + 261 " Event bla {}" + 262 " Event bli {}" + 263 " Event blup {}" + 264 " }" + 265 " }" + 266 " Event ble {}" + 267 " Event blo {}" + 268 " Event blu {}" + 269 " Iteration iteration2 {" + 270 " Sequence sequence3 {" + 271 " Event bla {}" + 272 " Event bli {}" + 273 " Event blup {}" + 274 " }" + 275 " }" + 276 " Event blu {}" + 277 " Event blo {}" + 278 " Event ble {}" + 279 " Iteration iteration3 {" + 280 " Sequence sequence4 {" + 281 " Iteration iteration4 {" + 282 " Sequence sequence4 {" + 283 " Event bla {}" + 284 " Event bli {}" + 285 " Event blup {}" + 286 " }" + 287 " }" + 288 " Iteration iteration5 {" + 289 " Sequence sequence5 {" + 290 " Event bli {}" + 291 " Event bla {}" + 292 " Event blup {}" + 293 " }" + 294 " }" + 295 " Iteration iteration6 {" + 296 " Sequence sequence6 {" + 297 " Event bla {}" + 298 " Event bli {}" + 299 " Event blup {}" + 300 " }" + 301 " }" + 302 " }" + 303 " }" + 304 "}", getTaskTree()); 82 305 } 83 simulateInteraction(element1, interaction3); 84 simulateInteraction(element1, interaction2); 85 86 new TaskTreeChecker().assertTaskTree 87 ("Sequence sequence1 {" + 88 " Iteration iteration1 {" + 89 " Interaction bla {}" + 90 " }" + 91 " Interaction bli {}" + 92 " Interaction blup {}" + 93 " Iteration iteration2 {" + 94 " Interaction bla {}" + 95 " }" + 96 " Interaction blup {}" + 97 " Interaction bli {}" + 98 "}", getTaskTree()); 99 100 // now test with iterations of iterations 101 102 for (int i = 0; i < 10; i++) 103 { 104 for (int j = 0; j < 5; j++) 105 { 106 simulateInteraction(element1, interaction1); 107 } 108 for (int j = 0; j < 5; j++) 109 { 110 simulateInteraction(element1, interaction2); 111 } 112 for (int j = 0; j < 5; j++) 113 { 114 simulateInteraction(element1, interaction3); 115 } 116 } 117 118 new TaskTreeChecker().assertTaskTree 119 ("Sequence sequence1 {" + 120 " Iteration iteration1 {" + 121 " Interaction bla {}" + 122 " }" + 123 " Interaction bli {}" + 124 " Interaction blup {}" + 125 " Iteration iteration2 {" + 126 " Interaction bla {}" + 127 " }" + 128 " Interaction blup {}" + 129 " Interaction bli {}" + 130 " Iteration iteration3 {" + 131 " Sequence sequence2 {" + 132 " Iteration iteration4 {" + 133 " Interaction bla {}" + 134 " }" + 135 " Iteration iteration5 {" + 136 " Interaction bli {}" + 137 " }" + 138 " Iteration iteration6 {" + 139 " Interaction blup {}" + 140 " }" + 141 " }" + 142 " }" + 143 "}", getTaskTree()); 144 145 } 146 147 //----------------------------------------------------------------------------------------------- 148 /** 149 * 150 */ 151 //----------------------------------------------------------------------------------------------- 152 @Test 153 public void testSequenceIterationDetection() throws Exception 154 { 155 GUIElement element1 = new DummyGUIElement("elem1"); 156 Interaction interaction1 = new DummyInteraction("bla", 1); 157 Interaction interaction2 = new DummyInteraction("bli", 1); 158 Interaction interaction3 = new DummyInteraction("blup", 1); 159 simulateInteraction(element1, interaction1); 160 simulateInteraction(element1, interaction2); 161 simulateInteraction(element1, interaction3); 162 new TaskTreeChecker().assertTaskTree 163 ("Sequence sequence1 {" + 164 " Interaction bla {}" + 165 " Interaction bli {}" + 166 " Interaction blup {}" + 167 "}", getTaskTree()); 168 169 simulateInteraction(element1, interaction1); 170 simulateInteraction(element1, interaction2); 171 simulateInteraction(element1, interaction3); 172 new TaskTreeChecker().assertTaskTree 173 ("Sequence sequence1 {" + 174 " Iteration iteration1 {" + 175 " Sequence sequence2 {" + 176 " Interaction bla {}" + 177 " Interaction bli {}" + 178 " Interaction blup {}" + 179 " }" + 180 " }" + 181 "}", getTaskTree()); 182 183 simulateInteraction(element1, interaction1); 184 simulateInteraction(element1, interaction2); 185 simulateInteraction(element1, interaction3); 186 new TaskTreeChecker().assertTaskTree 187 ("Sequence sequence1 {" + 188 " Iteration iteration1 {" + 189 " Sequence sequence2 {" + 190 " Interaction bla {}" + 191 " Interaction bli {}" + 192 " Interaction blup {}" + 193 " }" + 194 " }" + 195 "}", getTaskTree()); 196 197 for (int i = 0; i < 10; i++) 198 { 199 simulateInteraction(element1, interaction1); 200 simulateInteraction(element1, interaction2); 201 simulateInteraction(element1, interaction3); 202 } 203 204 new TaskTreeChecker().assertTaskTree 205 ("Sequence sequence1 {" + 206 " Iteration iteration1 {" + 207 " Sequence sequence2 {" + 208 " Interaction bla {}" + 209 " Interaction bli {}" + 210 " Interaction blup {}" + 211 " }" + 212 " }" + 213 "}", getTaskTree()); 214 215 // now test with preceding and trailing other interactions 216 Interaction interaction4 = new DummyInteraction("ble", 1); 217 Interaction interaction5 = new DummyInteraction("blo", 1); 218 Interaction interaction6 = new DummyInteraction("blu", 1); 219 simulateInteraction(element1, interaction4); 220 simulateInteraction(element1, interaction5); 221 simulateInteraction(element1, interaction6); 222 for (int i = 0; i < 10; i++) 223 { 224 simulateInteraction(element1, interaction1); 225 simulateInteraction(element1, interaction2); 226 simulateInteraction(element1, interaction3); 227 } 228 simulateInteraction(element1, interaction6); 229 simulateInteraction(element1, interaction5); 230 simulateInteraction(element1, interaction4); 231 232 new TaskTreeChecker().assertTaskTree 233 ("Sequence sequence1 {" + 234 " Iteration iteration1 {" + 235 " Sequence sequence2 {" + 236 " Interaction bla {}" + 237 " Interaction bli {}" + 238 " Interaction blup {}" + 239 " }" + 240 " }" + 241 " Interaction ble {}" + 242 " Interaction blo {}" + 243 " Interaction blu {}" + 244 " Iteration iteration2 {" + 245 " Sequence sequence3 {" + 246 " Interaction bla {}" + 247 " Interaction bli {}" + 248 " Interaction blup {}" + 249 " }" + 250 " }" + 251 " Interaction blu {}" + 252 " Interaction blo {}" + 253 " Interaction ble {}" + 254 "}", getTaskTree()); 255 256 // now test with iterations of iterations 257 for (int i = 0; i < 10; i++) 258 { 259 for (int j = 0; j < 5; j++) 260 { 261 simulateInteraction(element1, interaction1); 262 simulateInteraction(element1, interaction2); 263 simulateInteraction(element1, interaction3); 264 } 265 for (int j = 0; j < 5; j++) 266 { 267 simulateInteraction(element1, interaction2); 268 simulateInteraction(element1, interaction1); 269 simulateInteraction(element1, interaction3); 270 } 271 for (int j = 0; j < 5; j++) 272 { 273 simulateInteraction(element1, interaction1); 274 simulateInteraction(element1, interaction2); 275 simulateInteraction(element1, interaction3); 276 } 277 } 278 279 new TaskTreeChecker().assertTaskTree 280 ("Sequence sequence1 {" + 281 " Iteration iteration1 {" + 282 " Sequence sequence2 {" + 283 " Interaction bla {}" + 284 " Interaction bli {}" + 285 " Interaction blup {}" + 286 " }" + 287 " }" + 288 " Interaction ble {}" + 289 " Interaction blo {}" + 290 " Interaction blu {}" + 291 " Iteration iteration2 {" + 292 " Sequence sequence3 {" + 293 " Interaction bla {}" + 294 " Interaction bli {}" + 295 " Interaction blup {}" + 296 " }" + 297 " }" + 298 " Interaction blu {}" + 299 " Interaction blo {}" + 300 " Interaction ble {}" + 301 " Iteration iteration3 {" + 302 " Sequence sequence4 {" + 303 " Iteration iteration4 {" + 304 " Sequence sequence4 {" + 305 " Interaction bla {}" + 306 " Interaction bli {}" + 307 " Interaction blup {}" + 308 " }" + 309 " }" + 310 " Iteration iteration5 {" + 311 " Sequence sequence5 {" + 312 " Interaction bli {}" + 313 " Interaction bla {}" + 314 " Interaction blup {}" + 315 " }" + 316 " }" + 317 " Iteration iteration6 {" + 318 " Sequence sequence6 {" + 319 " Interaction bla {}" + 320 " Interaction bli {}" + 321 " Interaction blup {}" + 322 " }" + 323 " }" + 324 " }" + 325 " }" + 326 "}", getTaskTree()); 327 } 328 306 329 307 } -
trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultMouseClickReductionRuleTest.java
r468 r557 1 //-------------------------------------------------------------------------------------------------2 1 // Module : $RCSfile: TaskTreeManagerTest.java,v $ 3 2 // Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 08.11.2011 21:32:36 $ … … 5 4 // Creation : 2011 by Patrick 6 5 // Copyright : Patrick Harms, 2011 7 //-------------------------------------------------------------------------------------------------8 6 9 7 package de.ugoe.cs.quest.tasktrees.temporalrelation; … … 11 9 import org.junit.Test; 12 10 13 import de.ugoe.cs.quest.eventcore.gui model.GUIElement;14 import de.ugoe.cs.quest.eventcore. userinteraction.MouseButtonDown;15 import de.ugoe.cs.quest.eventcore. userinteraction.MouseButtonInteraction;16 import de.ugoe.cs.quest.eventcore. userinteraction.MouseButtonUp;17 import de.ugoe.cs.quest.eventcore. userinteraction.MouseClick;11 import de.ugoe.cs.quest.eventcore.gui.MouseButtonDown; 12 import de.ugoe.cs.quest.eventcore.gui.MouseButtonInteraction; 13 import de.ugoe.cs.quest.eventcore.gui.MouseButtonUp; 14 import de.ugoe.cs.quest.eventcore.gui.MouseClick; 15 import de.ugoe.cs.quest.eventcore.guimodel.IGUIElement; 18 16 import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; 19 17 import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; 20 18 import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; 21 19 22 //-------------------------------------------------------------------------------------------------23 20 /** 24 21 * TODO comment 25 * 22 * 26 23 * @version $Revision: $ $Date: $ 27 * @author 24 * @author 2011, last modified by $Author: $ 28 25 */ 29 //------------------------------------------------------------------------------------------------- 30 public class DefaultMouseClickReductionRuleTest extends AbstractTemporalRelationshipTC 31 { 32 //----------------------------------------------------------------------------------------------- 33 /** 34 * 35 */ 36 //----------------------------------------------------------------------------------------------- 37 @Test 38 public void testMouseClickInOneSequenceElement() 39 { 40 MouseButtonInteraction.Button leftBtn = MouseButtonInteraction.Button.LEFT; 41 MouseButtonInteraction.Button middleBtn = MouseButtonInteraction.Button.MIDDLE; 42 MouseButtonInteraction.Button rightBtn = MouseButtonInteraction.Button.RIGHT; 43 44 GUIElement element1 = new DummyGUIElement("elem1"); 45 GUIElement element2 = new DummyGUIElement("elem1"); 46 47 simulateInteraction(element1, new MouseButtonDown(leftBtn)); 48 simulateInteraction(element1, new MouseButtonUp(leftBtn)); 49 simulateInteraction(element1, new MouseClick(leftBtn)); 26 public class DefaultMouseClickReductionRuleTest extends AbstractTemporalRelationshipTC { 50 27 51 new TaskTreeChecker().assertTaskTree 52 ("Sequence sequence {" + 53 " Interaction LeftMouseClick {}" + 54 "}", getTaskTree()); 55 56 simulateInteraction(element1, new DummyInteraction("bla", 1)); 57 simulateInteraction(element1, new DummyInteraction("bli", 1)); 58 simulateInteraction(element1, new MouseButtonDown(middleBtn)); 59 simulateInteraction(element1, new MouseButtonUp(middleBtn)); 60 simulateInteraction(element1, new MouseClick(middleBtn)); 61 simulateInteraction(element1, new DummyInteraction("blo", 1)); 62 simulateInteraction(element1, new DummyInteraction("blu", 1)); 28 /** 29 * 30 */ 31 @Test 32 public void testMouseClickInOneSequenceElement() { 33 MouseButtonInteraction.Button leftBtn = MouseButtonInteraction.Button.LEFT; 34 MouseButtonInteraction.Button middleBtn = MouseButtonInteraction.Button.MIDDLE; 35 MouseButtonInteraction.Button rightBtn = MouseButtonInteraction.Button.RIGHT; 63 36 64 new TaskTreeChecker().assertTaskTree 65 ("Sequence sequence {" + 66 " Interaction LeftMouseClick {}" + 67 " Interaction bla {}" + 68 " Interaction bli {}" + 69 " Interaction MiddleMouseClick {}" + 70 " Interaction blo {}" + 71 " Interaction blu {}" + 72 "}", getTaskTree()); 37 IGUIElement element1 = new DummyGUIElement("elem1"); 38 IGUIElement element2 = new DummyGUIElement("elem1"); 73 39 74 simulateInteraction(element2, new DummyInteraction("bla", 1)); 75 simulateInteraction(element2, new DummyInteraction("bli", 1)); 76 simulateInteraction(element2, new MouseButtonDown(rightBtn)); 77 simulateInteraction(element2, new MouseButtonUp(rightBtn)); 78 simulateInteraction(element2, new MouseClick(rightBtn)); 79 simulateInteraction(element2, new DummyInteraction("blo", 1)); 80 simulateInteraction(element2, new DummyInteraction("blu", 1)); 40 simulateEvent(new MouseButtonDown(leftBtn), element1); 41 simulateEvent(new MouseButtonUp(leftBtn), element1); 42 simulateEvent(new MouseClick(leftBtn), element1); 81 43 82 new TaskTreeChecker().assertTaskTree 83 ("Sequence sequence0 {" + 84 " Sequence sequence1 {" + 85 " Interaction LeftMouseClick {}" + 86 " Interaction bla {}" + 87 " Interaction bli {}" + 88 " Interaction MiddleMouseClick {}" + 89 " Interaction blo {}" + 90 " Interaction blu {}" + 91 " }" + 92 " Sequence sequence2 {" + 93 " Interaction bla {}" + 94 " Interaction bli {}" + 95 " Interaction RightMouseClick {}" + 96 " Interaction blo {}" + 97 " Interaction blu {}" + 98 " }" + 99 "}", getTaskTree()); 44 new TaskTreeChecker().assertTaskTree 45 ("Sequence sequence {" + 46 " Event LeftMouseClick {}" + 47 "}", getTaskTree()); 100 48 101 simulateInteraction(element1, new MouseButtonDown(leftBtn)); 102 simulateInteraction(element1, new MouseButtonUp(leftBtn)); 103 simulateInteraction(element2, new MouseClick(leftBtn)); 49 simulateEvent(new DummyInteraction("bla", 1), element1); 50 simulateEvent(new DummyInteraction("bli", 1), element1); 51 simulateEvent(new MouseButtonDown(middleBtn), element1); 52 simulateEvent(new MouseButtonUp(middleBtn), element1); 53 simulateEvent(new MouseClick(middleBtn), element1); 54 simulateEvent(new DummyInteraction("blo", 1), element1); 55 simulateEvent(new DummyInteraction("blu", 1), element1); 104 56 105 new TaskTreeChecker().assertTaskTree 106 ("Sequence sequence0 {" + 107 " Sequence sequence1 {" + 108 " Interaction LeftMouseClick {}" + 109 " Interaction bla {}" + 110 " Interaction bli {}" + 111 " Interaction MiddleMouseClick {}" + 112 " Interaction blo {}" + 113 " Interaction blu {}" + 114 " }" + 115 " Sequence sequence2 {" + 116 " Interaction bla {}" + 117 " Interaction bli {}" + 118 " Interaction RightMouseClick {}" + 119 " Interaction blo {}" + 120 " Interaction blu {}" + 121 " }" + 122 " Sequence sequence3 {" + 123 " Interaction LeftMouseButtonDown {}" + 124 " Interaction LeftMouseButtonUp {}" + 125 " }" + 126 " Sequence sequence4 {" + 127 " Interaction LeftMouseClick {}" + 128 " }" + 129 "}", getTaskTree()); 57 new TaskTreeChecker().assertTaskTree 58 ("Sequence sequence {" + 59 " Event LeftMouseClick {}" + 60 " Event bla {}" + 61 " Event bli {}" + 62 " Event MiddleMouseClick {}" + 63 " Event blo {}" + 64 " Event blu {}" + 65 "}", getTaskTree()); 130 66 131 simulateInteraction(element1, new MouseButtonDown(middleBtn)); 132 simulateInteraction(element1, new MouseButtonUp(middleBtn)); 133 simulateInteraction(element1, new MouseClick(rightBtn)); 134 simulateInteraction(element2, new DummyInteraction("bla", 1)); 67 simulateEvent(new DummyInteraction("bla", 1), element2); 68 simulateEvent(new DummyInteraction("bli", 1), element2); 69 simulateEvent(new MouseButtonDown(rightBtn), element2); 70 simulateEvent(new MouseButtonUp(rightBtn), element2); 71 simulateEvent(new MouseClick(rightBtn), element2); 72 simulateEvent(new DummyInteraction("blo", 1), element2); 73 simulateEvent(new DummyInteraction("blu", 1), element2); 135 74 136 new TaskTreeChecker().assertTaskTree 137 ("Sequence sequence0 {" + 138 " Sequence sequence1 {" + 139 " Interaction LeftMouseClick {}" + 140 " Interaction bla {}" + 141 " Interaction bli {}" + 142 " Interaction MiddleMouseClick {}" + 143 " Interaction blo {}" + 144 " Interaction blu {}" + 145 " }" + 146 " Sequence sequence2 {" + 147 " Interaction bla {}" + 148 " Interaction bli {}" + 149 " Interaction RightMouseClick {}" + 150 " Interaction blo {}" + 151 " Interaction blu {}" + 152 " }" + 153 " Sequence sequence3 {" + 154 " Interaction LeftMouseButtonDown {}" + 155 " Interaction LeftMouseButtonUp {}" + 156 " }" + 157 " Sequence sequence4 {" + 158 " Interaction LeftMouseClick {}" + 159 " }" + 160 " Sequence sequence5 {" + 161 " Sequence sequence6 {" + 162 " Interaction MiddleMouseButtonDown {}" + 163 " Interaction MiddleMouseButtonUp {}" + 164 " }" + 165 " Interaction RightMouseClick {}" + 166 " }" + 167 " Sequence sequence7 {" + 168 " Interaction bla {}" + 169 " }" + 170 "}", getTaskTree()); 75 new TaskTreeChecker().assertTaskTree 76 ("Sequence sequence0 {" + 77 " Sequence sequence1 {" + 78 " Event LeftMouseClick {}" + 79 " Event bla {}" + 80 " Event bli {}" + 81 " Event MiddleMouseClick {}" + 82 " Event blo {}" + 83 " Event blu {}" + 84 " }" + 85 " Sequence sequence2 {" + 86 " Event bla {}" + 87 " Event bli {}" + 88 " Event RightMouseClick {}" + 89 " Event blo {}" + 90 " Event blu {}" + 91 " }" + 92 "}", getTaskTree()); 171 93 172 } 173 94 simulateEvent(new MouseButtonDown(leftBtn), element1); 95 simulateEvent(new MouseButtonUp(leftBtn), element1); 96 simulateEvent(new MouseClick(leftBtn), element2); 97 98 new TaskTreeChecker().assertTaskTree 99 ("Sequence sequence0 {" + 100 " Sequence sequence1 {" + 101 " Event LeftMouseClick {}" + 102 " Event bla {}" + 103 " Event bli {}" + 104 " Event MiddleMouseClick {}" + 105 " Event blo {}" + 106 " Event blu {}" + 107 " }" + 108 " Sequence sequence2 {" + 109 " Event bla {}" + 110 " Event bli {}" + 111 " Event RightMouseClick {}" + 112 " Event blo {}" + 113 " Event blu {}" + 114 " }" + 115 " Sequence sequence3 {" + 116 " Event LeftMouseButtonDown {}" + 117 " Event LeftMouseButtonUp {}" + 118 " }" + 119 " Sequence sequence4 {" + 120 " Event LeftMouseClick {}" + 121 " }" + 122 "}", getTaskTree()); 123 124 simulateEvent(new MouseButtonDown(middleBtn), element1); 125 simulateEvent(new MouseButtonUp(middleBtn), element1); 126 simulateEvent(new MouseClick(rightBtn), element1); 127 simulateEvent(new DummyInteraction("bla", 1), element2); 128 129 new TaskTreeChecker().assertTaskTree 130 ("Sequence sequence0 {" + 131 " Sequence sequence1 {" + 132 " Event LeftMouseClick {}" + 133 " Event bla {}" + 134 " Event bli {}" + 135 " Event MiddleMouseClick {}" + 136 " Event blo {}" + 137 " Event blu {}" + 138 " }" + 139 " Sequence sequence2 {" + 140 " Event bla {}" + 141 " Event bli {}" + 142 " Event RightMouseClick {}" + 143 " Event blo {}" + 144 " Event blu {}" + 145 " }" + 146 " Sequence sequence3 {" + 147 " Event LeftMouseButtonDown {}" + 148 " Event LeftMouseButtonUp {}" + 149 " }" + 150 " Sequence sequence4 {" + 151 " Event LeftMouseClick {}" + 152 " }" + 153 " Sequence sequence5 {" + 154 " Sequence sequence6 {" + 155 " Event MiddleMouseButtonDown {}" + 156 " Event MiddleMouseButtonUp {}" + 157 " }" + 158 " Event RightMouseClick {}" + 159 " }" + 160 " Sequence sequence7 {" + 161 " Event bla {}" + 162 " }" + 163 "}", getTaskTree()); 164 165 } 166 174 167 } -
trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultTextInputReductionRuleTest.java
r468 r557 1 //-------------------------------------------------------------------------------------------------2 1 // Module : $RCSfile: DefaultIterationDetectionRuleTest.java,v $ 3 2 // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 28.04.2012 $ … … 5 4 // Creation : 2012 by patrick 6 5 // Copyright : Patrick Harms, 2012 7 //------------------------------------------------------------------------------------------------- 6 8 7 package de.ugoe.cs.quest.tasktrees.temporalrelation; 9 8 10 9 import org.junit.Test; 11 10 12 import de.ugoe.cs.quest.eventcore.gui model.GUIElement;13 import de.ugoe.cs.quest.eventcore.gui model.TextField;14 import de.ugoe.cs.quest.eventcore. userinteraction.KeyPressed;15 import de.ugoe.cs.quest.eventcore. userinteraction.KeyReleased;11 import de.ugoe.cs.quest.eventcore.gui.KeyPressed; 12 import de.ugoe.cs.quest.eventcore.gui.KeyReleased; 13 import de.ugoe.cs.quest.eventcore.guimodel.IGUIElement; 14 import de.ugoe.cs.quest.eventcore.guimodel.ITextField; 16 15 import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; 17 16 import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; 18 17 import de.ugoe.cs.tasktree.keyboardmaps.VirtualKey; 19 18 20 //-------------------------------------------------------------------------------------------------21 19 /** 22 20 * TODO comment … … 25 23 * @author 2012, last modified by $Author: patrick$ 26 24 */ 27 //------------------------------------------------------------------------------------------------- 28 public class DefaultTextInputReductionRuleTest extends AbstractTemporalRelationshipTC 29 { 30 31 //----------------------------------------------------------------------------------------------- 32 /** 33 * 34 */ 35 //----------------------------------------------------------------------------------------------- 36 @Test 37 public void testSimpleTextEntry() 38 { 39 GUIElement element1 = new DummyTextField("elem1"); 40 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_A)); 41 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_A)); 42 new TaskTreeChecker(true).assertTaskTree 43 ("Sequence sequence0 {" + 44 " TextInputInteraction TextInput a {" + 45 " Interaction KeyPressed LETTER_A {}" + 46 " Interaction KeyReleased LETTER_A {}" + 47 " }" + 48 "}", getTaskTree()); 49 50 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_B)); 51 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_B)); 52 new TaskTreeChecker().assertTaskTree 53 ("Sequence sequence0 {" + 54 " TextInputInteraction TextInput ab {" + 55 " Interaction KeyPressed LETTER_A {}" + 56 " Interaction KeyReleased LETTER_A {}" + 57 " Interaction KeyPressed LETTER_B {}" + 58 " Interaction KeyReleased LETTER_B {}" + 59 " }" + 60 "}", getTaskTree()); 61 62 simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); 63 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_C)); 64 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_C)); 65 simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); 66 new TaskTreeChecker().assertTaskTree 67 ("Sequence sequence0 {" + 68 " TextInputInteraction TextInput abC {" + 69 " Interaction KeyPressed LETTER_A {}" + 70 " Interaction KeyReleased LETTER_A {}" + 71 " Interaction KeyPressed LETTER_B {}" + 72 " Interaction KeyReleased LETTER_B {}" + 73 " Interaction KeyPressed SHIFT {}" + 74 " Interaction KeyPressed LETTER_C {}" + 75 " Interaction KeyReleased LETTER_C {}" + 76 " Interaction KeyReleased SHIFT {}" + 77 " }" + 78 "}", getTaskTree()); 79 80 simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); 81 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_D)); 82 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_D)); 83 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_E)); 84 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_E)); 85 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_F)); 86 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_F)); 87 simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); 88 new TaskTreeChecker().assertTaskTree 89 ("Sequence sequence0 {" + 90 " TextInputInteraction TextInput abCDEF {" + 91 " Interaction KeyPressed LETTER_A {}" + 92 " Interaction KeyReleased LETTER_A {}" + 93 " Interaction KeyPressed LETTER_B {}" + 94 " Interaction KeyReleased LETTER_B {}" + 95 " Interaction KeyPressed SHIFT {}" + 96 " Interaction KeyPressed LETTER_C {}" + 97 " Interaction KeyReleased LETTER_C {}" + 98 " Interaction KeyReleased SHIFT {}" + 99 " Interaction KeyPressed SHIFT {}" + 100 " Interaction KeyPressed LETTER_D {}" + 101 " Interaction KeyReleased LETTER_D {}" + 102 " Interaction KeyPressed LETTER_E {}" + 103 " Interaction KeyReleased LETTER_E {}" + 104 " Interaction KeyPressed LETTER_F {}" + 105 " Interaction KeyReleased LETTER_F {}" + 106 " Interaction KeyReleased SHIFT {}" + 107 " }" + 108 "}", getTaskTree()); 109 110 111 simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); 112 simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); 113 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_G)); 114 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_G)); 115 simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); 116 simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); 117 new TaskTreeChecker().assertTaskTree 118 ("Sequence sequence0 {" + 119 " TextInputInteraction TextInput abCDEFg {" + 120 " Interaction KeyPressed LETTER_A {}" + 121 " Interaction KeyReleased LETTER_A {}" + 122 " Interaction KeyPressed LETTER_B {}" + 123 " Interaction KeyReleased LETTER_B {}" + 124 " Interaction KeyPressed SHIFT {}" + 125 " Interaction KeyPressed LETTER_C {}" + 126 " Interaction KeyReleased LETTER_C {}" + 127 " Interaction KeyReleased SHIFT {}" + 128 " Interaction KeyPressed SHIFT {}" + 129 " Interaction KeyPressed LETTER_D {}" + 130 " Interaction KeyReleased LETTER_D {}" + 131 " Interaction KeyPressed LETTER_E {}" + 132 " Interaction KeyReleased LETTER_E {}" + 133 " Interaction KeyPressed LETTER_F {}" + 134 " Interaction KeyReleased LETTER_F {}" + 135 " Interaction KeyReleased SHIFT {}" + 136 " Interaction KeyPressed SHIFT {}" + 137 " Interaction KeyPressed SHIFT {}" + 138 " Interaction KeyPressed LETTER_G {}" + 139 " Interaction KeyReleased LETTER_G {}" + 140 " Interaction KeyReleased SHIFT {}" + 141 " Interaction KeyReleased SHIFT {}" + 142 " }" + 143 "}", getTaskTree()); 144 145 } 146 147 //----------------------------------------------------------------------------------------------- 148 /** 149 * 150 */ 151 //----------------------------------------------------------------------------------------------- 152 @Test 153 public void testTextEntryOnDifferentGuiElements() 154 { 155 GUIElement element1 = new DummyTextField("elem1"); 156 GUIElement element2 = new DummyTextField("elem2"); 157 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_A)); 158 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_A)); 159 new TaskTreeChecker().assertTaskTree 160 ("Sequence sequence0 {" + 161 " TextInputInteraction TextInput a {" + 162 " Interaction KeyPressed LETTER_A {}" + 163 " Interaction KeyReleased LETTER_A {}" + 164 " }" + 165 "}", getTaskTree()); 166 167 simulateInteraction(element2, new KeyPressed(VirtualKey.LETTER_B)); 168 simulateInteraction(element2, new KeyReleased(VirtualKey.LETTER_B)); 169 new TaskTreeChecker().assertTaskTree 170 ("Sequence sequence0 {" + 171 " Sequence sequence1 {" + 172 " TextInputInteraction TextInput a {" + 173 " Interaction KeyPressed LETTER_A {}" + 174 " Interaction KeyReleased LETTER_A {}" + 175 " }" + 176 " }" + 177 " Sequence sequence2 {" + 178 " TextInputInteraction TextInput b {" + 179 " Interaction KeyPressed LETTER_B {}" + 180 " Interaction KeyReleased LETTER_B {}" + 181 " }" + 182 " }" + 183 "}", getTaskTree()); 184 185 simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); 186 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_C)); 187 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_C)); 188 simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); 189 new TaskTreeChecker().assertTaskTree 190 ("Sequence sequence0 {" + 191 " Sequence sequence1 {" + 192 " TextInputInteraction TextInput a {" + 193 " Interaction KeyPressed LETTER_A {}" + 194 " Interaction KeyReleased LETTER_A {}" + 195 " }" + 196 " }" + 197 " Sequence sequence2 {" + 198 " TextInputInteraction TextInput b {" + 199 " Interaction KeyPressed LETTER_B {}" + 200 " Interaction KeyReleased LETTER_B {}" + 201 " }" + 202 " }" + 203 " Sequence sequence3 {" + 204 " TextInputInteraction TextInput C {" + 205 " Interaction KeyPressed SHIFT {}" + 206 " Interaction KeyPressed LETTER_C {}" + 207 " Interaction KeyReleased LETTER_C {}" + 208 " Interaction KeyReleased SHIFT {}" + 209 " }" + 210 " }" + 211 "}", getTaskTree()); 212 213 simulateInteraction(element2, new KeyPressed(VirtualKey.SHIFT)); 214 simulateInteraction(element2, new KeyPressed(VirtualKey.LETTER_D)); 215 simulateInteraction(element2, new KeyReleased(VirtualKey.LETTER_D)); 216 simulateInteraction(element2, new KeyPressed(VirtualKey.LETTER_E)); 217 simulateInteraction(element2, new KeyReleased(VirtualKey.LETTER_E)); 218 simulateInteraction(element2, new KeyPressed(VirtualKey.LETTER_F)); 219 simulateInteraction(element2, new KeyReleased(VirtualKey.LETTER_F)); 220 simulateInteraction(element2, new KeyReleased(VirtualKey.SHIFT)); 221 new TaskTreeChecker().assertTaskTree 222 ("Sequence sequence0 {" + 223 " Sequence sequence1 {" + 224 " TextInputInteraction TextInput a {" + 225 " Interaction KeyPressed LETTER_A {}" + 226 " Interaction KeyReleased LETTER_A {}" + 227 " }" + 228 " }" + 229 " Sequence sequence2 {" + 230 " TextInputInteraction TextInput b {" + 231 " Interaction KeyPressed LETTER_B {}" + 232 " Interaction KeyReleased LETTER_B {}" + 233 " }" + 234 " }" + 235 " Sequence sequence3 {" + 236 " TextInputInteraction TextInput C {" + 237 " Interaction KeyPressed SHIFT {}" + 238 " Interaction KeyPressed LETTER_C {}" + 239 " Interaction KeyReleased LETTER_C {}" + 240 " Interaction KeyReleased SHIFT {}" + 241 " }" + 242 " }" + 243 " Sequence sequence4 {" + 244 " TextInputInteraction TextInput DEF {" + 245 " Interaction KeyPressed SHIFT {}" + 246 " Interaction KeyPressed LETTER_D {}" + 247 " Interaction KeyReleased LETTER_D {}" + 248 " Interaction KeyPressed LETTER_E {}" + 249 " Interaction KeyReleased LETTER_E {}" + 250 " Interaction KeyPressed LETTER_F {}" + 251 " Interaction KeyReleased LETTER_F {}" + 252 " Interaction KeyReleased SHIFT {}" + 253 " }" + 254 " }" + 255 "}", getTaskTree()); 256 257 258 simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); 259 simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); 260 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_G)); 261 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_G)); 262 simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); 263 simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); 264 new TaskTreeChecker().assertTaskTree 265 ("Sequence sequence0 {" + 266 " Sequence sequence1 {" + 267 " TextInputInteraction TextInput a {" + 268 " Interaction KeyPressed LETTER_A {}" + 269 " Interaction KeyReleased LETTER_A {}" + 270 " }" + 271 " }" + 272 " Sequence sequence2 {" + 273 " TextInputInteraction TextInput b {" + 274 " Interaction KeyPressed LETTER_B {}" + 275 " Interaction KeyReleased LETTER_B {}" + 276 " }" + 277 " }" + 278 " Sequence sequence3 {" + 279 " TextInputInteraction TextInput C {" + 280 " Interaction KeyPressed SHIFT {}" + 281 " Interaction KeyPressed LETTER_C {}" + 282 " Interaction KeyReleased LETTER_C {}" + 283 " Interaction KeyReleased SHIFT {}" + 284 " }" + 285 " }" + 286 " Sequence sequence4 {" + 287 " TextInputInteraction TextInput DEF {" + 288 " Interaction KeyPressed SHIFT {}" + 289 " Interaction KeyPressed LETTER_D {}" + 290 " Interaction KeyReleased LETTER_D {}" + 291 " Interaction KeyPressed LETTER_E {}" + 292 " Interaction KeyReleased LETTER_E {}" + 293 " Interaction KeyPressed LETTER_F {}" + 294 " Interaction KeyReleased LETTER_F {}" + 295 " Interaction KeyReleased SHIFT {}" + 296 " }" + 297 " }" + 298 " Sequence sequence5 {" + 299 " TextInputInteraction TextInput g {" + 300 " Interaction KeyPressed SHIFT {}" + 301 " Interaction KeyPressed SHIFT {}" + 302 " Interaction KeyPressed LETTER_G {}" + 303 " Interaction KeyReleased LETTER_G {}" + 304 " Interaction KeyReleased SHIFT {}" + 305 " Interaction KeyReleased SHIFT {}" + 306 " }" + 307 " }" + 308 "}", getTaskTree()); 309 310 } 311 312 //----------------------------------------------------------------------------------------------- 313 /** 314 * 315 */ 316 //----------------------------------------------------------------------------------------------- 317 @Test 318 public void testUsageOfBackspace() 319 { 320 GUIElement element1 = new DummyTextField("elem1"); 321 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_A)); 322 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_A)); 323 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_B)); 324 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_B)); 325 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_C)); 326 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_C)); 327 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_D)); 328 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_D)); 329 simulateInteraction(element1, new KeyPressed(VirtualKey.BACK_SPACE)); 330 simulateInteraction(element1, new KeyReleased(VirtualKey.BACK_SPACE)); 331 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_E)); 332 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_E)); 333 simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_F)); 334 simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_F)); 335 new TaskTreeChecker().assertTaskTree 336 ("Sequence sequence0 {" + 337 " TextInputInteraction TextInput abcef {" + 338 " Interaction KeyPressed LETTER_A {}" + 339 " Interaction KeyReleased LETTER_A {}" + 340 " Interaction KeyPressed LETTER_B {}" + 341 " Interaction KeyReleased LETTER_B {}" + 342 " Interaction KeyPressed LETTER_C {}" + 343 " Interaction KeyReleased LETTER_C {}" + 344 " Interaction KeyPressed LETTER_D {}" + 345 " Interaction KeyReleased LETTER_D {}" + 346 " Interaction KeyPressed BACK_SPACE {}" + 347 " Interaction KeyReleased BACK_SPACE {}" + 348 " Interaction KeyPressed LETTER_E {}" + 349 " Interaction KeyReleased LETTER_E {}" + 350 " Interaction KeyPressed LETTER_F {}" + 351 " Interaction KeyReleased LETTER_F {}" + 352 " }" + 353 "}", getTaskTree()); 354 355 simulateInteraction(element1, new KeyPressed(VirtualKey.BACK_SPACE)); 356 simulateInteraction(element1, new KeyReleased(VirtualKey.BACK_SPACE)); 357 simulateInteraction(element1, new KeyPressed(VirtualKey.BACK_SPACE)); 358 simulateInteraction(element1, new KeyReleased(VirtualKey.BACK_SPACE)); 359 simulateInteraction(element1, new KeyPressed(VirtualKey.BACK_SPACE)); 360 simulateInteraction(element1, new KeyReleased(VirtualKey.BACK_SPACE)); 361 new TaskTreeChecker().assertTaskTree 362 ("Sequence sequence0 {" + 363 " TextInputInteraction TextInput ab {" + 364 " Interaction KeyPressed LETTER_A {}" + 365 " Interaction KeyReleased LETTER_A {}" + 366 " Interaction KeyPressed LETTER_B {}" + 367 " Interaction KeyReleased LETTER_B {}" + 368 " Interaction KeyPressed LETTER_C {}" + 369 " Interaction KeyReleased LETTER_C {}" + 370 " Interaction KeyPressed LETTER_D {}" + 371 " Interaction KeyReleased LETTER_D {}" + 372 " Interaction KeyPressed BACK_SPACE {}" + 373 " Interaction KeyReleased BACK_SPACE {}" + 374 " Interaction KeyPressed LETTER_E {}" + 375 " Interaction KeyReleased LETTER_E {}" + 376 " Interaction KeyPressed LETTER_F {}" + 377 " Interaction KeyReleased LETTER_F {}" + 378 " Interaction KeyPressed BACK_SPACE {}" + 379 " Interaction KeyReleased BACK_SPACE {}" + 380 " Interaction KeyPressed BACK_SPACE {}" + 381 " Interaction KeyReleased BACK_SPACE {}" + 382 " Interaction KeyPressed BACK_SPACE {}" + 383 " Interaction KeyReleased BACK_SPACE {}" + 384 " }" + 385 "}", getTaskTree()); 386 387 } 388 389 //----------------------------------------------------------------------------------------------- 390 /** 391 * 392 */ 393 //----------------------------------------------------------------------------------------------- 394 private static class DummyTextField extends DummyGUIElement implements TextField 395 { 396 397 //--------------------------------------------------------------------------------------------- 25 public class DefaultTextInputReductionRuleTest extends AbstractTemporalRelationshipTC { 26 398 27 /** 399 * TODO: comment400 28 * 401 * @param name402 29 */ 403 //--------------------------------------------------------------------------------------------- 404 public DummyTextField(String name) 405 { 406 super(name); 30 @Test 31 public void testSimpleTextEntry() { 32 IGUIElement element1 = new DummyTextField("elem1"); 33 simulateEvent(new KeyPressed(VirtualKey.LETTER_A), element1); 34 simulateEvent(new KeyReleased(VirtualKey.LETTER_A), element1); 35 new TaskTreeChecker(true).assertTaskTree 36 ("Sequence sequence0 {" + 37 " TextInputEvent TextInput a {" + 38 " Event KeyPressed LETTER_A {}" + 39 " Event KeyReleased LETTER_A {}" + 40 " }" + 41 "}", getTaskTree()); 42 43 simulateEvent(new KeyPressed(VirtualKey.LETTER_B), element1); 44 simulateEvent(new KeyReleased(VirtualKey.LETTER_B), element1); 45 new TaskTreeChecker().assertTaskTree 46 ("Sequence sequence0 {" + 47 " TextInputEvent TextInput ab {" + 48 " Event KeyPressed LETTER_A {}" + 49 " Event KeyReleased LETTER_A {}" + 50 " Event KeyPressed LETTER_B {}" + 51 " Event KeyReleased LETTER_B {}" + 52 " }" + 53 "}", getTaskTree()); 54 55 simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); 56 simulateEvent(new KeyPressed(VirtualKey.LETTER_C), element1); 57 simulateEvent(new KeyReleased(VirtualKey.LETTER_C), element1); 58 simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); 59 new TaskTreeChecker().assertTaskTree 60 ("Sequence sequence0 {" + 61 " TextInputEvent TextInput abC {" + 62 " Event KeyPressed LETTER_A {}" + 63 " Event KeyReleased LETTER_A {}" + 64 " Event KeyPressed LETTER_B {}" + 65 " Event KeyReleased LETTER_B {}" + 66 " Event KeyPressed SHIFT {}" + 67 " Event KeyPressed LETTER_C {}" + 68 " Event KeyReleased LETTER_C {}" + 69 " Event KeyReleased SHIFT {}" + 70 " }" + 71 "}", getTaskTree()); 72 73 simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); 74 simulateEvent(new KeyPressed(VirtualKey.LETTER_D), element1); 75 simulateEvent(new KeyReleased(VirtualKey.LETTER_D), element1); 76 simulateEvent(new KeyPressed(VirtualKey.LETTER_E), element1); 77 simulateEvent(new KeyReleased(VirtualKey.LETTER_E), element1); 78 simulateEvent(new KeyPressed(VirtualKey.LETTER_F), element1); 79 simulateEvent(new KeyReleased(VirtualKey.LETTER_F), element1); 80 simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); 81 new TaskTreeChecker().assertTaskTree 82 ("Sequence sequence0 {" + 83 " TextInputEvent TextInput abCDEF {" + 84 " Event KeyPressed LETTER_A {}" + 85 " Event KeyReleased LETTER_A {}" + 86 " Event KeyPressed LETTER_B {}" + 87 " Event KeyReleased LETTER_B {}" + 88 " Event KeyPressed SHIFT {}" + 89 " Event KeyPressed LETTER_C {}" + 90 " Event KeyReleased LETTER_C {}" + 91 " Event KeyReleased SHIFT {}" + 92 " Event KeyPressed SHIFT {}" + 93 " Event KeyPressed LETTER_D {}" + 94 " Event KeyReleased LETTER_D {}" + 95 " Event KeyPressed LETTER_E {}" + 96 " Event KeyReleased LETTER_E {}" + 97 " Event KeyPressed LETTER_F {}" + 98 " Event KeyReleased LETTER_F {}" + 99 " Event KeyReleased SHIFT {}" + 100 " }" + 101 "}", getTaskTree()); 102 103 simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); 104 simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); 105 simulateEvent(new KeyPressed(VirtualKey.LETTER_G), element1); 106 simulateEvent(new KeyReleased(VirtualKey.LETTER_G), element1); 107 simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); 108 simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); 109 new TaskTreeChecker().assertTaskTree 110 ("Sequence sequence0 {" + 111 " TextInputEvent TextInput abCDEFg {" + 112 " Event KeyPressed LETTER_A {}" + 113 " Event KeyReleased LETTER_A {}" + 114 " Event KeyPressed LETTER_B {}" + 115 " Event KeyReleased LETTER_B {}" + 116 " Event KeyPressed SHIFT {}" + 117 " Event KeyPressed LETTER_C {}" + 118 " Event KeyReleased LETTER_C {}" + 119 " Event KeyReleased SHIFT {}" + 120 " Event KeyPressed SHIFT {}" + 121 " Event KeyPressed LETTER_D {}" + 122 " Event KeyReleased LETTER_D {}" + 123 " Event KeyPressed LETTER_E {}" + 124 " Event KeyReleased LETTER_E {}" + 125 " Event KeyPressed LETTER_F {}" + 126 " Event KeyReleased LETTER_F {}" + 127 " Event KeyReleased SHIFT {}" + 128 " Event KeyPressed SHIFT {}" + 129 " Event KeyPressed SHIFT {}" + 130 " Event KeyPressed LETTER_G {}" + 131 " Event KeyReleased LETTER_G {}" + 132 " Event KeyReleased SHIFT {}" + 133 " Event KeyReleased SHIFT {}" + 134 " }" + 135 "}", getTaskTree()); 136 407 137 } 408 138 409 } 139 /** 140 * 141 */ 142 @Test 143 public void testTextEntryOnDifferentGuiElements() { 144 IGUIElement element1 = new DummyTextField("elem1"); 145 IGUIElement element2 = new DummyTextField("elem2"); 146 simulateEvent(new KeyPressed(VirtualKey.LETTER_A), element1); 147 simulateEvent(new KeyReleased(VirtualKey.LETTER_A), element1); 148 new TaskTreeChecker().assertTaskTree 149 ("Sequence sequence0 {" + 150 " TextInputEvent TextInput a {" + 151 " Event KeyPressed LETTER_A {}" + 152 " Event KeyReleased LETTER_A {}" + 153 " }" + 154 "}", getTaskTree()); 155 156 simulateEvent(new KeyPressed(VirtualKey.LETTER_B), element2); 157 simulateEvent(new KeyReleased(VirtualKey.LETTER_B), element2); 158 new TaskTreeChecker().assertTaskTree 159 ("Sequence sequence0 {" + 160 " Sequence sequence1 {" + 161 " TextInputEvent TextInput a {" + 162 " Event KeyPressed LETTER_A {}" + 163 " Event KeyReleased LETTER_A {}" + 164 " }" + 165 " }" + 166 " Sequence sequence2 {" + 167 " TextInputEvent TextInput b {" + 168 " Event KeyPressed LETTER_B {}" + 169 " Event KeyReleased LETTER_B {}" + 170 " }" + 171 " }" + 172 "}", getTaskTree()); 173 174 simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); 175 simulateEvent(new KeyPressed(VirtualKey.LETTER_C), element1); 176 simulateEvent(new KeyReleased(VirtualKey.LETTER_C), element1); 177 simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); 178 new TaskTreeChecker().assertTaskTree 179 ("Sequence sequence0 {" + 180 " Sequence sequence1 {" + 181 " TextInputEvent TextInput a {" + 182 " Event KeyPressed LETTER_A {}" + 183 " Event KeyReleased LETTER_A {}" + 184 " }" + 185 " }" + 186 " Sequence sequence2 {" + 187 " TextInputEvent TextInput b {" + 188 " Event KeyPressed LETTER_B {}" + 189 " Event KeyReleased LETTER_B {}" + 190 " }" + 191 " }" + 192 " Sequence sequence3 {" + 193 " TextInputEvent TextInput C {" + 194 " Event KeyPressed SHIFT {}" + 195 " Event KeyPressed LETTER_C {}" + 196 " Event KeyReleased LETTER_C {}" + 197 " Event KeyReleased SHIFT {}" + 198 " }" + 199 " }" + 200 "}", getTaskTree()); 201 202 simulateEvent(new KeyPressed(VirtualKey.SHIFT), element2); 203 simulateEvent(new KeyPressed(VirtualKey.LETTER_D), element2); 204 simulateEvent(new KeyReleased(VirtualKey.LETTER_D), element2); 205 simulateEvent(new KeyPressed(VirtualKey.LETTER_E), element2); 206 simulateEvent(new KeyReleased(VirtualKey.LETTER_E), element2); 207 simulateEvent(new KeyPressed(VirtualKey.LETTER_F), element2); 208 simulateEvent(new KeyReleased(VirtualKey.LETTER_F), element2); 209 simulateEvent(new KeyReleased(VirtualKey.SHIFT), element2); 210 new TaskTreeChecker().assertTaskTree 211 ("Sequence sequence0 {" + 212 " Sequence sequence1 {" + 213 " TextInputEvent TextInput a {" + 214 " Event KeyPressed LETTER_A {}" + 215 " Event KeyReleased LETTER_A {}" + 216 " }" + 217 " }" + 218 " Sequence sequence2 {" + 219 " TextInputEvent TextInput b {" + 220 " Event KeyPressed LETTER_B {}" + 221 " Event KeyReleased LETTER_B {}" + 222 " }" + 223 " }" + 224 " Sequence sequence3 {" + 225 " TextInputEvent TextInput C {" + 226 " Event KeyPressed SHIFT {}" + 227 " Event KeyPressed LETTER_C {}" + 228 " Event KeyReleased LETTER_C {}" + 229 " Event KeyReleased SHIFT {}" + 230 " }" + 231 " }" + 232 " Sequence sequence4 {" + 233 " TextInputEvent TextInput DEF {" + 234 " Event KeyPressed SHIFT {}" + 235 " Event KeyPressed LETTER_D {}" + 236 " Event KeyReleased LETTER_D {}" + 237 " Event KeyPressed LETTER_E {}" + 238 " Event KeyReleased LETTER_E {}" + 239 " Event KeyPressed LETTER_F {}" + 240 " Event KeyReleased LETTER_F {}" + 241 " Event KeyReleased SHIFT {}" + 242 " }" + 243 " }" + 244 "}", getTaskTree()); 245 246 simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); 247 simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); 248 simulateEvent(new KeyPressed(VirtualKey.LETTER_G), element1); 249 simulateEvent(new KeyReleased(VirtualKey.LETTER_G), element1); 250 simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); 251 simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); 252 new TaskTreeChecker().assertTaskTree 253 ("Sequence sequence0 {" + 254 " Sequence sequence1 {" + 255 " TextInputEvent TextInput a {" + 256 " Event KeyPressed LETTER_A {}" + 257 " Event KeyReleased LETTER_A {}" + 258 " }" + 259 " }" + 260 " Sequence sequence2 {" + 261 " TextInputEvent TextInput b {" + 262 " Event KeyPressed LETTER_B {}" + 263 " Event KeyReleased LETTER_B {}" + 264 " }" + 265 " }" + 266 " Sequence sequence3 {" + 267 " TextInputEvent TextInput C {" + 268 " Event KeyPressed SHIFT {}" + 269 " Event KeyPressed LETTER_C {}" + 270 " Event KeyReleased LETTER_C {}" + 271 " Event KeyReleased SHIFT {}" + 272 " }" + 273 " }" + 274 " Sequence sequence4 {" + 275 " TextInputEvent TextInput DEF {" + 276 " Event KeyPressed SHIFT {}" + 277 " Event KeyPressed LETTER_D {}" + 278 " Event KeyReleased LETTER_D {}" + 279 " Event KeyPressed LETTER_E {}" + 280 " Event KeyReleased LETTER_E {}" + 281 " Event KeyPressed LETTER_F {}" + 282 " Event KeyReleased LETTER_F {}" + 283 " Event KeyReleased SHIFT {}" + 284 " }" + 285 " }" + 286 " Sequence sequence5 {" + 287 " TextInputEvent TextInput g {" + 288 " Event KeyPressed SHIFT {}" + 289 " Event KeyPressed SHIFT {}" + 290 " Event KeyPressed LETTER_G {}" + 291 " Event KeyReleased LETTER_G {}" + 292 " Event KeyReleased SHIFT {}" + 293 " Event KeyReleased SHIFT {}" + 294 " }" + 295 " }" + 296 "}", getTaskTree()); 297 298 } 299 300 /** 301 * 302 */ 303 @Test 304 public void testUsageOfBackspace() { 305 IGUIElement element1 = new DummyTextField("elem1"); 306 simulateEvent(new KeyPressed(VirtualKey.LETTER_A), element1); 307 simulateEvent(new KeyReleased(VirtualKey.LETTER_A), element1); 308 simulateEvent(new KeyPressed(VirtualKey.LETTER_B), element1); 309 simulateEvent(new KeyReleased(VirtualKey.LETTER_B), element1); 310 simulateEvent(new KeyPressed(VirtualKey.LETTER_C), element1); 311 simulateEvent(new KeyReleased(VirtualKey.LETTER_C), element1); 312 simulateEvent(new KeyPressed(VirtualKey.LETTER_D), element1); 313 simulateEvent(new KeyReleased(VirtualKey.LETTER_D), element1); 314 simulateEvent(new KeyPressed(VirtualKey.BACK_SPACE), element1); 315 simulateEvent(new KeyReleased(VirtualKey.BACK_SPACE), element1); 316 simulateEvent(new KeyPressed(VirtualKey.LETTER_E), element1); 317 simulateEvent(new KeyReleased(VirtualKey.LETTER_E), element1); 318 simulateEvent(new KeyPressed(VirtualKey.LETTER_F), element1); 319 simulateEvent(new KeyReleased(VirtualKey.LETTER_F), element1); 320 new TaskTreeChecker().assertTaskTree 321 ("Sequence sequence0 {" + 322 " TextInputEvent TextInput abcef {" + 323 " Event KeyPressed LETTER_A {}" + 324 " Event KeyReleased LETTER_A {}" + 325 " Event KeyPressed LETTER_B {}" + 326 " Event KeyReleased LETTER_B {}" + 327 " Event KeyPressed LETTER_C {}" + 328 " Event KeyReleased LETTER_C {}" + 329 " Event KeyPressed LETTER_D {}" + 330 " Event KeyReleased LETTER_D {}" + 331 " Event KeyPressed BACK_SPACE {}" + 332 " Event KeyReleased BACK_SPACE {}" + 333 " Event KeyPressed LETTER_E {}" + 334 " Event KeyReleased LETTER_E {}" + 335 " Event KeyPressed LETTER_F {}" + 336 " Event KeyReleased LETTER_F {}" + 337 " }" + 338 "}", getTaskTree()); 339 340 simulateEvent(new KeyPressed(VirtualKey.BACK_SPACE), element1); 341 simulateEvent(new KeyReleased(VirtualKey.BACK_SPACE), element1); 342 simulateEvent(new KeyPressed(VirtualKey.BACK_SPACE), element1); 343 simulateEvent(new KeyReleased(VirtualKey.BACK_SPACE), element1); 344 simulateEvent(new KeyPressed(VirtualKey.BACK_SPACE), element1); 345 simulateEvent(new KeyReleased(VirtualKey.BACK_SPACE), element1); 346 new TaskTreeChecker().assertTaskTree 347 ("Sequence sequence0 {" + 348 " TextInputEvent TextInput ab {" + 349 " Event KeyPressed LETTER_A {}" + 350 " Event KeyReleased LETTER_A {}" + 351 " Event KeyPressed LETTER_B {}" + 352 " Event KeyReleased LETTER_B {}" + 353 " Event KeyPressed LETTER_C {}" + 354 " Event KeyReleased LETTER_C {}" + 355 " Event KeyPressed LETTER_D {}" + 356 " Event KeyReleased LETTER_D {}" + 357 " Event KeyPressed BACK_SPACE {}" + 358 " Event KeyReleased BACK_SPACE {}" + 359 " Event KeyPressed LETTER_E {}" + 360 " Event KeyReleased LETTER_E {}" + 361 " Event KeyPressed LETTER_F {}" + 362 " Event KeyReleased LETTER_F {}" + 363 " Event KeyPressed BACK_SPACE {}" + 364 " Event KeyReleased BACK_SPACE {}" + 365 " Event KeyPressed BACK_SPACE {}" + 366 " Event KeyReleased BACK_SPACE {}" + 367 " Event KeyPressed BACK_SPACE {}" + 368 " Event KeyReleased BACK_SPACE {}" + 369 " }" + 370 "}", getTaskTree()); 371 372 } 373 374 /** 375 * 376 */ 377 private static class DummyTextField extends DummyGUIElement implements ITextField { 378 379 /** */ 380 private static final long serialVersionUID = 1L; 381 382 /** 383 * TODO: comment 384 * 385 * @param name 386 */ 387 public DummyTextField(String name) { 388 super(name); 389 } 390 391 } 410 392 411 393 } -
trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java
r468 r557 1 //-------------------------------------------------------------------------------------------------2 1 // Module : $RCSfile: DefaultIterationDetectionRuleTest.java,v $ 3 2 // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 28.04.2012 $ … … 5 4 // Creation : 2012 by patrick 6 5 // Copyright : Patrick Harms, 2012 7 //------------------------------------------------------------------------------------------------- 6 8 7 package de.ugoe.cs.quest.tasktrees.temporalrelation; 9 8 10 9 import org.junit.Test; 11 10 12 import de.ugoe.cs.quest.eventcore.gui model.GUIElement;13 import de.ugoe.cs.quest.eventcore.guimodel. TrackBar;14 import de.ugoe.cs.quest.eventcore. userinteraction.ValueSelection;11 import de.ugoe.cs.quest.eventcore.gui.ValueSelection; 12 import de.ugoe.cs.quest.eventcore.guimodel.IGUIElement; 13 import de.ugoe.cs.quest.eventcore.guimodel.ITrackBar; 15 14 import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; 16 15 import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; 17 16 import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; 18 17 19 //-------------------------------------------------------------------------------------------------20 18 /** 21 19 * TODO comment … … 24 22 * @author 2012, last modified by $Author: patrick$ 25 23 */ 26 //------------------------------------------------------------------------------------------------- 27 public class TrackBarSelectionDetectionRuleTest extends AbstractTemporalRelationshipTC 28 { 24 public class TrackBarSelectionDetectionRuleTest extends AbstractTemporalRelationshipTC { 29 25 30 //-----------------------------------------------------------------------------------------------31 /**32 *33 */34 //-----------------------------------------------------------------------------------------------35 @Test36 public void testSimpleDetection() throws Exception37 {38 GUIElement element1 = new DummyTrackBar();39 simulateInteraction(element1, new ValueSelection<Integer>(1));40 new TaskTreeChecker().assertTaskTree41 ("Sequence sequence1 {" +42 " Iteration interation1 {" +43 " Selection selection1 {" +44 " Interaction ValueSelection {}" +45 " }" +46 " }" +47 "}", getTaskTree());48 49 simulateInteraction(element1, new ValueSelection<Integer>(2));50 new TaskTreeChecker().assertTaskTree51 ("Sequence sequence1 {" +52 " Iteration interation1 {" +53 " Selection selection1 {" +54 " Interaction ValueSelection {}" +55 " Interaction ValueSelection {}" +56 " }" +57 " }" +58 "}", getTaskTree());59 60 simulateInteraction(element1, new ValueSelection<Integer>(3));61 new TaskTreeChecker().assertTaskTree62 ("Sequence sequence1 {" +63 " Iteration interation1 {" +64 " Selection selection1 {" +65 " Interaction ValueSelection {}" +66 " Interaction ValueSelection {}" +67 " Interaction ValueSelection {}" +68 " }" +69 " }" +70 "}", getTaskTree());71 72 simulateInteraction(element1, new ValueSelection<Integer>(2));73 new TaskTreeChecker().assertTaskTree74 ("Sequence sequence1 {" +75 " Iteration interation1 {" +76 " Selection selection1 {" +77 " Interaction ValueSelection {}" +78 " Interaction ValueSelection {}" +79 " Interaction ValueSelection {}" +80 " }" +81 " }" +82 "}", getTaskTree());83 84 simulateInteraction(element1, new ValueSelection<Integer>(3));85 new TaskTreeChecker().assertTaskTree86 ("Sequence sequence1 {" +87 " Iteration interation1 {" +88 " Selection selection1 {" +89 " Interaction ValueSelection {}" +90 " Interaction ValueSelection {}" +91 " Interaction ValueSelection {}" +92 " }" +93 " }" +94 "}", getTaskTree());95 96 }97 98 //-----------------------------------------------------------------------------------------------99 /**100 *101 */102 //-----------------------------------------------------------------------------------------------103 @Test104 public void testComplexDetection() throws Exception105 {106 GUIElement element1 = new DummyTrackBar();107 simulateInteraction(element1, new ValueSelection<Integer>(1));108 simulateInteraction(element1, new ValueSelection<Integer>(2));109 simulateInteraction(element1, new ValueSelection<Integer>(3));110 simulateInteraction(element1, new ValueSelection<Integer>(1));111 simulateInteraction(element1, new DummyInteraction("bla", 1));112 simulateInteraction(element1, new DummyInteraction("bla", 2));113 simulateInteraction(element1, new ValueSelection<Integer>(2));114 simulateInteraction(element1, new ValueSelection<Integer>(1));115 simulateInteraction(element1, new DummyInteraction("bla", 3));116 simulateInteraction(element1, new ValueSelection<Integer>(3));117 simulateInteraction(element1, new ValueSelection<Integer>(2));118 simulateInteraction(element1, new ValueSelection<Integer>(3));119 simulateInteraction(element1, new DummyInteraction("bla", 1));120 simulateInteraction(element1, new DummyInteraction("bla", 2));121 simulateInteraction(element1, new ValueSelection<Integer>(1));122 simulateInteraction(element1, new ValueSelection<Integer>(1));123 124 new TaskTreeChecker().assertTaskTree125 ("Sequence sequence1 {" +126 " Iteration interation1 {" +127 " Selection selection1 {" +128 " Interaction ValueSelection {}" +129 " Interaction ValueSelection {}" +130 " Interaction ValueSelection {}" +131 " }" +132 " }" +133 " Interaction bla {}" +134 " Interaction bla {}" +135 " Iteration interation2 {" +136 " Selection selection2 {" +137 " Interaction ValueSelection {}" +138 " Interaction ValueSelection {}" +139 " }" +140 " }" +141 " Interaction bla {}" +142 " Iteration interation3 {" +143 " Selection selection3 {" +144 " Interaction ValueSelection {}" +145 " Interaction ValueSelection {}" +146 " }" +147 " }" +148 " Interaction bla {}" +149 " Interaction bla {}" +150 " Iteration interation4 {" +151 " Selection selection4 {" +152 " Interaction ValueSelection {}" +153 " }" +154 " }" +155 "}", getTaskTree());156 }157 158 //-----------------------------------------------------------------------------------------------159 /**160 * TODO comment161 *162 * @version $Revision: $ $Date: 28.04.2012$163 * @author 2012, last modified by $Author: patrick$164 */165 //-----------------------------------------------------------------------------------------------166 public class DummyTrackBar extends DummyGUIElement implements TrackBar167 {168 169 //---------------------------------------------------------------------------------------------170 26 /** 171 27 * 172 28 */ 173 //--------------------------------------------------------------------------------------------- 174 public DummyTrackBar() 175 { 176 super("DummyTrackBar"); 29 @Test 30 public void testSimpleDetection() throws Exception { 31 IGUIElement element1 = new DummyTrackBar(); 32 simulateEvent(new ValueSelection<Integer>(1), element1); 33 new TaskTreeChecker().assertTaskTree 34 ("Sequence sequence1 {" + 35 " Iteration interation1 {" + 36 " Selection selection1 {" + 37 " Event ValueSelection {}" + 38 " }" + 39 " }" + 40 "}", getTaskTree()); 41 42 simulateEvent(new ValueSelection<Integer>(2), element1); 43 new TaskTreeChecker().assertTaskTree 44 ("Sequence sequence1 {" + 45 " Iteration interation1 {" + 46 " Selection selection1 {" + 47 " Event ValueSelection {}" + 48 " Event ValueSelection {}" + 49 " }" + 50 " }" + 51 "}", getTaskTree()); 52 53 simulateEvent(new ValueSelection<Integer>(3), element1); 54 new TaskTreeChecker().assertTaskTree 55 ("Sequence sequence1 {" + 56 " Iteration interation1 {" + 57 " Selection selection1 {" + 58 " Event ValueSelection {}" + 59 " Event ValueSelection {}" + 60 " Event ValueSelection {}" + 61 " }" + 62 " }" + 63 "}", getTaskTree()); 64 65 simulateEvent(new ValueSelection<Integer>(2), element1); 66 new TaskTreeChecker().assertTaskTree 67 ("Sequence sequence1 {" + 68 " Iteration interation1 {" + 69 " Selection selection1 {" + 70 " Event ValueSelection {}" + 71 " Event ValueSelection {}" + 72 " Event ValueSelection {}" + 73 " }" + 74 " }" + 75 "}", getTaskTree()); 76 77 simulateEvent(new ValueSelection<Integer>(3), element1); 78 new TaskTreeChecker().assertTaskTree 79 ("Sequence sequence1 {" + 80 " Iteration interation1 {" + 81 " Selection selection1 {" + 82 " Event ValueSelection {}" + 83 " Event ValueSelection {}" + 84 " Event ValueSelection {}" + 85 " }" + 86 " }" + 87 "}", getTaskTree()); 88 177 89 } 178 } 90 91 /** 92 * 93 */ 94 @Test 95 public void testComplexDetection() throws Exception { 96 IGUIElement element1 = new DummyTrackBar(); 97 simulateEvent(new ValueSelection<Integer>(1), element1); 98 simulateEvent(new ValueSelection<Integer>(2), element1); 99 simulateEvent(new ValueSelection<Integer>(3), element1); 100 simulateEvent(new ValueSelection<Integer>(1), element1); 101 simulateEvent(new DummyInteraction("bla", 1), element1); 102 simulateEvent(new DummyInteraction("bla", 2), element1); 103 simulateEvent(new ValueSelection<Integer>(2), element1); 104 simulateEvent(new ValueSelection<Integer>(1), element1); 105 simulateEvent(new DummyInteraction("bla", 3), element1); 106 simulateEvent(new ValueSelection<Integer>(3), element1); 107 simulateEvent(new ValueSelection<Integer>(2), element1); 108 simulateEvent(new ValueSelection<Integer>(3), element1); 109 simulateEvent(new DummyInteraction("bla", 1), element1); 110 simulateEvent(new DummyInteraction("bla", 2), element1); 111 simulateEvent(new ValueSelection<Integer>(1), element1); 112 simulateEvent(new ValueSelection<Integer>(1), element1); 113 114 new TaskTreeChecker().assertTaskTree 115 ("Sequence sequence1 {" + 116 " Iteration interation1 {" + 117 " Selection selection1 {" + 118 " Event ValueSelection {}" + 119 " Event ValueSelection {}" + 120 " Event ValueSelection {}" + 121 " }" + 122 " }" + 123 " Event bla {}" + 124 " Event bla {}" + 125 " Iteration interation2 {" + 126 " Selection selection2 {" + 127 " Event ValueSelection {}" + 128 " Event ValueSelection {}" + 129 " }" + 130 " }" + 131 " Event bla {}" + 132 " Iteration interation3 {" + 133 " Selection selection3 {" + 134 " Event ValueSelection {}" + 135 " Event ValueSelection {}" + 136 " }" + 137 " }" + 138 " Event bla {}" + 139 " Event bla {}" + 140 " Iteration interation4 {" + 141 " Selection selection4 {" + 142 " Event ValueSelection {}" + 143 " }" + 144 " }" + 145 "}", getTaskTree()); 146 } 147 148 /** 149 * TODO comment 150 * 151 * @version $Revision: $ $Date: 28.04.2012$ 152 * @author 2012, last modified by $Author: patrick$ 153 */ 154 public class DummyTrackBar extends DummyGUIElement implements ITrackBar { 155 156 /** */ 157 private static final long serialVersionUID = 1L; 158 159 /** 160 * 161 */ 162 public DummyTrackBar() { 163 super("DummyTrackBar"); 164 } 165 } 179 166 180 167 }
Note: See TracChangeset
for help on using the changeset viewer.