Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/EventTaskComparisonRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/EventTaskComparisonRuleTest.java (revision 1109) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/EventTaskComparisonRuleTest.java (revision 1125) @@ -24,5 +24,4 @@ import de.ugoe.cs.autoquest.tasktrees.nodeequality.EventTaskComparisonRule; import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; @@ -39,43 +38,239 @@ */ @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)); - + public void test_isApplicable_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertTrue(rule.isApplicable(task1, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new StringEventType("eventType2"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + ITaskTreeNode selection = treeNodeFactory.createNewSelection(); + + assertFalse(rule.isApplicable(task1, selection)); + assertFalse(rule.isApplicable(selection, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_04() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + ITaskTreeNode sequence = treeNodeFactory.createNewSequence(); + + assertFalse(rule.isApplicable(task1, sequence)); + assertFalse(rule.isApplicable(sequence, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_05() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + ITaskTreeNode iteration = treeNodeFactory.createNewIteration(); + + assertFalse(rule.isApplicable(task1, iteration)); + assertFalse(rule.isApplicable(iteration, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_06() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + ITaskTreeNode optional = treeNodeFactory.createNewOptional(); + + assertFalse(rule.isApplicable(task1, optional)); + assertFalse(rule.isApplicable(optional, task1)); + } + + /** + * + */ + @Test + public void test_compare_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertEquals(NodeEquality.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() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, task2)); + assertTrue(rule.areLexicallyEqual(task1, task2)); + assertTrue(rule.areSyntacticallyEqual(task1, task2)); + assertTrue(rule.areSemanticallyEqual(task1, task2)); + assertEquals(NodeEquality.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() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); IEventType eventType2 = new StringEventType("eventType2"); - task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2)); + assertFalse(rule.areLexicallyEqual(task1, task2)); + assertFalse(rule.areSyntacticallyEqual(task1, task2)); + assertFalse(rule.areSemanticallyEqual(task1, task2)); + assertEquals(NodeEquality.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() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); IEventTarget eventTarget2 = new DummyGUIElement("elem2"); - task2 = treeNodeFactory.createNewEventTask(eventType1, eventTarget2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType1, eventTarget2); assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2)); + assertFalse(rule.areLexicallyEqual(task1, task2)); + assertFalse(rule.areSyntacticallyEqual(task1, task2)); + assertFalse(rule.areSemanticallyEqual(task1, task2)); + assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1)); - - task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + assertFalse(rule.areLexicallyEqual(task2, task1)); + assertFalse(rule.areSyntacticallyEqual(task2, task1)); + assertFalse(rule.areSemanticallyEqual(task2, task1)); + } + + + /** + * + */ + @Test + public void test_compare_05() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new StringEventType("eventType2"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2)); + assertFalse(rule.areLexicallyEqual(task1, task2)); + assertFalse(rule.areSyntacticallyEqual(task1, task2)); + assertFalse(rule.areSemanticallyEqual(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)); + 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/nodeequality/GUIEventTaskComparisonRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/GUIEventTaskComparisonRuleTest.java (revision 1109) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/GUIEventTaskComparisonRuleTest.java (revision 1125) @@ -26,10 +26,21 @@ 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.nodeequality.GUIEventTaskComparisonRule; import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality; -import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; @@ -46,102 +57,1434 @@ */ @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 + public void test_isApplicable_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertTrue(rule.isApplicable(task1, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new StringEventType("eventType2"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new KeyboardFocusChange(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + 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.LEXICALLY_EQUAL, rule.compare(task1, task2)); - assertEquals(NodeEquality.LEXICALLY_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 + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_04() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyReleased(VirtualKey.LETTER_B); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_05() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_C); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyTyped(VirtualKey.LETTER_D); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_06() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 5, 6); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.MIDDLE, 3, 1); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_07() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.RIGHT, 4, 7); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.X, 9, 12); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_08() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(5, 6, 7, 8); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_09() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new Scroll(1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new Scroll(3, 4); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_10() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + List inputEvents = new ArrayList(); + IEventType eventType1 = new TextInput("text1", inputEvents); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new TextInput("text2", inputEvents); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_11() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new TextSelection(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new ValueSelection("value"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertTrue(rule.isApplicable(task1, task2)); + assertTrue(rule.isApplicable(task2, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_12() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + ITaskTreeNode selection = treeNodeFactory.createNewSelection(); + + assertFalse(rule.isApplicable(task1, selection)); + assertFalse(rule.isApplicable(selection, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_13() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + ITaskTreeNode sequence = treeNodeFactory.createNewSequence(); + + assertFalse(rule.isApplicable(task1, sequence)); + assertFalse(rule.isApplicable(sequence, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_14() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + ITaskTreeNode iteration = treeNodeFactory.createNewIteration(); + + assertFalse(rule.isApplicable(task1, iteration)); + assertFalse(rule.isApplicable(iteration, task1)); + } + + /** + * + */ + @Test + public void test_isApplicable_15() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + EventTaskComparisonRule rule = new EventTaskComparisonRule(); + + IEventType eventType1 = new StringEventType("eventType1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + ITaskTreeNode optional = treeNodeFactory.createNewOptional(); + + assertFalse(rule.isApplicable(task1, optional)); + assertFalse(rule.isApplicable(optional, task1)); + } + + /** + * + */ + @Test + public void test_compare_KeyboardFocusChange_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyboardFocusChange(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_KeyboardFocusChange_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyboardFocusChange(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyboardFocusChange(); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyboardFocusChange_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyboardFocusChange(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyboardFocusChange(); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyPressed_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_KeyPressed_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyPressed(VirtualKey.LETTER_A); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyPressed_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyPressed(VirtualKey.LETTER_B); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyPressed_04() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyPressed(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyPressed(VirtualKey.LETTER_A); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyReleased_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyReleased(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_KeyReleased_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyReleased(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyReleased(VirtualKey.LETTER_A); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyReleased_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyReleased(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyReleased(VirtualKey.LETTER_B); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyReleased_04() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyReleased(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyReleased(VirtualKey.LETTER_A); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyTyped_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_KeyTyped_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyTyped(VirtualKey.LETTER_A); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyTyped_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyTyped(VirtualKey.LETTER_B); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_KeyTyped_04() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new KeyTyped(VirtualKey.LETTER_A); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new KeyTyped(VirtualKey.LETTER_A); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonDown_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonDown_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonDown_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 3); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonDown_04() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 3, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonDown_05() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.RIGHT, 1, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonDown_06() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonDown(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonUp_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonUp_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonUp_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 3); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonUp_04() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 3, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonUp_05() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.RIGHT, 1, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseButtonUp_06() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseButtonUp(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseClick_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_MouseClick_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseClick_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 3); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseClick_04() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.LEFT, 3, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseClick_05() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.RIGHT, 1, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseClick_06() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDoubleClick_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_MouseDoubleClick_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDoubleClick_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 3); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDoubleClick_04() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 3, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDoubleClick_05() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.RIGHT, 1, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDoubleClick_06() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDoubleClick(MouseButtonInteraction.Button.LEFT, 1, 2); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(1, 2, 3, 4); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(5, 2, 3, 4); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_04() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(1, 5, 3, 4); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_05() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(1, 2, 5, 4); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_06() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(1, 2, 3, 5); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_MouseDragAndDrop_07() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new MouseDragAndDrop(1, 2, 3, 4); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_Scroll_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new Scroll(1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_Scroll_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new Scroll(1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new Scroll(1, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_Scroll_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new Scroll(1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new Scroll(3, 2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_Scroll_04() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new Scroll(1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new Scroll(1, 3); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_Scroll_05() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new Scroll(1, 2); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new Scroll(1, 2); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_TextInput_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + 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); - 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)); - + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_TextInput_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + 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); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new TextInput("enteredText1", textInputEvents1); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_TextInput_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + 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); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new StringEventType("eventType2"); List textInputEvents2 = new ArrayList(); textInputEvents2.add(new Event(eventType2, eventTarget1)); eventType2 = new TextInput("enteredText1", textInputEvents2); - task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSyntacticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_TextInput_04() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + 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); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new StringEventType("eventType2"); + List textInputEvents2 = new ArrayList(); + textInputEvents2.add(new Event(eventType2, eventTarget1)); + eventType2 = new TextInput("enteredText2", textInputEvents2); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_TextInput_05() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + 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); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType1, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_TextSelection_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new TextSelection(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_TextSelection_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new TextSelection(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new TextSelection(); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_TextSelection_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new TextSelection(); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new TextSelection(); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_ValueSelection_01() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new ValueSelection("value1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + assertLexicallyEqual(task1, task1); + } + + /** + * + */ + @Test + public void test_compare_ValueSelection_02() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new ValueSelection("value1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new ValueSelection("value1"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertLexicallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_ValueSelection_03() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new ValueSelection("value1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new ValueSelection("value2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + + assertSemanticallyEqual(task1, task2); + } + + /** + * + */ + @Test + public void test_compare_ValueSelection_04() { + ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory(); + + IEventType eventType1 = new ValueSelection("value1"); + IEventTarget eventTarget1 = new DummyGUIElement("elem1"); + ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1); + + IEventType eventType2 = new ValueSelection("value1"); + IEventTarget eventTarget2 = new DummyGUIElement("elem2"); + ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2); + + assertUnequal(task1, task2); + } + + /** + * + */ + private void assertLexicallyEqual(ITaskTreeNode task1, ITaskTreeNode task2) { + GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule(); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, task2)); + assertTrue(rule.areLexicallyEqual(task1, task2)); + assertTrue(rule.areSyntacticallyEqual(task1, task2)); + assertTrue(rule.areSemanticallyEqual(task1, task2)); + + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task2, task1)); + assertTrue(rule.areLexicallyEqual(task2, task1)); + assertTrue(rule.areSyntacticallyEqual(task2, task1)); + assertTrue(rule.areSemanticallyEqual(task2, task1)); + } + + /** + * + */ + private void assertSyntacticallyEqual(ITaskTreeNode task1, ITaskTreeNode task2) { + GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule(); assertEquals(NodeEquality.SYNTACTICALLY_EQUAL, rule.compare(task1, task2)); + assertFalse(rule.areLexicallyEqual(task1, task2)); + assertTrue(rule.areSyntacticallyEqual(task1, task2)); + assertTrue(rule.areSemanticallyEqual(task1, task2)); + assertEquals(NodeEquality.SYNTACTICALLY_EQUAL, rule.compare(task2, task1)); - - eventType2 = new TextInput("enteredText2", textInputEvents2); - task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1); + assertFalse(rule.areLexicallyEqual(task2, task1)); + assertTrue(rule.areSyntacticallyEqual(task2, task1)); + assertTrue(rule.areSemanticallyEqual(task2, task1)); + } + + /** + * + */ + private void assertSemanticallyEqual(ITaskTreeNode task1, ITaskTreeNode task2) { + GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule(); assertEquals(NodeEquality.SEMANTICALLY_EQUAL, rule.compare(task1, task2)); + assertFalse(rule.areLexicallyEqual(task1, task2)); + assertFalse(rule.areSyntacticallyEqual(task1, task2)); + assertTrue(rule.areSemanticallyEqual(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); + assertFalse(rule.areLexicallyEqual(task2, task1)); + assertFalse(rule.areSyntacticallyEqual(task2, task1)); + assertTrue(rule.areSemanticallyEqual(task2, task1)); + } + + /** + * + */ + private void assertUnequal(ITaskTreeNode task1, ITaskTreeNode task2) { + GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule(); + assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2)); + assertFalse(rule.areLexicallyEqual(task1, task2)); + assertFalse(rule.areSyntacticallyEqual(task1, task2)); + assertFalse(rule.areSemanticallyEqual(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)); - } - + 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/nodeequality/IterationComparisonRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/IterationComparisonRuleTest.java (revision 1109) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/IterationComparisonRuleTest.java (revision 1125) @@ -52,8 +52,8 @@ ITaskTreeNode task2 = new TaskTreeNode("task2"); - assertNull(rule.compare(task1, task2)); + assertFalse(rule.isApplicable(task1, task2)); IIteration iteration1 = treeNodeFactory.createNewIteration(); - assertEquals(NodeEquality.IDENTICAL, rule.compare(iteration1, iteration1)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration1)); IIteration iteration2 = treeNodeFactory.createNewIteration(); @@ -96,13 +96,13 @@ 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)); + assertFalse(rule.isApplicable(iteration1, selection1)); + assertFalse(rule.isApplicable(selection1, iteration1)); + assertFalse(rule.isApplicable(iteration2, selection1)); + assertFalse(rule.isApplicable(selection1, iteration2)); - assertNull(rule.compare(iteration1, selection2)); - assertNull(rule.compare(selection2, iteration1)); - assertNull(rule.compare(iteration2, selection2)); - assertNull(rule.compare(selection2, 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/nodeequality/SelectionComparisonRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SelectionComparisonRuleTest.java (revision 1109) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SelectionComparisonRuleTest.java (revision 1125) @@ -52,8 +52,8 @@ ITaskTreeNode task2 = new TaskTreeNode("task2"); - assertNull(rule.compare(task1, task2)); + assertFalse(rule.isApplicable(task1, task2)); ISelection selection1 = treeNodeFactory.createNewSelection(); - assertEquals(NodeEquality.IDENTICAL, rule.compare(selection1, selection1)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection1)); ISelection selection2 = treeNodeFactory.createNewSelection(); @@ -93,10 +93,10 @@ 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)); + 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/nodeequality/SequenceComparisonRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SequenceComparisonRuleTest.java (revision 1109) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SequenceComparisonRuleTest.java (revision 1125) @@ -52,8 +52,8 @@ ITaskTreeNode task2 = new TaskTreeNode("task2"); - assertNull(rule.compare(task1, task2)); + assertFalse(rule.isApplicable(task1, task2)); ISequence sequence1 = treeNodeFactory.createNewSequence(); - assertEquals(NodeEquality.IDENTICAL, rule.compare(sequence1, sequence1)); + assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence1)); ISequence sequence2 = treeNodeFactory.createNewSequence(); @@ -92,10 +92,10 @@ 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)); + 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)); }