Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/manager/TaskTreeManagerTest.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/manager/TaskTreeManagerTest.java (revision 553) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/manager/TaskTreeManagerTest.java (revision 557) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: TaskTreeManagerTest.java,v $ // Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 08.11.2011 21:32:36 $ @@ -5,5 +4,4 @@ // Creation : 2011 by Patrick // Copyright : Patrick Harms, 2011 -//------------------------------------------------------------------------------------------------- package de.ugoe.cs.quest.tasktrees.manager; @@ -15,7 +13,7 @@ import org.junit.Test; -import de.ugoe.cs.quest.eventcore.guimodel.GUIElement; -import de.ugoe.cs.quest.eventcore.userinteraction.Interaction; -import de.ugoe.cs.quest.eventcore.userinteraction.InteractionEvent; +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.eventcore.IEventTarget; +import de.ugoe.cs.quest.eventcore.IEventType; import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; @@ -23,554 +21,456 @@ import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; -//------------------------------------------------------------------------------------------------- /** * TODO comment - * + * * @version $Revision: $ $Date: $ - * @author 2011, last modified by $Author: $ + * @author 2011, last modified by $Author: $ */ -//------------------------------------------------------------------------------------------------- - -public class TaskTreeManagerTest -{ - /** */ - TaskTreeManager mManager; - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Before - public void setUp() - { - Logger.getLogger("").getHandlers()[0].setFormatter(new SimpleLogFormatter()); +public class TaskTreeManagerTest { - mManager = new TaskTreeManager(); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @After - public void tearDown() - { - mManager = null; - ComponentManager.clearInstance(); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testOneInteractionOnOneElement() - { - simulateInteraction(new DummyGUIElement("elem1"), new DummyInteraction("bla", 1)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence {" + - " Interaction bla {}" + - "}", mManager.getTaskTree()); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testManyInteractionsOnOneElement() - { - GUIElement element = new DummyGUIElement("elem1"); - simulateInteraction(element, new DummyInteraction("bla", 1)); - simulateInteraction(element, new DummyInteraction("bli", 1)); - simulateInteraction(element, new DummyInteraction("blo", 1)); - simulateInteraction(element, new DummyInteraction("blu", 1)); - simulateInteraction(element, new DummyInteraction("bla", 1)); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blo {}" + - " Interaction blu {}" + - " Interaction bla {}" + - "}", mManager.getTaskTree()); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testOneInteractionOnManyElements() - { - GUIElement element1 = new DummyGUIElement("elem1"); - GUIElement element2 = new DummyGUIElement("elem2"); - GUIElement element3 = new DummyGUIElement("elem3"); - GUIElement element4 = new DummyGUIElement("elem4"); - GUIElement element5 = new DummyGUIElement("elem5"); - GUIElement element6 = new DummyGUIElement("elem6"); - simulateInteraction(element1, new DummyInteraction("bla", 1)); - simulateInteraction(element2, new DummyInteraction("bli", 1)); - simulateInteraction(element3, new DummyInteraction("bla", 1)); - simulateInteraction(element4, new DummyInteraction("bli", 1)); - simulateInteraction(element5, new DummyInteraction("blo", 1)); - simulateInteraction(element6, new DummyInteraction("bla", 1)); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Interaction bla {}" + - " }" + - " Sequence sequence2 {" + - " Interaction bli {}" + - " }" + - " Sequence sequence3 {" + - " Interaction bla {}" + - " }" + - " Sequence sequence4 {" + - " Interaction bli {}" + - " }" + - " Sequence sequence5 {" + - " Interaction blo {}" + - " }" + - " Sequence sequence6 {" + - " Interaction bla {}" + - " }" + - "}", mManager.getTaskTree()); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testManyInteractionsOnManyElements() - { - GUIElement element1 = new DummyGUIElement("elem1"); - GUIElement element2 = new DummyGUIElement("elem2"); - GUIElement element3 = new DummyGUIElement("elem3"); - GUIElement element4 = new DummyGUIElement("elem4"); - GUIElement element5 = new DummyGUIElement("elem5"); - GUIElement element6 = new DummyGUIElement("elem6"); - simulateInteraction(element1, new DummyInteraction("bla", 1)); - simulateInteraction(element1, new DummyInteraction("bli", 1)); - simulateInteraction(element1, new DummyInteraction("bla", 1)); - simulateInteraction(element2, new DummyInteraction("bli", 1)); - simulateInteraction(element2, new DummyInteraction("blo", 1)); - simulateInteraction(element3, new DummyInteraction("bla", 1)); - simulateInteraction(element4, new DummyInteraction("bli", 1)); - simulateInteraction(element4, new DummyInteraction("bla", 1)); - simulateInteraction(element4, new DummyInteraction("bli", 1)); - simulateInteraction(element4, new DummyInteraction("blo", 1)); - simulateInteraction(element5, new DummyInteraction("bla", 1)); - simulateInteraction(element6, new DummyInteraction("bli", 1)); - simulateInteraction(element6, new DummyInteraction("bla", 1)); - simulateInteraction(element6, new DummyInteraction("bli", 1)); - simulateInteraction(element6, new DummyInteraction("blo", 1)); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction bla {}" + - " }" + - " Sequence sequence2 {" + - " Interaction bli {}" + - " Interaction blo {}" + - " }" + - " Sequence sequence3 {" + - " Interaction bla {}" + - " }" + - " Sequence sequence4 {" + - " Interaction bli {}" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blo {}" + - " }" + - " Sequence sequence5 {" + - " Interaction bla {}" + - " }" + - " Sequence sequence6 {" + - " Interaction bli {}" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blo {}" + - " }" + - "}", mManager.getTaskTree()); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testInteractionIterationDetection() throws Exception - { - GUIElement element1 = new DummyGUIElement("elem1"); - Interaction interaction1 = new DummyInteraction("bla", 1); - simulateInteraction(element1, interaction1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Interaction bla {}" + - "}", mManager.getTaskTree()); - - simulateInteraction(element1, interaction1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Interaction bla {}" + - " }" + - "}", mManager.getTaskTree()); - - simulateInteraction(element1, interaction1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Interaction bla {}" + - " }" + - "}", mManager.getTaskTree()); - - for (int i = 0; i < 10; i++) - { - simulateInteraction(element1, interaction1); - } - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Interaction bla {}" + - " }" + - "}", mManager.getTaskTree()); - - // now test with preceding and trailing other interactions - Interaction interaction2 = new DummyInteraction("bli", 1); - Interaction interaction3 = new DummyInteraction("blup", 1); - - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - for (int i = 0; i < 10; i++) - { - simulateInteraction(element1, interaction1); - } - simulateInteraction(element1, interaction3); - simulateInteraction(element1, interaction2); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Interaction bla {}" + - " }" + - " Interaction bli {}" + - " Interaction blup {}" + - " Iteration iteration2 {" + - " Interaction bla {}" + - " }" + - " Interaction blup {}" + - " Interaction bli {}" + - "}", mManager.getTaskTree()); - - // now test with iterations of iterations - - for (int i = 0; i < 10; i++) - { - for (int j = 0; j < 5; j++) - { - simulateInteraction(element1, interaction1); - } - for (int j = 0; j < 5; j++) - { - simulateInteraction(element1, interaction2); - } - for (int j = 0; j < 5; j++) - { - simulateInteraction(element1, interaction3); - } - } - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Iteration iteration0 {" + - " Interaction bla {}" + - " }" + - " Interaction bli {}" + - " Interaction blup {}" + - " Iteration iteration1 {" + - " Interaction bla {}" + - " }" + - " Interaction blup {}" + - " Interaction bli {}" + - " Iteration iteration2 {" + - " Sequence sequence1 {" + - " Iteration iteration3 {" + - " Interaction bla {}" + - " }" + - " Iteration iteration4 {" + - " Interaction bli {}" + - " }" + - " Iteration iteration5 {" + - " Interaction blup {}" + - " }" + - " }" + - " }" + - "}", mManager.getTaskTree()); - - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testSequenceIterationDetection() throws Exception - { - GUIElement element1 = new DummyGUIElement("elem1"); - Interaction interaction1 = new DummyInteraction("bla", 1); - Interaction interaction2 = new DummyInteraction("bli", 1); - Interaction interaction3 = new DummyInteraction("blup", 1); - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - "}", mManager.getTaskTree()); - - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - "}", mManager.getTaskTree()); - - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - "}", mManager.getTaskTree()); - - for (int i = 0; i < 10; i++) - { - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - } - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - "}", mManager.getTaskTree()); - - // now test with preceding and trailing other interactions - Interaction interaction4 = new DummyInteraction("ble", 1); - Interaction interaction5 = new DummyInteraction("blo", 1); - Interaction interaction6 = new DummyInteraction("blu", 1); - simulateInteraction(element1, interaction4); - simulateInteraction(element1, interaction5); - simulateInteraction(element1, interaction6); - for (int i = 0; i < 10; i++) - { - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - } - simulateInteraction(element1, interaction6); - simulateInteraction(element1, interaction5); - simulateInteraction(element1, interaction4); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - " Interaction ble {}" + - " Interaction blo {}" + - " Interaction blu {}" + - " Iteration iteration2 {" + - " Sequence sequence3 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - " Interaction blu {}" + - " Interaction blo {}" + - " Interaction ble {}" + - "}", mManager.getTaskTree()); - - // now test with iterations of iterations - for (int i = 0; i < 10; i++) - { - for (int j = 0; j < 5; j++) - { - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - } - for (int j = 0; j < 5; j++) - { - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction3); - } - for (int j = 0; j < 5; j++) - { - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - } - } - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - " Interaction ble {}" + - " Interaction blo {}" + - " Interaction blu {}" + - " Iteration iteration2 {" + - " Sequence sequence3 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - " Interaction blu {}" + - " Interaction blo {}" + - " Interaction ble {}" + - " Iteration iteration3 {" + - " Sequence sequence4 {" + - " Iteration iteration4 {" + - " Sequence sequence4 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - " Iteration iteration5 {" + - " Sequence sequence5 {" + - " Interaction bli {}" + - " Interaction bla {}" + - " Interaction blup {}" + - " }" + - " }" + - " Iteration iteration6 {" + - " Sequence sequence6 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - " }" + - " }" + - "}", mManager.getTaskTree()); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testGUIElementHierarchyChanges() throws Exception - { - GUIElement element1 = new DummyGUIElement("elem1"); - GUIElement element2 = new DummyGUIElement("elem2"); - GUIElement element3 = new DummyGUIElement("elem3"); - GUIElement parent1 = new DummyGUIElement("parent1"); - GUIElement parent2 = new DummyGUIElement("parent2"); - GUIElement parent3 = new DummyGUIElement("parent3"); - - element1.setParent(parent1); - element2.setParent(parent2); - element3.setParent(parent3); - - parent1.setParent(parent2); - parent2.setParent(parent3); - - Interaction interaction1 = new DummyInteraction("bla", 1); - simulateInteraction(element1, interaction1); - simulateInteraction(element2, interaction1); - simulateInteraction(element3, interaction1); - simulateInteraction(element2, interaction1); - simulateInteraction(element3, interaction1); - simulateInteraction(element2, interaction1); - simulateInteraction(element1, interaction1); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Interaction bla {}" + - " }" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " }" + - " Iteration iteration0 {" + - " Sequence sequence3 {" + - " Sequence sequence4 {" + - " Interaction bla {}" + - " }" + - " Sequence sequence5 {" + - " Interaction bla {}" + - " }" + - " }" + - " }" + - " Sequence sequence6 {" + - " Interaction bla {}" + - " }" + - "}", mManager.getTaskTree()); - - } - - //----------------------------------------------------------------------------------------------- - /** - * @param interactionsDoNotOverwriteElement - */ - //----------------------------------------------------------------------------------------------- - private void simulateInteraction(GUIElement GUIElement, Interaction interaction) - { - mManager.handleNewInteractionEvent(new InteractionEvent(GUIElement, interaction)); - } + /** */ + TaskTreeManager manager; + + /** + * + */ + @Before + public void setUp() { + Logger.getLogger("").getHandlers()[0].setFormatter(new SimpleLogFormatter()); + + manager = new TaskTreeManager(); + } + + /** + * + */ + @After + public void tearDown() { + manager = null; + ComponentManager.clearInstance(); + } + + /** + * + */ + @Test + public void testOneEventOnOneElement() { + simulateEvent(new DummyInteraction("bla", 1), new DummyGUIElement("elem1")); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence {" + + " Event bla {}" + + "}", manager.getTaskTree()); + } + + /** + * + */ + @Test + public void testManyEventsOnOneElement() { + IEventTarget eventTarget = new DummyGUIElement("elem1"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget); + simulateEvent(new DummyInteraction("bli", 1), eventTarget); + simulateEvent(new DummyInteraction("blo", 1), eventTarget); + simulateEvent(new DummyInteraction("blu", 1), eventTarget); + simulateEvent(new DummyInteraction("bla", 1), eventTarget); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence {" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " Event blu {}" + + " Event bla {}" + + "}", manager.getTaskTree()); + } + + /** + * + */ + @Test + public void testOneEventOnManyElements() { + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + IEventTarget eventTarget3 = new DummyGUIElement("elem3"); + IEventTarget eventTarget4 = new DummyGUIElement("elem4"); + IEventTarget eventTarget5 = new DummyGUIElement("elem5"); + IEventTarget eventTarget6 = new DummyGUIElement("elem6"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget1); + simulateEvent(new DummyInteraction("bli", 1), eventTarget2); + simulateEvent(new DummyInteraction("bla", 1), eventTarget3); + simulateEvent(new DummyInteraction("bli", 1), eventTarget4); + simulateEvent(new DummyInteraction("blo", 1), eventTarget5); + simulateEvent(new DummyInteraction("bla", 1), eventTarget6); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event bla {}" + + " }" + + " Sequence sequence2 {" + + " Event bli {}" + + " }" + + " Sequence sequence3 {" + + " Event bla {}" + + " }" + + " Sequence sequence4 {" + + " Event bli {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " }" + + " Sequence sequence6 {" + + " Event bla {}" + + " }" + + "}", manager.getTaskTree()); + } + + /** + * + */ + @Test + public void testManyEventsOnManyElements() { + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + IEventTarget eventTarget3 = new DummyGUIElement("elem3"); + IEventTarget eventTarget4 = new DummyGUIElement("elem4"); + IEventTarget eventTarget5 = new DummyGUIElement("elem5"); + IEventTarget eventTarget6 = new DummyGUIElement("elem6"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget1); + simulateEvent(new DummyInteraction("bli", 1), eventTarget1); + simulateEvent(new DummyInteraction("bla", 1), eventTarget1); + simulateEvent(new DummyInteraction("bli", 1), eventTarget2); + simulateEvent(new DummyInteraction("blo", 1), eventTarget2); + simulateEvent(new DummyInteraction("bla", 1), eventTarget3); + simulateEvent(new DummyInteraction("bli", 1), eventTarget4); + simulateEvent(new DummyInteraction("bla", 1), eventTarget4); + simulateEvent(new DummyInteraction("bli", 1), eventTarget4); + simulateEvent(new DummyInteraction("blo", 1), eventTarget4); + simulateEvent(new DummyInteraction("bla", 1), eventTarget5); + simulateEvent(new DummyInteraction("bli", 1), eventTarget6); + simulateEvent(new DummyInteraction("bla", 1), eventTarget6); + simulateEvent(new DummyInteraction("bli", 1), eventTarget6); + simulateEvent(new DummyInteraction("blo", 1), eventTarget6); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event bla {}" + + " Event bli {}" + + " Event bla {}" + + " }" + + " Sequence sequence2 {" + + " Event bli {}" + + " Event blo {}" + + " }" + + " Sequence sequence3 {" + + " Event bla {}" + + " }" + + " Sequence sequence4 {" + + " Event bli {}" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " }" + + " Sequence sequence5 {" + + " Event bla {}" + + " }" + + " Sequence sequence6 {" + + " Event bli {}" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " }" + + "}", manager.getTaskTree()); + } + + /** + * + */ + @Test + public void testEventIterationDetection() throws Exception { + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + IEventType event1 = new DummyInteraction("bla", 1); + simulateEvent(event1, eventTarget1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Event bla {}" + + "}", manager.getTaskTree()); + + simulateEvent(event1, eventTarget1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", manager.getTaskTree()); + + simulateEvent(event1, eventTarget1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", manager.getTaskTree()); + + for (int i = 0; i < 10; i++) { + simulateEvent(event1, eventTarget1); + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", manager.getTaskTree()); + + // now test with preceding and trailing other interactions + IEventType event2 = new DummyInteraction("bli", 1); + IEventType event3 = new DummyInteraction("blup", 1); + + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + for (int i = 0; i < 10; i++) { + simulateEvent(event1, eventTarget1); + } + simulateEvent(event3, eventTarget1); + simulateEvent(event2, eventTarget1); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + " Event bli {}" + + " Event blup {}" + + " Iteration iteration2 {" + + " Event bla {}" + + " }" + + " Event blup {}" + + " Event bli {}" + + "}", manager.getTaskTree()); + + // now test with iterations of iterations + + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 5; j++) { + simulateEvent(event1, eventTarget1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event2, eventTarget1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event3, eventTarget1); + } + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Iteration iteration0 {" + + " Event bla {}" + + " }" + + " Event bli {}" + + " Event blup {}" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + " Event blup {}" + + " Event bli {}" + + " Iteration iteration2 {" + + " Sequence sequence1 {" + + " Iteration iteration3 {" + + " Event bla {}" + + " }" + + " Iteration iteration4 {" + + " Event bli {}" + + " }" + + " Iteration iteration5 {" + + " Event blup {}" + + " }" + + " }" + + " }" + + "}", manager.getTaskTree()); + + } + + /** + * + */ + @Test + public void testSequenceIterationDetection() throws Exception { + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + IEventType event1 = new DummyInteraction("bla", 1); + IEventType event2 = new DummyInteraction("bli", 1); + IEventType event3 = new DummyInteraction("blup", 1); + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + "}", manager.getTaskTree()); + + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", manager.getTaskTree()); + + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", manager.getTaskTree()); + + for (int i = 0; i < 10; i++) { + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", manager.getTaskTree()); + + // now test with preceding and trailing other interactions + IEventType event4 = new DummyInteraction("ble", 1); + IEventType event5 = new DummyInteraction("blo", 1); + IEventType event6 = new DummyInteraction("blu", 1); + simulateEvent(event4, eventTarget1); + simulateEvent(event5, eventTarget1); + simulateEvent(event6, eventTarget1); + for (int i = 0; i < 10; i++) { + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + } + simulateEvent(event6, eventTarget1); + simulateEvent(event5, eventTarget1); + simulateEvent(event4, eventTarget1); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event ble {}" + + " Event blo {}" + + " Event blu {}" + + " Iteration iteration2 {" + + " Sequence sequence3 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event blu {}" + + " Event blo {}" + + " Event ble {}" + + "}", manager.getTaskTree()); + + // now test with iterations of iterations + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 5; j++) { + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event2, eventTarget1); + simulateEvent(event1, eventTarget1); + simulateEvent(event3, eventTarget1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + } + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event ble {}" + + " Event blo {}" + + " Event blu {}" + + " Iteration iteration2 {" + + " Sequence sequence3 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event blu {}" + + " Event blo {}" + + " Event ble {}" + + " Iteration iteration3 {" + + " Sequence sequence4 {" + + " Iteration iteration4 {" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Iteration iteration5 {" + + " Sequence sequence5 {" + + " Event bli {}" + + " Event bla {}" + + " Event blup {}" + + " }" + + " }" + + " Iteration iteration6 {" + + " Sequence sequence6 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " }" + + " }" + + "}", manager.getTaskTree()); + } + + /** + * + */ + private void simulateEvent(IEventType eventType, IEventTarget eventTarget) { + manager.handleNewEvent(new Event(eventType, eventTarget)); + } } Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityTest.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityTest.java (revision 557) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityTest.java (revision 557) @@ -0,0 +1,57 @@ +// Module : $RCSfile: NodeEqualityTest.java,v $ +// Version : $Revision: 0.0 $ $Author: pharms $ $Date: 15.08.2012 $ +// Project : quest-core-tasktrees-test +// Creation : 2012 by pharms +// Copyright : Patrick Harms, 2012 +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 15.08.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +public class NodeEqualityTest { + + /** + * TODO: comment + * + */ + @Test + public void test() { + assertTrue(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.IDENTICAL)); + assertTrue(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); + assertTrue(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); + assertTrue(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); + assertFalse(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.UNEQUAL)); + + assertFalse(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.IDENTICAL)); + assertTrue(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); + assertTrue(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); + assertTrue(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); + assertFalse(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.UNEQUAL)); + + assertFalse(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.IDENTICAL)); + assertFalse(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); + assertTrue(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); + assertTrue(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); + assertFalse(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.UNEQUAL)); + + assertFalse(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.IDENTICAL)); + assertFalse(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); + assertFalse(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); + assertTrue(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); + assertFalse(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.UNEQUAL)); + + assertFalse(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.IDENTICAL)); + assertFalse(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); + assertFalse(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); + assertFalse(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); + assertTrue(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.UNEQUAL)); + } + +} Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/SequenceComparisonRuleTest.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/SequenceComparisonRuleTest.java (revision 557) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/SequenceComparisonRuleTest.java (revision 557) @@ -0,0 +1,87 @@ +// Module : $RCSfile: SequenceComparisonRuleTest.java,v $ +// Version : $Revision: 0.0 $ $Author: pharms $ $Date: 16.08.2012 $ +// Project : quest-core-tasktrees-test +// Creation : 2012 by pharms +// Copyright : Patrick Harms, 2012 +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNode; + +/** + *

