Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java (revision 987) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java (revision 1106) @@ -15,6 +15,14 @@ package de.ugoe.cs.autoquest.tasktrees.temporalrelation; +import static org.junit.Assert.fail; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertNotNull; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; +import java.util.LinkedList; import java.util.List; +import java.util.Stack; import java.util.logging.Level; @@ -23,6 +31,6 @@ import de.ugoe.cs.autoquest.eventcore.IEventTarget; import de.ugoe.cs.autoquest.eventcore.IEventType; +import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality; import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager; -import de.ugoe.cs.autoquest.tasktrees.temporalrelation.TemporalRelationshipRuleManager; import de.ugoe.cs.autoquest.tasktrees.testutils.Utilities; import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; @@ -30,7 +38,9 @@ import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree; import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode; import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory; import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeBuilder; import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory; +import de.ugoe.cs.util.console.Console; import de.ugoe.cs.util.console.TextConsole; @@ -57,6 +67,6 @@ /** - * - */ + * + */ @Before public void setUp() { @@ -70,4 +80,5 @@ protected void simulateEvent(IEventType eventType, IEventTarget eventTarget) { events.add(taskTreeNodeFactory.createNewEventTask(eventType, eventTarget)); + Console.reset(); } @@ -83,12 +94,115 @@ } - TemporalRelationshipRuleManager ruleManager = - new TemporalRelationshipRuleManager(nodeEqualityRuleManager); + TemporalRelationshipRuleManager ruleManager = new TemporalRelationshipRuleManager + (nodeEqualityRuleManager, taskTreeNodeFactory, taskTreeBuilder); ruleManager.init(); - ruleManager.applyRules(sequence, taskTreeBuilder, taskTreeNodeFactory, true); + ruleManager.applyRules(sequence); return taskTreeNodeFactory.createTaskTree(sequence); } + /** + * + * @return + */ + protected ITaskTree getTaskTree(Class ruleClass, + NodeEquality nodeEquality) + { + ISequence sequence = taskTreeNodeFactory.createNewSequence(); + + for (IEventTask task : events) { + taskTreeBuilder.addChild(sequence, task); + } + + TemporalRelationshipRule rule = null; + + CONSTRUCTOR_ITERATION: + for (Constructor constructor : ruleClass.getDeclaredConstructors()) { + List parameters = new LinkedList(); + + for (Class type : constructor.getParameterTypes()) { + if (ITaskTreeNodeFactory.class.equals(type)) { + parameters.add(taskTreeNodeFactory); + } + else if (ITaskTreeBuilder.class.equals(type)) { + parameters.add(taskTreeBuilder); + } + else if (NodeEqualityRuleManager.class.equals(type)) { + parameters.add(nodeEqualityRuleManager); + } + else if (NodeEquality.class.equals(type)) { + if (nodeEquality != null) { + parameters.add(nodeEquality); + } + else { + parameters.add(NodeEquality.LEXICALLY_EQUAL); + } + } + else { + continue CONSTRUCTOR_ITERATION; + } + } + + try { + rule = (TemporalRelationshipRule) constructor.newInstance(parameters.toArray()); + } + catch (IllegalArgumentException e) { + e.printStackTrace(); + fail("could not invoke the constructor " + constructor); + } + catch (InstantiationException e) { + e.printStackTrace(); + fail("could not invoke the constructor " + constructor); + } + catch (IllegalAccessException e) { + e.printStackTrace(); + fail("could not invoke the constructor " + constructor); + } + catch (InvocationTargetException e) { + e.printStackTrace(); + fail("could not invoke the constructor " + constructor); + } + } + + if (rule == null) { + fail("no matching constructor found to instantiate rule " + ruleClass); + } + + RuleApplicationResult result; + RuleApplicationStatus status; + + Stack toBeAppliedOn = new Stack(); + toBeAppliedOn.push(sequence); + + do { + result = rule.apply(toBeAppliedOn.peek(), true); + + if (result != null) { + status = result.getRuleApplicationStatus(); + assertNotNull(status); + } + else { + status = RuleApplicationStatus.RULE_NOT_APPLIED; + } + + assertTrue(status != RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); + + if ((result != null) && (result.getNewlyCreatedParentNodes() != null)) { + for (int i = result.getNewlyCreatedParentNodes().size() - 1; i >= 0; i--) { + toBeAppliedOn.push(result.getNewlyCreatedParentNodes().get(i)); + } + } + + if (status == RuleApplicationStatus.RULE_NOT_APPLIED) { + toBeAppliedOn.pop(); + } + + } + while ((!toBeAppliedOn.isEmpty()) || + (status == RuleApplicationStatus.RULE_APPLICATION_FINISHED)); + + return taskTreeNodeFactory.createTaskTree(sequence); + } + } Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRuleTest.java (revision 987) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRuleTest.java (revision 1106) @@ -62,5 +62,5 @@ " Event blu {}" + " Event bla {}" + - "}", getTaskTree()); + "}", getTaskTree(DefaultGuiElementSequenceDetectionRule.class, null)); } @@ -103,5 +103,5 @@ " Event bla {}" + " }" + - "}", getTaskTree()); + "}", getTaskTree(DefaultGuiElementSequenceDetectionRule.class, null)); } @@ -162,5 +162,5 @@ " Event blo {}" + " }" + - "}", getTaskTree()); + "}", getTaskTree(DefaultGuiElementSequenceDetectionRule.class, null)); } @@ -192,5 +192,5 @@ simulateEvent(new DummyInteraction("9", 1), eventTargetG); - new TaskTreeChecker(true).assertTaskTree + new TaskTreeChecker().assertTaskTree ("Sequence sequence0 {" + " Sequence sequence1 {" + @@ -233,5 +233,5 @@ " }" + " }" + - "}", getTaskTree()); + "}", getTaskTree(DefaultGuiElementSequenceDetectionRule.class, null)); } Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRuleTest.java (revision 987) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRuleTest.java (revision 1106) @@ -17,5 +17,5 @@ import org.junit.Test; -import de.ugoe.cs.autoquest.eventcore.IEventTarget; +import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement; import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker; import de.ugoe.cs.autoquest.test.DummyGUIElement; @@ -34,134 +34,314 @@ */ @Test - public void testOneInteractionOnOneElement() { - simulateEvent(new DummyInteraction("bla", 1), new DummyGUIElement("elem1")); + public void test_01() { + IGUIElement elem1 = new DummyGUIElement("elem1"); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new FinishSequenceInteraction("end", 1), elem1); new TaskTreeChecker().assertTaskTree ("Sequence sequence {" + + " Event start {}" + + " Event end {}" + + "}", getTaskTree(DefaultGuiEventSequenceDetectionRule.class, null)); + } + + + /** + * + */ + @Test + public void test_02() { + IGUIElement elem1 = new DummyGUIElement("elem1"); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new DummyInteraction("bla", 1), elem1); + simulateEvent(new FinishSequenceInteraction("end", 1), elem1); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence {" + + " Event start {}" + " Event bla {}" + - "}", 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); + " Event end {}" + + "}", getTaskTree(DefaultGuiEventSequenceDetectionRule.class, null)); + } + + /** + * + */ + @Test + public void test_03() { + IGUIElement elem1 = new DummyGUIElement("elem1"); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new DummyInteraction("bla", 1), elem1); + simulateEvent(new DummyInteraction("bli", 1), elem1); + simulateEvent(new DummyInteraction("blup", 1), elem1); + simulateEvent(new FinishSequenceInteraction("end", 1), elem1); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new DummyInteraction("bla", 1), elem1); + simulateEvent(new DummyInteraction("bli", 1), elem1); + simulateEvent(new FinishSequenceInteraction("end", 1), elem1); new TaskTreeChecker().assertTaskTree ("Sequence sequence0 {" + " Sequence sequence1 {" + - " Event bla {}" + + " Event start {}" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " Event end {}" + " }" + " Sequence sequence2 {" + + " Event start {}" + + " Event bla {}" + " 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); + " Event end {}" + + " }" + + "}", getTaskTree(DefaultGuiEventSequenceDetectionRule.class, null)); + } + + /** + * + */ + @Test + public void test_04() { + IGUIElement elem1 = new DummyGUIElement("elem1"); + simulateEvent(new StartAndFinishSequenceInteraction("startFinish", 1), elem1); + simulateEvent(new DummyInteraction("bla", 1), elem1); + simulateEvent(new DummyInteraction("bli", 1), elem1); + simulateEvent(new DummyInteraction("blup", 1), elem1); + simulateEvent(new StartAndFinishSequenceInteraction("startFinish", 1), elem1); + simulateEvent(new DummyInteraction("bla", 1), elem1); + simulateEvent(new DummyInteraction("bli", 1), elem1); + simulateEvent(new StartAndFinishSequenceInteraction("startFinish", 1), elem1); new TaskTreeChecker().assertTaskTree ("Sequence sequence0 {" + " Sequence sequence1 {" + + " Event startFinish {}" + " Event bla {}" + " Event bli {}" + - " Event bla {}" + + " Event blup {}" + " }" + " Sequence sequence2 {" + + " Event startFinish {}" + + " Event bla {}" + " 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()); - } - + " }" + + " Event startFinish {}" + + "}", getTaskTree(DefaultGuiEventSequenceDetectionRule.class, null)); + } + + /** + * + */ + @Test + public void test_05() { + IGUIElement elem1 = new DummyGUIElement("elem1"); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new DummyInteraction("bla", 1), elem1); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new DummyInteraction("bli", 1), elem1); + simulateEvent(new DummyInteraction("blup", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + simulateEvent(new DummyInteraction("bla", 1), elem1); + simulateEvent(new DummyInteraction("bli", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new DummyInteraction("blup", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event start {}" + + " Event bla {}" + + " Sequence sequence2 {" + + " Event start {}" + + " Sequence sequence3 {" + + " Event start {}" + + " Event bli {}" + + " Event blup {}" + + " Event finish {}" + + " }" + + " Event bla {}" + + " Event bli {}" + + " Event finish {}" + + " }" + + " Sequence sequence4 {" + + " Event start {}" + + " Sequence sequence5 {" + + " Event start {}" + + " Sequence sequence6 {" + + " Event start {}" + + " Event blup {}" + + " Event finish {}" + + " }" + + " Event finish {}" + + " }" + + " Event finish {}" + + " }" + + " Event finish {}" + + " }" + + " Event finish {}" + + "}", getTaskTree(DefaultGuiEventSequenceDetectionRule.class, null)); + } + + /** + * + */ + @Test + public void test_06() { + IGUIElement elem1 = new DummyGUIElement("elem1"); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new DummyInteraction("bla", 1), elem1); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new DummyInteraction("bli", 1), elem1); + simulateEvent(new DummyInteraction("blup", 1), elem1); + simulateEvent(new StartAndFinishSequenceInteraction("startFinish", 1), elem1); + simulateEvent(new DummyInteraction("bla", 1), elem1); + simulateEvent(new DummyInteraction("bli", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new StartSequenceInteraction("start", 1), elem1); + simulateEvent(new DummyInteraction("blup", 1), elem1); + simulateEvent(new StartAndFinishSequenceInteraction("startFinish", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + simulateEvent(new FinishSequenceInteraction("finish", 1), elem1); + + new TaskTreeChecker().assertTaskTree + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Event start {}" + + " Event bla {}" + + " Sequence sequence2 {" + + " Event start {}" + + " Sequence sequence3 {" + + " Event start {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " Sequence sequence4 {" + + " Event startFinish {}" + + " Event bla {}" + + " Event bli {}" + + " Event finish {}" + + " }" + + " Sequence sequence5 {" + + " Event start {}" + + " Sequence sequence6 {" + + " Event start {}" + + " Sequence sequence7 {" + + " Event start {}" + + " Event blup {}" + + " }" + + " Sequence sequence8 {" + + " Event startFinish {}" + + " Event finish {}" + + " }" + + " Event finish {}" + + " }" + + " Event finish {}" + + " }" + + " Event finish {}" + + " }" + + " Event finish {}" + + " }" + + " Event finish {}" + + "}", getTaskTree(DefaultGuiEventSequenceDetectionRule.class, null)); + } + + /** + * + */ + private class StartSequenceInteraction extends DummyInteraction { + + /** */ + private static final long serialVersionUID = 1L; + + /** + * + */ + public StartSequenceInteraction(String interactionType, int interactionNumber) { + super(interactionType, interactionNumber); + } + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.test.DummyInteraction#startsLogicalSequence() + */ + @Override + public boolean startsLogicalSequence() { + return true; + } + + } + + /** + * + */ + private class FinishSequenceInteraction extends DummyInteraction { + + /** */ + private static final long serialVersionUID = 1L; + + /** + * + */ + public FinishSequenceInteraction(String interactionType, int interactionNumber) { + super(interactionType, interactionNumber); + } + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.test.DummyInteraction#finishesLogicalSequence() + */ + @Override + public boolean finishesLogicalSequence() { + return true; + } + + } + + /** + * + */ + private class StartAndFinishSequenceInteraction extends DummyInteraction { + + /** */ + private static final long serialVersionUID = 1L; + + /** + * + */ + public StartAndFinishSequenceInteraction(String interactionType, int interactionNumber) { + super(interactionType, interactionNumber); + } + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.test.DummyInteraction#startsLogicalSequence() + */ + @Override + public boolean startsLogicalSequence() { + return true; + } + + /* (non-Javadoc) + * @see de.ugoe.cs.autoquest.test.DummyInteraction#finishesLogicalSequence() + */ + @Override + public boolean finishesLogicalSequence() { + return true; + } + + } } Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java (revision 987) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java (revision 1106) @@ -42,21 +42,21 @@ ("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()); + "}", getTaskTree(DefaultIterationDetectionRule.class, null)); + + simulateEvent(event1, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", getTaskTree(DefaultIterationDetectionRule.class, null)); + + simulateEvent(event1, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Event bla {}" + + " }" + + "}", getTaskTree(DefaultIterationDetectionRule.class, null)); for (int i = 0; i < 10; i++) { @@ -69,5 +69,5 @@ " Event bla {}" + " }" + - "}", getTaskTree()); + "}", getTaskTree(DefaultIterationDetectionRule.class, null)); // now test with preceding and trailing other events @@ -95,5 +95,5 @@ " Event blup {}" + " Event bli {}" + - "}", getTaskTree()); + "}", getTaskTree(DefaultIterationDetectionRule.class, null)); // now test with iterations of iterations @@ -136,5 +136,5 @@ " }" + " }" + - "}", getTaskTree()); + "}", getTaskTree(DefaultIterationDetectionRule.class, null)); } @@ -157,33 +157,33 @@ " 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()); + "}", getTaskTree(DefaultIterationDetectionRule.class, null)); + + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", getTaskTree(DefaultIterationDetectionRule.class, null)); + + simulateEvent(event1, element1); + simulateEvent(event2, element1); + simulateEvent(event3, element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Event bla {}" + + " Event bli {}" + + " Event blup {}" + + " }" + + " }" + + "}", getTaskTree(DefaultIterationDetectionRule.class, null)); for (int i = 0; i < 10; i++) { @@ -202,5 +202,5 @@ " }" + " }" + - "}", getTaskTree()); + "}", getTaskTree(DefaultIterationDetectionRule.class, null)); // now test with preceding and trailing other events @@ -242,5 +242,5 @@ " Event blo {}" + " Event ble {}" + - "}", getTaskTree()); + "}", getTaskTree(DefaultIterationDetectionRule.class, null)); // now test with iterations of iterations @@ -310,5 +310,5 @@ " }" + " }" + - "}", getTaskTree()); + "}", getTaskTree(DefaultIterationDetectionRule.class, null)); } Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java =================================================================== --- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java (revision 987) +++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java (revision 1106) @@ -46,52 +46,52 @@ " }" + " }" + - "}", getTaskTree()); - - simulateEvent(new ValueSelection(2), element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Selection selection1 {" + - " Event ValueSelection(\"1\") {}" + - " Event ValueSelection(\"2\") {}" + - " }" + - " }" + - "}", getTaskTree()); - - simulateEvent(new ValueSelection(3), element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Selection selection1 {" + - " Event ValueSelection(\"1\") {}" + - " Event ValueSelection(\"2\") {}" + - " Event ValueSelection(\"3\") {}" + - " }" + - " }" + - "}", getTaskTree()); - - simulateEvent(new ValueSelection(2), element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Selection selection1 {" + - " Event ValueSelection(\"1\") {}" + - " Event ValueSelection(\"2\") {}" + - " Event ValueSelection(\"3\") {}" + - " }" + - " }" + - "}", getTaskTree()); - - simulateEvent(new ValueSelection(3), element1); - new TaskTreeChecker().assertTaskTree - ("Sequence sequence1 {" + - " Iteration iteration1 {" + - " Selection selection1 {" + - " Event ValueSelection(\"1\") {}" + - " Event ValueSelection(\"2\") {}" + - " Event ValueSelection(\"3\") {}" + - " }" + - " }" + - "}", getTaskTree()); + "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); + + simulateEvent(new ValueSelection(2), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Selection selection1 {" + + " Event ValueSelection(\"1\") {}" + + " Event ValueSelection(\"2\") {}" + + " }" + + " }" + + "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); + + simulateEvent(new ValueSelection(3), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Selection selection1 {" + + " Event ValueSelection(\"1\") {}" + + " Event ValueSelection(\"2\") {}" + + " Event ValueSelection(\"3\") {}" + + " }" + + " }" + + "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); + + simulateEvent(new ValueSelection(2), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Selection selection1 {" + + " Event ValueSelection(\"1\") {}" + + " Event ValueSelection(\"2\") {}" + + " Event ValueSelection(\"3\") {}" + + " }" + + " }" + + "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); + + simulateEvent(new ValueSelection(3), element1); + new TaskTreeChecker().assertTaskTree + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Selection selection1 {" + + " Event ValueSelection(\"1\") {}" + + " Event ValueSelection(\"2\") {}" + + " Event ValueSelection(\"3\") {}" + + " }" + + " }" + + "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); } @@ -151,5 +151,5 @@ " }" + " }" + - "}", getTaskTree()); + "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); } @@ -176,25 +176,28 @@ ("Sequence sequence1 {" + " Iteration iteration1 {" + - " Sequence sequence2 {" + - " Sequence sequence3 {" + - " Iteration iteration2 {" + - " Selection selection1 {" + - " Event ValueSelection(\"1\") {}" + - " Event ValueSelection(\"3\") {}" + - " Event ValueSelection(\"2\") {}" + - " }" + - " }" + - " }" + - " Sequence sequence4 {" + - " Iteration iteration3 {" + - " Selection selection2 {" + - " Event ValueSelection(\"2\") {}" + - " Event ValueSelection(\"1\") {}" + - " }" + - " }" + - " }" + - " }" + - " }" + - "}", getTaskTree()); + " Selection selection1 {" + + " Event ValueSelection(\"1\") {}" + + " Event ValueSelection(\"2\") {}" + + " Event ValueSelection(\"3\") {}" + + " }" + + " }" + + " Iteration iteration2 {" + + " Selection selection2 {" + + " Event ValueSelection(\"2\") {}" + + " Event ValueSelection(\"1\") {}" + + " }" + + " }" + + " Iteration iteration3 {" + + " Selection selection3 {" + + " Event ValueSelection(\"3\") {}" + + " Event ValueSelection(\"2\") {}" + + " }" + + " }" + + " Iteration iteration4 {" + + " Selection selection4 {" + + " Event ValueSelection(\"1\") {}" + + " }" + + " }" + + "}", getTaskTree(TrackBarSelectionDetectionRule.class, null)); }