Index: /trunk/autoquest-core-tasktrees-test/.classpath =================================================================== --- /trunk/autoquest-core-tasktrees-test/.classpath (revision 894) +++ /trunk/autoquest-core-tasktrees-test/.classpath (revision 894) @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + + + Index: /trunk/autoquest-core-tasktrees-test/.project =================================================================== --- /trunk/autoquest-core-tasktrees-test/.project (revision 894) +++ /trunk/autoquest-core-tasktrees-test/.project (revision 894) @@ -0,0 +1,23 @@ + + + quest-core-tasktrees-test + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.m2e.core.maven2Nature + org.eclipse.jdt.core.javanature + + Index: /trunk/autoquest-core-tasktrees-test/.settings/org.eclipse.jdt.core.prefs =================================================================== --- /trunk/autoquest-core-tasktrees-test/.settings/org.eclipse.jdt.core.prefs (revision 894) +++ /trunk/autoquest-core-tasktrees-test/.settings/org.eclipse.jdt.core.prefs (revision 894) @@ -0,0 +1,5 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 +org.eclipse.jdt.core.compiler.compliance=1.6 +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.source=1.6 Index: /trunk/autoquest-core-tasktrees-test/.settings/org.eclipse.m2e.core.prefs =================================================================== --- /trunk/autoquest-core-tasktrees-test/.settings/org.eclipse.m2e.core.prefs (revision 894) +++ /trunk/autoquest-core-tasktrees-test/.settings/org.eclipse.m2e.core.prefs (revision 894) @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 Index: /trunk/autoquest-core-tasktrees-test/pom.xml =================================================================== --- /trunk/autoquest-core-tasktrees-test/pom.xml (revision 894) +++ /trunk/autoquest-core-tasktrees-test/pom.xml (revision 894) @@ -0,0 +1,16 @@ + + + de.ugoe.cs.quest + quest-test + 0.0.1-SNAPSHOT + + 4.0.0 + quest-core-tasktrees-test + + quest-core-tasktrees + + Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/manager/TaskTreeManagerTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/manager/TaskTreeManagerTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/manager/TaskTreeManagerTest.java (revision 894) @@ -0,0 +1,469 @@ +package de.ugoe.cs.quest.tasktrees.manager; + +import java.util.logging.Level; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.eventcore.IEventTarget; +import de.ugoe.cs.quest.eventcore.IEventType; +import de.ugoe.cs.quest.tasktrees.TaskTreeChecker; +import de.ugoe.cs.quest.test.DummyGUIElement; +import de.ugoe.cs.quest.test.DummyInteraction; +import de.ugoe.cs.util.console.TextConsole; + +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +public class TaskTreeManagerTest { + + /** */ + TaskTreeManager manager; + + /** + * + */ + @Before + public void setUp() { + new TextConsole(Level.FINEST); + manager = new TaskTreeManager(); + } + + /** + * + */ + @After + public void tearDown() { + manager = null; + ComponentManager.clearInstance(); + } + + /** + * + */ + @Test + public void testOneEventOnOneElement() { + simulateEvent(new DummyInteraction("bla", 1), new DummyGUIElement("elem1")); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence {" + + " Event bla {}" + + "}", manager.getTaskTree()); + } + + /** + * + */ + @Test + public void testManyEventsOnOneElement() { + IEventTarget eventTarget = new DummyGUIElement("elem1"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget); + simulateEvent(new DummyInteraction("bli", 1), eventTarget); + simulateEvent(new DummyInteraction("blo", 1), eventTarget); + simulateEvent(new DummyInteraction("blu", 1), eventTarget); + simulateEvent(new DummyInteraction("bla", 1), eventTarget); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence {" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " Event blu {}" + + " Event bla {}" + + "}", manager.getTaskTree()); + } + + /** + * + */ + @Test + public void testOneEventOnManyElements() { + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + IEventTarget eventTarget3 = new DummyGUIElement("elem3"); + IEventTarget eventTarget4 = new DummyGUIElement("elem4"); + IEventTarget eventTarget5 = new DummyGUIElement("elem5"); + IEventTarget eventTarget6 = new DummyGUIElement("elem6"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget1); + simulateEvent(new DummyInteraction("bli", 1), eventTarget2); + simulateEvent(new DummyInteraction("bla", 1), eventTarget3); + simulateEvent(new DummyInteraction("bli", 1), eventTarget4); + simulateEvent(new DummyInteraction("blo", 1), eventTarget5); + simulateEvent(new DummyInteraction("bla", 1), eventTarget6); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event bla {}" + + " }" + + " Sequence sequence2 {" + + " Event bli {}" + + " }" + + " Sequence sequence3 {" + + " Event bla {}" + + " }" + + " Sequence sequence4 {" + + " Event bli {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " }" + + " Sequence sequence6 {" + + " Event bla {}" + + " }" + + "}", manager.getTaskTree()); + } + + /** + * + */ + @Test + public void testManyEventsOnManyElements() { + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + IEventTarget eventTarget3 = new DummyGUIElement("elem3"); + IEventTarget eventTarget4 = new DummyGUIElement("elem4"); + IEventTarget eventTarget5 = new DummyGUIElement("elem5"); + IEventTarget eventTarget6 = new DummyGUIElement("elem6"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget1); + simulateEvent(new DummyInteraction("bli", 1), eventTarget1); + simulateEvent(new DummyInteraction("bla", 1), eventTarget1); + simulateEvent(new DummyInteraction("bli", 1), eventTarget2); + simulateEvent(new DummyInteraction("blo", 1), eventTarget2); + simulateEvent(new DummyInteraction("bla", 1), eventTarget3); + simulateEvent(new DummyInteraction("bli", 1), eventTarget4); + simulateEvent(new DummyInteraction("bla", 1), eventTarget4); + simulateEvent(new DummyInteraction("bli", 1), eventTarget4); + simulateEvent(new DummyInteraction("blo", 1), eventTarget4); + simulateEvent(new DummyInteraction("bla", 1), eventTarget5); + simulateEvent(new DummyInteraction("bli", 1), eventTarget6); + simulateEvent(new DummyInteraction("bla", 1), eventTarget6); + simulateEvent(new DummyInteraction("bli", 1), eventTarget6); + simulateEvent(new DummyInteraction("blo", 1), eventTarget6); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event bla {}" + + " Event bli {}" + + " Event bla {}" + + " }" + + " Sequence sequence2 {" + + " Event bli {}" + + " Event blo {}" + + " }" + + " Sequence sequence3 {" + + " Event bla {}" + + " }" + + " Sequence sequence4 {" + + " Event bli {}" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " }" + + " Sequence sequence5 {" + + " Event bla {}" + + " }" + + " Sequence sequence6 {" + + " Event bli {}" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " }" + + "}", manager.getTaskTree()); + } + + /** + * + */ + @Test + public void testEventIterationDetection() throws Exception { + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + IEventType event1 = new DummyInteraction("bla", 1); + simulateEvent(event1, eventTarget1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Event bla {}" + + "}", manager.getTaskTree()); + + simulateEvent(event1, eventTarget1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", manager.getTaskTree()); + + simulateEvent(event1, eventTarget1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", manager.getTaskTree()); + + for (int i = 0; i < 10; i++) { + simulateEvent(event1, eventTarget1); + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", manager.getTaskTree()); + + // now test with preceding and trailing other interactions + IEventType event2 = new DummyInteraction("bli", 1); + IEventType event3 = new DummyInteraction("blup", 1); + + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + for (int i = 0; i < 10; i++) { + simulateEvent(event1, eventTarget1); + } + simulateEvent(event3, eventTarget1); + simulateEvent(event2, eventTarget1); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + " Event bli {}" + + " Event blup {}" + + " Iteration iteration2 {" + + " Event bla {}" + + " }" + + " Event blup {}" + + " Event bli {}" + + "}", manager.getTaskTree()); + + // now test with iterations of iterations + + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 5; j++) { + simulateEvent(event1, eventTarget1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event2, eventTarget1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event3, eventTarget1); + } + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Iteration iteration0 {" + + " Event bla {}" + + " }" + + " Event bli {}" + + " Event blup {}" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + " Event blup {}" + + " Event bli {}" + + " Iteration iteration2 {" + + " Sequence sequence1 {" + + " Iteration iteration3 {" + + " Event bla {}" + + " }" + + " Iteration iteration4 {" + + " Event bli {}" + + " }" + + " Iteration iteration5 {" + + " Event blup {}" + + " }" + + " }" + + " }" + + "}", manager.getTaskTree()); + + } + + /** + * + */ + @Test + public void testSequenceIterationDetection() throws Exception { + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + IEventType event1 = new DummyInteraction("bla", 1); + IEventType event2 = new DummyInteraction("bli", 1); + IEventType event3 = new DummyInteraction("blup", 1); + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + "}", manager.getTaskTree()); + + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", manager.getTaskTree()); + + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", manager.getTaskTree()); + + for (int i = 0; i < 10; i++) { + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", manager.getTaskTree()); + + // now test with preceding and trailing other interactions + IEventType event4 = new DummyInteraction("ble", 1); + IEventType event5 = new DummyInteraction("blo", 1); + IEventType event6 = new DummyInteraction("blu", 1); + simulateEvent(event4, eventTarget1); + simulateEvent(event5, eventTarget1); + simulateEvent(event6, eventTarget1); + for (int i = 0; i < 10; i++) { + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + } + simulateEvent(event6, eventTarget1); + simulateEvent(event5, eventTarget1); + simulateEvent(event4, eventTarget1); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event ble {}" + + " Event blo {}" + + " Event blu {}" + + " Iteration iteration2 {" + + " Sequence sequence3 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event blu {}" + + " Event blo {}" + + " Event ble {}" + + "}", manager.getTaskTree()); + + // now test with iterations of iterations + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 5; j++) { + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event2, eventTarget1); + simulateEvent(event1, eventTarget1); + simulateEvent(event3, eventTarget1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event1, eventTarget1); + simulateEvent(event2, eventTarget1); + simulateEvent(event3, eventTarget1); + } + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event ble {}" + + " Event blo {}" + + " Event blu {}" + + " Iteration iteration2 {" + + " Sequence sequence3 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event blu {}" + + " Event blo {}" + + " Event ble {}" + + " Iteration iteration3 {" + + " Sequence sequence4 {" + + " Iteration iteration4 {" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Iteration iteration5 {" + + " Sequence sequence5 {" + + " Event bli {}" + + " Event bla {}" + + " Event blup {}" + + " }" + + " }" + + " Iteration iteration6 {" + + " Sequence sequence6 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " }" + + " }" + + "}", manager.getTaskTree()); + } + + /** + * + */ + private void simulateEvent(IEventType eventType, IEventTarget eventTarget) { + manager.handleNewEvent(new Event(eventType, eventTarget)); + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/EventTaskComparisonRuleTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/EventTaskComparisonRuleTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/EventTaskComparisonRuleTest.java (revision 894) @@ -0,0 +1,66 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.quest.eventcore.IEventTarget; +import de.ugoe.cs.quest.eventcore.IEventType; +import de.ugoe.cs.quest.eventcore.StringEventType; +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; +import de.ugoe.cs.quest.test.DummyGUIElement; + +/** + * @author Patrick Harms + */ +public class EventTaskComparisonRuleTest { + + /** + * + */ + @Test + public void test() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + // test the identity check + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertEquals(NodeEquality.IDENTICAL, rule.compare(task1, task1)); + + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task2, task1)); + + IEventType eventType2 = new StringEventType("eventType2"); + task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1)); + + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + task2 = treeNodeFactory.createNewEventTask(eventType1, eventTarget2); + + assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1)); + + task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1)); + + ISelection selection = treeNodeFactory.createNewSelection(); + assertNull(rule.compare(task1, selection)); + assertNull(rule.compare(selection, task1)); + assertNull(rule.compare(task2, selection)); + assertNull(rule.compare(selection, task2)); + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/GUIEventTaskComparisonRuleTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/GUIEventTaskComparisonRuleTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/GUIEventTaskComparisonRuleTest.java (revision 894) @@ -0,0 +1,131 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import static org.junit.Assert.*; + +import java.util.ArrayList; +import java.util.List; + +import org.junit.Test; + +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.eventcore.IEventTarget; +import de.ugoe.cs.quest.eventcore.IEventType; +import de.ugoe.cs.quest.eventcore.StringEventType; +import de.ugoe.cs.quest.eventcore.gui.KeyboardFocusChange; +import de.ugoe.cs.quest.eventcore.gui.TextInput; +import de.ugoe.cs.quest.eventcore.gui.ValueSelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; +import de.ugoe.cs.quest.test.DummyGUIElement; + +/** + * @author Patrick Harms + */ +public class GUIEventTaskComparisonRuleTest { + + /** + * + */ + @Test + public void test() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule(); + + // test the identity check + IEventType eventType1 = new StringEventType("blub"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertNull(rule.compare(task1, task1)); + + eventType1 = new KeyboardFocusChange(); + task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertEquals(NodeEquality.IDENTICAL, rule.compare(task1, task1)); + + // test lexical equality for interaction events which are no value selections or text inputs + IEventType eventType2 = new KeyboardFocusChange(); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task2, task1)); + + // test equality of value selections + eventType1 = new ValueSelection("value1"); + task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1)); + + eventType2 = new ValueSelection("value1"); + task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertEquals(NodeEquality.SYNTACTICALLY_EQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.SYNTACTICALLY_EQUAL, rule.compare(task2, task1)); + + eventType2 = new ValueSelection("value2"); + task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertEquals(NodeEquality.SEMANTICALLY_EQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.SEMANTICALLY_EQUAL, rule.compare(task2, task1)); + + // test equality of text inputs + List textInputEvents1 = new ArrayList(); + textInputEvents1.add(new Event(eventType1, eventTarget1)); + eventType1 = new TextInput("enteredText1", textInputEvents1); + task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1)); + + eventType2 = new TextInput("enteredText1", textInputEvents1); + task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task2, task1)); + + List textInputEvents2 = new ArrayList(); + textInputEvents2.add(new Event(eventType2, eventTarget1)); + eventType2 = new TextInput("enteredText1", textInputEvents2); + task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertEquals(NodeEquality.SYNTACTICALLY_EQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.SYNTACTICALLY_EQUAL, rule.compare(task2, task1)); + + eventType2 = new TextInput("enteredText2", textInputEvents2); + task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertEquals(NodeEquality.SEMANTICALLY_EQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.SEMANTICALLY_EQUAL, rule.compare(task2, task1)); + + // now ensure unequality for all combinations, if the event targets do not match + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + eventType1 = new KeyboardFocusChange(); + task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1)); + + eventType1 = new ValueSelection("value1"); + task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + task2 = treeNodeFactory.createNewEventTask(eventType1, eventTarget2); + assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1)); + + eventType1 = new TextInput("enteredText1", textInputEvents1); + task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + task2 = treeNodeFactory.createNewEventTask(eventType1, eventTarget2); + assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1)); + + ISelection selection = treeNodeFactory.createNewSelection(); + assertNull(rule.compare(task1, selection)); + assertNull(rule.compare(selection, task1)); + assertNull(rule.compare(task2, selection)); + assertNull(rule.compare(selection, task2)); + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/IterationComparisonRuleTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/IterationComparisonRuleTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/IterationComparisonRuleTest.java (revision 894) @@ -0,0 +1,92 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.quest.tasktrees.treeifc.IIteration; +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNode; + +/** + * @author Patrick Harms + */ +public class IterationComparisonRuleTest { + + /** + * + */ + @Test + public void test() { + NodeEqualityRuleManager manager = new NodeEqualityRuleManager(); + manager.init(); + + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + ITaskTreeBuilder treeBuilder = new TaskTreeBuilder(); + + IterationComparisonRule rule = new IterationComparisonRule(manager); + + ITaskTreeNode task1 = new TaskTreeNode("task1"); + ITaskTreeNode task2 = new TaskTreeNode("task2"); + + assertNull(rule.compare(task1, task2)); + + IIteration iteration1 = treeNodeFactory.createNewIteration(); + assertEquals(NodeEquality.IDENTICAL, rule.compare(iteration1, iteration1)); + + IIteration iteration2 = treeNodeFactory.createNewIteration(); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1)); + + treeBuilder.setChild(iteration1, task1); + + assertEquals(NodeEquality.UNEQUAL, rule.compare(iteration1, iteration2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(iteration2, iteration1)); + + treeBuilder.setChild(iteration2, task1); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1)); + + treeBuilder.setChild(iteration1, task2); + + assertEquals(NodeEquality.UNEQUAL, rule.compare(iteration1, iteration2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(iteration2, iteration1)); + + treeBuilder.setChild(iteration2, task2); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1)); + + ISelection selection1 = treeNodeFactory.createNewSelection(); + treeBuilder.addChild(selection1, task2); + treeBuilder.setChild(iteration1, selection1); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1)); + + ISelection selection2 = treeNodeFactory.createNewSelection(); + treeBuilder.addChild(selection2, task2); + treeBuilder.setChild(iteration2, selection2); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1)); + + assertNull(rule.compare(iteration1, selection1)); + assertNull(rule.compare(selection1, iteration1)); + assertNull(rule.compare(iteration2, selection1)); + assertNull(rule.compare(selection1, iteration2)); + + assertNull(rule.compare(iteration1, selection2)); + assertNull(rule.compare(selection2, iteration1)); + assertNull(rule.compare(iteration2, selection2)); + assertNull(rule.compare(selection2, iteration2)); + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeAndIterationComparisonRuleTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeAndIterationComparisonRuleTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeAndIterationComparisonRuleTest.java (revision 894) @@ -0,0 +1,56 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.quest.tasktrees.treeifc.IIteration; +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNode; + +/** + * @author Patrick Harms + */ +public class NodeAndIterationComparisonRuleTest { + + /** + * + */ + @Test + public void test() { + NodeEqualityRuleManager manager = new NodeEqualityRuleManager(); + manager.init(); + + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + ITaskTreeBuilder treeBuilder = new TaskTreeBuilder(); + + NodeAndIterationComparisonRule rule = new NodeAndIterationComparisonRule(manager); + + ITaskTreeNode task1 = new TaskTreeNode("task1"); + + assertNull(rule.compare(task1, task1)); + + IIteration iteration1 = treeNodeFactory.createNewIteration(); + assertNull(rule.compare(iteration1, iteration1)); + assertNull(rule.compare(task1, iteration1)); + assertNull(rule.compare(iteration1, task1)); + + treeBuilder.setChild(iteration1, task1); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, task1)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, iteration1)); + + ISelection selection1 = treeNodeFactory.createNewSelection(); + treeBuilder.addChild(selection1, task1); + treeBuilder.setChild(iteration1, selection1); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, task1)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, iteration1)); + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeAndSelectionComparisonRuleTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeAndSelectionComparisonRuleTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeAndSelectionComparisonRuleTest.java (revision 894) @@ -0,0 +1,56 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNode; + +/** + * @author Patrick Harms + */ +public class NodeAndSelectionComparisonRuleTest { + + /** + * + */ + @Test + public void test() { + NodeEqualityRuleManager manager = new NodeEqualityRuleManager(); + manager.init(); + + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + ITaskTreeBuilder treeBuilder = new TaskTreeBuilder(); + + NodeAndSelectionComparisonRule rule = new NodeAndSelectionComparisonRule(manager); + + ITaskTreeNode task1 = new TaskTreeNode("task1"); + + assertNull(rule.compare(task1, task1)); + + ISelection selection1 = treeNodeFactory.createNewSelection(); + assertNull(rule.compare(selection1, selection1)); + assertNull(rule.compare(task1, selection1)); + assertNull(rule.compare(selection1, task1)); + + treeBuilder.addChild(selection1, task1); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection1, task1)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, selection1)); + + selection1 = treeNodeFactory.createNewSelection(); + ISelection selection2 = treeNodeFactory.createNewSelection(); + treeBuilder.addChild(selection2, task1); + treeBuilder.addChild(selection1, selection2); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection1, task1)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, selection1)); + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityTest.java (revision 894) @@ -0,0 +1,48 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +/** + * @author Patrick Harms + */ +public class NodeEqualityTest { + + /** + * + */ + @Test + public void test() { + assertTrue(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.IDENTICAL)); + assertTrue(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); + assertTrue(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); + assertTrue(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); + assertFalse(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.UNEQUAL)); + + assertFalse(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.IDENTICAL)); + assertTrue(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); + assertTrue(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); + assertTrue(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); + assertFalse(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.UNEQUAL)); + + assertFalse(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.IDENTICAL)); + assertFalse(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); + assertTrue(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); + assertTrue(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); + assertFalse(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.UNEQUAL)); + + assertFalse(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.IDENTICAL)); + assertFalse(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); + assertFalse(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); + assertTrue(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); + assertFalse(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.UNEQUAL)); + + assertFalse(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.IDENTICAL)); + assertFalse(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL)); + assertFalse(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)); + assertFalse(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)); + assertTrue(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.UNEQUAL)); + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/SelectionComparisonRuleTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/SelectionComparisonRuleTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/SelectionComparisonRuleTest.java (revision 894) @@ -0,0 +1,86 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNode; + +/** + * @author Patrick Harms + */ +public class SelectionComparisonRuleTest { + + /** + * + */ + @Test + public void test() { + NodeEqualityRuleManager manager = new NodeEqualityRuleManager(); + manager.init(); + + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + ITaskTreeBuilder treeBuilder = new TaskTreeBuilder(); + + SelectionComparisonRule rule = new SelectionComparisonRule(manager); + + ITaskTreeNode task1 = new TaskTreeNode("task1"); + ITaskTreeNode task2 = new TaskTreeNode("task2"); + + assertNull(rule.compare(task1, task2)); + + ISelection selection1 = treeNodeFactory.createNewSelection(); + assertEquals(NodeEquality.IDENTICAL, rule.compare(selection1, selection1)); + + ISelection selection2 = treeNodeFactory.createNewSelection(); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection2, selection1)); + + treeBuilder.addChild(selection1, task1); + + assertEquals(NodeEquality.UNEQUAL, rule.compare(selection1, selection2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(selection2, selection1)); + + treeBuilder.addChild(selection2, task1); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection2, selection1)); + + treeBuilder.addChild(selection1, task2); + + assertEquals(NodeEquality.UNEQUAL, rule.compare(selection1, selection2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(selection2, selection1)); + + treeBuilder.addChild(selection2, task2); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection2, selection1)); + + ISelection selection3 = treeNodeFactory.createNewSelection(); + treeBuilder.addChild(selection3, task2); + treeBuilder.addChild(selection3, task1); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection3)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection3, selection1)); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection2, selection3)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection3, selection2)); + + ISequence sequence = treeNodeFactory.createNewSequence(); + assertNull(rule.compare(selection1, sequence)); + assertNull(rule.compare(sequence, selection1)); + assertNull(rule.compare(selection2, sequence)); + assertNull(rule.compare(sequence, selection2)); + assertNull(rule.compare(selection3, sequence)); + assertNull(rule.compare(sequence, selection3)); + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/SequenceComparisonRuleTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/SequenceComparisonRuleTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/nodeequality/SequenceComparisonRuleTest.java (revision 894) @@ -0,0 +1,85 @@ +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNode; + +/** + * @author Patrick Harms + */ +public class SequenceComparisonRuleTest { + + /** + * + */ + @Test + public void test() { + NodeEqualityRuleManager manager = new NodeEqualityRuleManager(); + manager.init(); + + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + ITaskTreeBuilder treeBuilder = new TaskTreeBuilder(); + + SequenceComparisonRule rule = new SequenceComparisonRule(manager); + + ITaskTreeNode task1 = new TaskTreeNode("task1"); + ITaskTreeNode task2 = new TaskTreeNode("task2"); + + assertNull(rule.compare(task1, task2)); + + ISequence sequence1 = treeNodeFactory.createNewSequence(); + assertEquals(NodeEquality.IDENTICAL, rule.compare(sequence1, sequence1)); + + ISequence sequence2 = treeNodeFactory.createNewSequence(); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1)); + + treeBuilder.addChild(sequence1, task1); + + assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence1, sequence2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence2, sequence1)); + + treeBuilder.addChild(sequence2, task1); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1)); + + treeBuilder.addChild(sequence1, task2); + + assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence1, sequence2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence2, sequence1)); + + treeBuilder.addChild(sequence2, task2); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1)); + + ISequence sequence3 = treeNodeFactory.createNewSequence(); + treeBuilder.addChild(sequence3, task2); + treeBuilder.addChild(sequence3, task1); + + assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence1, sequence3)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence3, sequence1)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence2, sequence3)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence3, sequence2)); + + ISelection selection = treeNodeFactory.createNewSelection(); + assertNull(rule.compare(sequence1, selection)); + assertNull(rule.compare(selection, sequence1)); + assertNull(rule.compare(sequence2, selection)); + assertNull(rule.compare(selection, sequence2)); + assertNull(rule.compare(sequence3, selection)); + assertNull(rule.compare(selection, sequence3)); + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java (revision 894) @@ -0,0 +1,79 @@ +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Level; + +import org.junit.Before; + +import de.ugoe.cs.quest.eventcore.IEventTarget; +import de.ugoe.cs.quest.eventcore.IEventType; +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; +import de.ugoe.cs.quest.tasktrees.testutils.Utilities; +import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; +import de.ugoe.cs.util.console.TextConsole; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 28.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public class AbstractTemporalRelationshipTC { + + /** */ + private List events; + + /** */ + private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder(); + + /** */ + private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory(); + + /** */ + private NodeEqualityRuleManager nodeEqualityRuleManager = + Utilities.getNodeEqualityRuleManagerForTests(); + + /** + * + */ + @Before + public void setUp() { + new TextConsole(Level.FINEST); + events = new ArrayList(); + } + + /** + * + */ + protected void simulateEvent(IEventType eventType, IEventTarget eventTarget) { + events.add(taskTreeNodeFactory.createNewEventTask(eventType, eventTarget)); + } + + /** + * + * @return + */ + protected ITaskTree getTaskTree() { + ISequence sequence = taskTreeNodeFactory.createNewSequence(); + + for (IEventTask task : events) { + taskTreeBuilder.addChild(sequence, task); + } + + TemporalRelationshipRuleManager ruleManager = + new TemporalRelationshipRuleManager(nodeEqualityRuleManager); + + ruleManager.init(); + ruleManager.applyRules(sequence, taskTreeBuilder, taskTreeNodeFactory, true); + + return taskTreeNodeFactory.createTaskTree(sequence); + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRuleTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRuleTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRuleTest.java (revision 894) @@ -0,0 +1,212 @@ +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import org.junit.Test; + +import de.ugoe.cs.quest.eventcore.IEventTarget; +import de.ugoe.cs.quest.tasktrees.TaskTreeChecker; +import de.ugoe.cs.quest.test.DummyGUIElement; +import de.ugoe.cs.quest.test.DummyInteraction; + +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +public class DefaultGuiElementSequenceDetectionRuleTest extends AbstractTemporalRelationshipTC { + + /** + * + */ + @Test + public void testOneInteractionOnOneElement() { + simulateEvent(new DummyInteraction("bla", 1), new DummyGUIElement("elem1")); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence {" + + " Event bla {}" + + "}", getTaskTree()); + } + + /** + * + */ + @Test + public void testManyInteractionsOnOneElement() { + IEventTarget eventTarget = new DummyGUIElement("elem1"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget); + simulateEvent(new DummyInteraction("bli", 1), eventTarget); + simulateEvent(new DummyInteraction("blo", 1), eventTarget); + simulateEvent(new DummyInteraction("blu", 1), eventTarget); + simulateEvent(new DummyInteraction("bla", 1), eventTarget); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence {" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " Event blu {}" + + " Event bla {}" + + "}", getTaskTree()); + } + + /** + * + */ + @Test + public void testOneInteractionOnManyElements() { + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + IEventTarget eventTarget3 = new DummyGUIElement("elem3"); + IEventTarget eventTarget4 = new DummyGUIElement("elem4"); + IEventTarget eventTarget5 = new DummyGUIElement("elem5"); + IEventTarget eventTarget6 = new DummyGUIElement("elem6"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget1); + simulateEvent(new DummyInteraction("bli", 1), eventTarget2); + simulateEvent(new DummyInteraction("bla", 1), eventTarget3); + simulateEvent(new DummyInteraction("bli", 1), eventTarget4); + simulateEvent(new DummyInteraction("blo", 1), eventTarget5); + simulateEvent(new DummyInteraction("bla", 1), eventTarget6); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event bla {}" + + " }" + + " Sequence sequence2 {" + + " Event bli {}" + + " }" + + " Sequence sequence3 {" + + " Event bla {}" + + " }" + + " Sequence sequence4 {" + + " Event bli {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " }" + + " Sequence sequence6 {" + + " Event bla {}" + + " }" + + "}", getTaskTree()); + } + + /** + * + */ + @Test + public void 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()); + } + + /** + * + */ + @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 {" + + " Event 5 {}" + + " Event 6 {}" + + " }" + + " Sequence sequence7 {" + + " Event 7 {}" + + " }" + + " }" + + " Sequence sequence8 {" + + " Event 8 {}" + + " }" + + " Sequence sequence9 {" + + " Event 9 {}" + + " }" + + "}", getTaskTree()); + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRuleTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRuleTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRuleTest.java (revision 894) @@ -0,0 +1,153 @@ +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import org.junit.Test; + +import de.ugoe.cs.quest.eventcore.IEventTarget; +import de.ugoe.cs.quest.tasktrees.TaskTreeChecker; +import de.ugoe.cs.quest.test.DummyGUIElement; +import de.ugoe.cs.quest.test.DummyInteraction; + +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +public class DefaultGuiEventSequenceDetectionRuleTest extends AbstractTemporalRelationshipTC { + + /** + * + */ + @Test + public void testOneInteractionOnOneElement() { + simulateEvent(new DummyInteraction("bla", 1), new DummyGUIElement("elem1")); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence {" + + " Event bla {}" + + "}", getTaskTree()); + } + + /** + * + */ + @Test + public void testManyInteractionsOnOneElement() { + IEventTarget eventTarget = new DummyGUIElement("elem1"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget); + simulateEvent(new DummyInteraction("bli", 1), eventTarget); + simulateEvent(new DummyInteraction("blo", 1), eventTarget); + simulateEvent(new DummyInteraction("blu", 1), eventTarget); + simulateEvent(new DummyInteraction("bla", 1), eventTarget); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence {" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " Event blu {}" + + " Event bla {}" + + "}", getTaskTree()); + } + + /** + * + */ + @Test + public void testOneInteractionOnManyElements() { + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + IEventTarget eventTarget3 = new DummyGUIElement("elem3"); + IEventTarget eventTarget4 = new DummyGUIElement("elem4"); + IEventTarget eventTarget5 = new DummyGUIElement("elem5"); + IEventTarget eventTarget6 = new DummyGUIElement("elem6"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget1); + simulateEvent(new DummyInteraction("bli", 1), eventTarget2); + simulateEvent(new DummyInteraction("bla", 1), eventTarget3); + simulateEvent(new DummyInteraction("bli", 1), eventTarget4); + simulateEvent(new DummyInteraction("blo", 1), eventTarget5); + simulateEvent(new DummyInteraction("bla", 1), eventTarget6); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event bla {}" + + " }" + + " Sequence sequence2 {" + + " Event bli {}" + + " }" + + " Sequence sequence3 {" + + " Event bla {}" + + " }" + + " Sequence sequence4 {" + + " Event bli {}" + + " }" + + " Sequence sequence5 {" + + " Event blo {}" + + " }" + + " Sequence sequence6 {" + + " Event bla {}" + + " }" + + "}", getTaskTree()); + } + + /** + * + */ + @Test + public void testManyInteractionsOnManyElements() { + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + IEventTarget eventTarget3 = new DummyGUIElement("elem3"); + IEventTarget eventTarget4 = new DummyGUIElement("elem4"); + IEventTarget eventTarget5 = new DummyGUIElement("elem5"); + IEventTarget eventTarget6 = new DummyGUIElement("elem6"); + simulateEvent(new DummyInteraction("bla", 1), eventTarget1); + simulateEvent(new DummyInteraction("bli", 1), eventTarget1); + simulateEvent(new DummyInteraction("bla", 1), eventTarget1); + simulateEvent(new DummyInteraction("bli", 1), eventTarget2); + simulateEvent(new DummyInteraction("blo", 1), eventTarget2); + simulateEvent(new DummyInteraction("bla", 1), eventTarget3); + simulateEvent(new DummyInteraction("bli", 1), eventTarget4); + simulateEvent(new DummyInteraction("bla", 1), eventTarget4); + simulateEvent(new DummyInteraction("bli", 1), eventTarget4); + simulateEvent(new DummyInteraction("blo", 1), eventTarget4); + simulateEvent(new DummyInteraction("bla", 1), eventTarget5); + simulateEvent(new DummyInteraction("bli", 1), eventTarget6); + simulateEvent(new DummyInteraction("bla", 1), eventTarget6); + simulateEvent(new DummyInteraction("bli", 1), eventTarget6); + simulateEvent(new DummyInteraction("blo", 1), eventTarget6); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event bla {}" + + " Event bli {}" + + " Event bla {}" + + " }" + + " Sequence sequence2 {" + + " Event bli {}" + + " Event blo {}" + + " }" + + " Sequence sequence3 {" + + " Event bla {}" + + " }" + + " Sequence sequence4 {" + + " Event bli {}" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " }" + + " Sequence sequence5 {" + + " Event bla {}" + + " }" + + " Sequence sequence6 {" + + " Event bli {}" + + " Event bla {}" + + " Event bli {}" + + " Event blo {}" + + " }" + + "}", getTaskTree()); + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java (revision 894) @@ -0,0 +1,301 @@ +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import org.junit.Test; + +import de.ugoe.cs.quest.eventcore.IEventTarget; +import de.ugoe.cs.quest.eventcore.IEventType; +import de.ugoe.cs.quest.tasktrees.TaskTreeChecker; +import de.ugoe.cs.quest.test.DummyGUIElement; +import de.ugoe.cs.quest.test.DummyInteraction; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 28.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public class DefaultIterationDetectionRuleTest extends AbstractTemporalRelationshipTC { + + /** + * + */ + @Test + public void testInteractionIterationDetection() throws Exception { + IEventTarget element1 = new DummyGUIElement("elem1"); + IEventType event1 = new DummyInteraction("bla", 1); + simulateEvent(event1, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Event bla {}" + + "}", getTaskTree()); + + simulateEvent(event1, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", getTaskTree()); + + simulateEvent(event1, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", getTaskTree()); + + for (int i = 0; i < 10; i++) { + simulateEvent(event1, element1); + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", getTaskTree()); + + // now test with preceding and trailing other events + IEventType event2 = new DummyInteraction("bli", 1); + IEventType event3 = new DummyInteraction("blup", 1); + + simulateEvent(event2, element1); + simulateEvent(event3, element1); + for (int i = 0; i < 10; i++) { + simulateEvent(event1, element1); + } + simulateEvent(event3, element1); + simulateEvent(event2, element1); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + " Event bli {}" + + " Event blup {}" + + " Iteration iteration2 {" + + " Event bla {}" + + " }" + + " Event blup {}" + + " Event bli {}" + + "}", getTaskTree()); + + // now test with iterations of iterations + + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 5; j++) { + simulateEvent(event1, element1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event2, element1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event3, element1); + } + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + " Event bli {}" + + " Event blup {}" + + " Iteration iteration2 {" + + " Event bla {}" + + " }" + + " Event blup {}" + + " Event bli {}" + + " Iteration iteration3 {" + + " Sequence sequence2 {" + + " Iteration iteration4 {" + + " Event bla {}" + + " }" + + " Iteration iteration5 {" + + " Event bli {}" + + " }" + + " Iteration iteration6 {" + + " Event blup {}" + + " }" + + " }" + + " }" + + "}", getTaskTree()); + + } + + /** + * + */ + @Test + public void testSequenceIterationDetection() throws Exception { + IEventTarget element1 = new DummyGUIElement("elem1"); + IEventType event1 = new DummyInteraction("bla", 1); + IEventType event2 = new DummyInteraction("bli", 1); + IEventType event3 = new DummyInteraction("blup", 1); + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + "}", getTaskTree()); + + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", getTaskTree()); + + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", getTaskTree()); + + for (int i = 0; i < 10; i++) { + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", getTaskTree()); + + // now test with preceding and trailing other events + IEventType event4 = new DummyInteraction("ble", 1); + IEventType event5 = new DummyInteraction("blo", 1); + IEventType event6 = new DummyInteraction("blu", 1); + simulateEvent(event4, element1); + simulateEvent(event5, element1); + simulateEvent(event6, element1); + for (int i = 0; i < 10; i++) { + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + } + simulateEvent(event6, element1); + simulateEvent(event5, element1); + simulateEvent(event4, element1); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event ble {}" + + " Event blo {}" + + " Event blu {}" + + " Iteration iteration2 {" + + " Sequence sequence3 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event blu {}" + + " Event blo {}" + + " Event ble {}" + + "}", getTaskTree()); + + // now test with iterations of iterations + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 5; j++) { + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event2, element1); + simulateEvent(event1, element1); + simulateEvent(event3, element1); + } + for (int j = 0; j < 5; j++) { + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + } + } + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event ble {}" + + " Event blo {}" + + " Event blu {}" + + " Iteration iteration2 {" + + " Sequence sequence3 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Event blu {}" + + " Event blo {}" + + " Event ble {}" + + " Iteration iteration3 {" + + " Sequence sequence4 {" + + " Iteration iteration4 {" + + " Sequence sequence4 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " Iteration iteration5 {" + + " Sequence sequence5 {" + + " Event bli {}" + + " Event bla {}" + + " Event blup {}" + + " }" + + " }" + + " Iteration iteration6 {" + + " Sequence sequence6 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + " }" + + " }" + + "}", getTaskTree()); + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java (revision 894) @@ -0,0 +1,161 @@ +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import org.junit.Test; + +import de.ugoe.cs.quest.eventcore.gui.ValueSelection; +import de.ugoe.cs.quest.eventcore.guimodel.IGUIElement; +import de.ugoe.cs.quest.eventcore.guimodel.ITrackBar; +import de.ugoe.cs.quest.tasktrees.TaskTreeChecker; +import de.ugoe.cs.quest.test.DummyGUIElement; +import de.ugoe.cs.quest.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 interation1 {" + + " Selection selection1 {" + + " Event ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree()); + + simulateEvent(new ValueSelection(2), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree()); + + simulateEvent(new ValueSelection(3), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree()); + + simulateEvent(new ValueSelection(2), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree()); + + simulateEvent(new ValueSelection(3), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree()); + + } + + /** + * + */ + @Test + public void testComplexDetection() throws Exception { + IGUIElement element1 = new DummyTrackBar(); + simulateEvent(new ValueSelection(1), element1); + simulateEvent(new ValueSelection(2), element1); + simulateEvent(new ValueSelection(3), element1); + simulateEvent(new ValueSelection(1), element1); + simulateEvent(new DummyInteraction("bla", 1), element1); + simulateEvent(new DummyInteraction("bla", 2), element1); + simulateEvent(new ValueSelection(2), element1); + simulateEvent(new ValueSelection(1), element1); + simulateEvent(new DummyInteraction("bla", 3), element1); + simulateEvent(new ValueSelection(3), element1); + simulateEvent(new ValueSelection(2), element1); + simulateEvent(new ValueSelection(3), element1); + simulateEvent(new DummyInteraction("bla", 1), element1); + simulateEvent(new DummyInteraction("bla", 2), element1); + simulateEvent(new ValueSelection(1), element1); + simulateEvent(new ValueSelection(1), element1); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + " Event bla {}" + + " Event bla {}" + + " Iteration interation2 {" + + " Selection selection2 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + " Event bla {}" + + " Iteration interation3 {" + + " Selection selection3 {" + + " Event ValueSelection {}" + + " Event ValueSelection {}" + + " }" + + " }" + + " Event bla {}" + + " Event bla {}" + + " Iteration interation4 {" + + " Selection selection4 {" + + " Event ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree()); + } + + /** + * TODO comment + * + * @version $Revision: $ $Date: 28.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ + public class DummyTrackBar extends DummyGUIElement implements ITrackBar { + + /** */ + private static final long serialVersionUID = 1L; + + /** + * + */ + public DummyTrackBar() { + super("DummyTrackBar"); + } + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/Utilities.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/Utilities.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/Utilities.java (revision 894) @@ -0,0 +1,30 @@ +package de.ugoe.cs.quest.tasktrees.testutils; + +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 02.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +public class Utilities { + + /** */ + private static final NodeEqualityRuleManager NODE_EQUALITY_RULE_MANAGER = + new NodeEqualityRuleManager(); + + static { + NODE_EQUALITY_RULE_MANAGER.init(); + } + + /** + * TODO: comment + * + * @return + */ + public static NodeEqualityRuleManager getNodeEqualityRuleManagerForTests() { + return NODE_EQUALITY_RULE_MANAGER; + } + +} Index: /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeImplTest.java =================================================================== --- /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeImplTest.java (revision 894) +++ /trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeImplTest.java (revision 894) @@ -0,0 +1,463 @@ +package de.ugoe.cs.quest.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.quest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.quest.tasktrees.treeifc.IIteration; +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeInfo; +import de.ugoe.cs.quest.test.DummyGUIElement; +import de.ugoe.cs.quest.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"); + } + +}