+ * TODO comment + *

+ * + * @version $Revision: $ $Date: 16.08.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +public class SequenceComparisonRuleTest { + + /** + *

+ * TODO: comment + *

+ * + */ + @Test + public void test() { + NodeEqualityRuleManager manager = new NodeEqualityRuleManager(); + manager.init(); + + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + ITaskTreeBuilder treeBuilder = new TaskTreeBuilder(); + + SequenceComparisonRule rule = new SequenceComparisonRule(manager); + + ITaskTreeNode task1 = new TaskTreeNode("task1"); + ITaskTreeNode task2 = new TaskTreeNode("task2"); + + assertNull(rule.compare(task1, task2)); + + ISequence sequence1 = treeNodeFactory.createNewSequence(); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence1)); + + ISequence sequence2 = treeNodeFactory.createNewSequence(); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1)); + + treeBuilder.addChild(sequence1, task1); + + assertNull(rule.compare(sequence1, sequence2)); + assertNull(rule.compare(sequence2, sequence1)); + + treeBuilder.addChild(sequence2, task1); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1)); + + treeBuilder.addChild(sequence1, task2); + + assertNull(rule.compare(sequence1, sequence2)); + assertNull(rule.compare(sequence2, sequence1)); + + treeBuilder.addChild(sequence2, task2); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1)); + + ISequence sequence3 = treeNodeFactory.createNewSequence(); + treeBuilder.addChild(sequence3, task2); + treeBuilder.addChild(sequence3, task1); + + assertNull(rule.compare(sequence1, sequence3)); + assertNull(rule.compare(sequence3, sequence1)); + } + +} Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java (revision 553) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java (revision 557) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: AbstractTemporalRelationshipTC.java,v $ // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 28.04.2012 $ @@ -5,5 +4,5 @@ // Creation : 2012 by patrick // Copyright : Patrick Harms, 2012 -//------------------------------------------------------------------------------------------------- + package de.ugoe.cs.quest.tasktrees.temporalrelation; @@ -14,18 +13,17 @@ import org.junit.Before; -import de.ugoe.cs.quest.eventcore.guimodel.GUIElement; -import de.ugoe.cs.quest.eventcore.userinteraction.Interaction; +import de.ugoe.cs.quest.eventcore.IEventTarget; +import de.ugoe.cs.quest.eventcore.IEventType; import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; import de.ugoe.cs.quest.tasktrees.testutils.SimpleLogFormatter; import de.ugoe.cs.quest.tasktrees.testutils.Utilities; -import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; -import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; -import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; -import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; -import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; -import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilderImpl; -import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactoryImpl; +import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; -//------------------------------------------------------------------------------------------------- /** * TODO comment @@ -34,67 +32,54 @@ * @author 2012, last modified by $Author: patrick$ */ -//------------------------------------------------------------------------------------------------- -public class AbstractTemporalRelationshipTC -{ +public class AbstractTemporalRelationshipTC { - /** */ - private List mInteractions; - - /** */ - private TaskTreeBuilder mTaskTreeBuilder = new TaskTreeBuilderImpl(); + /** */ + private List events; - /** */ - private TaskTreeNodeFactory mTaskTreeNodeFactory = new TaskTreeNodeFactoryImpl(); - - /** */ - private NodeEqualityRuleManager mNodeEqualityRuleManager = - Utilities.getNodeEqualityRuleManagerForTests(); + /** */ + private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder(); - //----------------------------------------------------------------------------------------------- - /** + /** */ + private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory(); + + /** */ + private NodeEqualityRuleManager nodeEqualityRuleManager = + Utilities.getNodeEqualityRuleManagerForTests(); + + /** * */ - //----------------------------------------------------------------------------------------------- - @Before - public void setUp() - { - Logger.getLogger("").getHandlers()[0].setFormatter(new SimpleLogFormatter()); - mInteractions = new ArrayList(); - } + @Before + public void setUp() { + Logger.getLogger("").getHandlers()[0].setFormatter(new SimpleLogFormatter()); + events = new ArrayList(); + } - //----------------------------------------------------------------------------------------------- - /** - * @param interactionsDoNotOverwriteElement - */ - //----------------------------------------------------------------------------------------------- - protected void simulateInteraction(GUIElement GUIElement, Interaction interaction) - { - mInteractions.add - (mTaskTreeNodeFactory.createNewInteractionTask(GUIElement, interaction)); - } + /** + * + */ + protected void simulateEvent(IEventType eventType, IEventTarget eventTarget) { + events.add(taskTreeNodeFactory.createNewEventTask(eventType, eventTarget)); + } - //----------------------------------------------------------------------------------------------- - /** - * @param interactionsDoNotOverwriteElement - * @return - */ - //----------------------------------------------------------------------------------------------- - protected TaskTree getTaskTree() - { - Sequence sequence = mTaskTreeNodeFactory.createNewSequence(); - - for (InteractionTask task : mInteractions) - { - mTaskTreeBuilder.addChild(sequence, task); + /** + * + * @return + */ + protected ITaskTree getTaskTree() { + ISequence sequence = taskTreeNodeFactory.createNewSequence(); + + for (IEventTask task : events) { + taskTreeBuilder.addChild(sequence, task); + } + + TemporalRelationshipRuleManager ruleManager = + new TemporalRelationshipRuleManager(nodeEqualityRuleManager); + + ruleManager.init(); + ruleManager.applyRules(sequence, taskTreeBuilder, taskTreeNodeFactory, true); + + return taskTreeNodeFactory.createTaskTree(sequence); } - - TemporalRelationshipRuleManager ruleManager = - new TemporalRelationshipRuleManager(mNodeEqualityRuleManager); - - ruleManager.init(); - ruleManager.applyRules(sequence, mTaskTreeBuilder, mTaskTreeNodeFactory, true); - - return mTaskTreeNodeFactory.createTaskTree(sequence); - } } Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGUIElementSequenceDetectionRuleTest.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGUIElementSequenceDetectionRuleTest.java (revision 553) +++ (revision ) @@ -1,232 +1,0 @@ -//------------------------------------------------------------------------------------------------- -// Module : $RCSfile: TaskTreeManagerTest.java,v $ -// Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 08.11.2011 21:32:36 $ -// Project : TaskTreePerformanceTest -// Creation : 2011 by Patrick -// Copyright : Patrick Harms, 2011 -//------------------------------------------------------------------------------------------------- - -package de.ugoe.cs.quest.tasktrees.temporalrelation; - -import org.junit.Test; - -import de.ugoe.cs.quest.eventcore.guimodel.GUIElement; -import de.ugoe.cs.quest.eventcore.userinteraction.Interaction; -import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; -import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; -import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; - -//------------------------------------------------------------------------------------------------- -/** - * TODO comment - * - * @version $Revision: $ $Date: $ - * @author 2011, last modified by $Author: $ - */ -//------------------------------------------------------------------------------------------------- -public class DefaultGUIElementSequenceDetectionRuleTest extends AbstractTemporalRelationshipTC -{ - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testOneInteractionOnOneElement() - { - simulateInteraction(new DummyGUIElement("elem1"), new DummyInteraction("bla", 1)); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence {" + - " Interaction bla {}" + - "}", getTaskTree()); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testManyInteractionsOnOneElement() - { - GUIElement element = new DummyGUIElement("elem1"); - simulateInteraction(element, new DummyInteraction("bla", 1)); - simulateInteraction(element, new DummyInteraction("bli", 1)); - simulateInteraction(element, new DummyInteraction("blo", 1)); - simulateInteraction(element, new DummyInteraction("blu", 1)); - simulateInteraction(element, new DummyInteraction("bla", 1)); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blo {}" + - " Interaction blu {}" + - " Interaction bla {}" + - "}", getTaskTree()); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testOneInteractionOnManyElements() - { - GUIElement element1 = new DummyGUIElement("elem1"); - GUIElement element2 = new DummyGUIElement("elem2"); - GUIElement element3 = new DummyGUIElement("elem3"); - GUIElement element4 = new DummyGUIElement("elem4"); - GUIElement element5 = new DummyGUIElement("elem5"); - GUIElement element6 = new DummyGUIElement("elem6"); - simulateInteraction(element1, new DummyInteraction("bla", 1)); - simulateInteraction(element2, new DummyInteraction("bli", 1)); - simulateInteraction(element3, new DummyInteraction("bla", 1)); - simulateInteraction(element4, new DummyInteraction("bli", 1)); - simulateInteraction(element5, new DummyInteraction("blo", 1)); - simulateInteraction(element6, new DummyInteraction("bla", 1)); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Interaction bla {}" + - " }" + - " Sequence sequence2 {" + - " Interaction bli {}" + - " }" + - " Sequence sequence3 {" + - " Interaction bla {}" + - " }" + - " Sequence sequence4 {" + - " Interaction bli {}" + - " }" + - " Sequence sequence5 {" + - " Interaction blo {}" + - " }" + - " Sequence sequence6 {" + - " Interaction bla {}" + - " }" + - "}", getTaskTree()); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testManyInteractionsOnManyElements() - { - GUIElement element1 = new DummyGUIElement("elem1"); - GUIElement element2 = new DummyGUIElement("elem2"); - GUIElement element3 = new DummyGUIElement("elem3"); - GUIElement element4 = new DummyGUIElement("elem4"); - GUIElement element5 = new DummyGUIElement("elem5"); - GUIElement element6 = new DummyGUIElement("elem6"); - simulateInteraction(element1, new DummyInteraction("bla", 1)); - simulateInteraction(element1, new DummyInteraction("bli", 1)); - simulateInteraction(element1, new DummyInteraction("bla", 1)); - simulateInteraction(element2, new DummyInteraction("bli", 1)); - simulateInteraction(element2, new DummyInteraction("blo", 1)); - simulateInteraction(element3, new DummyInteraction("bla", 1)); - simulateInteraction(element4, new DummyInteraction("bli", 1)); - simulateInteraction(element4, new DummyInteraction("bla", 1)); - simulateInteraction(element4, new DummyInteraction("bli", 1)); - simulateInteraction(element4, new DummyInteraction("blo", 1)); - simulateInteraction(element5, new DummyInteraction("bla", 1)); - simulateInteraction(element6, new DummyInteraction("bli", 1)); - simulateInteraction(element6, new DummyInteraction("bla", 1)); - simulateInteraction(element6, new DummyInteraction("bli", 1)); - simulateInteraction(element6, new DummyInteraction("blo", 1)); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction bla {}" + - " }" + - " Sequence sequence2 {" + - " Interaction bli {}" + - " Interaction blo {}" + - " }" + - " Sequence sequence3 {" + - " Interaction bla {}" + - " }" + - " Sequence sequence4 {" + - " Interaction bli {}" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blo {}" + - " }" + - " Sequence sequence5 {" + - " Interaction bla {}" + - " }" + - " Sequence sequence6 {" + - " Interaction bli {}" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blo {}" + - " }" + - "}", getTaskTree()); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testGUIElementHierarchyChanges() throws Exception - { - GUIElement element1 = new DummyGUIElement("elem1"); - GUIElement element2 = new DummyGUIElement("elem2"); - GUIElement element3 = new DummyGUIElement("elem3"); - GUIElement parent1 = new DummyGUIElement("parent1"); - GUIElement parent2 = new DummyGUIElement("parent2"); - GUIElement parent3 = new DummyGUIElement("parent3"); - - element1.setParent(parent1); - element2.setParent(parent2); - element3.setParent(parent3); - - parent1.setParent(parent2); - parent2.setParent(parent3); - - Interaction interaction1 = new DummyInteraction("bla", 1); - simulateInteraction(element1, interaction1); - simulateInteraction(element2, interaction1); - simulateInteraction(element3, interaction1); - simulateInteraction(element2, interaction1); - simulateInteraction(element3, interaction1); - simulateInteraction(element2, interaction1); - simulateInteraction(element1, interaction1); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Interaction bla {}" + - " }" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " }" + - " Iteration iteration0 {" + - " Sequence sequence3 {" + - " Sequence sequence4 {" + - " Interaction bla {}" + - " }" + - " Sequence sequence5 {" + - " Interaction bla {}" + - " }" + - " }" + - " }" + - " Sequence sequence6 {" + - " Interaction bla {}" + - " }" + - "}", getTaskTree()); - - } - -} Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRuleTest.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRuleTest.java (revision 557) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRuleTest.java (revision 557) @@ -0,0 +1,159 @@ +// Module : $RCSfile: TaskTreeManagerTest.java,v $ +// Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 08.11.2011 21:32:36 $ +// Project : TaskTreePerformanceTest +// Creation : 2011 by Patrick +// Copyright : Patrick Harms, 2011 + +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import org.junit.Test; + +import de.ugoe.cs.quest.eventcore.IEventTarget; +import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; +import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; +import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; + +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +public class DefaultGuiEventSequenceDetectionRuleTest extends AbstractTemporalRelationshipTC { + + /** + * + */ + @Test + public void testOneInteractionOnOneElement() { + simulateEvent(new DummyInteraction("bla", 1), new DummyGUIElement("elem1")); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence {" + + " Event bla {}" + + "}", getTaskTree()); + } + + /** + * + */ + @Test + public void testManyInteractionsOnOneElement() { + IEventTarget eventTarget = new DummyGUIElement("elem1"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget); + simulateEvent(new DummyInteraction("bli", 1), eventTarget); + simulateEvent(new DummyInteraction("blo", 1), eventTarget); + simulateEvent(new DummyInteraction("blu", 1), eventTarget); + simulateEvent(new DummyInteraction("bla", 1), eventTarget); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence {" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " Event blu {}" + + " Event bla {}" + + "}", getTaskTree()); + } + + /** + * + */ + @Test + public void testOneInteractionOnManyElements() { + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + IEventTarget eventTarget3 = new DummyGUIElement("elem3"); + IEventTarget eventTarget4 = new DummyGUIElement("elem4"); + IEventTarget eventTarget5 = new DummyGUIElement("elem5"); + IEventTarget eventTarget6 = new DummyGUIElement("elem6"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget1); + simulateEvent(new DummyInteraction("bli", 1), eventTarget2); + simulateEvent(new DummyInteraction("bla", 1), eventTarget3); + simulateEvent(new DummyInteraction("bli", 1), eventTarget4); + simulateEvent(new DummyInteraction("blo", 1), eventTarget5); + simulateEvent(new DummyInteraction("bla", 1), eventTarget6); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event bla {}" + + " }" + + " Sequence sequence2 {" + + " Event bli {}" + + " }" + + " Sequence sequence3 {" + + " Event bla {}" + + " }" + + " Sequence sequence4 {" + + " Event bli {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " }" + + " Sequence sequence6 {" + + " Event bla {}" + + " }" + + "}", getTaskTree()); + } + + /** + * + */ + @Test + public void testManyInteractionsOnManyElements() { + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + IEventTarget eventTarget3 = new DummyGUIElement("elem3"); + IEventTarget eventTarget4 = new DummyGUIElement("elem4"); + IEventTarget eventTarget5 = new DummyGUIElement("elem5"); + IEventTarget eventTarget6 = new DummyGUIElement("elem6"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget1); + simulateEvent(new DummyInteraction("bli", 1), eventTarget1); + simulateEvent(new DummyInteraction("bla", 1), eventTarget1); + simulateEvent(new DummyInteraction("bli", 1), eventTarget2); + simulateEvent(new DummyInteraction("blo", 1), eventTarget2); + simulateEvent(new DummyInteraction("bla", 1), eventTarget3); + simulateEvent(new DummyInteraction("bli", 1), eventTarget4); + simulateEvent(new DummyInteraction("bla", 1), eventTarget4); + simulateEvent(new DummyInteraction("bli", 1), eventTarget4); + simulateEvent(new DummyInteraction("blo", 1), eventTarget4); + simulateEvent(new DummyInteraction("bla", 1), eventTarget5); + simulateEvent(new DummyInteraction("bli", 1), eventTarget6); + simulateEvent(new DummyInteraction("bla", 1), eventTarget6); + simulateEvent(new DummyInteraction("bli", 1), eventTarget6); + simulateEvent(new DummyInteraction("blo", 1), eventTarget6); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event bla {}" + + " Event bli {}" + + " Event bla {}" + + " }" + + " Sequence sequence2 {" + + " Event bli {}" + + " Event blo {}" + + " }" + + " Sequence sequence3 {" + + " Event bla {}" + + " }" + + " Sequence sequence4 {" + + " Event bli {}" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " }" + + " Sequence sequence5 {" + + " Event bla {}" + + " }" + + " Sequence sequence6 {" + + " Event bli {}" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " }" + + "}", getTaskTree()); + } + +} Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java (revision 553) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java (revision 557) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: DefaultIterationDetectionRuleTest.java,v $ // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 28.04.2012 $ @@ -5,16 +4,15 @@ // Creation : 2012 by patrick // Copyright : Patrick Harms, 2012 -//------------------------------------------------------------------------------------------------- + package de.ugoe.cs.quest.tasktrees.temporalrelation; import org.junit.Test; -import de.ugoe.cs.quest.eventcore.guimodel.GUIElement; -import de.ugoe.cs.quest.eventcore.userinteraction.Interaction; +import de.ugoe.cs.quest.eventcore.IEventTarget; +import de.ugoe.cs.quest.eventcore.IEventType; import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; -//------------------------------------------------------------------------------------------------- /** * TODO comment @@ -23,307 +21,287 @@ * @author 2012, last modified by $Author: patrick$ */ -//------------------------------------------------------------------------------------------------- -public class DefaultIterationDetectionRuleTest extends AbstractTemporalRelationshipTC -{ - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testInteractionIterationDetection() throws Exception - { - GUIElement element1 = new DummyGUIElement("elem1"); - Interaction interaction1 = new DummyInteraction("bla", 1); - simulateInteraction(element1, interaction1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Interaction bla {}" + - "}", getTaskTree()); - - simulateInteraction(element1, interaction1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Interaction bla {}" + - " }" + - "}", getTaskTree()); - - simulateInteraction(element1, interaction1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Interaction bla {}" + - " }" + - "}", getTaskTree()); - - for (int i = 0; i < 10; i++) - { - simulateInteraction(element1, interaction1); +public class DefaultIterationDetectionRuleTest extends AbstractTemporalRelationshipTC { + + /** + * + */ + @Test + public void testInteractionIterationDetection() throws Exception { + IEventTarget element1 = new DummyGUIElement("elem1"); + IEventType event1 = new DummyInteraction("bla", 1); + simulateEvent(event1, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Event bla {}" + + "}", getTaskTree()); + + simulateEvent(event1, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", getTaskTree()); + + simulateEvent(event1, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", getTaskTree()); + + for (int i = 0; i < 10; i++) { + simulateEvent(event1, element1); + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", getTaskTree()); + + // now test with preceding and trailing other events + IEventType event2 = new DummyInteraction("bli", 1); + IEventType event3 = new DummyInteraction("blup", 1); + + simulateEvent(event2, element1); + simulateEvent(event3, element1); + for (int i = 0; i < 10; i++) { + simulateEvent(event1, element1); + } + simulateEvent(event3, element1); + simulateEvent(event2, element1); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + " Event bli {}" + + " Event blup {}" + + " Iteration iteration2 {" + + " Event bla {}" + + " }" + + " Event blup {}" + + " Event bli {}" + + "}", getTaskTree()); + + // now test with iterations of iterations + + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 5; j++) { + simulateEvent(event1, element1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event2, element1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event3, element1); + } + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + " Event bli {}" + + " Event blup {}" + + " Iteration iteration2 {" + + " Event bla {}" + + " }" + + " Event blup {}" + + " Event bli {}" + + " Iteration iteration3 {" + + " Sequence sequence2 {" + + " Iteration iteration4 {" + + " Event bla {}" + + " }" + + " Iteration iteration5 {" + + " Event bli {}" + + " }" + + " Iteration iteration6 {" + + " Event blup {}" + + " }" + + " }" + + " }" + + "}", getTaskTree()); + } - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Interaction bla {}" + - " }" + - "}", getTaskTree()); - - // now test with preceding and trailing other interactions - Interaction interaction2 = new DummyInteraction("bli", 1); - Interaction interaction3 = new DummyInteraction("blup", 1); - - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - for (int i = 0; i < 10; i++) - { - simulateInteraction(element1, interaction1); + + /** + * + */ + @Test + public void testSequenceIterationDetection() throws Exception { + IEventTarget element1 = new DummyGUIElement("elem1"); + IEventType event1 = new DummyInteraction("bla", 1); + IEventType event2 = new DummyInteraction("bli", 1); + IEventType event3 = new DummyInteraction("blup", 1); + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + "}", getTaskTree()); + + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", getTaskTree()); + + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", getTaskTree()); + + for (int i = 0; i < 10; i++) { + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", getTaskTree()); + + // now test with preceding and trailing other events + IEventType event4 = new DummyInteraction("ble", 1); + IEventType event5 = new DummyInteraction("blo", 1); + IEventType event6 = new DummyInteraction("blu", 1); + simulateEvent(event4, element1); + simulateEvent(event5, element1); + simulateEvent(event6, element1); + for (int i = 0; i < 10; i++) { + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + } + simulateEvent(event6, element1); + simulateEvent(event5, element1); + simulateEvent(event4, element1); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event ble {}" + + " Event blo {}" + + " Event blu {}" + + " Iteration iteration2 {" + + " Sequence sequence3 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event blu {}" + + " Event blo {}" + + " Event ble {}" + + "}", getTaskTree()); + + // now test with iterations of iterations + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 5; j++) { + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event2, element1); + simulateEvent(event1, element1); + simulateEvent(event3, element1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + } + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event ble {}" + + " Event blo {}" + + " Event blu {}" + + " Iteration iteration2 {" + + " Sequence sequence3 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event blu {}" + + " Event blo {}" + + " Event ble {}" + + " Iteration iteration3 {" + + " Sequence sequence4 {" + + " Iteration iteration4 {" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Iteration iteration5 {" + + " Sequence sequence5 {" + + " Event bli {}" + + " Event bla {}" + + " Event blup {}" + + " }" + + " }" + + " Iteration iteration6 {" + + " Sequence sequence6 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " }" + + " }" + + "}", getTaskTree()); } - simulateInteraction(element1, interaction3); - simulateInteraction(element1, interaction2); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Interaction bla {}" + - " }" + - " Interaction bli {}" + - " Interaction blup {}" + - " Iteration iteration2 {" + - " Interaction bla {}" + - " }" + - " Interaction blup {}" + - " Interaction bli {}" + - "}", getTaskTree()); - - // now test with iterations of iterations - - for (int i = 0; i < 10; i++) - { - for (int j = 0; j < 5; j++) - { - simulateInteraction(element1, interaction1); - } - for (int j = 0; j < 5; j++) - { - simulateInteraction(element1, interaction2); - } - for (int j = 0; j < 5; j++) - { - simulateInteraction(element1, interaction3); - } - } - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Interaction bla {}" + - " }" + - " Interaction bli {}" + - " Interaction blup {}" + - " Iteration iteration2 {" + - " Interaction bla {}" + - " }" + - " Interaction blup {}" + - " Interaction bli {}" + - " Iteration iteration3 {" + - " Sequence sequence2 {" + - " Iteration iteration4 {" + - " Interaction bla {}" + - " }" + - " Iteration iteration5 {" + - " Interaction bli {}" + - " }" + - " Iteration iteration6 {" + - " Interaction blup {}" + - " }" + - " }" + - " }" + - "}", getTaskTree()); - - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testSequenceIterationDetection() throws Exception - { - GUIElement element1 = new DummyGUIElement("elem1"); - Interaction interaction1 = new DummyInteraction("bla", 1); - Interaction interaction2 = new DummyInteraction("bli", 1); - Interaction interaction3 = new DummyInteraction("blup", 1); - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - "}", getTaskTree()); - - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - "}", getTaskTree()); - - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - "}", getTaskTree()); - - for (int i = 0; i < 10; i++) - { - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - } - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - "}", getTaskTree()); - - // now test with preceding and trailing other interactions - Interaction interaction4 = new DummyInteraction("ble", 1); - Interaction interaction5 = new DummyInteraction("blo", 1); - Interaction interaction6 = new DummyInteraction("blu", 1); - simulateInteraction(element1, interaction4); - simulateInteraction(element1, interaction5); - simulateInteraction(element1, interaction6); - for (int i = 0; i < 10; i++) - { - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - } - simulateInteraction(element1, interaction6); - simulateInteraction(element1, interaction5); - simulateInteraction(element1, interaction4); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - " Interaction ble {}" + - " Interaction blo {}" + - " Interaction blu {}" + - " Iteration iteration2 {" + - " Sequence sequence3 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - " Interaction blu {}" + - " Interaction blo {}" + - " Interaction ble {}" + - "}", getTaskTree()); - - // now test with iterations of iterations - for (int i = 0; i < 10; i++) - { - for (int j = 0; j < 5; j++) - { - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - } - for (int j = 0; j < 5; j++) - { - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction3); - } - for (int j = 0; j < 5; j++) - { - simulateInteraction(element1, interaction1); - simulateInteraction(element1, interaction2); - simulateInteraction(element1, interaction3); - } - } - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - " Interaction ble {}" + - " Interaction blo {}" + - " Interaction blu {}" + - " Iteration iteration2 {" + - " Sequence sequence3 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - " Interaction blu {}" + - " Interaction blo {}" + - " Interaction ble {}" + - " Iteration iteration3 {" + - " Sequence sequence4 {" + - " Iteration iteration4 {" + - " Sequence sequence4 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - " Iteration iteration5 {" + - " Sequence sequence5 {" + - " Interaction bli {}" + - " Interaction bla {}" + - " Interaction blup {}" + - " }" + - " }" + - " Iteration iteration6 {" + - " Sequence sequence6 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction blup {}" + - " }" + - " }" + - " }" + - " }" + - "}", getTaskTree()); - } - + } Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultMouseClickReductionRuleTest.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultMouseClickReductionRuleTest.java (revision 553) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultMouseClickReductionRuleTest.java (revision 557) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: TaskTreeManagerTest.java,v $ // Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 08.11.2011 21:32:36 $ @@ -5,5 +4,4 @@ // Creation : 2011 by Patrick // Copyright : Patrick Harms, 2011 -//------------------------------------------------------------------------------------------------- package de.ugoe.cs.quest.tasktrees.temporalrelation; @@ -11,164 +9,159 @@ import org.junit.Test; -import de.ugoe.cs.quest.eventcore.guimodel.GUIElement; -import de.ugoe.cs.quest.eventcore.userinteraction.MouseButtonDown; -import de.ugoe.cs.quest.eventcore.userinteraction.MouseButtonInteraction; -import de.ugoe.cs.quest.eventcore.userinteraction.MouseButtonUp; -import de.ugoe.cs.quest.eventcore.userinteraction.MouseClick; +import de.ugoe.cs.quest.eventcore.gui.MouseButtonDown; +import de.ugoe.cs.quest.eventcore.gui.MouseButtonInteraction; +import de.ugoe.cs.quest.eventcore.gui.MouseButtonUp; +import de.ugoe.cs.quest.eventcore.gui.MouseClick; +import de.ugoe.cs.quest.eventcore.guimodel.IGUIElement; import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; -//------------------------------------------------------------------------------------------------- /** * TODO comment - * + * * @version $Revision: $ $Date: $ - * @author 2011, last modified by $Author: $ + * @author 2011, last modified by $Author: $ */ -//------------------------------------------------------------------------------------------------- -public class DefaultMouseClickReductionRuleTest extends AbstractTemporalRelationshipTC -{ - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testMouseClickInOneSequenceElement() - { - MouseButtonInteraction.Button leftBtn = MouseButtonInteraction.Button.LEFT; - MouseButtonInteraction.Button middleBtn = MouseButtonInteraction.Button.MIDDLE; - MouseButtonInteraction.Button rightBtn = MouseButtonInteraction.Button.RIGHT; - - GUIElement element1 = new DummyGUIElement("elem1"); - GUIElement element2 = new DummyGUIElement("elem1"); - - simulateInteraction(element1, new MouseButtonDown(leftBtn)); - simulateInteraction(element1, new MouseButtonUp(leftBtn)); - simulateInteraction(element1, new MouseClick(leftBtn)); +public class DefaultMouseClickReductionRuleTest extends AbstractTemporalRelationshipTC { - new TaskTreeChecker().assertTaskTree - ("Sequence sequence {" + - " Interaction LeftMouseClick {}" + - "}", getTaskTree()); - - simulateInteraction(element1, new DummyInteraction("bla", 1)); - simulateInteraction(element1, new DummyInteraction("bli", 1)); - simulateInteraction(element1, new MouseButtonDown(middleBtn)); - simulateInteraction(element1, new MouseButtonUp(middleBtn)); - simulateInteraction(element1, new MouseClick(middleBtn)); - simulateInteraction(element1, new DummyInteraction("blo", 1)); - simulateInteraction(element1, new DummyInteraction("blu", 1)); + /** + * + */ + @Test + public void testMouseClickInOneSequenceElement() { + MouseButtonInteraction.Button leftBtn = MouseButtonInteraction.Button.LEFT; + MouseButtonInteraction.Button middleBtn = MouseButtonInteraction.Button.MIDDLE; + MouseButtonInteraction.Button rightBtn = MouseButtonInteraction.Button.RIGHT; - new TaskTreeChecker().assertTaskTree - ("Sequence sequence {" + - " Interaction LeftMouseClick {}" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction MiddleMouseClick {}" + - " Interaction blo {}" + - " Interaction blu {}" + - "}", getTaskTree()); + IGUIElement element1 = new DummyGUIElement("elem1"); + IGUIElement element2 = new DummyGUIElement("elem1"); - simulateInteraction(element2, new DummyInteraction("bla", 1)); - simulateInteraction(element2, new DummyInteraction("bli", 1)); - simulateInteraction(element2, new MouseButtonDown(rightBtn)); - simulateInteraction(element2, new MouseButtonUp(rightBtn)); - simulateInteraction(element2, new MouseClick(rightBtn)); - simulateInteraction(element2, new DummyInteraction("blo", 1)); - simulateInteraction(element2, new DummyInteraction("blu", 1)); + simulateEvent(new MouseButtonDown(leftBtn), element1); + simulateEvent(new MouseButtonUp(leftBtn), element1); + simulateEvent(new MouseClick(leftBtn), element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Interaction LeftMouseClick {}" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction MiddleMouseClick {}" + - " Interaction blo {}" + - " Interaction blu {}" + - " }" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction RightMouseClick {}" + - " Interaction blo {}" + - " Interaction blu {}" + - " }" + - "}", getTaskTree()); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence {" + + " Event LeftMouseClick {}" + + "}", getTaskTree()); - simulateInteraction(element1, new MouseButtonDown(leftBtn)); - simulateInteraction(element1, new MouseButtonUp(leftBtn)); - simulateInteraction(element2, new MouseClick(leftBtn)); + simulateEvent(new DummyInteraction("bla", 1), element1); + simulateEvent(new DummyInteraction("bli", 1), element1); + simulateEvent(new MouseButtonDown(middleBtn), element1); + simulateEvent(new MouseButtonUp(middleBtn), element1); + simulateEvent(new MouseClick(middleBtn), element1); + simulateEvent(new DummyInteraction("blo", 1), element1); + simulateEvent(new DummyInteraction("blu", 1), element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Interaction LeftMouseClick {}" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction MiddleMouseClick {}" + - " Interaction blo {}" + - " Interaction blu {}" + - " }" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction RightMouseClick {}" + - " Interaction blo {}" + - " Interaction blu {}" + - " }" + - " Sequence sequence3 {" + - " Interaction LeftMouseButtonDown {}" + - " Interaction LeftMouseButtonUp {}" + - " }" + - " Sequence sequence4 {" + - " Interaction LeftMouseClick {}" + - " }" + - "}", getTaskTree()); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence {" + + " Event LeftMouseClick {}" + + " Event bla {}" + + " Event bli {}" + + " Event MiddleMouseClick {}" + + " Event blo {}" + + " Event blu {}" + + "}", getTaskTree()); - simulateInteraction(element1, new MouseButtonDown(middleBtn)); - simulateInteraction(element1, new MouseButtonUp(middleBtn)); - simulateInteraction(element1, new MouseClick(rightBtn)); - simulateInteraction(element2, new DummyInteraction("bla", 1)); + simulateEvent(new DummyInteraction("bla", 1), element2); + simulateEvent(new DummyInteraction("bli", 1), element2); + simulateEvent(new MouseButtonDown(rightBtn), element2); + simulateEvent(new MouseButtonUp(rightBtn), element2); + simulateEvent(new MouseClick(rightBtn), element2); + simulateEvent(new DummyInteraction("blo", 1), element2); + simulateEvent(new DummyInteraction("blu", 1), element2); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Interaction LeftMouseClick {}" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction MiddleMouseClick {}" + - " Interaction blo {}" + - " Interaction blu {}" + - " }" + - " Sequence sequence2 {" + - " Interaction bla {}" + - " Interaction bli {}" + - " Interaction RightMouseClick {}" + - " Interaction blo {}" + - " Interaction blu {}" + - " }" + - " Sequence sequence3 {" + - " Interaction LeftMouseButtonDown {}" + - " Interaction LeftMouseButtonUp {}" + - " }" + - " Sequence sequence4 {" + - " Interaction LeftMouseClick {}" + - " }" + - " Sequence sequence5 {" + - " Sequence sequence6 {" + - " Interaction MiddleMouseButtonDown {}" + - " Interaction MiddleMouseButtonUp {}" + - " }" + - " Interaction RightMouseClick {}" + - " }" + - " Sequence sequence7 {" + - " Interaction bla {}" + - " }" + - "}", getTaskTree()); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event LeftMouseClick {}" + + " Event bla {}" + + " Event bli {}" + + " Event MiddleMouseClick {}" + + " Event blo {}" + + " Event blu {}" + + " }" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event RightMouseClick {}" + + " Event blo {}" + + " Event blu {}" + + " }" + + "}", getTaskTree()); - } - + simulateEvent(new MouseButtonDown(leftBtn), element1); + simulateEvent(new MouseButtonUp(leftBtn), element1); + simulateEvent(new MouseClick(leftBtn), element2); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event LeftMouseClick {}" + + " Event bla {}" + + " Event bli {}" + + " Event MiddleMouseClick {}" + + " Event blo {}" + + " Event blu {}" + + " }" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event RightMouseClick {}" + + " Event blo {}" + + " Event blu {}" + + " }" + + " Sequence sequence3 {" + + " Event LeftMouseButtonDown {}" + + " Event LeftMouseButtonUp {}" + + " }" + + " Sequence sequence4 {" + + " Event LeftMouseClick {}" + + " }" + + "}", getTaskTree()); + + simulateEvent(new MouseButtonDown(middleBtn), element1); + simulateEvent(new MouseButtonUp(middleBtn), element1); + simulateEvent(new MouseClick(rightBtn), element1); + simulateEvent(new DummyInteraction("bla", 1), element2); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event LeftMouseClick {}" + + " Event bla {}" + + " Event bli {}" + + " Event MiddleMouseClick {}" + + " Event blo {}" + + " Event blu {}" + + " }" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event RightMouseClick {}" + + " Event blo {}" + + " Event blu {}" + + " }" + + " Sequence sequence3 {" + + " Event LeftMouseButtonDown {}" + + " Event LeftMouseButtonUp {}" + + " }" + + " Sequence sequence4 {" + + " Event LeftMouseClick {}" + + " }" + + " Sequence sequence5 {" + + " Sequence sequence6 {" + + " Event MiddleMouseButtonDown {}" + + " Event MiddleMouseButtonUp {}" + + " }" + + " Event RightMouseClick {}" + + " }" + + " Sequence sequence7 {" + + " Event bla {}" + + " }" + + "}", getTaskTree()); + + } + } Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultTextInputReductionRuleTest.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultTextInputReductionRuleTest.java (revision 553) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultTextInputReductionRuleTest.java (revision 557) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: DefaultIterationDetectionRuleTest.java,v $ // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 28.04.2012 $ @@ -5,18 +4,17 @@ // Creation : 2012 by patrick // Copyright : Patrick Harms, 2012 -//------------------------------------------------------------------------------------------------- + package de.ugoe.cs.quest.tasktrees.temporalrelation; import org.junit.Test; -import de.ugoe.cs.quest.eventcore.guimodel.GUIElement; -import de.ugoe.cs.quest.eventcore.guimodel.TextField; -import de.ugoe.cs.quest.eventcore.userinteraction.KeyPressed; -import de.ugoe.cs.quest.eventcore.userinteraction.KeyReleased; +import de.ugoe.cs.quest.eventcore.gui.KeyPressed; +import de.ugoe.cs.quest.eventcore.gui.KeyReleased; +import de.ugoe.cs.quest.eventcore.guimodel.IGUIElement; +import de.ugoe.cs.quest.eventcore.guimodel.ITextField; import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; import de.ugoe.cs.tasktree.keyboardmaps.VirtualKey; -//------------------------------------------------------------------------------------------------- /** * TODO comment @@ -25,387 +23,371 @@ * @author 2012, last modified by $Author: patrick$ */ -//------------------------------------------------------------------------------------------------- -public class DefaultTextInputReductionRuleTest extends AbstractTemporalRelationshipTC -{ - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testSimpleTextEntry() - { - GUIElement element1 = new DummyTextField("elem1"); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_A)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_A)); - new TaskTreeChecker(true).assertTaskTree - ("Sequence sequence0 {" + - " TextInputInteraction TextInput a {" + - " Interaction KeyPressed LETTER_A {}" + - " Interaction KeyReleased LETTER_A {}" + - " }" + - "}", getTaskTree()); - - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_B)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_B)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " TextInputInteraction TextInput ab {" + - " Interaction KeyPressed LETTER_A {}" + - " Interaction KeyReleased LETTER_A {}" + - " Interaction KeyPressed LETTER_B {}" + - " Interaction KeyReleased LETTER_B {}" + - " }" + - "}", getTaskTree()); - - simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_C)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_C)); - simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " TextInputInteraction TextInput abC {" + - " Interaction KeyPressed LETTER_A {}" + - " Interaction KeyReleased LETTER_A {}" + - " Interaction KeyPressed LETTER_B {}" + - " Interaction KeyReleased LETTER_B {}" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed LETTER_C {}" + - " Interaction KeyReleased LETTER_C {}" + - " Interaction KeyReleased SHIFT {}" + - " }" + - "}", getTaskTree()); - - simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_D)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_D)); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_E)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_E)); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_F)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_F)); - simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " TextInputInteraction TextInput abCDEF {" + - " Interaction KeyPressed LETTER_A {}" + - " Interaction KeyReleased LETTER_A {}" + - " Interaction KeyPressed LETTER_B {}" + - " Interaction KeyReleased LETTER_B {}" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed LETTER_C {}" + - " Interaction KeyReleased LETTER_C {}" + - " Interaction KeyReleased SHIFT {}" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed LETTER_D {}" + - " Interaction KeyReleased LETTER_D {}" + - " Interaction KeyPressed LETTER_E {}" + - " Interaction KeyReleased LETTER_E {}" + - " Interaction KeyPressed LETTER_F {}" + - " Interaction KeyReleased LETTER_F {}" + - " Interaction KeyReleased SHIFT {}" + - " }" + - "}", getTaskTree()); - - - simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); - simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_G)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_G)); - simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); - simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " TextInputInteraction TextInput abCDEFg {" + - " Interaction KeyPressed LETTER_A {}" + - " Interaction KeyReleased LETTER_A {}" + - " Interaction KeyPressed LETTER_B {}" + - " Interaction KeyReleased LETTER_B {}" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed LETTER_C {}" + - " Interaction KeyReleased LETTER_C {}" + - " Interaction KeyReleased SHIFT {}" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed LETTER_D {}" + - " Interaction KeyReleased LETTER_D {}" + - " Interaction KeyPressed LETTER_E {}" + - " Interaction KeyReleased LETTER_E {}" + - " Interaction KeyPressed LETTER_F {}" + - " Interaction KeyReleased LETTER_F {}" + - " Interaction KeyReleased SHIFT {}" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed LETTER_G {}" + - " Interaction KeyReleased LETTER_G {}" + - " Interaction KeyReleased SHIFT {}" + - " Interaction KeyReleased SHIFT {}" + - " }" + - "}", getTaskTree()); - - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testTextEntryOnDifferentGuiElements() - { - GUIElement element1 = new DummyTextField("elem1"); - GUIElement element2 = new DummyTextField("elem2"); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_A)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_A)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " TextInputInteraction TextInput a {" + - " Interaction KeyPressed LETTER_A {}" + - " Interaction KeyReleased LETTER_A {}" + - " }" + - "}", getTaskTree()); - - simulateInteraction(element2, new KeyPressed(VirtualKey.LETTER_B)); - simulateInteraction(element2, new KeyReleased(VirtualKey.LETTER_B)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " TextInputInteraction TextInput a {" + - " Interaction KeyPressed LETTER_A {}" + - " Interaction KeyReleased LETTER_A {}" + - " }" + - " }" + - " Sequence sequence2 {" + - " TextInputInteraction TextInput b {" + - " Interaction KeyPressed LETTER_B {}" + - " Interaction KeyReleased LETTER_B {}" + - " }" + - " }" + - "}", getTaskTree()); - - simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_C)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_C)); - simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " TextInputInteraction TextInput a {" + - " Interaction KeyPressed LETTER_A {}" + - " Interaction KeyReleased LETTER_A {}" + - " }" + - " }" + - " Sequence sequence2 {" + - " TextInputInteraction TextInput b {" + - " Interaction KeyPressed LETTER_B {}" + - " Interaction KeyReleased LETTER_B {}" + - " }" + - " }" + - " Sequence sequence3 {" + - " TextInputInteraction TextInput C {" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed LETTER_C {}" + - " Interaction KeyReleased LETTER_C {}" + - " Interaction KeyReleased SHIFT {}" + - " }" + - " }" + - "}", getTaskTree()); - - simulateInteraction(element2, new KeyPressed(VirtualKey.SHIFT)); - simulateInteraction(element2, new KeyPressed(VirtualKey.LETTER_D)); - simulateInteraction(element2, new KeyReleased(VirtualKey.LETTER_D)); - simulateInteraction(element2, new KeyPressed(VirtualKey.LETTER_E)); - simulateInteraction(element2, new KeyReleased(VirtualKey.LETTER_E)); - simulateInteraction(element2, new KeyPressed(VirtualKey.LETTER_F)); - simulateInteraction(element2, new KeyReleased(VirtualKey.LETTER_F)); - simulateInteraction(element2, new KeyReleased(VirtualKey.SHIFT)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " TextInputInteraction TextInput a {" + - " Interaction KeyPressed LETTER_A {}" + - " Interaction KeyReleased LETTER_A {}" + - " }" + - " }" + - " Sequence sequence2 {" + - " TextInputInteraction TextInput b {" + - " Interaction KeyPressed LETTER_B {}" + - " Interaction KeyReleased LETTER_B {}" + - " }" + - " }" + - " Sequence sequence3 {" + - " TextInputInteraction TextInput C {" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed LETTER_C {}" + - " Interaction KeyReleased LETTER_C {}" + - " Interaction KeyReleased SHIFT {}" + - " }" + - " }" + - " Sequence sequence4 {" + - " TextInputInteraction TextInput DEF {" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed LETTER_D {}" + - " Interaction KeyReleased LETTER_D {}" + - " Interaction KeyPressed LETTER_E {}" + - " Interaction KeyReleased LETTER_E {}" + - " Interaction KeyPressed LETTER_F {}" + - " Interaction KeyReleased LETTER_F {}" + - " Interaction KeyReleased SHIFT {}" + - " }" + - " }" + - "}", getTaskTree()); - - - simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); - simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_G)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_G)); - simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); - simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " TextInputInteraction TextInput a {" + - " Interaction KeyPressed LETTER_A {}" + - " Interaction KeyReleased LETTER_A {}" + - " }" + - " }" + - " Sequence sequence2 {" + - " TextInputInteraction TextInput b {" + - " Interaction KeyPressed LETTER_B {}" + - " Interaction KeyReleased LETTER_B {}" + - " }" + - " }" + - " Sequence sequence3 {" + - " TextInputInteraction TextInput C {" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed LETTER_C {}" + - " Interaction KeyReleased LETTER_C {}" + - " Interaction KeyReleased SHIFT {}" + - " }" + - " }" + - " Sequence sequence4 {" + - " TextInputInteraction TextInput DEF {" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed LETTER_D {}" + - " Interaction KeyReleased LETTER_D {}" + - " Interaction KeyPressed LETTER_E {}" + - " Interaction KeyReleased LETTER_E {}" + - " Interaction KeyPressed LETTER_F {}" + - " Interaction KeyReleased LETTER_F {}" + - " Interaction KeyReleased SHIFT {}" + - " }" + - " }" + - " Sequence sequence5 {" + - " TextInputInteraction TextInput g {" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed SHIFT {}" + - " Interaction KeyPressed LETTER_G {}" + - " Interaction KeyReleased LETTER_G {}" + - " Interaction KeyReleased SHIFT {}" + - " Interaction KeyReleased SHIFT {}" + - " }" + - " }" + - "}", getTaskTree()); - - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testUsageOfBackspace() - { - GUIElement element1 = new DummyTextField("elem1"); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_A)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_A)); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_B)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_B)); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_C)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_C)); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_D)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_D)); - simulateInteraction(element1, new KeyPressed(VirtualKey.BACK_SPACE)); - simulateInteraction(element1, new KeyReleased(VirtualKey.BACK_SPACE)); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_E)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_E)); - simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_F)); - simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_F)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " TextInputInteraction TextInput abcef {" + - " Interaction KeyPressed LETTER_A {}" + - " Interaction KeyReleased LETTER_A {}" + - " Interaction KeyPressed LETTER_B {}" + - " Interaction KeyReleased LETTER_B {}" + - " Interaction KeyPressed LETTER_C {}" + - " Interaction KeyReleased LETTER_C {}" + - " Interaction KeyPressed LETTER_D {}" + - " Interaction KeyReleased LETTER_D {}" + - " Interaction KeyPressed BACK_SPACE {}" + - " Interaction KeyReleased BACK_SPACE {}" + - " Interaction KeyPressed LETTER_E {}" + - " Interaction KeyReleased LETTER_E {}" + - " Interaction KeyPressed LETTER_F {}" + - " Interaction KeyReleased LETTER_F {}" + - " }" + - "}", getTaskTree()); - - simulateInteraction(element1, new KeyPressed(VirtualKey.BACK_SPACE)); - simulateInteraction(element1, new KeyReleased(VirtualKey.BACK_SPACE)); - simulateInteraction(element1, new KeyPressed(VirtualKey.BACK_SPACE)); - simulateInteraction(element1, new KeyReleased(VirtualKey.BACK_SPACE)); - simulateInteraction(element1, new KeyPressed(VirtualKey.BACK_SPACE)); - simulateInteraction(element1, new KeyReleased(VirtualKey.BACK_SPACE)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " TextInputInteraction TextInput ab {" + - " Interaction KeyPressed LETTER_A {}" + - " Interaction KeyReleased LETTER_A {}" + - " Interaction KeyPressed LETTER_B {}" + - " Interaction KeyReleased LETTER_B {}" + - " Interaction KeyPressed LETTER_C {}" + - " Interaction KeyReleased LETTER_C {}" + - " Interaction KeyPressed LETTER_D {}" + - " Interaction KeyReleased LETTER_D {}" + - " Interaction KeyPressed BACK_SPACE {}" + - " Interaction KeyReleased BACK_SPACE {}" + - " Interaction KeyPressed LETTER_E {}" + - " Interaction KeyReleased LETTER_E {}" + - " Interaction KeyPressed LETTER_F {}" + - " Interaction KeyReleased LETTER_F {}" + - " Interaction KeyPressed BACK_SPACE {}" + - " Interaction KeyReleased BACK_SPACE {}" + - " Interaction KeyPressed BACK_SPACE {}" + - " Interaction KeyReleased BACK_SPACE {}" + - " Interaction KeyPressed BACK_SPACE {}" + - " Interaction KeyReleased BACK_SPACE {}" + - " }" + - "}", getTaskTree()); - - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - private static class DummyTextField extends DummyGUIElement implements TextField - { - - //--------------------------------------------------------------------------------------------- +public class DefaultTextInputReductionRuleTest extends AbstractTemporalRelationshipTC { + /** - * TODO: comment * - * @param name */ - //--------------------------------------------------------------------------------------------- - public DummyTextField(String name) - { - super(name); + @Test + public void testSimpleTextEntry() { + IGUIElement element1 = new DummyTextField("elem1"); + simulateEvent(new KeyPressed(VirtualKey.LETTER_A), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_A), element1); + new TaskTreeChecker(true).assertTaskTree + ("Sequence sequence0 {" + + " TextInputEvent TextInput a {" + + " Event KeyPressed LETTER_A {}" + + " Event KeyReleased LETTER_A {}" + + " }" + + "}", getTaskTree()); + + simulateEvent(new KeyPressed(VirtualKey.LETTER_B), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_B), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " TextInputEvent TextInput ab {" + + " Event KeyPressed LETTER_A {}" + + " Event KeyReleased LETTER_A {}" + + " Event KeyPressed LETTER_B {}" + + " Event KeyReleased LETTER_B {}" + + " }" + + "}", getTaskTree()); + + simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); + simulateEvent(new KeyPressed(VirtualKey.LETTER_C), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_C), element1); + simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " TextInputEvent TextInput abC {" + + " Event KeyPressed LETTER_A {}" + + " Event KeyReleased LETTER_A {}" + + " Event KeyPressed LETTER_B {}" + + " Event KeyReleased LETTER_B {}" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed LETTER_C {}" + + " Event KeyReleased LETTER_C {}" + + " Event KeyReleased SHIFT {}" + + " }" + + "}", getTaskTree()); + + simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); + simulateEvent(new KeyPressed(VirtualKey.LETTER_D), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_D), element1); + simulateEvent(new KeyPressed(VirtualKey.LETTER_E), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_E), element1); + simulateEvent(new KeyPressed(VirtualKey.LETTER_F), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_F), element1); + simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " TextInputEvent TextInput abCDEF {" + + " Event KeyPressed LETTER_A {}" + + " Event KeyReleased LETTER_A {}" + + " Event KeyPressed LETTER_B {}" + + " Event KeyReleased LETTER_B {}" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed LETTER_C {}" + + " Event KeyReleased LETTER_C {}" + + " Event KeyReleased SHIFT {}" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed LETTER_D {}" + + " Event KeyReleased LETTER_D {}" + + " Event KeyPressed LETTER_E {}" + + " Event KeyReleased LETTER_E {}" + + " Event KeyPressed LETTER_F {}" + + " Event KeyReleased LETTER_F {}" + + " Event KeyReleased SHIFT {}" + + " }" + + "}", getTaskTree()); + + simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); + simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); + simulateEvent(new KeyPressed(VirtualKey.LETTER_G), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_G), element1); + simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); + simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " TextInputEvent TextInput abCDEFg {" + + " Event KeyPressed LETTER_A {}" + + " Event KeyReleased LETTER_A {}" + + " Event KeyPressed LETTER_B {}" + + " Event KeyReleased LETTER_B {}" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed LETTER_C {}" + + " Event KeyReleased LETTER_C {}" + + " Event KeyReleased SHIFT {}" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed LETTER_D {}" + + " Event KeyReleased LETTER_D {}" + + " Event KeyPressed LETTER_E {}" + + " Event KeyReleased LETTER_E {}" + + " Event KeyPressed LETTER_F {}" + + " Event KeyReleased LETTER_F {}" + + " Event KeyReleased SHIFT {}" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed LETTER_G {}" + + " Event KeyReleased LETTER_G {}" + + " Event KeyReleased SHIFT {}" + + " Event KeyReleased SHIFT {}" + + " }" + + "}", getTaskTree()); + } - } + /** + * + */ + @Test + public void testTextEntryOnDifferentGuiElements() { + IGUIElement element1 = new DummyTextField("elem1"); + IGUIElement element2 = new DummyTextField("elem2"); + simulateEvent(new KeyPressed(VirtualKey.LETTER_A), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_A), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " TextInputEvent TextInput a {" + + " Event KeyPressed LETTER_A {}" + + " Event KeyReleased LETTER_A {}" + + " }" + + "}", getTaskTree()); + + simulateEvent(new KeyPressed(VirtualKey.LETTER_B), element2); + simulateEvent(new KeyReleased(VirtualKey.LETTER_B), element2); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " TextInputEvent TextInput a {" + + " Event KeyPressed LETTER_A {}" + + " Event KeyReleased LETTER_A {}" + + " }" + + " }" + + " Sequence sequence2 {" + + " TextInputEvent TextInput b {" + + " Event KeyPressed LETTER_B {}" + + " Event KeyReleased LETTER_B {}" + + " }" + + " }" + + "}", getTaskTree()); + + simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); + simulateEvent(new KeyPressed(VirtualKey.LETTER_C), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_C), element1); + simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " TextInputEvent TextInput a {" + + " Event KeyPressed LETTER_A {}" + + " Event KeyReleased LETTER_A {}" + + " }" + + " }" + + " Sequence sequence2 {" + + " TextInputEvent TextInput b {" + + " Event KeyPressed LETTER_B {}" + + " Event KeyReleased LETTER_B {}" + + " }" + + " }" + + " Sequence sequence3 {" + + " TextInputEvent TextInput C {" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed LETTER_C {}" + + " Event KeyReleased LETTER_C {}" + + " Event KeyReleased SHIFT {}" + + " }" + + " }" + + "}", getTaskTree()); + + simulateEvent(new KeyPressed(VirtualKey.SHIFT), element2); + simulateEvent(new KeyPressed(VirtualKey.LETTER_D), element2); + simulateEvent(new KeyReleased(VirtualKey.LETTER_D), element2); + simulateEvent(new KeyPressed(VirtualKey.LETTER_E), element2); + simulateEvent(new KeyReleased(VirtualKey.LETTER_E), element2); + simulateEvent(new KeyPressed(VirtualKey.LETTER_F), element2); + simulateEvent(new KeyReleased(VirtualKey.LETTER_F), element2); + simulateEvent(new KeyReleased(VirtualKey.SHIFT), element2); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " TextInputEvent TextInput a {" + + " Event KeyPressed LETTER_A {}" + + " Event KeyReleased LETTER_A {}" + + " }" + + " }" + + " Sequence sequence2 {" + + " TextInputEvent TextInput b {" + + " Event KeyPressed LETTER_B {}" + + " Event KeyReleased LETTER_B {}" + + " }" + + " }" + + " Sequence sequence3 {" + + " TextInputEvent TextInput C {" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed LETTER_C {}" + + " Event KeyReleased LETTER_C {}" + + " Event KeyReleased SHIFT {}" + + " }" + + " }" + + " Sequence sequence4 {" + + " TextInputEvent TextInput DEF {" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed LETTER_D {}" + + " Event KeyReleased LETTER_D {}" + + " Event KeyPressed LETTER_E {}" + + " Event KeyReleased LETTER_E {}" + + " Event KeyPressed LETTER_F {}" + + " Event KeyReleased LETTER_F {}" + + " Event KeyReleased SHIFT {}" + + " }" + + " }" + + "}", getTaskTree()); + + simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); + simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1); + simulateEvent(new KeyPressed(VirtualKey.LETTER_G), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_G), element1); + simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); + simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " TextInputEvent TextInput a {" + + " Event KeyPressed LETTER_A {}" + + " Event KeyReleased LETTER_A {}" + + " }" + + " }" + + " Sequence sequence2 {" + + " TextInputEvent TextInput b {" + + " Event KeyPressed LETTER_B {}" + + " Event KeyReleased LETTER_B {}" + + " }" + + " }" + + " Sequence sequence3 {" + + " TextInputEvent TextInput C {" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed LETTER_C {}" + + " Event KeyReleased LETTER_C {}" + + " Event KeyReleased SHIFT {}" + + " }" + + " }" + + " Sequence sequence4 {" + + " TextInputEvent TextInput DEF {" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed LETTER_D {}" + + " Event KeyReleased LETTER_D {}" + + " Event KeyPressed LETTER_E {}" + + " Event KeyReleased LETTER_E {}" + + " Event KeyPressed LETTER_F {}" + + " Event KeyReleased LETTER_F {}" + + " Event KeyReleased SHIFT {}" + + " }" + + " }" + + " Sequence sequence5 {" + + " TextInputEvent TextInput g {" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed SHIFT {}" + + " Event KeyPressed LETTER_G {}" + + " Event KeyReleased LETTER_G {}" + + " Event KeyReleased SHIFT {}" + + " Event KeyReleased SHIFT {}" + + " }" + + " }" + + "}", getTaskTree()); + + } + + /** + * + */ + @Test + public void testUsageOfBackspace() { + IGUIElement element1 = new DummyTextField("elem1"); + simulateEvent(new KeyPressed(VirtualKey.LETTER_A), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_A), element1); + simulateEvent(new KeyPressed(VirtualKey.LETTER_B), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_B), element1); + simulateEvent(new KeyPressed(VirtualKey.LETTER_C), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_C), element1); + simulateEvent(new KeyPressed(VirtualKey.LETTER_D), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_D), element1); + simulateEvent(new KeyPressed(VirtualKey.BACK_SPACE), element1); + simulateEvent(new KeyReleased(VirtualKey.BACK_SPACE), element1); + simulateEvent(new KeyPressed(VirtualKey.LETTER_E), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_E), element1); + simulateEvent(new KeyPressed(VirtualKey.LETTER_F), element1); + simulateEvent(new KeyReleased(VirtualKey.LETTER_F), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " TextInputEvent TextInput abcef {" + + " Event KeyPressed LETTER_A {}" + + " Event KeyReleased LETTER_A {}" + + " Event KeyPressed LETTER_B {}" + + " Event KeyReleased LETTER_B {}" + + " Event KeyPressed LETTER_C {}" + + " Event KeyReleased LETTER_C {}" + + " Event KeyPressed LETTER_D {}" + + " Event KeyReleased LETTER_D {}" + + " Event KeyPressed BACK_SPACE {}" + + " Event KeyReleased BACK_SPACE {}" + + " Event KeyPressed LETTER_E {}" + + " Event KeyReleased LETTER_E {}" + + " Event KeyPressed LETTER_F {}" + + " Event KeyReleased LETTER_F {}" + + " }" + + "}", getTaskTree()); + + simulateEvent(new KeyPressed(VirtualKey.BACK_SPACE), element1); + simulateEvent(new KeyReleased(VirtualKey.BACK_SPACE), element1); + simulateEvent(new KeyPressed(VirtualKey.BACK_SPACE), element1); + simulateEvent(new KeyReleased(VirtualKey.BACK_SPACE), element1); + simulateEvent(new KeyPressed(VirtualKey.BACK_SPACE), element1); + simulateEvent(new KeyReleased(VirtualKey.BACK_SPACE), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " TextInputEvent TextInput ab {" + + " Event KeyPressed LETTER_A {}" + + " Event KeyReleased LETTER_A {}" + + " Event KeyPressed LETTER_B {}" + + " Event KeyReleased LETTER_B {}" + + " Event KeyPressed LETTER_C {}" + + " Event KeyReleased LETTER_C {}" + + " Event KeyPressed LETTER_D {}" + + " Event KeyReleased LETTER_D {}" + + " Event KeyPressed BACK_SPACE {}" + + " Event KeyReleased BACK_SPACE {}" + + " Event KeyPressed LETTER_E {}" + + " Event KeyReleased LETTER_E {}" + + " Event KeyPressed LETTER_F {}" + + " Event KeyReleased LETTER_F {}" + + " Event KeyPressed BACK_SPACE {}" + + " Event KeyReleased BACK_SPACE {}" + + " Event KeyPressed BACK_SPACE {}" + + " Event KeyReleased BACK_SPACE {}" + + " Event KeyPressed BACK_SPACE {}" + + " Event KeyReleased BACK_SPACE {}" + + " }" + + "}", getTaskTree()); + + } + + /** + * + */ + private static class DummyTextField extends DummyGUIElement implements ITextField { + + /** */ + private static final long serialVersionUID = 1L; + + /** + * TODO: comment + * + * @param name + */ + public DummyTextField(String name) { + super(name); + } + + } } Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java (revision 553) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java (revision 557) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: DefaultIterationDetectionRuleTest.java,v $ // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 28.04.2012 $ @@ -5,17 +4,16 @@ // Creation : 2012 by patrick // Copyright : Patrick Harms, 2012 -//------------------------------------------------------------------------------------------------- + package de.ugoe.cs.quest.tasktrees.temporalrelation; import org.junit.Test; -import de.ugoe.cs.quest.eventcore.guimodel.GUIElement; -import de.ugoe.cs.quest.eventcore.guimodel.TrackBar; -import de.ugoe.cs.quest.eventcore.userinteraction.ValueSelection; +import de.ugoe.cs.quest.eventcore.gui.ValueSelection; +import de.ugoe.cs.quest.eventcore.guimodel.IGUIElement; +import de.ugoe.cs.quest.eventcore.guimodel.ITrackBar; import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; -//------------------------------------------------------------------------------------------------- /** * TODO comment @@ -24,157 +22,146 @@ * @author 2012, last modified by $Author: patrick$ */ -//------------------------------------------------------------------------------------------------- -public class TrackBarSelectionDetectionRuleTest extends AbstractTemporalRelationshipTC -{ +public class TrackBarSelectionDetectionRuleTest extends AbstractTemporalRelationshipTC { - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testSimpleDetection() throws Exception - { - GUIElement element1 = new DummyTrackBar(); - simulateInteraction(element1, new ValueSelection(1)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration interation1 {" + - " Selection selection1 {" + - " Interaction ValueSelection {}" + - " }" + - " }" + - "}", getTaskTree()); - - simulateInteraction(element1, new ValueSelection(2)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration interation1 {" + - " Selection selection1 {" + - " Interaction ValueSelection {}" + - " Interaction ValueSelection {}" + - " }" + - " }" + - "}", getTaskTree()); - - simulateInteraction(element1, new ValueSelection(3)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration interation1 {" + - " Selection selection1 {" + - " Interaction ValueSelection {}" + - " Interaction ValueSelection {}" + - " Interaction ValueSelection {}" + - " }" + - " }" + - "}", getTaskTree()); - - simulateInteraction(element1, new ValueSelection(2)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration interation1 {" + - " Selection selection1 {" + - " Interaction ValueSelection {}" + - " Interaction ValueSelection {}" + - " Interaction ValueSelection {}" + - " }" + - " }" + - "}", getTaskTree()); - - simulateInteraction(element1, new ValueSelection(3)); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration interation1 {" + - " Selection selection1 {" + - " Interaction ValueSelection {}" + - " Interaction ValueSelection {}" + - " Interaction ValueSelection {}" + - " }" + - " }" + - "}", getTaskTree()); - - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testComplexDetection() throws Exception - { - GUIElement element1 = new DummyTrackBar(); - simulateInteraction(element1, new ValueSelection(1)); - simulateInteraction(element1, new ValueSelection(2)); - simulateInteraction(element1, new ValueSelection(3)); - simulateInteraction(element1, new ValueSelection(1)); - simulateInteraction(element1, new DummyInteraction("bla", 1)); - simulateInteraction(element1, new DummyInteraction("bla", 2)); - simulateInteraction(element1, new ValueSelection(2)); - simulateInteraction(element1, new ValueSelection(1)); - simulateInteraction(element1, new DummyInteraction("bla", 3)); - simulateInteraction(element1, new ValueSelection(3)); - simulateInteraction(element1, new ValueSelection(2)); - simulateInteraction(element1, new ValueSelection(3)); - simulateInteraction(element1, new DummyInteraction("bla", 1)); - simulateInteraction(element1, new DummyInteraction("bla", 2)); - simulateInteraction(element1, new ValueSelection(1)); - simulateInteraction(element1, new ValueSelection(1)); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration interation1 {" + - " Selection selection1 {" + - " Interaction ValueSelection {}" + - " Interaction ValueSelection {}" + - " Interaction ValueSelection {}" + - " }" + - " }" + - " Interaction bla {}" + - " Interaction bla {}" + - " Iteration interation2 {" + - " Selection selection2 {" + - " Interaction ValueSelection {}" + - " Interaction ValueSelection {}" + - " }" + - " }" + - " Interaction bla {}" + - " Iteration interation3 {" + - " Selection selection3 {" + - " Interaction ValueSelection {}" + - " Interaction ValueSelection {}" + - " }" + - " }" + - " Interaction bla {}" + - " Interaction bla {}" + - " Iteration interation4 {" + - " Selection selection4 {" + - " Interaction ValueSelection {}" + - " }" + - " }" + - "}", getTaskTree()); - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO comment - * - * @version $Revision: $ $Date: 28.04.2012$ - * @author 2012, last modified by $Author: patrick$ - */ - //----------------------------------------------------------------------------------------------- - public class DummyTrackBar extends DummyGUIElement implements TrackBar - { - - //--------------------------------------------------------------------------------------------- /** * */ - //--------------------------------------------------------------------------------------------- - public DummyTrackBar() - { - super("DummyTrackBar"); + @Test + public void testSimpleDetection() throws Exception { + IGUIElement element1 = new DummyTrackBar(); + simulateEvent(new ValueSelection(1), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Event ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree()); + + simulateEvent(new ValueSelection(2), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree()); + + simulateEvent(new ValueSelection(3), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree()); + + simulateEvent(new ValueSelection(2), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree()); + + simulateEvent(new ValueSelection(3), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree()); + } - } + + /** + * + */ + @Test + public void testComplexDetection() throws Exception { + IGUIElement element1 = new DummyTrackBar(); + simulateEvent(new ValueSelection(1), element1); + simulateEvent(new ValueSelection(2), element1); + simulateEvent(new ValueSelection(3), element1); + simulateEvent(new ValueSelection(1), element1); + simulateEvent(new DummyInteraction("bla", 1), element1); + simulateEvent(new DummyInteraction("bla", 2), element1); + simulateEvent(new ValueSelection(2), element1); + simulateEvent(new ValueSelection(1), element1); + simulateEvent(new DummyInteraction("bla", 3), element1); + simulateEvent(new ValueSelection(3), element1); + simulateEvent(new ValueSelection(2), element1); + simulateEvent(new ValueSelection(3), element1); + simulateEvent(new DummyInteraction("bla", 1), element1); + simulateEvent(new DummyInteraction("bla", 2), element1); + simulateEvent(new ValueSelection(1), element1); + simulateEvent(new ValueSelection(1), element1); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + " Event bla {}" + + " Event bla {}" + + " Iteration interation2 {" + + " Selection selection2 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + " Event bla {}" + + " Iteration interation3 {" + + " Selection selection3 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + " Event bla {}" + + " Event bla {}" + + " Iteration interation4 {" + + " Selection selection4 {" + + " Event ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree()); + } + + /** + * TODO comment + * + * @version $Revision: $ $Date: 28.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ + public class DummyTrackBar extends DummyGUIElement implements ITrackBar { + + /** */ + private static final long serialVersionUID = 1L; + + /** + * + */ + public DummyTrackBar() { + super("DummyTrackBar"); + } + } } Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyGUIElement.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyGUIElement.java (revision 553) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyGUIElement.java (revision 557) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: DummyGUIElement.java,v $ // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 02.04.2012 $ @@ -5,11 +4,10 @@ // Creation : 2012 by patrick // Copyright : Patrick Harms, 2012 -//------------------------------------------------------------------------------------------------- + package de.ugoe.cs.quest.tasktrees.testutils; import de.ugoe.cs.quest.eventcore.guimodel.AbstractDefaultGUIElement; -import de.ugoe.cs.quest.eventcore.guimodel.GUIElement; +import de.ugoe.cs.quest.eventcore.guimodel.IGUIElement; -//------------------------------------------------------------------------------------------------- /** * TODO comment @@ -18,42 +16,46 @@ * @author 2012, last modified by $Author: patrick$ */ -//------------------------------------------------------------------------------------------------- -public class DummyGUIElement extends AbstractDefaultGUIElement - implements GUIElement -{ - /** */ - private String mName; +public class DummyGUIElement extends AbstractDefaultGUIElement implements IGUIElement { + + /** */ + private static final long serialVersionUID = 1L; - //--------------------------------------------------------------------------------------------- - /** - * - */ - //--------------------------------------------------------------------------------------------- - public DummyGUIElement(String name) - { - super(); - mName = name; - } + /** */ + private String name; - //----------------------------------------------------------------------------------------------- - /* (non-Javadoc) - * @see java.lang.Object#toString() - */ - //----------------------------------------------------------------------------------------------- - @Override - public String toString() - { - return mName; - } + /** + * + */ + public DummyGUIElement(String name) { + super(); + this.name = name; + } - //----------------------------------------------------------------------------------------------- - /* (non-Javadoc) - * @see de.harms.attef.userinteraction.GUIElement#equals(GUIElement) - */ - //----------------------------------------------------------------------------------------------- - public boolean equals(GUIElement other) - { - return this == other; - } + /* (non-Javadoc) + * @see de.ugoe.cs.quest.eventcore.IEventTarget#getPlatform() + */ + @Override + public String getPlatform() { + return "Dummy"; + } + + /* + * (non-Javadoc) + * + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return name; + } + + /* + * (non-Javadoc) + * + * @see de.harms.attef.userinteraction.GUIElement#equals(GUIElement) + */ + public boolean equals(IGUIElement other) { + return this == other; + } } Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyInteraction.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyInteraction.java (revision 553) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyInteraction.java (revision 557) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: DummyInteraction.java,v $ // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 02.04.2012 $ @@ -5,10 +4,9 @@ // Creation : 2012 by patrick // Copyright : Patrick Harms, 2012 -//------------------------------------------------------------------------------------------------- + package de.ugoe.cs.quest.tasktrees.testutils; -import de.ugoe.cs.quest.eventcore.userinteraction.Interaction; +import de.ugoe.cs.quest.eventcore.gui.IInteraction; -//------------------------------------------------------------------------------------------------- /** * TODO comment @@ -17,86 +15,75 @@ * @author 2012, last modified by $Author: patrick$ */ -//------------------------------------------------------------------------------------------------- -public class DummyInteraction implements Interaction -{ - /** */ - private int mInteractionNumber; - - /** */ - private String mInteractionType; - - //----------------------------------------------------------------------------------------------- - /** - * @param interactionNumber - * @param interactionType - */ - //----------------------------------------------------------------------------------------------- - public DummyInteraction(String interactionType, int interactionNumber) - { - super(); - mInteractionNumber = interactionNumber; - mInteractionType = interactionType; - } +public class DummyInteraction implements IInteraction { + + /** */ + private static final long serialVersionUID = 1L; - //----------------------------------------------------------------------------------------------- - /* (non-Javadoc) - * @see de.harms.attef.userinteraction.Interaction#getName() - */ - //----------------------------------------------------------------------------------------------- - public String getName() - { - return mInteractionType; - } + /** */ + private int interactionNumber; - //----------------------------------------------------------------------------------------------- - /* (non-Javadoc) - * @see java.lang.Object#toString() - */ - //----------------------------------------------------------------------------------------------- - @Override - public String toString() - { - return mInteractionType; - } + /** */ + private String interactionType; - //----------------------------------------------------------------------------------------------- - /* (non-Javadoc) - * @see de.harms.attef.userinteraction.Interaction#startsLogicalSequence() - */ - //----------------------------------------------------------------------------------------------- - public boolean startsLogicalSequence() - { - return false; - } + /** + * @param interactionNumber + * @param interactionType + */ + public DummyInteraction(String interactionType, int interactionNumber) { + super(); + this.interactionNumber = interactionNumber; + this.interactionType = interactionType; + } - //----------------------------------------------------------------------------------------------- - /* (non-Javadoc) - * @see de.harms.attef.userinteraction.Interaction#finishesLogicalSequence() - */ - //----------------------------------------------------------------------------------------------- - public boolean finishesLogicalSequence() - { - return false; - } + /* + * (non-Javadoc) + * + * @see de.harms.attef.userinteraction.Interaction#getName() + */ + public String getName() { + return interactionType; + } - //----------------------------------------------------------------------------------------------- - /** - * @return the interactionType - */ - //----------------------------------------------------------------------------------------------- - public String getInteractionType() - { - return mInteractionType; - } + /* + * (non-Javadoc) + * + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return interactionType; + } - //----------------------------------------------------------------------------------------------- - /** - * @return the interactionNumber - */ - //----------------------------------------------------------------------------------------------- - public int getInteractionNumber() - { - return mInteractionNumber; - } + /* + * (non-Javadoc) + * + * @see de.harms.attef.userinteraction.Interaction#startsLogicalSequence() + */ + public boolean startsLogicalSequence() { + return false; + } + + /* + * (non-Javadoc) + * + * @see de.harms.attef.userinteraction.Interaction#finishesLogicalSequence() + */ + public boolean finishesLogicalSequence() { + return false; + } + + /** + * @return the interactionType + */ + public String getInteractionType() { + return interactionType; + } + + /** + * @return the interactionNumber + */ + public int getInteractionNumber() { + return interactionNumber; + } } Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyTextField.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyTextField.java (revision 553) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyTextField.java (revision 557) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: DummyGUIElement.java,v $ // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 02.04.2012 $ @@ -5,10 +4,10 @@ // Creation : 2012 by patrick // Copyright : Patrick Harms, 2012 -//------------------------------------------------------------------------------------------------- + + package de.ugoe.cs.quest.tasktrees.testutils; -import de.ugoe.cs.quest.eventcore.guimodel.TextField; +import de.ugoe.cs.quest.eventcore.guimodel.ITextField; -//------------------------------------------------------------------------------------------------- /** * TODO comment @@ -17,18 +16,15 @@ * @author 2012, last modified by $Author: patrick$ */ -//------------------------------------------------------------------------------------------------- -public class DummyTextField extends DummyGUIElement - implements TextField -{ +public class DummyTextField extends DummyGUIElement implements ITextField { - //--------------------------------------------------------------------------------------------- - /** - * - */ - //--------------------------------------------------------------------------------------------- - public DummyTextField(String name) - { - super("text field \"" + name + "\""); - } + /** */ + private static final long serialVersionUID = 1L; + + /** + * + */ + public DummyTextField(String name) { + super("text field \"" + name + "\""); + } } Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/SimpleLogFormatter.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/SimpleLogFormatter.java (revision 553) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/SimpleLogFormatter.java (revision 557) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: TestLogger.java,v $ // Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 26.11.2011 15:26:38 $ @@ -5,5 +4,4 @@ // Creation : 2011 by Patrick // Copyright : Patrick Harms, 2011 -//------------------------------------------------------------------------------------------------- package de.ugoe.cs.quest.tasktrees.testutils; @@ -16,74 +14,58 @@ import java.util.logging.LogRecord; - -//------------------------------------------------------------------------------------------------- /** * TODO comment - * + * * @version $Revision: $ $Date: $ - * @author 2011, last modified by $Author: $ + * @author 2011, last modified by $Author: $ */ -//------------------------------------------------------------------------------------------------- +public class SimpleLogFormatter extends Formatter { -public class SimpleLogFormatter extends Formatter -{ - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - @Override - public String format(LogRecord record) - { - StringBuffer result = new StringBuffer(); - result.append(record.getLevel().getName().charAt(0)); - result.append(" | "); - result.append(new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss,SSS").format(record.getMillis())); - result.append(" | "); - tailValue("" + record.getThreadID(), 6, result); - result.append(" | "); - tailValue(record.getLoggerName(), 30, result); - result.append(" | "); - result.append(record.getMessage()); - - if (record.getThrown() != null) - { - ByteArrayOutputStream out = new ByteArrayOutputStream(); - record.getThrown().printStackTrace(new PrintStream(out)); - result.append("\n"); - result.append(out.toString()); - try - { - out.close(); - } - catch (IOException e) - { - // ignore - } + /** + * + */ + @Override + public String format(LogRecord record) { + StringBuffer result = new StringBuffer(); + result.append(record.getLevel().getName().charAt(0)); + result.append(" | "); + result.append(new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss,SSS").format(record.getMillis())); + result.append(" | "); + tailValue("" + record.getThreadID(), 6, result); + result.append(" | "); + tailValue(record.getLoggerName(), 30, result); + result.append(" | "); + result.append(record.getMessage()); + + if (record.getThrown() != null) { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + record.getThrown().printStackTrace(new PrintStream(out)); + result.append("\n"); + result.append(out.toString()); + try { + out.close(); + } + catch (IOException e) { + // ignore + } + } + + result.append("\n"); + + return result.toString(); } - - result.append("\n"); - - return result.toString(); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - private void tailValue(String value, int length, StringBuffer output) - { - for (int i = value.length() - length - 1; i < value.length(); i++) - { - if (i < 0) - { - output.append(" "); - } - else - { - output.append(value.charAt(i)); - } + + /** + * + */ + private void tailValue(String value, int length, StringBuffer output) { + for (int i = value.length() - length - 1; i < value.length(); i++) { + if (i < 0) { + output.append(" "); + } + else { + output.append(value.charAt(i)); + } + } } - } } Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/TaskTreeChecker.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/TaskTreeChecker.java (revision 553) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/TaskTreeChecker.java (revision 557) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: TaskTreeChecker.java,v $ // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 01.04.2012 $ @@ -5,5 +4,5 @@ // Creation : 2012 by patrick // Copyright : Patrick Harms, 2012 -//------------------------------------------------------------------------------------------------- + package de.ugoe.cs.quest.tasktrees.testutils; @@ -21,14 +20,14 @@ import java.util.regex.Pattern; -import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; -import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; -import de.ugoe.cs.quest.tasktrees.treeifc.NodeInfo; -import de.ugoe.cs.quest.tasktrees.treeifc.Selection; -import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; -import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; -import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; -import de.ugoe.cs.quest.tasktrees.treeifc.TextInputInteractionTask; - -//------------------------------------------------------------------------------------------------- +import de.ugoe.cs.quest.eventcore.guimodel.IGUIElement; +import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.quest.tasktrees.treeifc.IIteration; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeInfo; +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITextInputEventTask; + /** * TODO comment @@ -37,537 +36,436 @@ * @author 2012, last modified by $Author: patrick$ */ -//------------------------------------------------------------------------------------------------- -public class TaskTreeChecker -{ - /** */ - private boolean mDoTrace; - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment +public class TaskTreeChecker { + + /** */ + private boolean doTrace; + + /** + * TODO: comment + * + */ + public TaskTreeChecker() { + this(false); + } + + /** + * TODO: comment + * + */ + public TaskTreeChecker(boolean doTrace) { + this.doTrace = doTrace; + } + + /** + * + */ + public void assertTaskTree(String taskTreeSpec, ITaskTree taskTree) { + Map taskMapCopy = new HashMap(); + + for (Map.Entry entry : taskTree.getTaskMap().entrySet()) { + if (entry.getValue().getNoOfOccurencesInTree() > 0) { + taskMapCopy.put(entry.getKey(), entry.getValue().getNoOfOccurencesInTree()); + } + else { + taskMapCopy.put(entry.getKey(), 1); + } + } + + if (doTrace) { + dumpTaskMap(taskMapCopy); + } + + TaskSpec task = null; + + Matcher matcher = Pattern.compile + ("(\\s*(\\w+)\\s+(\\w+)\\s+((\\w*\\s)*)(\\{))|((\\}))").matcher(taskTreeSpec); + + do { + if (!matcher.find()) { + if (!matcher.hitEnd()) { + throw new IllegalArgumentException("could not parse task specification"); + } + else { + break; + } + } + + task = parseTask(matcher); + if (task != null) { + assertTaskAndChildrenInMapAndRemove(task, taskMapCopy); + } + } + while (task != null); + + assertTrue("more tasks in map, than expected", taskMapCopy.isEmpty()); + } + + /** + * TODO: comment + * + * @param taskTree + */ + public void dumpAsCheckString(ITaskTree taskTree) { + dumpNodeAsCheckString(taskTree.getRoot(), new int[4], ""); + } + + /** + * TODO: comment + * + * @param root + * @param string + */ + private void dumpNodeAsCheckString(ITaskTreeNode node, int[] typeCounters, String indent) { + System.err.print(" \""); + System.err.print(indent); + + if (node instanceof ISequence) { + System.err.print("Sequence sequence"); + System.err.print(typeCounters[0]++); + System.err.println(" {\" +"); + } + else if (node instanceof IIteration) { + System.err.print("Iteration iteration"); + System.err.print(typeCounters[1]++); + System.err.println(" {\" +"); + } + else if (node instanceof ISelection) { + System.err.print("Selection selection"); + System.err.print(typeCounters[2]++); + System.err.println(" {\" +"); + } + else if (node instanceof ITextInputEventTask) { + System.err.print("TextInputEvent textInput"); + System.err.print(typeCounters[3]++); + System.err.print(" "); + System.err.print(((ITextInputEventTask) node).getEnteredText()); + System.err.println(" {\" +"); + } + else if (node instanceof IEventTask) { + System.err.print("Event "); + System.err.print(((IEventTask) node).getEventType().getName()); + System.err.print(" {}\" +"); + } + else { + fail("unknown type of node in task tree " + node); + } + + for (ITaskTreeNode child : node.getChildren()) { + dumpNodeAsCheckString(child, typeCounters, indent + " "); + } + + if (!(node instanceof IEventTask) || (node instanceof ITextInputEventTask)) { + System.err.print(" \""); + System.err.print(indent); + System.err.print("}\" +"); + } + + System.err.println(); + } + + /** + * TODO: comment + * + * @param taskTree + */ + public void dumpFullTaskTree(ITaskTree taskTree) throws FileNotFoundException { + PrintWriter out = null; + try { + out = new PrintWriter(new FileOutputStream("taskTree.txt")); + dumpFullNode(taskTree.getRoot(), out, ""); + } + finally { + if (out != null) { + out.close(); + } + } + + } + + /** + * + */ + private void dumpFullNode(ITaskTreeNode node, PrintWriter out, String indent) { + out.print(indent); + if (node instanceof ISequence) { + out.println("Sequence"); + out.print(indent); + out.println("{"); + } + else if (node instanceof IIteration) { + out.println("Iteration"); + out.print(indent); + out.println("{"); + } + else if (node instanceof ISelection) { + out.println("Selection"); + out.print(indent); + out.println("{"); + } + else if (node instanceof ITextInputEventTask) { + out.print("TextInputEvent"); + out.print(" "); + out.println(((ITextInputEventTask) node).getEnteredText()); + out.print(indent); + out.println("{"); + } + else if (node instanceof IEventTask) { + out.print(((IEventTask) node).getEventType().getName()); + out.print(" "); + out.print(((IEventTask) node).getEventTarget()); + if (((IEventTask) node).getEventTarget() instanceof IGUIElement) + { + out.print(" "); + out.print(((IGUIElement) ((IEventTask) node).getEventTarget()).getOriginalTypeInfo()); + } + } + else { + fail("unknown type of node in task tree " + node); + } + + for (ITaskTreeNode child : node.getChildren()) { + dumpFullNode(child, out, indent + " "); + } + + if (!(node instanceof IEventTask) || (node instanceof ITextInputEventTask)) { + out.print(indent); + out.print("}"); + } + + out.println(); + } + + /** + * + */ + private TaskSpec parseTask(Matcher tokenMatcher) { + String firstToken = tokenMatcher.group(); + + if ("}".equals(firstToken)) { + throw new IllegalArgumentException("found a closing bracket at an unexpected place"); + } + + TaskSpec task = new TaskSpec(); + task.type = tokenMatcher.group(2); + task.name = tokenMatcher.group(3); + task.additionalInfo = tokenMatcher.group(4).trim(); + + if ("".equals(task.name)) { + task.name = null; + } + + if (!tokenMatcher.find()) { + throw new IllegalArgumentException("could not parse task specification"); + } + + firstToken = tokenMatcher.group(); + + if (!"}".equals(firstToken)) { + ArrayList children = new ArrayList(); + + TaskSpec child = null; + + do { + child = parseTask(tokenMatcher); + + if (child != null) { + children.add(child); + + if (!tokenMatcher.find()) { + throw new IllegalArgumentException("could not parse task specification"); + } + + firstToken = tokenMatcher.group(); + + if ("}".equals(firstToken)) { + break; + } + } + + } + while (child != null); + + task.children = children.toArray(new TaskSpec[children.size()]); + } + + return task; + } + + /** + * @param task + * @param taskMapCopy + */ + private void assertTaskAndChildrenInMapAndRemove(TaskSpec task, + Map taskMap) + { + for (Map.Entry entry : taskMap.entrySet()) { + if (taskSpecEqualsTask(task, entry.getKey())) { + if (task.children != null) { + for (TaskSpec child : task.children) { + assertTaskAndChildrenInMapAndRemove(child, taskMap); + } + } + + int count = taskMap.get(entry.getKey()); + if (count == 1) { + taskMap.remove(entry.getKey()); + } + else { + taskMap.put(entry.getKey(), count - 1); + } + return; + } + } + + fail("expected task " + task.type + " " + task.name + + " not included in task map"); + } + + /** + * + */ + private boolean taskSpecEqualsTask(TaskSpec taskSpec, ITaskTreeNode task) { + if (doTrace) { + System.err.println("comparing " + taskSpec.name + " with"); + dumpTask(task, 0, ""); + } + + if (("Event".equals(taskSpec.type) && (!(task instanceof IEventTask))) || + ("TextInputEvent".equals(taskSpec.type) && (!(task instanceof ITextInputEventTask))) || + ("Sequence".equals(taskSpec.type) && (!(task instanceof ISequence))) || + ("Selection".equals(taskSpec.type) && (!(task instanceof ISelection))) || + ("Iteration".equals(taskSpec.type) && (!(task instanceof IIteration)))) + { + if (doTrace) { + System.err.println("task types do not match: " + taskSpec.type + " != " + + task.getClass().getSimpleName() + "\n"); + } + return false; + } + else if (!"Event".equals(taskSpec.type) && + !"TextInputEvent".equals(taskSpec.type) && + !"Sequence".equals(taskSpec.type) && + !"Selection".equals(taskSpec.type) && + !"Iteration".equals(taskSpec.type)) + { + fail("unknown task type " + taskSpec.type + " --> please extend test case"); + } + + if ("TextInputEvent".equals(taskSpec.type)) { + if (!"".equals(taskSpec.additionalInfo) && + !(taskSpec.additionalInfo.equals(((ITextInputEventTask) task).getEnteredText()))) + { + if (doTrace) { + System.err.println("expected text \"" + taskSpec.additionalInfo + + "\" is not equal to the text " + "provided by the task \"" + + ((ITextInputEventTask) task).getEnteredText() + "\"\n"); + } + return false; + } + } + else if ((task instanceof IEventTask) && (((IEventTask) task).getEventType() != null) && + (!taskSpec.name.equals(((IEventTask) task).getEventType().getName()))) + { + // simple event names do not match. But what about the event name in + // combination with the additional info + String complexName = + taskSpec.name + + (!"".equals(taskSpec.additionalInfo) ? " " + taskSpec.additionalInfo : ""); + + if (!complexName.equals(((IEventTask) task).getEventType().getName())) { + if (doTrace) { + System.err.println("event names do not match: " + taskSpec.name + " != " + + ((IEventTask) task).getEventType().getName() + "\n"); + } + return false; + } + } + + if (((taskSpec.children == null) && (task.getChildren().size() > 0)) || + ((taskSpec.children != null) && (taskSpec.children.length != task.getChildren().size()))) + { + if (doTrace) { + System.err.println + ("numbers of children do not match: " + + (taskSpec.children == null ? "0" : taskSpec.children.length) + " != " + + (task.getChildren() == null ? "0" : task.getChildren().size()) + "\n"); + } + return false; + } + + Iterator children = task.getChildren().iterator(); + if (taskSpec.children != null) { + for (TaskSpec child : taskSpec.children) { + if (!taskSpecEqualsTask(child, children.next())) { + if (doTrace) { + System.err.println("one of the children does not match\n"); + } + return false; + } + } + } + + if (!children.hasNext()) { + if (doTrace) { + System.err.println("nodes match\n"); + } + return true; + } + else { + if (doTrace) { + System.err.println("number of children does not match\n"); + } + return false; + } + } + + /** * */ - //----------------------------------------------------------------------------------------------- - public TaskTreeChecker() - { - this(false); - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment + private void dumpTaskMap(Map taskMap) { + System.err.println(); + for (Map.Entry entry : taskMap.entrySet()) { + dumpTask(entry.getKey(), entry.getValue(), ""); + System.err.println(); + } + } + + /** * */ - //----------------------------------------------------------------------------------------------- - public TaskTreeChecker(boolean doTrace) - { - mDoTrace = doTrace; - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - public void assertTaskTree(String taskTreeSpec, TaskTree taskTree) - { - Map taskMapCopy = new HashMap(); - - for (Map.Entry entry : taskTree.getTaskMap().entrySet()) - { - if (entry.getValue().getNoOfOccurencesInTree() > 0) - { - taskMapCopy.put(entry.getKey(), entry.getValue().getNoOfOccurencesInTree()); - } - else - { - taskMapCopy.put(entry.getKey(), 1); - } - } - - if (mDoTrace) - { - dumpTaskMap(taskMapCopy); - } - - TaskSpec task = null; - - Matcher matcher = - Pattern.compile("(\\s*(\\w+)\\s+(\\w+)\\s+((\\w*\\s)*)(\\{))|((\\}))").matcher(taskTreeSpec); - - do - { - if (!matcher.find()) - { - if (!matcher.hitEnd()) - { - throw new IllegalArgumentException("could not parse task specification"); - } - else - { - break; - } - } - - task = parseTask(matcher); - if (task != null) - { - assertTaskAndChildrenInMapAndRemove(task, taskMapCopy); - } - } - while (task != null); - - assertTrue("more tasks in map, than expected", taskMapCopy.isEmpty()); - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param taskTree - */ - //----------------------------------------------------------------------------------------------- - public void dumpAsCheckString(TaskTree taskTree) - { - dumpNodeAsCheckString(taskTree.getRoot(), new int[4], ""); - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param root - * @param string - */ - //----------------------------------------------------------------------------------------------- - private void dumpNodeAsCheckString(TaskTreeNode node, - int[] typeCounters, - String indent) - { - System.err.print(" \""); - System.err.print(indent); - - if (node instanceof Sequence) - { - System.err.print("Sequence sequence"); - System.err.print(typeCounters[0]++); - System.err.println(" {\" +"); - } - else if (node instanceof Iteration) - { - System.err.print("Iteration iteration"); - System.err.print(typeCounters[1]++); - System.err.println(" {\" +"); - } - else if (node instanceof Selection) - { - System.err.print("Selection selection"); - System.err.print(typeCounters[2]++); - System.err.println(" {\" +"); - } - else if (node instanceof TextInputInteractionTask) - { - System.err.print("TextInputInteraction textInput"); - System.err.print(typeCounters[3]++); - System.err.print(" "); - System.err.print(((TextInputInteractionTask) node).getEnteredText()); - System.err.println(" {\" +"); - } - else if (node instanceof InteractionTask) - { - System.err.print("Interaction "); - System.err.print(((InteractionTask) node).getInteraction().getName()); - System.err.print(" {}\" +"); - } - else - { - fail("unknown type of node in task tree " + node); - } - - for (TaskTreeNode child : node.getChildren()) - { - dumpNodeAsCheckString(child, typeCounters, indent + " "); - } - - if (!(node instanceof InteractionTask) || - (node instanceof TextInputInteractionTask)) - { - System.err.print(" \""); - System.err.print(indent); - System.err.print("}\" +"); - } - - System.err.println(); - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param taskTree - */ - //----------------------------------------------------------------------------------------------- - public void dumpFullTaskTree(TaskTree taskTree) throws FileNotFoundException - { - PrintWriter out = null; - try - { - out = new PrintWriter(new FileOutputStream("taskTree.txt")); - dumpFullNode(taskTree.getRoot(), out, ""); - } - finally - { - if (out != null) - { - out.close(); - } - } - - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - private void dumpFullNode(TaskTreeNode node, PrintWriter out, String indent) - { - out.print(indent); - if (node instanceof Sequence) - { - out.println("Sequence"); - out.print(indent); - out.println("{"); - } - else if (node instanceof Iteration) - { - out.println("Iteration"); - out.print(indent); - out.println("{"); - } - else if (node instanceof Selection) - { - out.println("Selection"); - out.print(indent); - out.println("{"); - } - else if (node instanceof TextInputInteractionTask) - { - out.print("TextInputInteraction"); - out.print(" "); - out.println(((TextInputInteractionTask) node).getEnteredText()); - out.print(indent); - out.println("{"); - } - else if (node instanceof InteractionTask) - { - out.print(((InteractionTask) node).getInteraction().getName()); - out.print(" "); - out.print(((InteractionTask) node).getGUIElement()); - out.print(" "); - out.print(((InteractionTask) node).getGUIElement().getOriginalTypeInfo()); - } - else - { - fail("unknown type of node in task tree " + node); - } - - for (TaskTreeNode child : node.getChildren()) - { - dumpFullNode(child, out, indent + " "); - } - - if (!(node instanceof InteractionTask) || - (node instanceof TextInputInteractionTask)) - { - out.print(indent); - out.print("}"); - } - - out.println(); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - private TaskSpec parseTask(Matcher tokenMatcher) - { - String firstToken = tokenMatcher.group(); - - if ("}".equals(firstToken)) - { - throw new IllegalArgumentException("found a closing bracket at an unexpected place"); - } - - TaskSpec task = new TaskSpec(); - task.type = tokenMatcher.group(2); - task.interactionName = tokenMatcher.group(3); - task.additionalInfo = tokenMatcher.group(4).trim(); - - if ("".equals(task.interactionName)) - { - task.interactionName = null; - } - - if (!tokenMatcher.find()) - { - throw new IllegalArgumentException("could not parse task specification"); - } - - firstToken = tokenMatcher.group(); - - if (!"}".equals(firstToken)) - { - ArrayList children = new ArrayList(); - - TaskSpec child = null; - - do - { - child = parseTask(tokenMatcher); - - if (child != null) - { - children.add(child); - - if (!tokenMatcher.find()) - { - throw new IllegalArgumentException("could not parse task specification"); - } - - firstToken = tokenMatcher.group(); - - if ("}".equals(firstToken)) - { - break; - } - } - - } - while (child != null); - - task.children = children.toArray(new TaskSpec[children.size()]); - } - - return task; - } - - //----------------------------------------------------------------------------------------------- - /** - * @param task - * @param taskMapCopy - */ - //----------------------------------------------------------------------------------------------- - private void assertTaskAndChildrenInMapAndRemove(TaskSpec task, - Map taskMap) - { - for (Map.Entry entry : taskMap.entrySet()) - { - if (taskSpecEqualsTask(task, entry.getKey())) - { - if (task.children != null) - { - for (TaskSpec child : task.children) - { - assertTaskAndChildrenInMapAndRemove(child, taskMap); - } - } - - int count = taskMap.get(entry.getKey()); - if (count == 1) - { - taskMap.remove(entry.getKey()); - } - else - { - taskMap.put(entry.getKey(), count - 1); - } - return; - } - } - - fail("expected task " + task.type + " " + task.interactionName + " not included in task map"); - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - private boolean taskSpecEqualsTask(TaskSpec taskSpec, TaskTreeNode task) - { - if (mDoTrace) - { - System.err.println("comparing " + taskSpec.interactionName + " with"); - dumpTask(task, 0, ""); - } - - if (("Interaction".equals(taskSpec.type) && (!(task instanceof InteractionTask))) || - ("TextInputInteraction".equals(taskSpec.type) && - (!(task instanceof TextInputInteractionTask))) || - ("Sequence".equals(taskSpec.type) && (!(task instanceof Sequence))) || - ("Selection".equals(taskSpec.type) && (!(task instanceof Selection))) || - ("Iteration".equals(taskSpec.type) && (!(task instanceof Iteration)))) - { - if (mDoTrace) - { - System.err.println("task types do not match: " + taskSpec.type + " != " + - task.getClass().getSimpleName() + "\n"); - } - return false; - } - else if (!"Interaction".equals(taskSpec.type) && - !"TextInputInteraction".equals(taskSpec.type) && - !"Sequence".equals(taskSpec.type) && - !"Selection".equals(taskSpec.type) && - !"Iteration".equals(taskSpec.type)) - { - fail("unknown task type " + taskSpec.type + " --> please extend test case"); - } - - if ("TextInputInteraction".equals(taskSpec.type)) - { - if (!"".equals(taskSpec.additionalInfo) && - !(taskSpec.additionalInfo.equals(((TextInputInteractionTask) task).getEnteredText()))) - { - if (mDoTrace) - { - System.err.println - ("expected text \"" + taskSpec.additionalInfo + "\" is not equal to the text " + - "provided by the task \"" + ((TextInputInteractionTask) task).getEnteredText() + - "\"\n"); - } - return false; - } - } - else if ((task instanceof InteractionTask) && - (((InteractionTask) task).getInteraction() != null) && - (!taskSpec.interactionName.equals(((InteractionTask) task).getInteraction().getName()))) - { - // simple interaction names do not match. But what about the interaction name in combination - // with the additional info - String complexInteractionName = taskSpec.interactionName + - (!"".equals(taskSpec.additionalInfo) ? " " + taskSpec.additionalInfo : ""); - - if (!complexInteractionName.equals(((InteractionTask) task).getInteraction().getName())) - { - if (mDoTrace) - { - System.err.println("interaction names do not match: " + taskSpec.interactionName + - " != " + ((InteractionTask) task).getInteraction().getName() + "\n"); - } - return false; - } - } - - if (((taskSpec.children == null) && (task.getChildren().size() > 0)) || - ((taskSpec.children != null) && (taskSpec.children.length != task.getChildren().size()))) - { - if (mDoTrace) - { - System.err.println("numbers of children do not match: " + - (taskSpec.children == null ? "0" : taskSpec.children.length) + " != " + - (task.getChildren() == null ? "0" : task.getChildren().size()) + "\n"); - } - return false; - } - - Iterator children = task.getChildren().iterator(); - if (taskSpec.children != null) - { - for (TaskSpec child : taskSpec.children) - { - if (!taskSpecEqualsTask(child, children.next())) - { - if (mDoTrace) - { - System.err.println("one of the children does not match\n"); - } - return false; - } - } - } - - if (!children.hasNext()) - { - if (mDoTrace) - { - System.err.println("nodes match\n"); - } - return true; - } - else - { - if (mDoTrace) - { - System.err.println("number of children does not match\n"); - } - return false; - } - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - private void dumpTaskMap(Map taskMap) - { - System.err.println(); - for (Map.Entry entry : taskMap.entrySet()) - { - dumpTask(entry.getKey(), entry.getValue(), ""); - System.err.println(); - } - } - - //----------------------------------------------------------------------------------------------- - /** - * - */ - //----------------------------------------------------------------------------------------------- - private void dumpTask(TaskTreeNode task, int count, String indent) - { - System.err.print(indent); - System.err.print(task); - System.err.print(" "); - System.err.print(task.getDescription()); - System.err.print(" "); - - if (count > 0) - { - System.err.print("("); - System.err.print(count); - System.err.print(" occurrences)"); - } - - System.err.println(); - - if ((task.getChildren() != null) && (task.getChildren().size() > 0)) - { - for (TaskTreeNode child : task.getChildren()) - { - dumpTask(child, 0, indent + " "); - } - } - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO comment - * - * @version $Revision: $ $Date: $ - * @author 2011, last modified by $Author: $ - */ - //----------------------------------------------------------------------------------------------- - private class TaskSpec - { - public String type; - public String interactionName; - public String additionalInfo; - public TaskSpec[] children; - } + private void dumpTask(ITaskTreeNode task, int count, String indent) { + System.err.print(indent); + System.err.print(task); + System.err.print(" "); + System.err.print(task.getDescription()); + System.err.print(" "); + + if (count > 0) { + System.err.print("("); + System.err.print(count); + System.err.print(" occurrences)"); + } + + System.err.println(); + + if ((task.getChildren() != null) && (task.getChildren().size() > 0)) { + for (ITaskTreeNode child : task.getChildren()) { + dumpTask(child, 0, indent + " "); + } + } + } + + /** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ + private class TaskSpec { + public String type; + public String name; + public String additionalInfo; + public TaskSpec[] children; + } } Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/Utilities.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/Utilities.java (revision 553) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/Utilities.java (revision 557) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: TestUtils.java,v $ // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 02.04.2012 $ @@ -5,10 +4,10 @@ // Creation : 2012 by patrick // Copyright : Patrick Harms, 2012 -//------------------------------------------------------------------------------------------------- + + package de.ugoe.cs.quest.tasktrees.testutils; import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; -//------------------------------------------------------------------------------------------------- /** * TODO comment @@ -17,27 +16,22 @@ * @author 2012, last modified by $Author: patrick$ */ -//------------------------------------------------------------------------------------------------- -public class Utilities -{ - /** */ - private static final NodeEqualityRuleManager NODE_EQUALITY_RULE_MANAGER = - new NodeEqualityRuleManager(); - - static - { - NODE_EQUALITY_RULE_MANAGER.init(); - } +public class Utilities { + + /** */ + private static final NodeEqualityRuleManager NODE_EQUALITY_RULE_MANAGER = + new NodeEqualityRuleManager(); - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @return - */ - //----------------------------------------------------------------------------------------------- - public static NodeEqualityRuleManager getNodeEqualityRuleManagerForTests() - { - return NODE_EQUALITY_RULE_MANAGER; - } + static { + NODE_EQUALITY_RULE_MANAGER.init(); + } + + /** + * TODO: comment + * + * @return + */ + public static NodeEqualityRuleManager getNodeEqualityRuleManagerForTests() { + return NODE_EQUALITY_RULE_MANAGER; + } } Index: trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeImplTest.java =================================================================== --- trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeImplTest.java (revision 553) +++ trunk/quest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeImplTest.java (revision 557) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: TaskTreeImplTest.java,v $ // Version : $Revision: 0.0 $ $Author: patrick $ $Date: 02.04.2012 $ @@ -5,5 +4,6 @@ // Creation : 2012 by patrick // Copyright : Patrick Harms, 2012 -//------------------------------------------------------------------------------------------------- + + package de.ugoe.cs.quest.tasktrees.treeimpl; @@ -19,15 +19,14 @@ import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; -import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; -import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; -import de.ugoe.cs.quest.tasktrees.treeifc.NodeInfo; -import de.ugoe.cs.quest.tasktrees.treeifc.Selection; -import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; -import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; -import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; -import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; -import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; - -//------------------------------------------------------------------------------------------------- +import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.quest.tasktrees.treeifc.IIteration; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeInfo; +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; + /** * TODO comment @@ -36,511 +35,436 @@ * @author 2012, last modified by $Author: patrick$ */ -//------------------------------------------------------------------------------------------------- -public class TaskTreeImplTest -{ - /** */ - private static final int MAX_TREE_DEPTH = 15; - - /** */ - private TaskTreeBuilder mTaskTreeBuilder = new TaskTreeBuilderImpl(); - - /** */ - private TaskTreeNodeFactory mTaskTreeNodeFactory = new TaskTreeNodeFactoryImpl(); - - //----------------------------------------------------------------------------------------------- - /** - * @throws Exception - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testRandomTrees() throws Exception - { - int noOfTrees = 10; - int noOfMaxChildren = 8; - int maxDepth = MAX_TREE_DEPTH; +public class TaskTreeImplTest { - for (int i = 0; i < noOfTrees; i++) - { - System.err.println("iteration " + (i + 1) + ":"); - System.err.println(" creating tree"); - Map treeInfos = new HashMap(); - TaskTreeNode rootNode = createTree(noOfMaxChildren, maxDepth, treeInfos); - System.err.println(" creating task tree"); - TaskTree taskTree = mTaskTreeNodeFactory.createTaskTree(rootNode); - - System.err.println(" validating task tree"); - assertEquals(rootNode, taskTree.getRoot()); - assertMapsEqual(treeInfos, taskTree.getTaskMap()); - } - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param treeInfos - * @param taskMap - */ - //----------------------------------------------------------------------------------------------- - private void assertMapsEqual(Map map1, - Map map2) - { - try - { - if (map1 == null) - { - assertNull(map2); - return; - } - - assertEquals(map1.size(), map2.size()); - - for (Map.Entry entry : map1.entrySet()) - { - NodeInfo value2 = map2.get(entry.getKey()); - assertNotNull(value2); - assertEquals(entry.getValue().getTask(), value2.getTask()); - assertEquals(entry.getValue().getNoOfOccurencesInTree(), value2.getNoOfOccurencesInTree()); - } - } - catch (AssertionError e) - { - dumpMap(map1); - dumpMap(map2); - throw e; - } - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param map2 - */ - //----------------------------------------------------------------------------------------------- - private void dumpMap(Map map) - { - System.err.println(); - - if (map == null) - { - System.err.println("map is null"); - } - else - { - System.err.println("map:"); - for (Map.Entry entry : map.entrySet()) - { - System.err.print(" "); - System.err.print(entry.getKey()); - for (int i = entry.getKey().toString().length(); i < 49; i++) + /** */ + private static final int MAX_TREE_DEPTH = 15; + + /** */ + private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder(); + + /** */ + private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory(); + + /** + * @throws Exception + * + */ + @Test + public void testRandomTrees() throws Exception { + int noOfTrees = 10; + int noOfMaxChildren = 8; + int maxDepth = MAX_TREE_DEPTH; + + for (int i = 0; i < noOfTrees; i++) { + System.err.println("iteration " + (i + 1) + ":"); + System.err.println(" creating tree"); + Map treeInfos = + new HashMap(); + ITaskTreeNode rootNode = createTree(noOfMaxChildren, maxDepth, treeInfos); + System.err.println(" creating task tree"); + ITaskTree taskTree = taskTreeNodeFactory.createTaskTree(rootNode); + + System.err.println(" validating task tree"); + assertEquals(rootNode, taskTree.getRoot()); + assertMapsEqual(treeInfos, taskTree.getTaskMap()); + } + } + + /** + * TODO: comment + * + * @param treeInfos + * @param taskMap + */ + private void assertMapsEqual(Map map1, + Map map2) + { + try { + if (map1 == null) { + assertNull(map2); + return; + } + + assertEquals(map1.size(), map2.size()); + + for (Map.Entry entry : map1.entrySet()) { + ITaskTreeNodeInfo value2 = map2.get(entry.getKey()); + assertNotNull(value2); + assertEquals(entry.getValue().getTask(), value2.getTask()); + assertEquals(entry.getValue().getNoOfOccurencesInTree(), + value2.getNoOfOccurencesInTree()); + } + } + catch (AssertionError e) { + dumpMap(map1); + dumpMap(map2); + throw e; + } + } + + /** + * TODO: comment + * + * @param map2 + */ + private void dumpMap(Map map) { + System.err.println(); + + if (map == null) { + System.err.println("map is null"); + } + else { + System.err.println("map:"); + for (Map.Entry entry : map.entrySet()) { + System.err.print(" "); + System.err.print(entry.getKey()); + for (int i = entry.getKey().toString().length(); i < 49; i++) { + System.err.print(" "); + } + System.err.print(" : "); + System.err.println(entry.getValue()); + } + } + + System.err.println(); + } + + /** + * TODO: comment + * + * @param noOfMaxChildren + * @param maxDepth + * @param treeInfos + * @return + */ + private ITaskTreeNode createTree(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + /* + * for (int i = 0; i < (MAX_TREE_DEPTH + 1 - maxDepth); i++) { System.err.print(" "); } + */ + + ITaskTreeNode tree; + + // integrating the maximum depth here assures, that either something between 0 and 8 will + // be the type, or if the max depth decreases near 0 only event tasks will be created + // to finish the tree creation + int type = (int) (Math.random() * (Math.min(8, maxDepth))); + + switch (type) { - System.err.print(" "); - } - System.err.print(" : "); - System.err.println(entry.getValue()); - } - } - - System.err.println(); - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param noOfMaxChildren - * @param maxDepth - * @param treeInfos - * @return - */ - //----------------------------------------------------------------------------------------------- - private TaskTreeNode createTree(int maxNoOfChildren, - int maxDepth, - Map treeInfos) - throws Exception - { - /*for (int i = 0; i < (MAX_TREE_DEPTH + 1 - maxDepth); i++) - { - System.err.print(" "); - }*/ - - TaskTreeNode tree; - - // integrating the maximum depth here assures, that either something between 0 and 8 will - // be the type, or if the max depth decreases near 0 only interaction tasks will be created - // to finish the tree creation - int type = (int) (Math.random() * (Math.min(8, maxDepth))); - - switch (type) - { - case 0: - { - //System.err.print("creating new interaction task "); - tree = createNewInteractionTask(treeInfos); - break; - } - case 1: - { - //System.err.print("reusing interaction task "); - tree = reuseInteractionTask(treeInfos); - break; - } - case 2: - { - //System.err.println("creating new sequence {"); - tree = createNewSequence(maxNoOfChildren, maxDepth, treeInfos); - break; - } - case 3: - { - //System.err.println("reusing sequence {"); - tree = reuseSequence(maxNoOfChildren, maxDepth, treeInfos); - break; - } - case 4: - { - //System.err.println("creating new selection {"); - tree = createNewSelection(maxNoOfChildren, maxDepth, treeInfos); - break; - } - case 5: - { - //System.err.println("reusing selection {"); - tree = reuseSelection(maxNoOfChildren, maxDepth, treeInfos); - break; - } - case 6: - { - //System.err.println("creating new iteration {"); - tree = createNewIteration(maxNoOfChildren, maxDepth, treeInfos); - break; - } - case 7: - { - //System.err.println("reusing iteration {"); - tree = reuseIteration(maxNoOfChildren, maxDepth, treeInfos); - break; - } - default: - { - //System.err.print("creating new interaction task per default "); - tree = createNewInteractionTask(treeInfos); - } - } - - /* - if (!(tree instanceof InteractionTask)) - { - for (int i = 0; i < (MAX_TREE_DEPTH + 1 - maxDepth); i++) - { - System.err.print(" "); - } - - System.err.print("} "); - } - - System.err.println(tree);*/ - - return tree; - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param treeInfos - * @return - */ - //----------------------------------------------------------------------------------------------- - private InteractionTask createNewInteractionTask(Map treeInfos) - throws Exception - { - Thread.sleep(2); - long id = System.currentTimeMillis(); - InteractionTask task = mTaskTreeNodeFactory.createNewInteractionTask - (new DummyGUIElement("elem" + id), new DummyInteraction("interaction" + id, 1)); - - treeInfos.put(task, new NodeInfoImpl(task)); - - return task; - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param treeInfos - * @return - */ - //----------------------------------------------------------------------------------------------- - private InteractionTask reuseInteractionTask(Map treeInfos) - throws Exception - { - int noOfInteractionTasks = 0; - - for (Map.Entry entry : treeInfos.entrySet()) - { - if (entry.getKey() instanceof InteractionTask) - { - noOfInteractionTasks++; - } - } - - if (noOfInteractionTasks > 0) - { - noOfInteractionTasks = (int) (Math.random() * noOfInteractionTasks); - - for (Map.Entry entry : treeInfos.entrySet()) - { - if (entry.getKey() instanceof InteractionTask) - { - if (--noOfInteractionTasks <= 0) - { - return (InteractionTask) entry.getKey(); - } - } - } - } - else - { - return createNewInteractionTask(treeInfos); - } - - throw new RuntimeException("this is an implementation error"); - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param treeInfos - * @return - */ - //----------------------------------------------------------------------------------------------- - private Sequence createNewSequence(int maxNoOfChildren, - int maxDepth, - Map treeInfos) - throws Exception - { - Sequence sequence = mTaskTreeNodeFactory.createNewSequence(); - - int noOfChildren = (int) (Math.random() * maxNoOfChildren); - - for (int i = 0; i < noOfChildren; i++) - { - TaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos); - - // through first removing an existing parent it is assured, that a parent is recorded - // only once. This is needed, because parent may be reused in a tree as well, but we always - // iterate the whole tree - ((NodeInfoImpl) treeInfos.get(child)).removeParent(sequence); - ((NodeInfoImpl) treeInfos.get(child)).addParent(sequence); - mTaskTreeBuilder.addChild(sequence, child); - } - - treeInfos.put(sequence, new NodeInfoImpl(sequence)); - return sequence; - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param treeInfos - * @return - */ - //----------------------------------------------------------------------------------------------- - private Sequence reuseSequence(int maxNoOfChildren, - int maxDepth, - Map treeInfos) - throws Exception - { - int noOfSequences = 0; - - for (Map.Entry entry : treeInfos.entrySet()) - { - if (entry.getKey() instanceof Sequence) - { - noOfSequences++; - } - } - - if (noOfSequences > 0) - { - noOfSequences = (int) (Math.random() * noOfSequences); - - for (Map.Entry entry : treeInfos.entrySet()) - { - if (entry.getKey() instanceof Sequence) - { - if (--noOfSequences <= 0) - { - return (Sequence) entry.getKey(); - } - } - } - } - else - { - return createNewSequence(maxNoOfChildren, maxDepth, treeInfos); - } - - throw new RuntimeException("this is an implementation error"); - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param treeInfos - * @return - */ - //----------------------------------------------------------------------------------------------- - private Selection createNewSelection(int maxNoOfChildren, - int maxDepth, - Map treeInfos) - throws Exception - { - Selection selection = mTaskTreeNodeFactory.createNewSelection(); - - int noOfChildren = (int) (Math.random() * maxNoOfChildren); - - for (int i = 0; i < noOfChildren; i++) - { - TaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos); - - // through first removing an existing parent it is assured, that a parent is recorded - // only once. This is needed, because parent may be reused in a tree as well, but we always - // iterate the whole tree - ((NodeInfoImpl) treeInfos.get(child)).removeParent(selection); - ((NodeInfoImpl) treeInfos.get(child)).addParent(selection); - mTaskTreeBuilder.addChild(selection, child); - } - - treeInfos.put(selection, new NodeInfoImpl(selection)); - return selection; - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param treeInfos - * @return - */ - //----------------------------------------------------------------------------------------------- - private Selection reuseSelection(int maxNoOfChildren, - int maxDepth, - Map treeInfos) - throws Exception - { - int noOfSelections = 0; - - for (Map.Entry entry : treeInfos.entrySet()) - { - if (entry.getKey() instanceof Selection) - { - noOfSelections++; - } - } - - if (noOfSelections > 0) - { - noOfSelections = (int) (Math.random() * noOfSelections); - - for (Map.Entry entry : treeInfos.entrySet()) - { - if (entry.getKey() instanceof Selection) - { - if (--noOfSelections <= 0) - { - return (Selection) entry.getKey(); - } - } - } - } - else - { - return createNewSelection(maxNoOfChildren, maxDepth, treeInfos); - } - - throw new RuntimeException("this is an implementation error"); - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param treeInfos - * @return - */ - //----------------------------------------------------------------------------------------------- - private Iteration createNewIteration(int maxNoOfChildren, - int maxDepth, - Map treeInfos) - throws Exception - { - Iteration iteration = mTaskTreeNodeFactory.createNewIteration(); - - TaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos); - - // through first removing an existing parent it is assured, that a parent is recorded - // only once. This is needed, because parent may be reused in a tree as well, but we always - // iterate the whole tree - ((NodeInfoImpl) treeInfos.get(child)).removeParent(iteration); - ((NodeInfoImpl) treeInfos.get(child)).addParent(iteration); - mTaskTreeBuilder.setChild(iteration, child); - - treeInfos.put(iteration, new NodeInfoImpl(iteration)); - return iteration; - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - * @param treeInfos - * @return - */ - //----------------------------------------------------------------------------------------------- - private Iteration reuseIteration(int maxNoOfChildren, - int maxDepth, - Map treeInfos) - throws Exception - { - int noOfIterations = 0; - - for (Map.Entry entry : treeInfos.entrySet()) - { - if (entry.getKey() instanceof Iteration) - { - noOfIterations++; - } - } - - if (noOfIterations > 0) - { - noOfIterations = (int) (Math.random() * noOfIterations); - - for (Map.Entry entry : treeInfos.entrySet()) - { - if (entry.getKey() instanceof Iteration) - { - if (--noOfIterations <= 0) - { - return (Iteration) entry.getKey(); - } - } - } - } - else - { - return createNewIteration(maxNoOfChildren, maxDepth, treeInfos); - } - - throw new RuntimeException("this is an implementation error"); - } + case 0: { + // System.err.print("creating new event task "); + tree = createNewEventTask(treeInfos); + break; + } + case 1: { + // System.err.print("reusing event task "); + tree = reuseEventTask(treeInfos); + break; + } + case 2: { + // System.err.println("creating new sequence {"); + tree = createNewSequence(maxNoOfChildren, maxDepth, treeInfos); + break; + } + case 3: { + // System.err.println("reusing sequence {"); + tree = reuseSequence(maxNoOfChildren, maxDepth, treeInfos); + break; + } + case 4: { + // System.err.println("creating new selection {"); + tree = createNewSelection(maxNoOfChildren, maxDepth, treeInfos); + break; + } + case 5: { + // System.err.println("reusing selection {"); + tree = reuseSelection(maxNoOfChildren, maxDepth, treeInfos); + break; + } + case 6: { + // System.err.println("creating new iteration {"); + tree = createNewIteration(maxNoOfChildren, maxDepth, treeInfos); + break; + } + case 7: { + // System.err.println("reusing iteration {"); + tree = reuseIteration(maxNoOfChildren, maxDepth, treeInfos); + break; + } + default: { + // System.err.print("creating new event task per default "); + tree = createNewEventTask(treeInfos); + } + } + + /* + * if (!(tree instanceof InteractionTask)) { for (int i = 0; i < (MAX_TREE_DEPTH + 1 - + * maxDepth); i++) { System.err.print(" "); } + * + * System.err.print("} "); } + * + * System.err.println(tree); + */ + + return tree; + } + + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + private IEventTask createNewEventTask(Map treeInfos) + throws Exception + { + Thread.sleep(2); + long id = System.currentTimeMillis(); + IEventTask task = + taskTreeNodeFactory.createNewEventTask(new DummyInteraction("interaction" + id, 1), + new DummyGUIElement("elem" + id)); + + treeInfos.put(task, new NodeInfo(task)); + + return task; + } + + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + private IEventTask reuseEventTask(Map treeInfos) + throws Exception + { + int noOfEventTasks = 0; + + for (Map.Entry entry : treeInfos.entrySet()) { + if (entry.getKey() instanceof IEventTask) { + noOfEventTasks++; + } + } + + if (noOfEventTasks > 0) { + noOfEventTasks = (int) (Math.random() * noOfEventTasks); + + for (Map.Entry entry : treeInfos.entrySet()) { + if (entry.getKey() instanceof IEventTask) { + if (--noOfEventTasks <= 0) { + return (IEventTask) entry.getKey(); + } + } + } + } + else { + return createNewEventTask(treeInfos); + } + + throw new RuntimeException("this is an implementation error"); + } + + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + private ISequence createNewSequence(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + ISequence sequence = taskTreeNodeFactory.createNewSequence(); + + int noOfChildren = (int) (Math.random() * maxNoOfChildren); + + for (int i = 0; i < noOfChildren; i++) { + ITaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos); + + // through first removing an existing parent it is assured, that a parent is recorded + // only once. This is needed, because parent may be reused in a tree as well, but we + // always + // iterate the whole tree + ((NodeInfo) treeInfos.get(child)).removeParent(sequence); + ((NodeInfo) treeInfos.get(child)).addParent(sequence); + taskTreeBuilder.addChild(sequence, child); + } + + treeInfos.put(sequence, new NodeInfo(sequence)); + return sequence; + } + + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + private ISequence reuseSequence(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + int noOfSequences = 0; + + for (Map.Entry entry : treeInfos.entrySet()) { + if (entry.getKey() instanceof ISequence) { + noOfSequences++; + } + } + + if (noOfSequences > 0) { + noOfSequences = (int) (Math.random() * noOfSequences); + + for (Map.Entry entry : treeInfos.entrySet()) { + if (entry.getKey() instanceof ISequence) { + if (--noOfSequences <= 0) { + return (ISequence) entry.getKey(); + } + } + } + } + else { + return createNewSequence(maxNoOfChildren, maxDepth, treeInfos); + } + + throw new RuntimeException("this is an implementation error"); + } + + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + private ISelection createNewSelection(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + ISelection selection = taskTreeNodeFactory.createNewSelection(); + + int noOfChildren = (int) (Math.random() * maxNoOfChildren); + + for (int i = 0; i < noOfChildren; i++) { + ITaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos); + + // through first removing an existing parent it is assured, that a parent is recorded + // only once. This is needed, because parent may be reused in a tree as well, but we + // always + // iterate the whole tree + ((NodeInfo) treeInfos.get(child)).removeParent(selection); + ((NodeInfo) treeInfos.get(child)).addParent(selection); + taskTreeBuilder.addChild(selection, child); + } + + treeInfos.put(selection, new NodeInfo(selection)); + return selection; + } + + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + private ISelection reuseSelection(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + int noOfSelections = 0; + + for (Map.Entry entry : treeInfos.entrySet()) { + if (entry.getKey() instanceof ISelection) { + noOfSelections++; + } + } + + if (noOfSelections > 0) { + noOfSelections = (int) (Math.random() * noOfSelections); + + for (Map.Entry entry : treeInfos.entrySet()) { + if (entry.getKey() instanceof ISelection) { + if (--noOfSelections <= 0) { + return (ISelection) entry.getKey(); + } + } + } + } + else { + return createNewSelection(maxNoOfChildren, maxDepth, treeInfos); + } + + throw new RuntimeException("this is an implementation error"); + } + + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + private IIteration createNewIteration(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + IIteration iteration = taskTreeNodeFactory.createNewIteration(); + + ITaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos); + + // through first removing an existing parent it is assured, that a parent is recorded + // only once. This is needed, because parent may be reused in a tree as well, but we always + // iterate the whole tree + ((NodeInfo) treeInfos.get(child)).removeParent(iteration); + ((NodeInfo) treeInfos.get(child)).addParent(iteration); + taskTreeBuilder.setChild(iteration, child); + + treeInfos.put(iteration, new NodeInfo(iteration)); + return iteration; + } + + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + private IIteration reuseIteration(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + int noOfIterations = 0; + + for (Map.Entry entry : treeInfos.entrySet()) { + if (entry.getKey() instanceof IIteration) { + noOfIterations++; + } + } + + if (noOfIterations > 0) { + noOfIterations = (int) (Math.random() * noOfIterations); + + for (Map.Entry entry : treeInfos.entrySet()) { + if (entry.getKey() instanceof IIteration) { + if (--noOfIterations <= 0) { + return (IIteration) entry.getKey(); + } + } + } + } + else { + return createNewIteration(maxNoOfChildren, maxDepth, treeInfos); + } + + throw new RuntimeException("this is an implementation error"); + } }