Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/manager/TaskTreeManagerTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/manager/TaskTreeManagerTest.java (revision 1132) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/manager/TaskTreeManagerTest.java (revision 1146) @@ -29,4 +29,5 @@ import de.ugoe.cs.autoquest.test.DummyGUIElement; import de.ugoe.cs.autoquest.test.DummyInteraction; +import de.ugoe.cs.util.console.Console; import de.ugoe.cs.util.console.TextConsole; @@ -47,4 +48,5 @@ @Before public void setUp() { + Console.reset(); new TextConsole(Level.FINEST); manager = new TaskTreeManager(); @@ -66,10 +68,8 @@ public void testOneEventOnOneElement() { simulateEvent(new DummyInteraction("bla", 1), new DummyGUIElement("elem1")); - new TaskTreeChecker().assertTaskTree - ("Sequence root {" + - " Sequence session {" + - " Event bla {}" + - " }" + - "}", manager.getTaskTree()); + new TaskTreeChecker().assertTaskInstanceList + ("UserSession session {" + + " Event bla {}" + + "}", manager.getTaskModel().getUserSessions().get(0)); } @@ -84,16 +84,14 @@ simulateEvent(new DummyInteraction("blo", 1), eventTarget); simulateEvent(new DummyInteraction("blu", 1), eventTarget); - simulateEvent(new DummyInteraction("bla", 1), eventTarget); - - new TaskTreeChecker().assertTaskTree - ("Sequence root {" + - " Sequence session {" + - " Event bla {}" + - " Event bli {}" + - " Event blo {}" + - " Event blu {}" + - " Event bla {}" + - " }" + - "}", manager.getTaskTree()); + simulateEvent(new DummyInteraction("ble", 1), eventTarget); + + new TaskTreeChecker().assertTaskInstanceList + ("UserSession session {" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " Event blu {}" + + " Event ble {}" + + "}", manager.getTaskModel().getUserSessions().get(0)); } @@ -111,20 +109,18 @@ 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 root {" + - " Sequence session {" + - " Event bla {}" + - " Event bli {}" + - " Event bla {}" + - " Event bli {}" + - " Event blo {}" + - " Event bla {}" + - " }" + - "}", manager.getTaskTree()); + simulateEvent(new DummyInteraction("blo", 1), eventTarget3); + simulateEvent(new DummyInteraction("blu", 1), eventTarget4); + simulateEvent(new DummyInteraction("ble", 1), eventTarget5); + simulateEvent(new DummyInteraction("blum", 1), eventTarget6); + + new TaskTreeChecker(true).assertTaskInstanceList + ("UserSession session {" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " Event blu {}" + + " Event ble {}" + + " Event blum {}" + + "}", manager.getTaskModel().getUserSessions().get(0)); } @@ -142,38 +138,36 @@ 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("blup", 1), eventTarget1); + simulateEvent(new DummyInteraction("ble", 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 root {" + - " Sequence session {" + - " Event bla {}" + - " Event bli {}" + - " Event bla {}" + - " Event bli {}" + - " Event blo {}" + - " Event bla {}" + - " Event bli {}" + - " Event bla {}" + - " Event bli {}" + - " Event blo {}" + - " Event bla {}" + - " Event bli {}" + - " Event bla {}" + - " Event bli {}" + - " Event blo {}" + - " }" + - "}", manager.getTaskTree()); + simulateEvent(new DummyInteraction("blau", 1), eventTarget3); + simulateEvent(new DummyInteraction("blass", 1), eventTarget4); + simulateEvent(new DummyInteraction("blum", 1), eventTarget4); + simulateEvent(new DummyInteraction("blim", 1), eventTarget4); + simulateEvent(new DummyInteraction("blom", 1), eventTarget4); + simulateEvent(new DummyInteraction("blam", 1), eventTarget5); + simulateEvent(new DummyInteraction("blip", 1), eventTarget6); + simulateEvent(new DummyInteraction("blap", 1), eventTarget6); + simulateEvent(new DummyInteraction("blep", 1), eventTarget6); + simulateEvent(new DummyInteraction("blop", 1), eventTarget6); + + new TaskTreeChecker().assertTaskInstanceList + ("UserSession session {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " Event ble {}" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " Event blum {}" + + " Event blim {}" + + " Event blom {}" + + " Event blam {}" + + " Event blip {}" + + " Event blap {}" + + " Event blep {}" + + " Event blop {}" + + "}", manager.getTaskModel().getUserSessions().get(0)); } @@ -187,12 +181,11 @@ simulateEvent(event1, eventTarget1); simulateEvent(event1, eventTarget1); - new TaskTreeChecker().assertTaskTree - ("Sequence root {" + - " Sequence session {" + - " Iteration iteration1 {" + - " Event bla {}" + - " }" + + new TaskTreeChecker().assertTaskInstanceList + ("UserSession session {" + + " Iteration iteration1 {" + + " Event bla {}" + + " Event bla {}" + " }" + - "}", manager.getTaskTree()); + "}", manager.getTaskModel().getUserSessions().get(0)); } @@ -208,12 +201,19 @@ } - new TaskTreeChecker().assertTaskTree - ("Sequence root {" + - " Sequence session {" + - " Iteration iteration1 {" + - " Event bla {}" + - " }" + + new TaskTreeChecker().assertTaskInstanceList + ("UserSession session {" + + " Iteration iteration1 {" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + " }" + - "}", manager.getTaskTree()); + "}", manager.getTaskModel().getUserSessions().get(0)); } @@ -229,4 +229,6 @@ IEventType event2 = new DummyInteraction("bli", 1); IEventType event3 = new DummyInteraction("blup", 1); + IEventType event4 = new DummyInteraction("ble", 1); + IEventType event5 = new DummyInteraction("blo", 1); simulateEvent(event2, eventTarget1); @@ -235,19 +237,26 @@ simulateEvent(event1, eventTarget1); } - simulateEvent(event3, eventTarget1); - simulateEvent(event2, eventTarget1); - - new TaskTreeChecker().assertTaskTree - ("Sequence root {" + - " Sequence session {" + - " Event bli {}" + - " Event blup {}" + - " Iteration iteration2 {" + - " Event bla {}" + - " }" + - " Event blup {}" + - " Event bli {}" + + simulateEvent(event4, eventTarget1); + simulateEvent(event5, eventTarget1); + + new TaskTreeChecker().assertTaskInstanceList + ("UserSession session {" + + " Event bli {}" + + " Event blup {}" + + " Iteration iteration2 {" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + " }" + - "}", manager.getTaskTree()); + " Event ble {}" + + " Event blo {}" + + "}", manager.getTaskModel().getUserSessions().get(0)); } @@ -264,5 +273,5 @@ // now test with iterations of iterations - for (int i = 0; i < 10; i++) { + for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { simulateEvent(event1, eventTarget1); @@ -276,22 +285,124 @@ } - new TaskTreeChecker().assertTaskTree - ("Sequence root {" + - " Sequence session {" + - " Iteration iteration2 {" + - " Sequence sequence1 {" + - " Iteration iteration3 {" + - " Event bla {}" + - " }" + - " Iteration iteration4 {" + - " Event bli {}" + - " }" + - " Iteration iteration5 {" + - " Event blup {}" + - " }" + + new TaskTreeChecker().assertTaskInstanceList + ("UserSession session {" + + " Iteration iteration2 {" + + " Sequence sequence1 {" + + " Iteration iteration3 {" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " }" + + " Iteration iteration4 {" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " }" + + " Iteration iteration5 {" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " }" + + " }" + + " Sequence sequence1 {" + + " Iteration iteration3 {" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " }" + + " Iteration iteration4 {" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " }" + + " Iteration iteration5 {" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " }" + + " }" + + " Sequence sequence1 {" + + " Iteration iteration3 {" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " }" + + " Iteration iteration4 {" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " }" + + " Iteration iteration5 {" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " }" + + " }" + + " Sequence sequence1 {" + + " Iteration iteration3 {" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " }" + + " Iteration iteration4 {" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " }" + + " Iteration iteration5 {" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " }" + + " }" + + " Sequence sequence1 {" + + " Iteration iteration3 {" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " Event bla {}" + + " }" + + " Iteration iteration4 {" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " Event bli {}" + + " }" + + " Iteration iteration5 {" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + + " Event blup {}" + " }" + " }" + " }" + - "}", manager.getTaskTree()); + "}", manager.getTaskModel().getUserSessions().get(0)); } @@ -315,16 +426,19 @@ simulateEvent(event3, eventTarget1); - new TaskTreeChecker().assertTaskTree - ("Sequence root {" + - " Sequence session {" + - " Iteration iteration1 {" + - " Sequence sequence2 {" + - " Event bla {}" + - " Event bli {}" + - " Event blup {}" + - " }" + + new TaskTreeChecker().assertTaskInstanceList + ("UserSession session {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + " }" + " }" + - "}", manager.getTaskTree()); + "}", manager.getTaskModel().getUserSessions().get(0)); } @@ -345,16 +459,59 @@ } - new TaskTreeChecker().assertTaskTree - ("Sequence root {" + - " Sequence session {" + - " Iteration iteration1 {" + - " Sequence sequence2 {" + - " Event bla {}" + - " Event bli {}" + - " Event blup {}" + - " }" + + new TaskTreeChecker().assertTaskInstanceList + ("UserSession session {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + " }" + " }" + - "}", manager.getTaskTree()); + "}", manager.getTaskModel().getUserSessions().get(0)); } @@ -375,33 +532,45 @@ simulateEvent(event4, eventTarget1); - simulateEvent(event5, eventTarget1); - simulateEvent(event6, eventTarget1); - for (int i = 0; i < 10; i++) { + for (int i = 0; i < 5; i++) { simulateEvent(event1, eventTarget1); simulateEvent(event2, eventTarget1); simulateEvent(event3, eventTarget1); } + simulateEvent(event5, eventTarget1); simulateEvent(event6, eventTarget1); - simulateEvent(event5, eventTarget1); - simulateEvent(event4, eventTarget1); - - new TaskTreeChecker().assertTaskTree - ("Sequence root {" + - " Sequence session {" + - " Event ble {}" + - " Event blo {}" + - " Event blu {}" + - " Iteration iteration2 {" + - " Sequence sequence3 {" + - " Event bla {}" + - " Event bli {}" + - " Event blup {}" + - " }" + - " }" + - " Event blu {}" + - " Event blo {}" + - " Event ble {}" + + + new TaskTreeChecker().assertTaskInstanceList + ("UserSession session {" + + " Event ble {}" + + " Iteration iteration2 {" + + " Sequence sequence3 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence3 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence3 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence3 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence3 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + " }" + - "}", manager.getTaskTree()); + " Event blo {}" + + " Event blu {}" + + "}", manager.getTaskModel().getUserSessions().get(0)); } @@ -418,7 +587,10 @@ IEventType event5 = new DummyInteraction("blau", 1); IEventType event6 = new DummyInteraction("blass", 1); + IEventType event7 = new DummyInteraction("ble", 1); + IEventType event8 = new DummyInteraction("blum", 1); + IEventType event9 = new DummyInteraction("blop", 1); // now test with iterations of iterations - for (int i = 0; i < 10; i++) { + for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { simulateEvent(event1, eventTarget1); @@ -432,40 +604,430 @@ } for (int j = 0; j < 5; j++) { - simulateEvent(event1, eventTarget1); - simulateEvent(event3, eventTarget1); - simulateEvent(event5, eventTarget1); + simulateEvent(event7, eventTarget1); + simulateEvent(event8, eventTarget1); + simulateEvent(event9, eventTarget1); } } - new TaskTreeChecker().assertTaskTree - ("Sequence root {" + - " Sequence session {" + - " Iteration iteration3 {" + - " Sequence sequence4 {" + - " Iteration iteration4 {" + - " Sequence sequence4 {" + - " Event bla {}" + - " Event bli {}" + - " Event blup {}" + - " }" + - " }" + - " Iteration iteration5 {" + - " Sequence sequence5 {" + - " Event blo {}" + - " Event blau {}" + - " Event blass {}" + - " }" + - " }" + - " Iteration iteration6 {" + - " Sequence sequence6 {" + - " Event bla {}" + - " Event blup {}" + - " Event blau {}" + - " }" + + new TaskTreeChecker().assertTaskInstanceList + ("UserSession session {" + + " Iteration iteration3 {" + + " Sequence sequence1 {" + + " Iteration iteration4 {" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Iteration iteration5 {" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " }" + + " Iteration iteration6 {" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " }" + + " }" + + " Sequence sequence1 {" + + " Iteration iteration4 {" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Iteration iteration5 {" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " }" + + " Iteration iteration6 {" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " }" + + " }" + + " Sequence sequence1 {" + + " Iteration iteration4 {" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Iteration iteration5 {" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " }" + + " Iteration iteration6 {" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " }" + + " }" + + " Sequence sequence1 {" + + " Iteration iteration4 {" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Iteration iteration5 {" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " }" + + " Iteration iteration6 {" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " }" + + " }" + + " Sequence sequence1 {" + + " Iteration iteration4 {" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Iteration iteration5 {" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " Event blau {}" + + " Event blass {}" + + " }" + + " }" + + " Iteration iteration6 {" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + + " }" + + " Sequence sequence6 {" + + " Event ble {}" + + " Event blum {}" + + " Event blop {}" + " }" + " }" + " }" + " }" + - "}", manager.getTaskTree()); + "}", manager.getTaskModel().getUserSessions().get(0)); } Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/EventTaskComparisonRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/EventTaskComparisonRuleTest.java (revision 1146) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/EventTaskComparisonRuleTest.java (revision 1146) @@ -0,0 +1,277 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.tasktrees.taskequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.autoquest.eventcore.IEventTarget; +import de.ugoe.cs.autoquest.eventcore.IEventType; +import de.ugoe.cs.autoquest.eventcore.StringEventType; +import de.ugoe.cs.autoquest.tasktrees.taskequality.EventTaskComparisonRule; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; +import de.ugoe.cs.autoquest.test.DummyGUIElement; + +/** + * @author Patrick Harms + */ +public class EventTaskComparisonRuleTest { + + /** + * + */ + @Test + public void test_isApplicable_01() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertTrue(rule.isApplicable(task1, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_02() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new StringEventType("eventType2"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_03() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + ITask selection = taskFactory.createNewSelection(); + + assertFalse(rule.isApplicable(task1, selection)); + assertFalse(rule.isApplicable(selection, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_04() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + ITask sequence = taskFactory.createNewSequence(); + + assertFalse(rule.isApplicable(task1, sequence)); + assertFalse(rule.isApplicable(sequence, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_05() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + ITask iteration = taskFactory.createNewIteration(); + + assertFalse(rule.isApplicable(task1, iteration)); + assertFalse(rule.isApplicable(iteration, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_06() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + ITask optional = taskFactory.createNewOptional(); + + assertFalse(rule.isApplicable(task1, optional)); + assertFalse(rule.isApplicable(optional, task1)); + } + + /** + * + */ + @Test + public void test_compare_01() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(task1, task1)); + assertTrue(rule.areLexicallyEqual(task1, task1)); + assertTrue(rule.areSyntacticallyEqual(task1, task1)); + assertTrue(rule.areSemanticallyEqual(task1, task1)); + } + + /** + * + */ + @Test + public void test_compare_02() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + ITask task2 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(task1, task2)); + assertTrue(rule.areLexicallyEqual(task1, task2)); + assertTrue(rule.areSyntacticallyEqual(task1, task2)); + assertTrue(rule.areSemanticallyEqual(task1, task2)); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(task2, task1)); + assertTrue(rule.areLexicallyEqual(task2, task1)); + assertTrue(rule.areSyntacticallyEqual(task2, task1)); + assertTrue(rule.areSemanticallyEqual(task2, task1)); + } + + /** + * + */ + @Test + public void test_compare_03() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new StringEventType("eventType2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(task1, task2)); + assertFalse(rule.areLexicallyEqual(task1, task2)); + assertFalse(rule.areSyntacticallyEqual(task1, task2)); + assertFalse(rule.areSemanticallyEqual(task1, task2)); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(task2, task1)); + assertFalse(rule.areLexicallyEqual(task2, task1)); + assertFalse(rule.areSyntacticallyEqual(task2, task1)); + assertFalse(rule.areSemanticallyEqual(task2, task1)); + } + + /** + * + */ + @Test + public void test_compare_04() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType1, eventTarget2); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(task1, task2)); + assertFalse(rule.areLexicallyEqual(task1, task2)); + assertFalse(rule.areSyntacticallyEqual(task1, task2)); + assertFalse(rule.areSemanticallyEqual(task1, task2)); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(task2, task1)); + assertFalse(rule.areLexicallyEqual(task2, task1)); + assertFalse(rule.areSyntacticallyEqual(task2, task1)); + assertFalse(rule.areSemanticallyEqual(task2, task1)); + } + + + /** + * + */ + @Test + public void test_compare_05() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new StringEventType("eventType2"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(task1, task2)); + assertFalse(rule.areLexicallyEqual(task1, task2)); + assertFalse(rule.areSyntacticallyEqual(task1, task2)); + assertFalse(rule.areSemanticallyEqual(task1, task2)); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(task2, task1)); + assertFalse(rule.areLexicallyEqual(task2, task1)); + assertFalse(rule.areSyntacticallyEqual(task2, task1)); + assertFalse(rule.areSemanticallyEqual(task2, task1)); + } + +} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/GUIEventTaskComparisonRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/GUIEventTaskComparisonRuleTest.java (revision 1146) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/GUIEventTaskComparisonRuleTest.java (revision 1146) @@ -0,0 +1,1491 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.tasktrees.taskequality; + +import static org.junit.Assert.*; + +import java.util.ArrayList; +import java.util.List; + +import org.junit.Test; + +import de.ugoe.cs.autoquest.eventcore.Event; +import de.ugoe.cs.autoquest.eventcore.IEventTarget; +import de.ugoe.cs.autoquest.eventcore.IEventType; +import de.ugoe.cs.autoquest.eventcore.StringEventType; +import de.ugoe.cs.autoquest.eventcore.gui.KeyPressed; +import de.ugoe.cs.autoquest.eventcore.gui.KeyReleased; +import de.ugoe.cs.autoquest.eventcore.gui.KeyTyped; +import de.ugoe.cs.autoquest.eventcore.gui.KeyboardFocusChange; +import de.ugoe.cs.autoquest.eventcore.gui.MouseButtonDown; +import de.ugoe.cs.autoquest.eventcore.gui.MouseButtonInteraction; +import de.ugoe.cs.autoquest.eventcore.gui.MouseButtonUp; +import de.ugoe.cs.autoquest.eventcore.gui.MouseClick; +import de.ugoe.cs.autoquest.eventcore.gui.MouseDoubleClick; +import de.ugoe.cs.autoquest.eventcore.gui.MouseDragAndDrop; +import de.ugoe.cs.autoquest.eventcore.gui.Scroll; +import de.ugoe.cs.autoquest.eventcore.gui.TextInput; +import de.ugoe.cs.autoquest.eventcore.gui.TextSelection; +import de.ugoe.cs.autoquest.eventcore.gui.ValueSelection; +import de.ugoe.cs.autoquest.keyboardmaps.VirtualKey; +import de.ugoe.cs.autoquest.tasktrees.taskequality.EventTaskComparisonRule; +import de.ugoe.cs.autoquest.tasktrees.taskequality.GUIEventTaskComparisonRule; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; +import de.ugoe.cs.autoquest.test.DummyGUIElement; + +/** + * @author Patrick Harms + */ +public class GUIEventTaskComparisonRuleTest { + + /** + * + */ + @Test + public void test_isApplicable_01() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertTrue(rule.isApplicable(task1, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_02() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new StringEventType("eventType2"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_03() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new KeyboardFocusChange(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyboardFocusChange(); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_04() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyReleased(VirtualKey.LETTER_B); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_05() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_C); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyTyped(VirtualKey.LETTER_D); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_06() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 5, 6); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.MIDDLE, 3, 1); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_07() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.RIGHT, 4, 7); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.X, 9, 12); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_08() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(5, 6, 7, 8); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_09() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new Scroll(1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new Scroll(3, 4); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_10() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + List inputEvents = new ArrayList(); + IEventType eventType1 = new TextInput("text1", inputEvents); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new TextInput("text2", inputEvents); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_11() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new TextSelection(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new ValueSelection("value"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_12() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + ITask selection = taskFactory.createNewSelection(); + + assertFalse(rule.isApplicable(task1, selection)); + assertFalse(rule.isApplicable(selection, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_13() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + ITask sequence = taskFactory.createNewSequence(); + + assertFalse(rule.isApplicable(task1, sequence)); + assertFalse(rule.isApplicable(sequence, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_14() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + ITask iteration = taskFactory.createNewIteration(); + + assertFalse(rule.isApplicable(task1, iteration)); + assertFalse(rule.isApplicable(iteration, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_15() { + ITaskFactory taskFactory = new TaskFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + ITask optional = taskFactory.createNewOptional(); + + assertFalse(rule.isApplicable(task1, optional)); + assertFalse(rule.isApplicable(optional, task1)); + } + + /** + * + */ + @Test + public void test_compare_KeyboardFocusChange_01() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyboardFocusChange(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_KeyboardFocusChange_02() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyboardFocusChange(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyboardFocusChange(); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyboardFocusChange_03() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyboardFocusChange(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyboardFocusChange(); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyPressed_01() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_KeyPressed_02() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyPressed(VirtualKey.LETTER_A); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyPressed_03() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyPressed(VirtualKey.LETTER_B); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyPressed_04() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyPressed(VirtualKey.LETTER_A); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyReleased_01() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyReleased(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_KeyReleased_02() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyReleased(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyReleased(VirtualKey.LETTER_A); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyReleased_03() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyReleased(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyReleased(VirtualKey.LETTER_B); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyReleased_04() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyReleased(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyReleased(VirtualKey.LETTER_A); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyTyped_01() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_KeyTyped_02() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyTyped(VirtualKey.LETTER_A); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyTyped_03() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyTyped(VirtualKey.LETTER_B); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyTyped_04() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyTyped(VirtualKey.LETTER_A); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonDown_01() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonDown_02() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonDown_03() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 3); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonDown_04() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 3, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonDown_05() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.RIGHT, 1, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonDown_06() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonUp_01() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonUp_02() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonUp_03() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 3); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonUp_04() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 3, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonUp_05() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.RIGHT, 1, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonUp_06() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseClick_01() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_MouseClick_02() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseClick_03() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 3); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseClick_04() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.LEFT, 3, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseClick_05() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.RIGHT, 1, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseClick_06() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDoubleClick_01() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_MouseDoubleClick_02() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDoubleClick_03() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 3); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDoubleClick_04() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 3, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDoubleClick_05() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.RIGHT, 1, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDoubleClick_06() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_01() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_02() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(1, 2, 3, 4); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_03() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(5, 2, 3, 4); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_04() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(1, 5, 3, 4); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_05() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(1, 2, 5, 4); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_06() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(1, 2, 3, 5); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_07() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_Scroll_01() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new Scroll(1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_Scroll_02() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new Scroll(1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new Scroll(1, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_Scroll_03() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new Scroll(1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new Scroll(3, 2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_Scroll_04() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new Scroll(1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new Scroll(1, 3); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_Scroll_05() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new Scroll(1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new Scroll(1, 2); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_TextInput_01() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + List textInputEvents1 = new ArrayList(); + textInputEvents1.add(new Event(eventType1, eventTarget1)); + eventType1 = new TextInput("enteredText1", textInputEvents1); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_TextInput_02() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + List textInputEvents1 = new ArrayList(); + textInputEvents1.add(new Event(eventType1, eventTarget1)); + eventType1 = new TextInput("enteredText1", textInputEvents1); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new TextInput("enteredText1", textInputEvents1); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_TextInput_03() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + List textInputEvents1 = new ArrayList(); + textInputEvents1.add(new Event(eventType1, eventTarget1)); + eventType1 = new TextInput("enteredText1", textInputEvents1); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new StringEventType("eventType2"); + List textInputEvents2 = new ArrayList(); + textInputEvents2.add(new Event(eventType2, eventTarget1)); + eventType2 = new TextInput("enteredText1", textInputEvents2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSyntacticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_TextInput_04() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + List textInputEvents1 = new ArrayList(); + textInputEvents1.add(new Event(eventType1, eventTarget1)); + eventType1 = new TextInput("enteredText1", textInputEvents1); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new StringEventType("eventType2"); + List textInputEvents2 = new ArrayList(); + textInputEvents2.add(new Event(eventType2, eventTarget1)); + eventType2 = new TextInput("enteredText2", textInputEvents2); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_TextInput_05() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + List textInputEvents1 = new ArrayList(); + textInputEvents1.add(new Event(eventType1, eventTarget1)); + eventType1 = new TextInput("enteredText1", textInputEvents1); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType1, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_TextSelection_01() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new TextSelection(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_TextSelection_02() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new TextSelection(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new TextSelection(); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_TextSelection_03() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new TextSelection(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new TextSelection(); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_ValueSelection_01() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new ValueSelection("value1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_ValueSelection_02() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new ValueSelection("value1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new ValueSelection("value1"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_ValueSelection_03() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new ValueSelection("value1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new ValueSelection("value2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_ValueSelection_04() { + ITaskFactory taskFactory = new TaskFactory(); + + IEventType eventType1 = new ValueSelection("value1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new ValueSelection("value1"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + private void assertLexicallyEqual(ITask task1, ITask task2) { + GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule(); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(task1, task2)); + assertTrue(rule.areLexicallyEqual(task1, task2)); + assertTrue(rule.areSyntacticallyEqual(task1, task2)); + assertTrue(rule.areSemanticallyEqual(task1, task2)); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(task2, task1)); + assertTrue(rule.areLexicallyEqual(task2, task1)); + assertTrue(rule.areSyntacticallyEqual(task2, task1)); + assertTrue(rule.areSemanticallyEqual(task2, task1)); + } + + /** + * + */ + private void assertSyntacticallyEqual(ITask task1, ITask task2) { + GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule(); + + assertEquals(TaskEquality.SYNTACTICALLY_EQUAL, rule.compare(task1, task2)); + assertFalse(rule.areLexicallyEqual(task1, task2)); + assertTrue(rule.areSyntacticallyEqual(task1, task2)); + assertTrue(rule.areSemanticallyEqual(task1, task2)); + + assertEquals(TaskEquality.SYNTACTICALLY_EQUAL, rule.compare(task2, task1)); + assertFalse(rule.areLexicallyEqual(task2, task1)); + assertTrue(rule.areSyntacticallyEqual(task2, task1)); + assertTrue(rule.areSemanticallyEqual(task2, task1)); + } + + /** + * + */ + private void assertSemanticallyEqual(ITask task1, ITask task2) { + GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule(); + + assertEquals(TaskEquality.SEMANTICALLY_EQUAL, rule.compare(task1, task2)); + assertFalse(rule.areLexicallyEqual(task1, task2)); + assertFalse(rule.areSyntacticallyEqual(task1, task2)); + assertTrue(rule.areSemanticallyEqual(task1, task2)); + + assertEquals(TaskEquality.SEMANTICALLY_EQUAL, rule.compare(task2, task1)); + assertFalse(rule.areLexicallyEqual(task2, task1)); + assertFalse(rule.areSyntacticallyEqual(task2, task1)); + assertTrue(rule.areSemanticallyEqual(task2, task1)); + } + + /** + * + */ + private void assertUnequal(ITask task1, ITask task2) { + GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule(); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(task1, task2)); + assertFalse(rule.areLexicallyEqual(task1, task2)); + assertFalse(rule.areSyntacticallyEqual(task1, task2)); + assertFalse(rule.areSemanticallyEqual(task1, task2)); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(task2, task1)); + assertFalse(rule.areLexicallyEqual(task2, task1)); + assertFalse(rule.areSyntacticallyEqual(task2, task1)); + assertFalse(rule.areSemanticallyEqual(task2, task1)); + } +} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/IterationComparisonRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/IterationComparisonRuleTest.java (revision 1146) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/IterationComparisonRuleTest.java (revision 1146) @@ -0,0 +1,118 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.tasktrees.taskequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.autoquest.eventcore.IEventTarget; +import de.ugoe.cs.autoquest.eventcore.IEventType; +import de.ugoe.cs.autoquest.eventcore.StringEventType; +import de.ugoe.cs.autoquest.tasktrees.taskequality.IterationComparisonRule; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEqualityRuleManager; +import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; +import de.ugoe.cs.autoquest.test.DummyGUIElement; + +/** + * @author Patrick Harms + */ +public class IterationComparisonRuleTest { + + /** + * + */ + @Test + public void test() { + TaskEqualityRuleManager manager = new TaskEqualityRuleManager(); + manager.init(); + + ITaskFactory taskFactory = new TaskFactory(); + ITaskBuilder treeBuilder = new TaskBuilder(); + + IterationComparisonRule rule = new IterationComparisonRule(manager); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + + IEventType eventType2 = new StringEventType("eventType2"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertFalse(rule.isApplicable(task1, task2)); + + IIteration iteration1 = taskFactory.createNewIteration(); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration1)); + + IIteration iteration2 = taskFactory.createNewIteration(); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1)); + + treeBuilder.setMarkedTask(iteration1, task1); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(iteration1, iteration2)); + assertEquals(TaskEquality.UNEQUAL, rule.compare(iteration2, iteration1)); + + treeBuilder.setMarkedTask(iteration2, task1); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1)); + + treeBuilder.setMarkedTask(iteration1, task2); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(iteration1, iteration2)); + assertEquals(TaskEquality.UNEQUAL, rule.compare(iteration2, iteration1)); + + treeBuilder.setMarkedTask(iteration2, task2); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1)); + + ISelection selection1 = taskFactory.createNewSelection(); + treeBuilder.addChild(selection1, task2); + treeBuilder.setMarkedTask(iteration1, selection1); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1)); + + ISelection selection2 = taskFactory.createNewSelection(); + treeBuilder.addChild(selection2, task2); + treeBuilder.setMarkedTask(iteration2, selection2); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1)); + + assertFalse(rule.isApplicable(iteration1, selection1)); + assertFalse(rule.isApplicable(selection1, iteration1)); + assertFalse(rule.isApplicable(iteration2, selection1)); + assertFalse(rule.isApplicable(selection1, iteration2)); + + assertFalse(rule.isApplicable(iteration1, selection2)); + assertFalse(rule.isApplicable(selection2, iteration1)); + assertFalse(rule.isApplicable(iteration2, selection2)); + assertFalse(rule.isApplicable(selection2, iteration2)); + } + +} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SelectionComparisonRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SelectionComparisonRuleTest.java (revision 1146) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SelectionComparisonRuleTest.java (revision 1146) @@ -0,0 +1,112 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.tasktrees.taskequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.autoquest.eventcore.IEventTarget; +import de.ugoe.cs.autoquest.eventcore.IEventType; +import de.ugoe.cs.autoquest.eventcore.StringEventType; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; +import de.ugoe.cs.autoquest.tasktrees.taskequality.SelectionComparisonRule; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEqualityRuleManager; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; +import de.ugoe.cs.autoquest.test.DummyGUIElement; + +/** + * @author Patrick Harms + */ +public class SelectionComparisonRuleTest { + + /** + * + */ + @Test + public void test() { + TaskEqualityRuleManager manager = new TaskEqualityRuleManager(); + manager.init(); + + ITaskFactory taskFactory = new TaskFactory(); + ITaskBuilder treeBuilder = new TaskBuilder(); + + SelectionComparisonRule rule = new SelectionComparisonRule(manager); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + + IEventType eventType2 = new StringEventType("eventType2"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertFalse(rule.isApplicable(task1, task2)); + + ISelection selection1 = taskFactory.createNewSelection(); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection1)); + + ISelection selection2 = taskFactory.createNewSelection(); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection2)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(selection2, selection1)); + + treeBuilder.addChild(selection1, task1); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(selection1, selection2)); + assertEquals(TaskEquality.UNEQUAL, rule.compare(selection2, selection1)); + + treeBuilder.addChild(selection2, task1); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection2)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(selection2, selection1)); + + treeBuilder.addChild(selection1, task2); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(selection1, selection2)); + assertEquals(TaskEquality.UNEQUAL, rule.compare(selection2, selection1)); + + treeBuilder.addChild(selection2, task2); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection2)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(selection2, selection1)); + + ISelection selection3 = taskFactory.createNewSelection(); + treeBuilder.addChild(selection3, task2); + treeBuilder.addChild(selection3, task1); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection3)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(selection3, selection1)); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(selection2, selection3)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(selection3, selection2)); + + ISequence sequence = taskFactory.createNewSequence(); + assertFalse(rule.isApplicable(selection1, sequence)); + assertFalse(rule.isApplicable(sequence, selection1)); + assertFalse(rule.isApplicable(selection2, sequence)); + assertFalse(rule.isApplicable(sequence, selection2)); + assertFalse(rule.isApplicable(selection3, sequence)); + assertFalse(rule.isApplicable(sequence, selection3)); + } + +} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SequenceComparisonRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SequenceComparisonRuleTest.java (revision 1146) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/SequenceComparisonRuleTest.java (revision 1146) @@ -0,0 +1,111 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.tasktrees.taskequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.autoquest.eventcore.IEventTarget; +import de.ugoe.cs.autoquest.eventcore.IEventType; +import de.ugoe.cs.autoquest.eventcore.StringEventType; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; +import de.ugoe.cs.autoquest.tasktrees.taskequality.SequenceComparisonRule; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEqualityRuleManager; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; +import de.ugoe.cs.autoquest.test.DummyGUIElement; + +/** + * @author Patrick Harms + */ +public class SequenceComparisonRuleTest { + + /** + * + */ + @Test + public void test() { + TaskEqualityRuleManager manager = new TaskEqualityRuleManager(); + manager.init(); + + ITaskFactory taskFactory = new TaskFactory(); + ITaskBuilder treeBuilder = new TaskBuilder(); + + SequenceComparisonRule rule = new SequenceComparisonRule(manager); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + + IEventType eventType2 = new StringEventType("eventType2"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + ITask task2 = taskFactory.createNewEventTask(eventType2, eventTarget2); + + assertFalse(rule.isApplicable(task1, task2)); + + ISequence sequence1 = taskFactory.createNewSequence(); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence1)); + + ISequence sequence2 = taskFactory.createNewSequence(); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1)); + + treeBuilder.addChild(sequence1, task1); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence1, sequence2)); + assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence2, sequence1)); + + treeBuilder.addChild(sequence2, task1); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1)); + + treeBuilder.addChild(sequence1, task2); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence1, sequence2)); + assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence2, sequence1)); + + treeBuilder.addChild(sequence2, task2); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1)); + + ISequence sequence3 = taskFactory.createNewSequence(); + treeBuilder.addChild(sequence3, task2); + treeBuilder.addChild(sequence3, task1); + + assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence1, sequence3)); + assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence3, sequence1)); + assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence2, sequence3)); + assertEquals(TaskEquality.UNEQUAL, rule.compare(sequence3, sequence2)); + + ISelection selection = taskFactory.createNewSelection(); + assertFalse(rule.isApplicable(sequence1, selection)); + assertFalse(rule.isApplicable(selection, sequence1)); + assertFalse(rule.isApplicable(sequence2, selection)); + assertFalse(rule.isApplicable(selection, sequence2)); + assertFalse(rule.isApplicable(sequence3, selection)); + assertFalse(rule.isApplicable(selection, sequence3)); + } + +} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskAndIterationComparisonRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskAndIterationComparisonRuleTest.java (revision 1146) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskAndIterationComparisonRuleTest.java (revision 1146) @@ -0,0 +1,78 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.tasktrees.taskequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.autoquest.eventcore.IEventTarget; +import de.ugoe.cs.autoquest.eventcore.IEventType; +import de.ugoe.cs.autoquest.eventcore.StringEventType; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskAndIterationComparisonRule; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEqualityRuleManager; +import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; +import de.ugoe.cs.autoquest.test.DummyGUIElement; + +/** + * @author Patrick Harms + */ +public class TaskAndIterationComparisonRuleTest { + + /** + * + */ + @Test + public void test() { + TaskEqualityRuleManager manager = new TaskEqualityRuleManager(); + manager.init(); + + ITaskFactory taskFactory = new TaskFactory(); + ITaskBuilder treeBuilder = new TaskBuilder(); + + TaskAndIterationComparisonRule rule = new TaskAndIterationComparisonRule(manager); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertNull(rule.compare(task1, task1)); + + IIteration iteration1 = taskFactory.createNewIteration(); + assertNull(rule.compare(iteration1, iteration1)); + assertNull(rule.compare(task1, iteration1)); + assertNull(rule.compare(iteration1, task1)); + + treeBuilder.setMarkedTask(iteration1, task1); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(iteration1, task1)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(task1, iteration1)); + + ISelection selection1 = taskFactory.createNewSelection(); + treeBuilder.addChild(selection1, task1); + treeBuilder.setMarkedTask(iteration1, selection1); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(iteration1, task1)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(task1, iteration1)); + } + +} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskAndSelectionComparisonRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskAndSelectionComparisonRuleTest.java (revision 1146) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskAndSelectionComparisonRuleTest.java (revision 1146) @@ -0,0 +1,78 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.tasktrees.taskequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.autoquest.eventcore.IEventTarget; +import de.ugoe.cs.autoquest.eventcore.IEventType; +import de.ugoe.cs.autoquest.eventcore.StringEventType; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskAndSelectionComparisonRule; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEqualityRuleManager; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; +import de.ugoe.cs.autoquest.test.DummyGUIElement; + +/** + * @author Patrick Harms + */ +public class TaskAndSelectionComparisonRuleTest { + + /** + * + */ + @Test + public void test() { + TaskEqualityRuleManager manager = new TaskEqualityRuleManager(); + manager.init(); + + ITaskFactory taskFactory = new TaskFactory(); + ITaskBuilder treeBuilder = new TaskBuilder(); + + TaskAndSelectionComparisonRule rule = new TaskAndSelectionComparisonRule(manager); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITask task1 = taskFactory.createNewEventTask(eventType1, eventTarget1); + + assertNull(rule.compare(task1, task1)); + + ISelection selection1 = taskFactory.createNewSelection(); + assertNull(rule.compare(selection1, selection1)); + assertNull(rule.compare(task1, selection1)); + assertNull(rule.compare(selection1, task1)); + + treeBuilder.addChild(selection1, task1); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(selection1, task1)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(task1, selection1)); + + selection1 = taskFactory.createNewSelection(); + ISelection selection2 = taskFactory.createNewSelection(); + treeBuilder.addChild(selection2, task1); + treeBuilder.addChild(selection1, selection2); + + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(selection1, task1)); + assertEquals(TaskEquality.LEXICALLY_EQUAL, rule.compare(task1, selection1)); + } + +} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskEqualityTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskEqualityTest.java (revision 1146) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/taskequality/TaskEqualityTest.java (revision 1146) @@ -0,0 +1,64 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.tasktrees.taskequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; + +/** + * @author Patrick Harms + */ +public class TaskEqualityTest { + + /** + * + */ + @Test + public void test() { + assertTrue(TaskEquality.IDENTICAL.isAtLeast(TaskEquality.IDENTICAL)); + assertTrue(TaskEquality.IDENTICAL.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); + assertTrue(TaskEquality.IDENTICAL.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); + assertTrue(TaskEquality.IDENTICAL.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); + assertFalse(TaskEquality.IDENTICAL.isAtLeast(TaskEquality.UNEQUAL)); + + assertFalse(TaskEquality.LEXICALLY_EQUAL.isAtLeast(TaskEquality.IDENTICAL)); + assertTrue(TaskEquality.LEXICALLY_EQUAL.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); + assertTrue(TaskEquality.LEXICALLY_EQUAL.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); + assertTrue(TaskEquality.LEXICALLY_EQUAL.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); + assertFalse(TaskEquality.LEXICALLY_EQUAL.isAtLeast(TaskEquality.UNEQUAL)); + + assertFalse(TaskEquality.SYNTACTICALLY_EQUAL.isAtLeast(TaskEquality.IDENTICAL)); + assertFalse(TaskEquality.SYNTACTICALLY_EQUAL.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); + assertTrue(TaskEquality.SYNTACTICALLY_EQUAL.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); + assertTrue(TaskEquality.SYNTACTICALLY_EQUAL.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); + assertFalse(TaskEquality.SYNTACTICALLY_EQUAL.isAtLeast(TaskEquality.UNEQUAL)); + + assertFalse(TaskEquality.SEMANTICALLY_EQUAL.isAtLeast(TaskEquality.IDENTICAL)); + assertFalse(TaskEquality.SEMANTICALLY_EQUAL.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); + assertFalse(TaskEquality.SEMANTICALLY_EQUAL.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); + assertTrue(TaskEquality.SEMANTICALLY_EQUAL.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); + assertFalse(TaskEquality.SEMANTICALLY_EQUAL.isAtLeast(TaskEquality.UNEQUAL)); + + assertFalse(TaskEquality.UNEQUAL.isAtLeast(TaskEquality.IDENTICAL)); + assertFalse(TaskEquality.UNEQUAL.isAtLeast(TaskEquality.LEXICALLY_EQUAL)); + assertFalse(TaskEquality.UNEQUAL.isAtLeast(TaskEquality.SYNTACTICALLY_EQUAL)); + assertFalse(TaskEquality.UNEQUAL.isAtLeast(TaskEquality.SEMANTICALLY_EQUAL)); + assertTrue(TaskEquality.UNEQUAL.isAtLeast(TaskEquality.UNEQUAL)); + } + +} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java (revision 1132) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java (revision 1146) @@ -21,5 +21,4 @@ import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; -import java.util.ArrayList; import java.util.LinkedList; import java.util.List; @@ -29,17 +28,17 @@ import org.junit.Before; -import de.ugoe.cs.autoquest.eventcore.IEventTarget; -import de.ugoe.cs.autoquest.eventcore.IEventType; -import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality; -import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager; +import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker; +import de.ugoe.cs.autoquest.tasktrees.TaskTreeDecoder; +import de.ugoe.cs.autoquest.tasktrees.TaskTreeEncoder; +import de.ugoe.cs.autoquest.tasktrees.TaskTreeValidator; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEqualityRuleManager; import de.ugoe.cs.autoquest.tasktrees.testutils.Utilities; -import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; -import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeBuilder; -import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceList; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; +import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; import de.ugoe.cs.util.console.Console; import de.ugoe.cs.util.console.TextConsole; @@ -52,15 +51,18 @@ /** */ - private List events; - - /** */ - private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder(); - - /** */ - private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory(); - - /** */ - private NodeEqualityRuleManager nodeEqualityRuleManager = - Utilities.getNodeEqualityRuleManagerForTests(); + private ITaskBuilder taskBuilder = new TaskBuilder(); + + /** */ + private ITaskFactory taskFactory = new TaskFactory(); + + /** */ + private TaskTreeDecoder decoder = null; + + /** */ + private TaskTreeEncoder encoder = new TaskTreeEncoder(); + + /** */ + private TaskEqualityRuleManager taskEqualityRuleManager = + Utilities.getTaskEqualityRuleManagerForTests(); /** @@ -69,6 +71,8 @@ @Before public void setUp() { + Console.reset(); new TextConsole(Level.FINEST); - events = new ArrayList(); + + decoder = new TaskTreeDecoder(taskFactory, taskBuilder); } @@ -76,7 +80,94 @@ * */ - protected void simulateEvent(IEventType eventType, IEventTarget eventTarget) { - events.add(taskTreeNodeFactory.createNewEventTask(eventType, eventTarget)); - Console.reset(); + protected void applyRule(Class ruleClass, + String inputSpec, + String expectedOutputSpec) + { + ITaskInstanceListScopeRule rule = null; + + CONSTRUCTOR_ITERATION: + for (Constructor constructor : ruleClass.getDeclaredConstructors()) { + List parameters = new LinkedList(); + + for (Class type : constructor.getParameterTypes()) { + if (ITaskFactory.class.equals(type)) { + parameters.add(taskFactory); + } + else if (ITaskBuilder.class.equals(type)) { + parameters.add(taskBuilder); + } + else if (TaskEqualityRuleManager.class.equals(type)) { + parameters.add(taskEqualityRuleManager); + } + else if (TaskEquality.class.equals(type)) { + parameters.add(TaskEquality.LEXICALLY_EQUAL); + } + else { + continue CONSTRUCTOR_ITERATION; + } + } + + try { + rule = (ITaskInstanceListScopeRule) constructor.newInstance(parameters.toArray()); + } + catch (IllegalArgumentException e) { + e.printStackTrace(); + fail("could not invoke the constructor " + constructor); + } + catch (InstantiationException e) { + e.printStackTrace(); + fail("could not invoke the constructor " + constructor); + } + catch (IllegalAccessException e) { + e.printStackTrace(); + fail("could not invoke the constructor " + constructor); + } + catch (InvocationTargetException e) { + e.printStackTrace(); + fail("could not invoke the constructor " + constructor); + } + } + + if (rule == null) { + fail("no matching constructor found to instantiate rule " + ruleClass); + } + + RuleApplicationResult result; + RuleApplicationStatus status; + + ITaskInstanceList inputList = decoder.decode(inputSpec); + + Stack toBeAppliedOn = new Stack(); + toBeAppliedOn.push(inputList); + + do { + result = rule.apply(toBeAppliedOn.peek()); + + if (result != null) { + status = result.getRuleApplicationStatus(); + assertNotNull(status); + } + else { + status = RuleApplicationStatus.NOT_APPLIED; + } + + assertTrue(status != RuleApplicationStatus.FEASIBLE); + + if ((result != null) && (result.getNewlyCreatedTaskInstances() != null)) { + for (int i = result.getNewlyCreatedTaskInstances().size() - 1; i >= 0; i--) { + toBeAppliedOn.push(result.getNewlyCreatedTaskInstances().get(i)); + } + } + + if (status == RuleApplicationStatus.NOT_APPLIED) { + toBeAppliedOn.pop(); + } + + } + while ((!toBeAppliedOn.isEmpty()) || (status == RuleApplicationStatus.FINISHED)); + + ITaskInstanceList expectedList = decoder.decode(expectedOutputSpec); + + new TaskTreeChecker().assertTaskInstanceListsEqual(expectedList, inputList); } @@ -84,49 +175,9 @@ * */ - protected ITaskTree getTaskTree() { - ISequence sequence = taskTreeNodeFactory.createNewSequence(); - - for (IEventTask task : events) { - taskTreeBuilder.addChild(sequence, task); - } - - TemporalRelationshipRuleManager ruleManager = new TemporalRelationshipRuleManager - (nodeEqualityRuleManager, taskTreeNodeFactory, taskTreeBuilder); - - ruleManager.init(); - ruleManager.applyRules(sequence); - - return taskTreeNodeFactory.createTaskTree(sequence); - } - - /** - * - */ - protected ITaskTree getTaskTree(Class ruleClass, - NodeEquality nodeEquality) + protected void applySessionScopeRule(Class ruleClass, + String inputSpec, + String expectedOutputSpec) { - return getTaskTree(ruleClass, nodeEquality, false); - } - - /** - * - */ - protected ITaskTree getTaskTree(Class ruleClass, - NodeEquality nodeEquality, - boolean explicitSessionSeq) - { - ISequence sequence = taskTreeNodeFactory.createNewSequence(); - - for (IEventTask task : events) { - taskTreeBuilder.addChild(sequence, task); - } - - if (explicitSessionSeq) { - ISequence root = taskTreeNodeFactory.createNewSequence(); - taskTreeBuilder.addChild(root, sequence); - sequence = root; - } - - TemporalRelationshipRule rule = null; + ISessionScopeRule rule = null; CONSTRUCTOR_ITERATION: @@ -135,20 +186,15 @@ for (Class type : constructor.getParameterTypes()) { - if (ITaskTreeNodeFactory.class.equals(type)) { - parameters.add(taskTreeNodeFactory); - } - else if (ITaskTreeBuilder.class.equals(type)) { - parameters.add(taskTreeBuilder); - } - else if (NodeEqualityRuleManager.class.equals(type)) { - parameters.add(nodeEqualityRuleManager); - } - else if (NodeEquality.class.equals(type)) { - if (nodeEquality != null) { - parameters.add(nodeEquality); - } - else { - parameters.add(NodeEquality.LEXICALLY_EQUAL); - } + if (ITaskFactory.class.equals(type)) { + parameters.add(taskFactory); + } + else if (ITaskBuilder.class.equals(type)) { + parameters.add(taskBuilder); + } + else if (TaskEqualityRuleManager.class.equals(type)) { + parameters.add(taskEqualityRuleManager); + } + else if (TaskEquality.class.equals(type)) { + parameters.add(TaskEquality.LEXICALLY_EQUAL); } else { @@ -158,5 +204,5 @@ try { - rule = (TemporalRelationshipRule) constructor.newInstance(parameters.toArray()); + rule = (ISessionScopeRule) constructor.newInstance(parameters.toArray()); } catch (IllegalArgumentException e) { @@ -182,37 +228,29 @@ } - RuleApplicationResult result; - RuleApplicationStatus status; - - Stack toBeAppliedOn = new Stack(); - toBeAppliedOn.push(sequence); - - do { - result = rule.apply(toBeAppliedOn.peek(), true); - - if (result != null) { - status = result.getRuleApplicationStatus(); - assertNotNull(status); - } - else { - status = RuleApplicationStatus.NOT_APPLIED; - } - - assertTrue(status != RuleApplicationStatus.FEASIBLE); - - if ((result != null) && (result.getNewlyCreatedParentNodes() != null)) { - for (int i = result.getNewlyCreatedParentNodes().size() - 1; i >= 0; i--) { - toBeAppliedOn.push(result.getNewlyCreatedParentNodes().get(i)); - } - } - - if (status == RuleApplicationStatus.NOT_APPLIED) { - toBeAppliedOn.pop(); - } - - } - while ((!toBeAppliedOn.isEmpty()) || (status == RuleApplicationStatus.FINISHED)); - - return taskTreeNodeFactory.createTaskTree(sequence); + ITaskInstanceList inputList = decoder.decode(inputSpec); + + assertTrue(inputList instanceof IUserSession); + + List sessionList = new LinkedList(); + sessionList.add((IUserSession) inputList); + + System.out.println("Input:"); + encoder.encode(inputList, System.out); + + RuleApplicationResult result = rule.apply(sessionList); + + assertNotNull(result); + assertNotNull(result.getRuleApplicationStatus()); + assertTrue(result.getRuleApplicationStatus() != RuleApplicationStatus.FEASIBLE); + + ITaskInstanceList expectedList = decoder.decode(expectedOutputSpec); + + System.out.println("\nExpected Result:"); + encoder.encode(expectedList, System.out); + System.out.println("\nResult:"); + encoder.encode(inputList, System.out); + + new TaskTreeChecker().assertTaskInstanceListsEqual(expectedList, inputList); + new TaskTreeValidator().validate(inputList); } Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/IterationOfSubtreesDetectionRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/IterationOfSubtreesDetectionRuleTest.java (revision 1132) +++ (revision ) @@ -1,315 +1,0 @@ -// Copyright 2012 Georg-August-Universität Göttingen, Germany -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package de.ugoe.cs.autoquest.tasktrees.temporalrelation; - -import org.junit.Test; - -import de.ugoe.cs.autoquest.eventcore.IEventTarget; -import de.ugoe.cs.autoquest.eventcore.IEventType; -import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker; -import de.ugoe.cs.autoquest.test.DummyGUIElement; -import de.ugoe.cs.autoquest.test.DummyInteraction; - -/** - * TODO comment - * - * @version $Revision: $ $Date: 28.04.2012$ - * @author 2012, last modified by $Author: patrick$ - */ -public class IterationOfSubtreesDetectionRuleTest 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(IterationOfSubtreesDetectionRule.class, null)); - - simulateEvent(event1, element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Event bla {}" + - " }" + - "}", getTaskTree(IterationOfSubtreesDetectionRule.class, null)); - - simulateEvent(event1, element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Event bla {}" + - " }" + - "}", getTaskTree(IterationOfSubtreesDetectionRule.class, null)); - - for (int i = 0; i < 10; i++) { - simulateEvent(event1, element1); - } - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Event bla {}" + - " }" + - "}", getTaskTree(IterationOfSubtreesDetectionRule.class, null)); - - // 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(IterationOfSubtreesDetectionRule.class, null)); - - // 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(IterationOfSubtreesDetectionRule.class, null)); - - } - - /** - * - */ - @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(IterationOfSubtreesDetectionRule.class, null)); - - 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(IterationOfSubtreesDetectionRule.class, null)); - - 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(IterationOfSubtreesDetectionRule.class, null)); - - 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(IterationOfSubtreesDetectionRule.class, null)); - - // 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(IterationOfSubtreesDetectionRule.class, null)); - - // 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(IterationOfSubtreesDetectionRule.class, null)); - } - -} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceDependingOnEventTypeDetectionRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceDependingOnEventTypeDetectionRuleTest.java (revision 1132) +++ (revision ) @@ -1,347 +1,0 @@ -// Copyright 2012 Georg-August-Universität Göttingen, Germany -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package de.ugoe.cs.autoquest.tasktrees.temporalrelation; - -import org.junit.Test; - -import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement; -import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker; -import de.ugoe.cs.autoquest.test.DummyGUIElement; -import de.ugoe.cs.autoquest.test.DummyInteraction; - -/** - * TODO comment - * - * @version $Revision: $ $Date: $ - * @author 2011, last modified by $Author: $ - */ -public class SequenceDependingOnEventTypeDetectionRuleTest extends AbstractTemporalRelationshipTC { - - /** - * - */ - @Test - public void test_01() { - IGUIElement elem1 = new DummyGUIElement("elem1"); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new FinishSequenceInteraction("end", 1), elem1); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence {" + - " Event start {}" + - " Event end {}" + - "}", getTaskTree(SequenceDependingOnEventTypeDetectionRule.class, null)); - } - - - /** - * - */ - @Test - public void test_02() { - IGUIElement elem1 = new DummyGUIElement("elem1"); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new DummyInteraction("bla", 1), elem1); - simulateEvent(new FinishSequenceInteraction("end", 1), elem1); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence {" + - " Event start {}" + - " Event bla {}" + - " Event end {}" + - "}", getTaskTree(SequenceDependingOnEventTypeDetectionRule.class, null)); - } - - /** - * - */ - @Test - public void test_03() { - IGUIElement elem1 = new DummyGUIElement("elem1"); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new DummyInteraction("bla", 1), elem1); - simulateEvent(new DummyInteraction("bli", 1), elem1); - simulateEvent(new DummyInteraction("blup", 1), elem1); - simulateEvent(new FinishSequenceInteraction("end", 1), elem1); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new DummyInteraction("bla", 1), elem1); - simulateEvent(new DummyInteraction("bli", 1), elem1); - simulateEvent(new FinishSequenceInteraction("end", 1), elem1); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Event start {}" + - " Event bla {}" + - " Event bli {}" + - " Event blup {}" + - " Event end {}" + - " }" + - " Sequence sequence2 {" + - " Event start {}" + - " Event bla {}" + - " Event bli {}" + - " Event end {}" + - " }" + - "}", getTaskTree(SequenceDependingOnEventTypeDetectionRule.class, null)); - } - - /** - * - */ - @Test - public void test_04() { - IGUIElement elem1 = new DummyGUIElement("elem1"); - simulateEvent(new StartAndFinishSequenceInteraction("startFinish", 1), elem1); - simulateEvent(new DummyInteraction("bla", 1), elem1); - simulateEvent(new DummyInteraction("bli", 1), elem1); - simulateEvent(new DummyInteraction("blup", 1), elem1); - simulateEvent(new StartAndFinishSequenceInteraction("startFinish", 1), elem1); - simulateEvent(new DummyInteraction("bla", 1), elem1); - simulateEvent(new DummyInteraction("bli", 1), elem1); - simulateEvent(new StartAndFinishSequenceInteraction("startFinish", 1), elem1); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Event startFinish {}" + - " Event bla {}" + - " Event bli {}" + - " Event blup {}" + - " }" + - " Sequence sequence2 {" + - " Event startFinish {}" + - " Event bla {}" + - " Event bli {}" + - " }" + - " Event startFinish {}" + - "}", getTaskTree(SequenceDependingOnEventTypeDetectionRule.class, null)); - } - - /** - * - */ - @Test - public void test_05() { - IGUIElement elem1 = new DummyGUIElement("elem1"); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new DummyInteraction("bla", 1), elem1); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new DummyInteraction("bli", 1), elem1); - simulateEvent(new DummyInteraction("blup", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - simulateEvent(new DummyInteraction("bla", 1), elem1); - simulateEvent(new DummyInteraction("bli", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new DummyInteraction("blup", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Event start {}" + - " Event bla {}" + - " Sequence sequence2 {" + - " Event start {}" + - " Sequence sequence3 {" + - " Event start {}" + - " Event bli {}" + - " Event blup {}" + - " Event finish {}" + - " }" + - " Event bla {}" + - " Event bli {}" + - " Event finish {}" + - " }" + - " Sequence sequence4 {" + - " Event start {}" + - " Sequence sequence5 {" + - " Event start {}" + - " Sequence sequence6 {" + - " Event start {}" + - " Event blup {}" + - " Event finish {}" + - " }" + - " Event finish {}" + - " }" + - " Event finish {}" + - " }" + - " Event finish {}" + - " }" + - " Event finish {}" + - "}", getTaskTree(SequenceDependingOnEventTypeDetectionRule.class, null)); - } - - /** - * - */ - @Test - public void test_06() { - IGUIElement elem1 = new DummyGUIElement("elem1"); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new DummyInteraction("bla", 1), elem1); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new DummyInteraction("bli", 1), elem1); - simulateEvent(new DummyInteraction("blup", 1), elem1); - simulateEvent(new StartAndFinishSequenceInteraction("startFinish", 1), elem1); - simulateEvent(new DummyInteraction("bla", 1), elem1); - simulateEvent(new DummyInteraction("bli", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new StartSequenceInteraction("start", 1), elem1); - simulateEvent(new DummyInteraction("blup", 1), elem1); - simulateEvent(new StartAndFinishSequenceInteraction("startFinish", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Event start {}" + - " Event bla {}" + - " Sequence sequence2 {" + - " Event start {}" + - " Sequence sequence3 {" + - " Event start {}" + - " Event bli {}" + - " Event blup {}" + - " }" + - " Sequence sequence4 {" + - " Event startFinish {}" + - " Event bla {}" + - " Event bli {}" + - " Event finish {}" + - " }" + - " Sequence sequence5 {" + - " Event start {}" + - " Sequence sequence6 {" + - " Event start {}" + - " Sequence sequence7 {" + - " Event start {}" + - " Event blup {}" + - " }" + - " Sequence sequence8 {" + - " Event startFinish {}" + - " Event finish {}" + - " }" + - " Event finish {}" + - " }" + - " Event finish {}" + - " }" + - " Event finish {}" + - " }" + - " Event finish {}" + - " }" + - " Event finish {}" + - "}", getTaskTree(SequenceDependingOnEventTypeDetectionRule.class, null)); - } - - /** - * - */ - private class StartSequenceInteraction extends DummyInteraction { - - /** */ - private static final long serialVersionUID = 1L; - - /** - * - */ - public StartSequenceInteraction(String interactionType, int interactionNumber) { - super(interactionType, interactionNumber); - } - - /* (non-Javadoc) - * @see de.ugoe.cs.autoquest.test.DummyInteraction#startsLogicalSequence() - */ - @Override - public boolean startsLogicalSequence() { - return true; - } - - } - - /** - * - */ - private class FinishSequenceInteraction extends DummyInteraction { - - /** */ - private static final long serialVersionUID = 1L; - - /** - * - */ - public FinishSequenceInteraction(String interactionType, int interactionNumber) { - super(interactionType, interactionNumber); - } - - /* (non-Javadoc) - * @see de.ugoe.cs.autoquest.test.DummyInteraction#finishesLogicalSequence() - */ - @Override - public boolean finishesLogicalSequence() { - return true; - } - - } - - /** - * - */ - private class StartAndFinishSequenceInteraction extends DummyInteraction { - - /** */ - private static final long serialVersionUID = 1L; - - /** - * - */ - public StartAndFinishSequenceInteraction(String interactionType, int interactionNumber) { - super(interactionType, interactionNumber); - } - - /* (non-Javadoc) - * @see de.ugoe.cs.autoquest.test.DummyInteraction#startsLogicalSequence() - */ - @Override - public boolean startsLogicalSequence() { - return true; - } - - /* (non-Javadoc) - * @see de.ugoe.cs.autoquest.test.DummyInteraction#finishesLogicalSequence() - */ - @Override - public boolean finishesLogicalSequence() { - return true; - } - - } -} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRuleTest.java (revision 1132) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceForTaskDetectionRuleTest.java (revision 1146) @@ -17,11 +17,4 @@ import org.junit.Test; -import de.ugoe.cs.autoquest.eventcore.IEventTarget; -import de.ugoe.cs.autoquest.eventcore.gui.IInteraction; -import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker; -import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality; -import de.ugoe.cs.autoquest.test.DummyGUIElement; -import de.ugoe.cs.autoquest.test.DummyInteraction; - /** * TODO comment @@ -36,67 +29,150 @@ */ @Test - public void testTaskDetection() throws Exception { - IEventTarget element1 = new DummyGUIElement("elem1"); - - IInteraction action1 = new DummyInteraction("action1", 1); - IInteraction action2 = new DummyInteraction("action2", 1); - IInteraction action3 = new DummyInteraction("action3", 1); - IInteraction action4 = new DummyInteraction("action4", 1); - - simulateEvent(new DummyInteraction("noise0", 1), element1); - simulateEvent(action1, element1); - simulateEvent(action2, element1); - simulateEvent(action3, element1); - simulateEvent(action4, element1); - simulateEvent(new DummyInteraction("noise1", 1), element1); - simulateEvent(new DummyInteraction("noise2", 1), element1); - simulateEvent(action1, element1); - simulateEvent(action2, element1); - simulateEvent(action3, element1); - simulateEvent(action4, element1); - simulateEvent(new DummyInteraction("noise3", 1), element1); - simulateEvent(new DummyInteraction("noise4", 1), element1); - simulateEvent(new DummyInteraction("noise5", 1), element1); - simulateEvent(new DummyInteraction("noise6", 1), element1); - simulateEvent(action1, element1); - simulateEvent(action2, element1); - simulateEvent(action3, element1); - simulateEvent(action4, element1); - simulateEvent(new DummyInteraction("noise7", 1), element1); - simulateEvent(new DummyInteraction("noise8", 1), element1); - - new TaskTreeChecker().assertTaskTree - ("Sequence root {" + - " Sequence session1 {" + - " Event noise0 {}" + - " Sequence sequence2 {" + - " Event action1 {}" + - " Event action2 {}" + - " Event action3 {}" + - " Event action4 {}" + - " }" + - " Event noise1 {}" + - " Event noise2 {}" + - " Sequence sequence2 {" + - " Event action1 {}" + - " Event action2 {}" + - " Event action3 {}" + - " Event action4 {}" + - " }" + - " Event noise3 {}" + - " Event noise4 {}" + - " Event noise5 {}" + - " Event noise6 {}" + - " Sequence sequence2 {" + - " Event action1 {}" + - " Event action2 {}" + - " Event action3 {}" + - " Event action4 {}" + - " }" + - " Event noise7 {}" + - " Event noise8 {}" + - " }" + - "}", getTaskTree(SequenceForTaskDetectionRule.class, NodeEquality.LEXICALLY_EQUAL, true)); + public void test_TaskDetection_01() throws Exception { + String input = + "UserSession {" + + " Event noise0 {}" + + " Event action1 {}" + + " Event action2 {}" + + " Event action3 {}" + + " Event action4 {}" + + " Event noise1 {}" + + " Event noise2 {}" + + " Event action1 {}" + + " Event action2 {}" + + " Event action3 {}" + + " Event action4 {}" + + " Event noise3 {}" + + " Event noise4 {}" + + " Event noise5 {}" + + " Event noise6 {}" + + " Event action1 {}" + + " Event action2 {}" + + " Event action3 {}" + + " Event action4 {}" + + " Event action1 {}" + + " Event action2 {}" + + " Event action3 {}" + + " Event action4 {}" + + " Event noise7 {}" + + "}"; + String output = + "UserSession {" + + " Event noise0 {}" + + " Iteration iteration1 {" + + " Sequence sequence1 {" + + " Event action1 {}" + + " Event action2 {}" + + " Event action3 {}" + + " Event action4 {}" + + " }" + + " }" + + " Event noise1 {}" + + " Event noise2 {}" + + " Iteration iteration1 {" + + " Sequence sequence1 {" + + " Event action1 {}" + + " Event action2 {}" + + " Event action3 {}" + + " Event action4 {}" + + " }" + + " }" + + " Event noise3 {}" + + " Event noise4 {}" + + " Event noise5 {}" + + " Event noise6 {}" + + " Iteration iteration1 {" + + " Sequence sequence1 {" + + " Event action1 {}" + + " Event action2 {}" + + " Event action3 {}" + + " Event action4 {}" + + " }" + + " Sequence sequence1 {" + + " Event action1 {}" + + " Event action2 {}" + + " Event action3 {}" + + " Event action4 {}" + + " }" + + " }" + + " Event noise7 {}" + + "}"; + + applySessionScopeRule(SequenceForTaskDetectionRule.class, input, output); + } + + /** + * + */ + @Test + public void test_TaskDetection_02() throws Exception { + String input = + "UserSession {" + + " Event noise0 {}" + + " Event action1 {}" + + " Event action2 {}" + + " Event noise1 {}" + + " Event noise2 {}" + + " Event action3 {}" + + " Event action1 {}" + + " Event action2 {}" + + " Event action4 {}" + + " Event noise3 {}" + + " Event noise4 {}" + + " Event noise5 {}" + + " Event noise6 {}" + + " Event action1 {}" + + " Event action2 {}" + + " Event action3 {}" + + " Event action4 {}" + + " Event action1 {}" + + " Event action2 {}" + + " Event action3 {}" + + " Event action4 {}" + + " Event noise7 {}" + + "}"; + + String output = + "UserSession {" + + " Event noise0 {}" + + " Sequence sequence1 {" + + " Event action1 {}" + + " Event action2 {}" + + " }" + + " Event noise1 {}" + + " Event noise2 {}" + + " Event action3 {}" + + " Sequence sequence1 {" + + " Event action1 {}" + + " Event action2 {}" + + " }" + + " Event action4 {}" + + " Event noise3 {}" + + " Event noise4 {}" + + " Event noise5 {}" + + " Event noise6 {}" + + " Iteration iteration1 {" + + " Sequence sequence3 {" + + " Sequence sequence1 {" + + " Event action1 {}" + + " Event action2 {}" + + " }" + + " Event action3 {}" + + " Event action4 {}" + + " }" + + " Sequence sequence3 {" + + " Sequence sequence1 {" + + " Event action1 {}" + + " Event action2 {}" + + " }" + + " Event action3 {}" + + " Event action4 {}" + + " }" + + " }" + + " Event noise7 {}" + + "}"; + + applySessionScopeRule(SequenceForTaskDetectionRule.class, input, output); } Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceOnGuiElementDetectionRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SequenceOnGuiElementDetectionRuleTest.java (revision 1132) +++ (revision ) @@ -1,238 +1,0 @@ -// Copyright 2012 Georg-August-Universität Göttingen, Germany -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package de.ugoe.cs.autoquest.tasktrees.temporalrelation; - -import org.junit.Test; - -import de.ugoe.cs.autoquest.eventcore.IEventTarget; -import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker; -import de.ugoe.cs.autoquest.test.DummyGUIElement; -import de.ugoe.cs.autoquest.test.DummyInteraction; - -/** - * TODO comment - * - * @version $Revision: $ $Date: $ - * @author 2011, last modified by $Author: $ - */ -public class SequenceOnGuiElementDetectionRuleTest extends AbstractTemporalRelationshipTC { - - /** - * - */ - @Test - public void testOneInteractionOnOneElement() { - simulateEvent(new DummyInteraction("bla", 1), new DummyGUIElement("elem1")); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence {" + - " Event bla {}" + - "}", getTaskTree(SequenceOnGuiElementDetectionRule.class, null)); - } - - /** - * - */ - @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(SequenceOnGuiElementDetectionRule.class, null)); - } - - /** - * - */ - @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(SequenceOnGuiElementDetectionRule.class, null)); - } - - /** - * - */ - @Test - public void testManyInteractionsOnManyElementsWithoutHierarchy() { - 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(SequenceOnGuiElementDetectionRule.class, null)); - } - - /** - * - */ - @Test - public void testManyInteractionsOnManyElementsWithHierarchy() { - DummyGUIElement parentA = new DummyGUIElement("A"); - DummyGUIElement parentB = new DummyGUIElement("B", parentA); - DummyGUIElement parentC = new DummyGUIElement("C", parentB); - DummyGUIElement parentF = new DummyGUIElement("F", parentB); - DummyGUIElement parentH = new DummyGUIElement("H", parentA); - DummyGUIElement parentI = new DummyGUIElement("I", parentH); - - DummyGUIElement eventTargetD = new DummyGUIElement("D", parentC); - DummyGUIElement eventTargetE = new DummyGUIElement("E", parentC); - DummyGUIElement eventTargetG = new DummyGUIElement("G", parentF); - DummyGUIElement eventTargetJ = new DummyGUIElement("J", parentI); - - simulateEvent(new DummyInteraction("1", 1), eventTargetD); - simulateEvent(new DummyInteraction("2", 1), eventTargetD); - simulateEvent(new DummyInteraction("3", 1), eventTargetE); - simulateEvent(new DummyInteraction("4", 1), eventTargetD); - simulateEvent(new DummyInteraction("5", 1), eventTargetG); - simulateEvent(new DummyInteraction("6", 1), eventTargetG); - simulateEvent(new DummyInteraction("7", 1), eventTargetD); - simulateEvent(new DummyInteraction("8", 1), eventTargetJ); - simulateEvent(new DummyInteraction("9", 1), eventTargetG); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence0 {" + - " Sequence sequence1 {" + - " Sequence sequence2 {" + - " Sequence sequence3 {" + - " Event 1 {}" + - " Event 2 {}" + - " }" + - " Sequence sequence4 {" + - " Event 3 {}" + - " }" + - " Sequence sequence5 {" + - " Event 4 {}" + - " }" + - " }" + - " Sequence sequence6 {" + - " Sequence sequence7 {" + - " Event 5 {}" + - " Event 6 {}" + - " }" + - " }" + - " Sequence sequence8 {" + - " Sequence sequence9 {" + - " Event 7 {}" + - " }" + - " }" + - " }" + - " Sequence sequence10 {" + - " Sequence sequence11 {" + - " Sequence sequence12 {" + - " Event 8 {}" + - " }" + - " }" + - " }" + - " Sequence sequence13 {" + - " Sequence sequence14 {" + - " Sequence sequence15 {" + - " Event 9 {}" + - " }" + - " }" + - " }" + - "}", getTaskTree(SequenceOnGuiElementDetectionRule.class, null)); - } - -} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SimpleIterationDetectionRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/SimpleIterationDetectionRuleTest.java (revision 1132) +++ (revision ) @@ -1,174 +1,0 @@ -// Copyright 2012 Georg-August-Universität Göttingen, Germany -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package de.ugoe.cs.autoquest.tasktrees.temporalrelation; - -import org.junit.Test; - -import de.ugoe.cs.autoquest.eventcore.IEventTarget; -import de.ugoe.cs.autoquest.eventcore.IEventType; -import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker; -import de.ugoe.cs.autoquest.test.DummyGUIElement; -import de.ugoe.cs.autoquest.test.DummyInteraction; - -/** - * TODO comment - * - * @version $Revision: $ $Date: 28.04.2012$ - * @author 2012, last modified by $Author: patrick$ - */ -public class SimpleIterationDetectionRuleTest 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(SimpleIterationDetectionRule.class, null)); - - simulateEvent(event1, element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Event bla {}" + - " }" + - "}", getTaskTree(SimpleIterationDetectionRule.class, null)); - - simulateEvent(event1, element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Event bla {}" + - " }" + - "}", getTaskTree(SimpleIterationDetectionRule.class, null)); - - for (int i = 0; i < 10; i++) { - simulateEvent(event1, element1); - } - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Event bla {}" + - " }" + - "}", getTaskTree(SimpleIterationDetectionRule.class, null)); - - // 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(SimpleIterationDetectionRule.class, null)); - - // now test with iterations of iterations - - for (int i = 0; i < 5; 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 iteration4 {" + - " Event bla {}" + - " }" + - " Iteration iteration5 {" + - " Event bli {}" + - " }" + - " Iteration iteration6 {" + - " Event blup {}" + - " }" + - " Iteration iteration7 {" + - " Event bla {}" + - " }" + - " Iteration iteration8 {" + - " Event bli {}" + - " }" + - " Iteration iteration9 {" + - " Event blup {}" + - " }" + - " Iteration iteration10 {" + - " Event bla {}" + - " }" + - " Iteration iteration11 {" + - " Event bli {}" + - " }" + - " Iteration iteration12 {" + - " Event blup {}" + - " }" + - " Iteration iteration13 {" + - " Event bla {}" + - " }" + - " Iteration iteration14 {" + - " Event bli {}" + - " }" + - " Iteration iteration15 {" + - " Event blup {}" + - " }" + - " Iteration iteration16 {" + - " Event bla {}" + - " }" + - " Iteration iteration17 {" + - " Event bli {}" + - " }" + - " Iteration iteration18 {" + - " Event blup {}" + - " }" + - "}", getTaskTree(SimpleIterationDetectionRule.class, null)); - - } - -} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskTreeNodeMergerTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskTreeNodeMergerTest.java (revision 1132) +++ (revision ) @@ -1,1194 +1,0 @@ -// Copyright 2012 Georg-August-Universität Göttingen, Germany -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package de.ugoe.cs.autoquest.tasktrees.temporalrelation; - -import org.junit.Test; - -import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker; -import de.ugoe.cs.autoquest.tasktrees.TaskTreeInstantiator; -import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality; -import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager; -import de.ugoe.cs.autoquest.tasktrees.testutils.Utilities; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; -import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeBuilder; -import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory; - -/** - *

- * TODO comment - *

- * - * @author Patrick Harms - */ -public class TaskTreeNodeMergerTest { - - /** */ - private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder(); - - /** */ - private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory(); - - /** */ - private NodeEqualityRuleManager nodeEqualityRuleManager = - Utilities.getNodeEqualityRuleManagerForTests(); - - /** - * - */ - @Test - public void test_EventTaskMerge_1() { - String spec1 = "EventTask target1 {}"; - String spec2 = "EventTask target1 {}"; - - String oracleSpec = "EventTask target1 {}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_EventTaskMerge_2() { - String spec1 = "EventTask target1 {}"; - String spec2 = "EventTask target2 {}"; - - String oracleSpec = - "Selection {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_EventTaskMerge_3() { - String spec1 = - "Selection {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - "}"; - - String spec2 = "EventTask target2 {}"; - - String oracleSpec = - "Selection {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_EventTaskMerge_4() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Selection {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - "}"; - - String oracleSpec = - "Selection {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_EventTaskMerge_5() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Iteration {" + - " EventTask target1 {}" + - "}"; - - String oracleSpec = - "Iteration {" + - " EventTask target1 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_EventTaskMerge_6() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Iteration {" + - " Selection {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - "}"; - - String oracleSpec = - "Iteration {" + - " Selection {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_EventTaskMerge_7() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Iteration {" + - " Selection {" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - "}"; - - String oracleSpec = - "Iteration {" + - " Selection {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_EventTaskMerge_8() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Sequence {" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String oracleSpec = - "Selection {" + - " EventTask target1 {}" + - " Sequence {" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_EventTaskMerge_9() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - "}"; - - String oracleSpec = - "Sequence {" + - " EventTask target1 {}" + - " Optional {" + - " EventTask target2 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SequenceMerge_1() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String spec2 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String oracleSpec = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SequenceMerge_2() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String spec2 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target4 {}" + - " EventTask target3 {}" + - "}"; - - String oracleSpec = - "Sequence {" + - " EventTask target1 {}" + - " Selection {" + - " EventTask target2 {}" + - " EventTask target4 {}" + - " }" + - " EventTask target3 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SequenceMerge_3() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String spec2 = - "Sequence {" + - " EventTask target4 {}" + - " EventTask target5 {}" + - " EventTask target6 {}" + - "}"; - - String oracleSpec = - "Selection {" + - " Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - " Sequence {" + - " EventTask target4 {}" + - " EventTask target5 {}" + - " EventTask target6 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SequenceMerge_4() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String spec2 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target4 {}" + - "}"; - - String oracleSpec = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " Selection {" + - " EventTask target3 {}" + - " EventTask target4 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SequenceMerge_5() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String spec2 = - "Sequence {" + - " EventTask target4 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String oracleSpec = - "Sequence {" + - " Selection {" + - " EventTask target1 {}" + - " EventTask target4 {}" + - " }" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SequenceMerge_6() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String spec2 = - "Sequence {" + - " EventTask target4 {}" + - " EventTask target2 {}" + - " EventTask target5 {}" + - "}"; - - String oracleSpec = - "Sequence {" + - " Selection {" + - " EventTask target1 {}" + - " EventTask target4 {}" + - " }" + - " EventTask target2 {}" + - " Selection {" + - " EventTask target3 {}" + - " EventTask target5 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SequenceMerge_7() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String spec2 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target3 {}" + - "}"; - - String oracleSpec = - "Sequence {" + - " EventTask target1 {}" + - " Optional {" + - " EventTask target2 {}" + - " }" + - " EventTask target3 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SequenceMerge_8() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String spec2 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - "}"; - - String oracleSpec = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " Optional {" + - " EventTask target3 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SequenceMerge_9() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String spec2 = - "Sequence {" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String oracleSpec = - "Sequence {" + - " Optional {" + - " EventTask target1 {}" + - " }" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SequenceMerge_10() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String spec2 = - "Sequence {" + - " EventTask target2 {}" + - "}"; - - String oracleSpec = - "Sequence {" + - " Optional {" + - " EventTask target1 {}" + - " }" + - " EventTask target2 {}" + - " Optional {" + - " EventTask target3 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SequenceMerge_11() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " EventTask target4 {}" + - " EventTask target5 {}" + - " EventTask target6 {}" + - " EventTask target7 {}" + - "}"; - - String spec2 = - "Sequence {" + - " EventTask target4 {}" + - " EventTask target3 {}" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " EventTask target4 {}" + - " EventTask target4 {}" + - " EventTask target2 {}" + - " EventTask target6 {}" + - " EventTask target7 {}" + - "}"; - - String oracleSpec = - "Sequence {" + - " Optional {" + - " Sequence {" + - " EventTask target4 {}" + - " EventTask target3 {}" + - " }" + - " }" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " EventTask target4 {}" + - " Selection {" + - " EventTask target5 {}" + - " Sequence {" + - " EventTask target4 {}" + - " EventTask target2 {}" + - " }" + - " }" + - " EventTask target6 {}" + - " EventTask target7 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SelectionMerge_1() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Selection {" + - " EventTask target1 {}" + - "}"; - - String oracleSpec = - "Selection {" + - " EventTask target1 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SelectionMerge_2() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Selection {" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - String oracleSpec = - "Selection {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SelectionMerge_3() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Selection {" + - " Sequence {" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - "}"; - - String oracleSpec = - "Selection {" + - " EventTask target1 {}" + - " Sequence {" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SelectionMerge_4() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Selection {" + - " Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - "}"; - - String oracleSpec = - "Selection {" + - " Sequence {" + - " EventTask target1 {}" + - " Optional {" + - " EventTask target2 {}" + - " }" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SelectionMerge_5() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - "}"; - - String spec2 = - "Selection {" + - " Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - "}"; - - String oracleSpec = - "Selection {" + - " Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_SelectionMerge_6() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - "}"; - - String spec2 = - "Selection {" + - " Sequence {" + - " EventTask target3 {}" + - " EventTask target4 {}" + - " }" + - " Sequence {" + - " EventTask target5 {}" + - " EventTask target6 {}" + - " }" + - "}"; - - String oracleSpec = - "Selection {" + - " Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - " Sequence {" + - " EventTask target3 {}" + - " EventTask target4 {}" + - " }" + - " Sequence {" + - " EventTask target5 {}" + - " EventTask target6 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_IterationMerge_1() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Iteration {" + - " EventTask target1 {}" + - "}"; - - String oracleSpec = - "Iteration {" + - " EventTask target1 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_IterationMerge_2() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Iteration {" + - " Selection {" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - "}"; - - String oracleSpec = - "Iteration {" + - " Selection {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_IterationMerge_3() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Iteration {" + - " Sequence {" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - "}"; - - String oracleSpec = - "Iteration {" + - " Selection {" + - " EventTask target1 {}" + - " Sequence {" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_IterationMerge_4() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Iteration {" + - " Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - "}"; - - String oracleSpec = - "Iteration {" + - " Sequence {" + - " EventTask target1 {}" + - " Optional {" + - " EventTask target2 {}" + - " }" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_IterationMerge_5() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - "}"; - - String spec2 = - "Iteration {" + - " Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - "}"; - - String oracleSpec = - "Iteration {" + - " Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_IterationMerge_6() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - "}"; - - String spec2 = - "Iteration {" + - " Selection {" + - " Sequence {" + - " EventTask target3 {}" + - " EventTask target4 {}" + - " }" + - " Sequence {" + - " EventTask target5 {}" + - " EventTask target6 {}" + - " }" + - " }" + - "}"; - - String oracleSpec = - "Iteration {" + - " Selection {" + - " Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - " Sequence {" + - " EventTask target3 {}" + - " EventTask target4 {}" + - " }" + - " Sequence {" + - " EventTask target5 {}" + - " EventTask target6 {}" + - " }" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_OptionalMerge_1() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Optional {" + - " EventTask target1 {}" + - "}"; - - String oracleSpec = - "Optional {" + - " EventTask target1 {}" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_OptionalMerge_2() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Optional {" + - " Selection {" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - "}"; - - String oracleSpec = - "Optional {" + - " Selection {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_OptionalMerge_3() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Optional {" + - " Sequence {" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - "}"; - - String oracleSpec = - "Optional {" + - " Selection {" + - " EventTask target1 {}" + - " Sequence {" + - " EventTask target2 {}" + - " EventTask target3 {}" + - " }" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_OptionalMerge_4() { - String spec1 = "EventTask target1 {}"; - - String spec2 = - "Optional {" + - " Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - "}"; - - String oracleSpec = - "Optional {" + - " Sequence {" + - " EventTask target1 {}" + - " Optional {" + - " EventTask target2 {}" + - " }" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_OptionalMerge_5() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - "}"; - - String spec2 = - "Optional {" + - " Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - "}"; - - String oracleSpec = - "Optional {" + - " Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - @Test - public void test_OptionalMerge_6() { - String spec1 = - "Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - "}"; - - String spec2 = - "Optional {" + - " Selection {" + - " Sequence {" + - " EventTask target3 {}" + - " EventTask target4 {}" + - " }" + - " Sequence {" + - " EventTask target5 {}" + - " EventTask target6 {}" + - " }" + - " }" + - "}"; - - String oracleSpec = - "Optional {" + - " Selection {" + - " Sequence {" + - " EventTask target1 {}" + - " EventTask target2 {}" + - " }" + - " Sequence {" + - " EventTask target3 {}" + - " EventTask target4 {}" + - " }" + - " Sequence {" + - " EventTask target5 {}" + - " EventTask target6 {}" + - " }" + - " }" + - "}"; - - performTest(spec1, spec2, oracleSpec); - } - - /** - * - */ - private void performTest(String spec1, String spec2, String specOracle) { - TaskTreeInstantiator instantiator = - new TaskTreeInstantiator(taskTreeNodeFactory, taskTreeBuilder); - - ITaskTreeNode node1 = instantiator.instantiateTaskTree(spec1); - ITaskTreeNode node2 = instantiator.instantiateTaskTree(spec2); - ITaskTreeNode oracle = instantiator.instantiateTaskTree(specOracle); - - TaskTreeNodeComparator comparator = - new TaskTreeNodeComparator(nodeEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL); - - TaskTreeNodeMerger merger = new TaskTreeNodeMerger - (taskTreeNodeFactory, taskTreeBuilder, comparator); - - try { - ITaskTreeNode result = merger.mergeTaskNodes(node1, node2); - new TaskTreeChecker().assertTaskNodesEqual(oracle, result); - } - catch (AssertionError e) { - AssertionError toThrow = new AssertionError("first check: " + e.getMessage()); - toThrow.setStackTrace(e.getStackTrace()); - throw toThrow; - } - - node1 = instantiator.instantiateTaskTree(spec1); - node2 = instantiator.instantiateTaskTree(spec2); - oracle = instantiator.instantiateTaskTree(specOracle); - - comparator = - new TaskTreeNodeComparator(nodeEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL); - - merger = new TaskTreeNodeMerger(taskTreeNodeFactory, taskTreeBuilder, comparator); - - try { - ITaskTreeNode result = merger.mergeTaskNodes(node2, node1); - new TaskTreeChecker().assertTaskNodesEqual(oracle, result); - } - catch (AssertionError e) { - AssertionError toThrow = new AssertionError("second check: " + e.getMessage()); - toThrow.setStackTrace(e.getStackTrace()); - throw toThrow; - } - } -} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java (revision 1132) +++ (revision ) @@ -1,223 +1,0 @@ -// Copyright 2012 Georg-August-Universität Göttingen, Germany -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package de.ugoe.cs.autoquest.tasktrees.temporalrelation; - -import org.junit.Test; - -import de.ugoe.cs.autoquest.eventcore.gui.ValueSelection; -import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement; -import de.ugoe.cs.autoquest.eventcore.guimodel.ITrackBar; -import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker; -import de.ugoe.cs.autoquest.test.DummyGUIElement; -import de.ugoe.cs.autoquest.test.DummyInteraction; - -/** - * TODO comment - * - * @version $Revision: $ $Date: 28.04.2012$ - * @author 2012, last modified by $Author: patrick$ - */ -public class TrackBarSelectionDetectionRuleTest extends AbstractTemporalRelationshipTC { - - /** - * - */ - @Test - public void testSimpleDetection() throws Exception { - IGUIElement element1 = new DummyTrackBar(); - simulateEvent(new ValueSelection(1), element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Selection selection1 {" + - " Event ValueSelection(\"1\") {}" + - " }" + - " }" + - "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); - - simulateEvent(new ValueSelection(2), element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Selection selection1 {" + - " Event ValueSelection(\"1\") {}" + - " Event ValueSelection(\"2\") {}" + - " }" + - " }" + - "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); - - simulateEvent(new ValueSelection(3), element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Selection selection1 {" + - " Event ValueSelection(\"1\") {}" + - " Event ValueSelection(\"2\") {}" + - " Event ValueSelection(\"3\") {}" + - " }" + - " }" + - "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); - - simulateEvent(new ValueSelection(2), element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Selection selection1 {" + - " Event ValueSelection(\"1\") {}" + - " Event ValueSelection(\"2\") {}" + - " Event ValueSelection(\"3\") {}" + - " }" + - " }" + - "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); - - simulateEvent(new ValueSelection(3), element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Selection selection1 {" + - " Event ValueSelection(\"1\") {}" + - " Event ValueSelection(\"2\") {}" + - " Event ValueSelection(\"3\") {}" + - " }" + - " }" + - "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); - - } - - /** - * - */ - @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 iteration1 {" + - " Selection selection1 {" + - " Event ValueSelection(\"1\") {}" + - " Event ValueSelection(\"2\") {}" + - " Event ValueSelection(\"3\") {}" + - " }" + - " }" + - " Event bla {}" + - " Event bla {}" + - " Iteration iteration2 {" + - " Selection selection2 {" + - " Event ValueSelection(\"2\") {}" + - " Event ValueSelection(\"1\") {}" + - " }" + - " }" + - " Event bla {}" + - " Iteration iteration3 {" + - " Selection selection3 {" + - " Event ValueSelection(\"3\") {}" + - " Event ValueSelection(\"2\") {}" + - " }" + - " }" + - " Event bla {}" + - " Event bla {}" + - " Iteration iteration4 {" + - " Selection selection4 {" + - " Event ValueSelection(\"1\") {}" + - " }" + - " }" + - "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); - } - - /** - * - */ - @Test - public void testSubsequentSelectionsOnDifferentTrackbars() throws Exception { - IGUIElement element1 = new DummyTrackBar(); - IGUIElement element2 = new DummyTrackBar(); - simulateEvent(new ValueSelection(1), element1); - simulateEvent(new ValueSelection(2), element1); - simulateEvent(new ValueSelection(3), element1); - simulateEvent(new ValueSelection(1), element1); - simulateEvent(new ValueSelection(2), element2); - simulateEvent(new ValueSelection(1), element2); - simulateEvent(new ValueSelection(3), element1); - simulateEvent(new ValueSelection(2), element1); - simulateEvent(new ValueSelection(3), element1); - simulateEvent(new ValueSelection(1), element2); - simulateEvent(new ValueSelection(1), element2); - - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Selection selection1 {" + - " Event ValueSelection(\"1\") {}" + - " Event ValueSelection(\"2\") {}" + - " Event ValueSelection(\"3\") {}" + - " }" + - " }" + - " Iteration iteration2 {" + - " Selection selection2 {" + - " Event ValueSelection(\"2\") {}" + - " Event ValueSelection(\"1\") {}" + - " }" + - " }" + - " Iteration iteration3 {" + - " Selection selection3 {" + - " Event ValueSelection(\"3\") {}" + - " Event ValueSelection(\"2\") {}" + - " }" + - " }" + - " Iteration iteration4 {" + - " Selection selection4 {" + - " Event ValueSelection(\"1\") {}" + - " }" + - " }" + - "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); - } - - /** - * 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/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/testutils/Utilities.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/testutils/Utilities.java (revision 1132) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/testutils/Utilities.java (revision 1146) @@ -15,5 +15,5 @@ package de.ugoe.cs.autoquest.tasktrees.testutils; -import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager; +import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEqualityRuleManager; /** @@ -26,7 +26,8 @@ /** */ - private static final NodeEqualityRuleManager NODE_EQUALITY_RULE_MANAGER = - new NodeEqualityRuleManager(); + private static final TaskEqualityRuleManager NODE_EQUALITY_RULE_MANAGER = + new TaskEqualityRuleManager(); + /** */ static { NODE_EQUALITY_RULE_MANAGER.init(); @@ -38,5 +39,5 @@ * @return */ - public static NodeEqualityRuleManager getNodeEqualityRuleManagerForTests() { + public static TaskEqualityRuleManager getTaskEqualityRuleManagerForTests() { return NODE_EQUALITY_RULE_MANAGER; } Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskModelTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskModelTest.java (revision 1146) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskModelTest.java (revision 1146) @@ -0,0 +1,1246 @@ +// Copyright 2012 Georg-August-Universität Göttingen, Germany +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package de.ugoe.cs.autoquest.tasktrees.treeimpl; + +import static org.junit.Assert.*; + +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import org.junit.Test; + +import de.ugoe.cs.autoquest.eventcore.IEventTarget; +import de.ugoe.cs.autoquest.eventcore.IEventType; +import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration; +import de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInfo; +import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskInfo; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory; +import de.ugoe.cs.autoquest.test.DummyGUIElement; +import de.ugoe.cs.autoquest.test.DummyInteraction; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 02.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public class TaskModelTest { + + /** */ + private static final int MAX_TREE_DEPTH = 15; + + /** */ + private ITaskBuilder taskBuilder = new TaskBuilder(); + + /** */ + private ITaskFactory taskFactory = new TaskFactory(); + + /** + * + */ + @Test + public void test_EventTask_01() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + + assertNotNull(task); + assertNotNull(task.getDescription()); + assertNotNull(task.getId()); + assertTrue(task.equals(task)); + + assertEquals(eventType, task.getEventType()); + assertEquals(eventTarget, task.getEventTarget()); + } + + /** + * + */ + @Test + public void test_EventTask_02() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget); + + // the tasks will not be equal as they should have a different id + assertFalse(task1.equals(task2)); + } + + /** + * + */ + @Test + public void test_EventTask_03() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task); + ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task); + + assertFalse(taskInstance1.equals(taskInstance2)); + } + + /** + * + */ + @Test + public void test_Sequence_01() throws Exception { + ISequence task = taskFactory.createNewSequence(); + + assertNotNull(task); + assertNotNull(task.getDescription()); + assertNotNull(task.getId()); + assertNotNull(task.getChildren()); + assertEquals(0, task.getChildren().size()); + assertTrue(task.equals(task)); + } + + /** + * + */ + @Test + public void test_Sequence_02() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask child = taskFactory.createNewEventTask(eventType, eventTarget); + + ISequence task = taskFactory.createNewSequence(); + + taskBuilder.addChild(task, child); + + assertNotNull(task.getChildren()); + assertEquals(1, task.getChildren().size()); + assertEquals(child, task.getChildren().get(0)); + } + + /** + * + */ + @Test + public void test_Sequence_03() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask child1 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask child2 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask child3 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask child4 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask child5 = taskFactory.createNewEventTask(eventType, eventTarget); + + ISequence task = taskFactory.createNewSequence(); + + taskBuilder.addChild(task, child1); + taskBuilder.addChild(task, child2); + taskBuilder.addChild(task, child3); + taskBuilder.addChild(task, child4); + taskBuilder.addChild(task, child5); + + assertNotNull(task.getChildren()); + assertEquals(5, task.getChildren().size()); + assertEquals(child1, task.getChildren().get(0)); + assertEquals(child2, task.getChildren().get(1)); + assertEquals(child3, task.getChildren().get(2)); + assertEquals(child4, task.getChildren().get(3)); + assertEquals(child5, task.getChildren().get(4)); + } + + /** + * + */ + @Test + public void test_Selection_01() throws Exception { + ISelection task = taskFactory.createNewSelection(); + + assertNotNull(task); + assertNotNull(task.getDescription()); + assertNotNull(task.getId()); + assertNotNull(task.getChildren()); + assertEquals(0, task.getChildren().size()); + assertTrue(task.equals(task)); + } + + /** + * + */ + @Test + public void test_Selection_02() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask child = taskFactory.createNewEventTask(eventType, eventTarget); + + ISelection task = taskFactory.createNewSelection(); + + taskBuilder.addChild(task, child); + + assertNotNull(task.getChildren()); + assertEquals(1, task.getChildren().size()); + assertEquals(child, task.getChildren().get(0)); + } + + /** + * + */ + @Test + public void test_Selection_03() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask child1 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask child2 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask child3 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask child4 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask child5 = taskFactory.createNewEventTask(eventType, eventTarget); + + ISelection task = taskFactory.createNewSelection(); + + taskBuilder.addChild(task, child1); + taskBuilder.addChild(task, child2); + taskBuilder.addChild(task, child3); + taskBuilder.addChild(task, child4); + taskBuilder.addChild(task, child5); + + assertNotNull(task.getChildren()); + assertEquals(5, task.getChildren().size()); + assertEquals(child1, task.getChildren().get(0)); + assertEquals(child2, task.getChildren().get(1)); + assertEquals(child3, task.getChildren().get(2)); + assertEquals(child4, task.getChildren().get(3)); + assertEquals(child5, task.getChildren().get(4)); + } + + /** + * + */ + @Test + public void test_Iteration_01() throws Exception { + IIteration task = taskFactory.createNewIteration(); + + assertNotNull(task); + assertNotNull(task.getDescription()); + assertNotNull(task.getId()); + assertNull(task.getMarkedTask()); + assertTrue(task.equals(task)); + } + + /** + * + */ + @Test + public void test_Iteration_02() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask child = taskFactory.createNewEventTask(eventType, eventTarget); + + IIteration task = taskFactory.createNewIteration(); + + taskBuilder.setMarkedTask(task, child); + + assertEquals(child, task.getMarkedTask()); + } + + /** + * + */ + @Test + public void test_Iteration_03() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask child1 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask child2 = taskFactory.createNewEventTask(eventType, eventTarget); + + IIteration task = taskFactory.createNewIteration(); + + taskBuilder.setMarkedTask(task, child1); + taskBuilder.setMarkedTask(task, child2); + + assertEquals(child2, task.getMarkedTask()); + } + + /** + * + */ + @Test + public void test_Optional_01() throws Exception { + IOptional task = taskFactory.createNewOptional(); + + assertNotNull(task); + assertNotNull(task.getDescription()); + assertNotNull(task.getId()); + assertNull(task.getMarkedTask()); + assertTrue(task.equals(task)); + } + + /** + * + */ + @Test + public void test_Optional_02() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask child = taskFactory.createNewEventTask(eventType, eventTarget); + + IOptional task = taskFactory.createNewOptional(); + + taskBuilder.setMarkedTask(task, child); + + assertEquals(child, task.getMarkedTask()); + } + + /** + * + */ + @Test + public void test_Optional_03() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask child1 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask child2 = taskFactory.createNewEventTask(eventType, eventTarget); + + IOptional task = taskFactory.createNewOptional(); + + taskBuilder.setMarkedTask(task, child1); + taskBuilder.setMarkedTask(task, child2); + + assertEquals(child2, task.getMarkedTask()); + } + + /** + * + */ + @Test + public void test_EventTaskInstance_01() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + + ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task); + + assertNotNull(taskInstance); + assertEquals(task, taskInstance.getTask()); + assertTrue(taskInstance.equals(taskInstance)); + assertFalse(taskInstance.equals(task)); + assertNotNull(taskInstance.getChildren()); + assertEquals(0, taskInstance.getChildren().size()); + } + + /** + * + */ + @Test + public void test_EventTaskInstance_02() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + + ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task); + ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task); + + assertFalse(taskInstance1.equals(taskInstance2)); + } + + /** + * + */ + @Test(expected=IllegalArgumentException.class) + public void test_EventTaskInstance_03() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + + ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task); + ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task); + + taskBuilder.addChild(taskInstance1, taskInstance2); + } + + /** + * + */ + @Test(expected=IllegalArgumentException.class) + public void test_SequenceInstance_01() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + + ISequence sequence = taskFactory.createNewSequence(); + + ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task); + ITaskInstance sequenceInstance = taskFactory.createNewTaskInstance(sequence); + + taskBuilder.addChild(sequenceInstance, taskInstance); + } + + /** + * + */ + @Test + public void test_SequenceInstance_02() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + + ISequence sequence = taskFactory.createNewSequence(); + taskBuilder.addChild(sequence, task); + + ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task); + ITaskInstance sequenceInstance = taskFactory.createNewTaskInstance(sequence); + + taskBuilder.addChild(sequenceInstance, taskInstance); + + assertNotNull(sequenceInstance.getChildren()); + assertEquals(1, sequenceInstance.getChildren().size()); + assertEquals(taskInstance, sequenceInstance.getChildren().get(0)); + } + + /** + * + */ + @Test + public void test_SequenceInstance_03() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask task3 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask task4 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask task5 = taskFactory.createNewEventTask(eventType, eventTarget); + + ISequence sequence = taskFactory.createNewSequence(); + taskBuilder.addChild(sequence, task1); + taskBuilder.addChild(sequence, task2); + taskBuilder.addChild(sequence, task3); + taskBuilder.addChild(sequence, task4); + taskBuilder.addChild(sequence, task5); + + ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task1); + ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task2); + ITaskInstance taskInstance3 = taskFactory.createNewTaskInstance(task3); + ITaskInstance taskInstance4 = taskFactory.createNewTaskInstance(task4); + ITaskInstance taskInstance5 = taskFactory.createNewTaskInstance(task5); + ITaskInstance sequenceInstance = taskFactory.createNewTaskInstance(sequence); + + taskBuilder.addChild(sequenceInstance, taskInstance1); + taskBuilder.addChild(sequenceInstance, taskInstance2); + taskBuilder.addChild(sequenceInstance, taskInstance3); + taskBuilder.addChild(sequenceInstance, taskInstance4); + taskBuilder.addChild(sequenceInstance, taskInstance5); + + assertNotNull(sequenceInstance.getChildren()); + assertEquals(5, sequenceInstance.getChildren().size()); + assertEquals(taskInstance1, sequenceInstance.getChildren().get(0)); + assertEquals(taskInstance2, sequenceInstance.getChildren().get(1)); + assertEquals(taskInstance3, sequenceInstance.getChildren().get(2)); + assertEquals(taskInstance4, sequenceInstance.getChildren().get(3)); + assertEquals(taskInstance5, sequenceInstance.getChildren().get(4)); + } + + /** + * + */ + @Test(expected=IllegalArgumentException.class) + public void test_SelectionInstance_01() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + + ISelection selection = taskFactory.createNewSelection(); + + ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task); + ITaskInstance selectionInstance = taskFactory.createNewTaskInstance(selection); + + taskBuilder.addChild(selectionInstance, taskInstance); + } + + /** + * + */ + @Test + public void test_SelectionInstance_02() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + + ISelection selection = taskFactory.createNewSelection(); + taskBuilder.addChild(selection, task); + + ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task); + ITaskInstance selectionInstance = taskFactory.createNewTaskInstance(selection); + + taskBuilder.addChild(selectionInstance, taskInstance); + + assertNotNull(selectionInstance.getChildren()); + assertEquals(1, selectionInstance.getChildren().size()); + assertEquals(taskInstance, selectionInstance.getChildren().get(0)); + } + + /** + * + */ + @Test(expected=IllegalArgumentException.class) + public void test_SelectionInstance_03() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask task3 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask task4 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask task5 = taskFactory.createNewEventTask(eventType, eventTarget); + + ISelection selection = taskFactory.createNewSelection(); + taskBuilder.addChild(selection, task1); + taskBuilder.addChild(selection, task2); + taskBuilder.addChild(selection, task3); + taskBuilder.addChild(selection, task4); + taskBuilder.addChild(selection, task5); + + ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task1); + ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task2); + ITaskInstance selectionInstance = taskFactory.createNewTaskInstance(selection); + + taskBuilder.addChild(selectionInstance, taskInstance1); + taskBuilder.addChild(selectionInstance, taskInstance2); + } + + /** + * + */ + @Test(expected=IllegalArgumentException.class) + public void test_IterationInstance_01() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + + IIteration iteration = taskFactory.createNewIteration(); + + ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task); + ITaskInstance iterationInstance = taskFactory.createNewTaskInstance(iteration); + + taskBuilder.addChild(iterationInstance, taskInstance); + } + + /** + * + */ + @Test + public void test_IterationInstance_02() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + + IIteration iteration = taskFactory.createNewIteration(); + taskBuilder.setMarkedTask(iteration, task); + + ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task); + ITaskInstance iterationInstance = taskFactory.createNewTaskInstance(iteration); + + taskBuilder.addChild(iterationInstance, taskInstance); + + assertNotNull(iterationInstance.getChildren()); + assertEquals(1, iterationInstance.getChildren().size()); + assertEquals(taskInstance, iterationInstance.getChildren().get(0)); + } + + /** + * + */ + @Test(expected=IllegalArgumentException.class) + public void test_IterationInstance_03() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget); + + IIteration iteration = taskFactory.createNewIteration(); + taskBuilder.setMarkedTask(iteration, task1); + taskBuilder.setMarkedTask(iteration, task2); + + ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task1); + ITaskInstance iterationInstance = taskFactory.createNewTaskInstance(iteration); + + taskBuilder.addChild(iterationInstance, taskInstance1); + } + + /** + * + */ + @Test + public void test_IterationInstance_04() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget); + + IIteration iteration = taskFactory.createNewIteration(); + taskBuilder.setMarkedTask(iteration, task1); + taskBuilder.setMarkedTask(iteration, task2); + + ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task2); + ITaskInstance iterationInstance = taskFactory.createNewTaskInstance(iteration); + + taskBuilder.addChild(iterationInstance, taskInstance2); + + assertNotNull(iterationInstance.getChildren()); + assertEquals(1, iterationInstance.getChildren().size()); + assertEquals(taskInstance2, iterationInstance.getChildren().get(0)); + } + + /** + * + */ + @Test(expected=IllegalArgumentException.class) + public void test_OptionalInstance_01() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + + IOptional optional = taskFactory.createNewOptional(); + + ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task); + ITaskInstance optionalInstance = taskFactory.createNewTaskInstance(optional); + + taskBuilder.addChild(optionalInstance, taskInstance); + } + + /** + * + */ + @Test + public void test_OptionalInstance_02() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + + IOptional optional = taskFactory.createNewOptional(); + taskBuilder.setMarkedTask(optional, task); + + ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task); + ITaskInstance optionalInstance = taskFactory.createNewTaskInstance(optional); + + taskBuilder.addChild(optionalInstance, taskInstance); + + assertNotNull(optionalInstance.getChildren()); + assertEquals(1, optionalInstance.getChildren().size()); + assertEquals(taskInstance, optionalInstance.getChildren().get(0)); + } + + /** + * + */ + @Test(expected=IllegalArgumentException.class) + public void test_OptionalInstance_03() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget); + + IOptional optional = taskFactory.createNewOptional(); + taskBuilder.setMarkedTask(optional, task1); + taskBuilder.setMarkedTask(optional, task2); + + ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task1); + ITaskInstance optionalInstance = taskFactory.createNewTaskInstance(optional); + + taskBuilder.addChild(optionalInstance, taskInstance1); + } + + /** + * + */ + @Test + public void test_OptionalInstance_04() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget); + IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget); + + IOptional optional = taskFactory.createNewOptional(); + taskBuilder.setMarkedTask(optional, task1); + taskBuilder.setMarkedTask(optional, task2); + + ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task2); + ITaskInstance optionalInstance = taskFactory.createNewTaskInstance(optional); + + taskBuilder.addChild(optionalInstance, taskInstance2); + + assertNotNull(optionalInstance.getChildren()); + assertEquals(1, optionalInstance.getChildren().size()); + assertEquals(taskInstance2, optionalInstance.getChildren().get(0)); + } + + /** + * + */ + @Test + public void test_UserSession_01() throws Exception { + IUserSession userSession = taskFactory.createUserSession(); + + assertNotNull(userSession); + assertNotNull(userSession.getExecutedTasks()); + assertEquals(0, userSession.getExecutedTasks().size()); + } + + /** + * + */ + @Test + public void test_UserSession_02() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + + IUserSession userSession = taskFactory.createUserSession(); + + ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task); + + taskBuilder.addExecutedTask(userSession, taskInstance); + + assertNotNull(userSession.getExecutedTasks()); + assertEquals(1, userSession.getExecutedTasks().size()); + assertEquals(taskInstance, userSession.getExecutedTasks().get(0)); + } + + /** + * + */ + @Test + public void test_UserSession_03() throws Exception { + IEventType eventType = new DummyInteraction("interaction", 1); + IEventTarget eventTarget = new DummyGUIElement("elem"); + + IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget); + ISequence sequence = taskFactory.createNewSequence(); + ISelection selection = taskFactory.createNewSelection(); + IIteration iteration = taskFactory.createNewIteration(); + IOptional optional = taskFactory.createNewOptional(); + + taskBuilder.addChild(sequence, task); + taskBuilder.addChild(selection, task); + taskBuilder.setMarkedTask(iteration, task); + taskBuilder.setMarkedTask(optional, task); + + ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task); + ITaskInstance sequenceInstance = taskFactory.createNewTaskInstance(sequence); + ITaskInstance selectionInstance = taskFactory.createNewTaskInstance(selection); + ITaskInstance iterationInstance = taskFactory.createNewTaskInstance(iteration); + ITaskInstance optionalInstance = taskFactory.createNewTaskInstance(optional); + + taskBuilder.addChild(sequenceInstance, taskFactory.createNewTaskInstance(task)); + taskBuilder.addChild(selectionInstance, taskFactory.createNewTaskInstance(task)); + taskBuilder.addChild(iterationInstance, taskFactory.createNewTaskInstance(task)); + taskBuilder.addChild(optionalInstance, taskFactory.createNewTaskInstance(task)); + + IUserSession userSession = taskFactory.createUserSession(); + + taskBuilder.addExecutedTask(userSession, taskInstance); + taskBuilder.addExecutedTask(userSession, sequenceInstance); + taskBuilder.addExecutedTask(userSession, selectionInstance); + taskBuilder.addExecutedTask(userSession, iterationInstance); + taskBuilder.addExecutedTask(userSession, optionalInstance); + + assertNotNull(userSession.getExecutedTasks()); + assertEquals(5, userSession.getExecutedTasks().size()); + assertEquals(taskInstance, userSession.getExecutedTasks().get(0)); + assertEquals(sequenceInstance, userSession.getExecutedTasks().get(1)); + assertEquals(selectionInstance, userSession.getExecutedTasks().get(2)); + assertEquals(iterationInstance, userSession.getExecutedTasks().get(3)); + assertEquals(optionalInstance, userSession.getExecutedTasks().get(4)); + } + + /** + * + */ + @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("\niteration " + (i + 1) + ":"); + System.err.println(" creating tasks"); + Map expectedTaskInfos = new HashMap(); + ITask task = createTaskTree(noOfMaxChildren, maxDepth, expectedTaskInfos); + if (!(task instanceof ISequence)) { + ISequence sequence = taskFactory.createNewSequence(); + taskBuilder.addChild(sequence, task); + task = sequence; + } + else { + expectedTaskInfos.remove(task); + } + + ITaskInstance taskInstance = instantiateTask(task, noOfMaxChildren); + + System.err.println(" creating user session"); + + IUserSession session = taskFactory.createUserSession(); + + for (ITaskInstance child : taskInstance.getChildren()) { + taskBuilder.addExecutedTask(session, child); + } + + List sessions = new LinkedList(); + sessions.add(session); + + ITaskModel taskTree = taskFactory.createTaskModel(sessions); + + System.err.println(" validating task tree"); + Map actualTaskInfos = new HashMap(); + + for (ITask currentTask : taskTree.getTasks()) { + actualTaskInfos.put(currentTask, taskTree.getTaskInfo(currentTask)); + } + + assertMapsEqual(expectedTaskInfos, actualTaskInfos); + } + } + + /** + * + */ + 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()) { + ITaskInfo 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; + } + } + + /** + * + */ + 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 < 60; i++) { + System.err.print(" "); + } + System.err.print(" : "); + System.err.println(entry.getValue()); + } + } + + System.err.println(); + } + + /** + * + */ + private ITask createTaskTree(int maxNoOfChildren, + int maxDepth, + Map taskInfos) + throws Exception + { + + ITask task; + + // 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 = randomize(Math.min(10, maxDepth)); + + switch (type) + { + case 0: { + // System.err.print("creating new event task "); + task = createNewEventTask(taskInfos); + break; + } + case 1: { + // System.err.print("reusing event task "); + task = reuseEventTask(taskInfos); + break; + } + case 2: { + // System.err.println("creating new sequence {"); + task = createNewSequence(maxNoOfChildren, maxDepth, taskInfos); + break; + } + case 3: { + // System.err.println("reusing sequence {"); + task = reuseSequence(maxNoOfChildren, maxDepth, taskInfos); + break; + } + case 4: { + // System.err.println("creating new selection {"); + task = createNewSelection(maxNoOfChildren, maxDepth, taskInfos); + break; + } + case 5: { + // System.err.println("reusing selection {"); + task = reuseSelection(maxNoOfChildren, maxDepth, taskInfos); + break; + } + case 6: { + // System.err.println("creating new iteration {"); + task = createNewIteration(maxNoOfChildren, maxDepth, taskInfos); + break; + } + case 7: { + // System.err.println("reusing iteration {"); + task = reuseIteration(maxNoOfChildren, maxDepth, taskInfos); + break; + } + case 8: { + // System.err.println("creating new optional {"); + task = createNewOptional(maxNoOfChildren, maxDepth, taskInfos); + break; + } + case 9: { + // System.err.println("reusing optional {"); + task = reuseOptional(maxNoOfChildren, maxDepth, taskInfos); + break; + } + default: { + // System.err.print("creating new event task per default "); + task = createNewEventTask(taskInfos); + } + } + + return task; + } + + /** + * + */ + private ITask createNewEventTask(Map taskInfos) + throws Exception + { + Thread.sleep(2); + long id = System.currentTimeMillis(); + IEventTask task = taskFactory.createNewEventTask + (new DummyInteraction("interaction" + id, 1), new DummyGUIElement("elem" + id)); + + taskInfos.put(task, new TaskInfo(task)); + + return task; + } + + /** + * + */ + private ITask reuseEventTask(Map taskInfos) + throws Exception + { + ITask eventTask = reuseTask(taskInfos, IEventTask.class); + + if (eventTask == null) { + eventTask = createNewEventTask(taskInfos); + } + + return eventTask; + } + + /** + * + */ + private ITask createNewSequence(int maxNoOfChildren, + int maxDepth, + Map taskInfos) + throws Exception + { + ISequence sequence = taskFactory.createNewSequence(); + + // ensure at the minimum 2 children + int noOfChildren = randomize(2, maxNoOfChildren); + + for (int i = 0; i < noOfChildren; i++) { + ITask child = createTaskTree(maxNoOfChildren, maxDepth - 1, taskInfos); + taskBuilder.addChild(sequence, child); + } + + taskInfos.put(sequence, new TaskInfo(sequence)); + return sequence; + } + + /** + * + */ + private ITask reuseSequence(int maxNoOfChildren, + int maxDepth, + Map taskInfos) + throws Exception + { + ITask sequence = reuseTask(taskInfos, ISequence.class); + + if (sequence == null) { + sequence = createNewSequence(maxNoOfChildren, maxDepth, taskInfos); + } + + return sequence; + } + + /** + * + */ + private ITask createNewSelection(int maxNoOfChildren, + int maxDepth, + Map taskInfos) + throws Exception + { + ISelection selection = taskFactory.createNewSelection(); + + // ensure at the minimum 1 child + int noOfChildren = randomize(1, maxNoOfChildren); + + for (int i = 0; i < noOfChildren; i++) { + ITask child = createTaskTree(maxNoOfChildren, maxDepth - 1, taskInfos); + taskBuilder.addChild(selection, child); + } + + taskInfos.put(selection, new TaskInfo(selection)); + return selection; + } + + /** + * + */ + private ITask reuseSelection(int maxNoOfChildren, + int maxDepth, + Map taskInfos) + throws Exception + { + ITask selection = reuseTask(taskInfos, ISelection.class); + + if (selection == null) { + selection = createNewSelection(maxNoOfChildren, maxDepth, taskInfos); + } + + return selection; + } + + /** + * + */ + private ITask createNewIteration(int maxNoOfChildren, + int maxDepth, + Map taskInfos) + throws Exception + { + IIteration iteration = taskFactory.createNewIteration(); + + ITask child = createTaskTree(maxNoOfChildren, maxDepth - 1, taskInfos); + taskBuilder.setMarkedTask(iteration, child); + + taskInfos.put(iteration, new TaskInfo(iteration)); + return iteration; + } + + /** + * + */ + private ITask reuseIteration(int maxNoOfChildren, + int maxDepth, + Map taskInfos) + throws Exception + { + ITask iteration = reuseTask(taskInfos, IIteration.class); + + if (iteration == null) { + iteration = createNewIteration(maxNoOfChildren, maxDepth, taskInfos); + } + + return iteration; + } + + /** + * + */ + private ITask createNewOptional(int maxNoOfChildren, + int maxDepth, + Map taskInfos) + throws Exception + { + IOptional optional = taskFactory.createNewOptional(); + + ITask child = createTaskTree(maxNoOfChildren, maxDepth - 1, taskInfos); + taskBuilder.setMarkedTask(optional, child); + + taskInfos.put(optional, new TaskInfo(optional)); + return optional; + } + + /** + * + */ + private ITask reuseOptional(int maxNoOfChildren, + int maxDepth, + Map taskInfos) + throws Exception + { + ITask optional = reuseTask(taskInfos, IOptional.class); + + if (optional == null) { + optional = createNewOptional(maxNoOfChildren, maxDepth, taskInfos); + } + + return optional; + } + + /** + * + */ + private ITask reuseTask(Map taskInfos, Class type) + throws Exception + { + int noOfTasks = 0; + + for (Map.Entry entry : taskInfos.entrySet()) { + if (type.isInstance(entry.getKey())) { + noOfTasks++; + } + } + + if (noOfTasks > 0) { + noOfTasks = randomize(noOfTasks); + + for (Map.Entry entry : taskInfos.entrySet()) { + if (type.isInstance(entry.getKey())) { + if (--noOfTasks <= 0) { + return entry.getKey(); + } + } + } + } + else { + return null; + } + + throw new RuntimeException("this is an implementation error"); + } + + /** + * + */ + private ITaskInstance instantiateTask(ITask task, int maxIterationCount) throws Exception { + ITaskInstance instance = taskFactory.createNewTaskInstance(task); + + if (task instanceof ISequence) { + for (ITask child : ((ISequence) task).getChildren()) { + taskBuilder.addChild(instance, instantiateTask(child, maxIterationCount)); + } + } + else if (task instanceof ISelection) { + List children = ((ISelection) task).getChildren(); + int index = randomize(children.size()); + taskBuilder.addChild(instance, instantiateTask(children.get(index), maxIterationCount)); + } + else if (task instanceof IIteration) { + int count = randomize(maxIterationCount); + ITask child = ((IIteration) task).getMarkedTask(); + + for (int i = 0; i < count; i++) { + taskBuilder.addChild(instance, instantiateTask(child, maxIterationCount)); + } + } + else if (task instanceof IOptional) { + ITask child = ((IOptional) task).getMarkedTask(); + + if (randomize(1) == 0) { + taskBuilder.addChild(instance, instantiateTask(child, maxIterationCount)); + } + } + + return instance; + } + + /** + * + */ + private int randomize(int max) throws Exception { + return randomize(0, max); + } + + /** + * + */ + private int randomize(int min, int max) throws Exception { + if (min > max) { + throw new IllegalArgumentException("min must always be smaller or equal than max"); + } + + int deviation = max - min; + int value = (int) (Math.random() * deviation); + + return value + min; + } +} Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeImplTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeImplTest.java (revision 1132) +++ (revision ) @@ -1,480 +1,0 @@ -// Copyright 2012 Georg-August-Universität Göttingen, Germany -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package de.ugoe.cs.autoquest.tasktrees.treeimpl; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; - -import java.util.HashMap; -import java.util.Map; - -import org.junit.Test; - -import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; -import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeInfo; -import de.ugoe.cs.autoquest.tasktrees.treeimpl.NodeInfo; -import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeBuilder; -import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory; -import de.ugoe.cs.autoquest.test.DummyGUIElement; -import de.ugoe.cs.autoquest.test.DummyInteraction; - -/** - * TODO comment - * - * @version $Revision: $ $Date: 02.04.2012$ - * @author 2012, last modified by $Author: patrick$ - */ -public class TaskTreeImplTest { - - /** */ - 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) - { - 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"); - } - -}