"
+ + ENDLINE, result);
+ }
+
+ public static void main(String[] args) {
+ new org.junit.runner.JUnitCore().run(FileEqualsReplayTest.class);
+ }
+}
Index: trunk/autoquest-core-assertions-test/src/test/java/de/ugoe/cs/autoquest/assertions/TextEqualsReplayTest.java
===================================================================
--- trunk/autoquest-core-assertions-test/src/test/java/de/ugoe/cs/autoquest/assertions/TextEqualsReplayTest.java (revision 922)
+++ trunk/autoquest-core-assertions-test/src/test/java/de/ugoe/cs/autoquest/assertions/TextEqualsReplayTest.java (revision 922)
@@ -0,0 +1,75 @@
+package de.ugoe.cs.autoquest.assertions;
+
+import org.junit.*;
+
+import de.ugoe.cs.autoquest.assertions.TextEqualsReplay;
+import static org.junit.Assert.*;
+
+/**
+ * The class TextEqualsReplayTest contains tests for the class
+ * {@link TextEqualsReplay}.
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class TextEqualsReplayTest {
+
+ private final static String ENDLINE = System.getProperty("line.separator");
+
+ @Test
+ public void testTextEqualsReplay_1() throws Exception {
+ String expectedValue = "expectedValueString";
+ String target = "targetString";
+
+ TextEqualsReplay result = new TextEqualsReplay(expectedValue, target);
+
+ assertNotNull(result);
+ assertEquals(expectedValue, result.expectedValue);
+ assertEquals(target, result.target);
+ }
+
+ @Test
+ public void testTextEqualsReplay_2() throws Exception {
+ String target = "targetString";
+
+ TextEqualsReplay result = new TextEqualsReplay(null, target);
+
+ assertNotNull(result);
+ assertEquals(null, result.expectedValue);
+ assertEquals(target, result.target);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testTextEqualsReplay_3() throws Exception {
+ String expectedValue = "expectedValueString";
+
+ new TextEqualsReplay(expectedValue, null);
+ }
+
+ @Test
+ public void testGetReplay_1() throws Exception {
+ TextEqualsReplay fixture = new TextEqualsReplay("", "");
+
+ String result = fixture.getReplay();
+
+ assertEquals(" " + ENDLINE + ""
+ + ENDLINE + ENDLINE + "" + ENDLINE + ""
+ + ENDLINE, result);
+ }
+
+ @Test
+ public void testGetReplay_2() throws Exception {
+ TextEqualsReplay fixture = new TextEqualsReplay("expectedValueString",
+ "targetString");
+
+ String result = fixture.getReplay();
+
+ assertEquals(" "
+ + ENDLINE + "" + ENDLINE + "targetString" + ENDLINE
+ + "" + ENDLINE + "" + ENDLINE, result);
+ }
+
+ public static void main(String[] args) {
+ new org.junit.runner.JUnitCore().run(TextEqualsReplayTest.class);
+ }
+}
Index: trunk/autoquest-core-assertions/src/main/java/de/ugoe/cs/autoquest/assertions/FileEqualsAssertEventType.java
===================================================================
--- trunk/autoquest-core-assertions/src/main/java/de/ugoe/cs/autoquest/assertions/FileEqualsAssertEventType.java (revision 922)
+++ trunk/autoquest-core-assertions/src/main/java/de/ugoe/cs/autoquest/assertions/FileEqualsAssertEventType.java (revision 922)
@@ -0,0 +1,33 @@
+
+package de.ugoe.cs.autoquest.assertions;
+
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+
+/**
+ *
+ * Event type for FileEquals assertions.
+ *
+ *
+ * @version 1.0
+ * @author Steffen Herbold
+ */
+public class FileEqualsAssertEventType implements IEventType {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.autoquest.eventcore.IEventType#getName()
+ */
+ @Override
+ public String getName() {
+ return "FileEqualsAssertion";
+ }
+
+}
Index: trunk/autoquest-core-assertions/src/main/java/de/ugoe/cs/autoquest/assertions/FileEqualsReplay.java
===================================================================
--- trunk/autoquest-core-assertions/src/main/java/de/ugoe/cs/autoquest/assertions/FileEqualsReplay.java (revision 922)
+++ trunk/autoquest-core-assertions/src/main/java/de/ugoe/cs/autoquest/assertions/FileEqualsReplay.java (revision 922)
@@ -0,0 +1,89 @@
+package de.ugoe.cs.autoquest.assertions;
+
+import de.ugoe.cs.autoquest.IReplayDecorator;
+import de.ugoe.cs.autoquest.eventcore.IReplayable;
+import de.ugoe.cs.util.StringTools;
+
+/**
+ *
+ * This class defines the replay for file equals assertions.
+ *
+ *
+ * @author Jeffrey Hall, Steffen Herbold
+ * @version 2.0
+ */
+public class FileEqualsReplay implements IReplayable {
+
+ /**
+ *
+ * The file that should be equal to expectedFile.
+ *
+ */
+ protected final String actualFile;
+
+ /**
+ *
+ * The file that is used as the reference.
+ *
+ */
+ protected final String expectedFile;
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Constructor. Creates a new FileEqualsReplay.
+ *
+ *
+ * @param expectedFile
+ * name and path of the expected file
+ * @param actualFile
+ * name and path of the actual file
+ * @throws IllegalArgumentException
+ * thrown if expectedFile or actualFile are null
+ */
+ public FileEqualsReplay(String expectedFile, String actualFile) {
+ if (expectedFile == null) {
+ throw new IllegalArgumentException("expected file must not be null");
+ }
+ if (actualFile == null) {
+ throw new IllegalArgumentException("actual file must not be null");
+ }
+ this.expectedFile = expectedFile;
+ this.actualFile = actualFile;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.autoquest.eventcore.IReplayable#getReplay()
+ */
+ public String getReplay() {
+
+ String actualFileTmp = StringTools.xmlEntityReplacement(actualFile);
+ String expectedFileTmp = StringTools.xmlEntityReplacement(expectedFile);
+
+ StringBuilder currentMsgStr = new StringBuilder(800);
+ currentMsgStr.append(" ");
+ currentMsgStr.append(StringTools.ENDLINE);
+ return currentMsgStr.toString();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.autoquest.eventcore.IReplayable#getDecorator()
+ */
+ @Override
+ public IReplayDecorator getDecorator() {
+ return null;
+ }
+
+}
Index: trunk/autoquest-core-assertions/src/main/java/de/ugoe/cs/autoquest/assertions/TextEqualsAssertEventType.java
===================================================================
--- trunk/autoquest-core-assertions/src/main/java/de/ugoe/cs/autoquest/assertions/TextEqualsAssertEventType.java (revision 922)
+++ trunk/autoquest-core-assertions/src/main/java/de/ugoe/cs/autoquest/assertions/TextEqualsAssertEventType.java (revision 922)
@@ -0,0 +1,31 @@
+
+package de.ugoe.cs.autoquest.assertions;
+
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+
+/**
+ * Event type for TextEquals assertions.
+ *
+ * @version 1.0
+ * @author Steffen Herbold
+ */
+public class TextEqualsAssertEventType implements IEventType {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.autoquest.eventcore.IEventType#getName()
+ */
+ @Override
+ public String getName() {
+ return "TextEqualsAssertion";
+ }
+
+}
Index: trunk/autoquest-core-assertions/src/main/java/de/ugoe/cs/autoquest/assertions/TextEqualsReplay.java
===================================================================
--- trunk/autoquest-core-assertions/src/main/java/de/ugoe/cs/autoquest/assertions/TextEqualsReplay.java (revision 922)
+++ trunk/autoquest-core-assertions/src/main/java/de/ugoe/cs/autoquest/assertions/TextEqualsReplay.java (revision 922)
@@ -0,0 +1,92 @@
+package de.ugoe.cs.autoquest.assertions;
+
+import de.ugoe.cs.autoquest.IReplayDecorator;
+import de.ugoe.cs.autoquest.eventcore.IReplayable;
+import de.ugoe.cs.util.StringTools;
+
+/**
+ *
+ * This class defines the replay for a textEquals assertion.
+ *
+ *
+ * @author Jeffrey Hall, Steffen Herbold
+ * @version 2.0
+ */
+public class TextEqualsReplay implements IReplayable {
+
+ /**
+ *
+ * Reference value which is compared to the targets text.
+ *
+ */
+ protected final String expectedValue;
+
+ /**
+ *
+ * Target to which the text is compared.
+ *
+ */
+ protected final String target;
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Constructor. Creates a new TextEqualsReplay.
+ *
+ * @param expectedValue
+ * expected string value
+ * @param target
+ * string description of the target whose string value is compared to the expected
+ * value
+ * @throws IllegalArgumentException
+ * thrown if target is null
+ */
+ public TextEqualsReplay(String expectedValue, String target) {
+ if (target == null) {
+ throw new IllegalArgumentException("target must not be null");
+ }
+ this.expectedValue = expectedValue;
+ this.target = target;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.autoquest.eventcore.IReplayable#getReplay()
+ */
+ @Override
+ public String getReplay() {
+
+ String expectedValueTmp = StringTools.xmlEntityReplacement(expectedValue);
+
+ StringBuilder currentMsgStr = new StringBuilder(400);
+ currentMsgStr.append(" ");
+ currentMsgStr.append(StringTools.ENDLINE);
+ currentMsgStr.append("");
+ currentMsgStr.append(StringTools.ENDLINE);
+ currentMsgStr.append(target);
+ currentMsgStr.append(StringTools.ENDLINE);
+ currentMsgStr.append("");
+ currentMsgStr.append(StringTools.ENDLINE);
+ currentMsgStr.append("");
+ currentMsgStr.append(StringTools.ENDLINE);
+ return currentMsgStr.toString();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.autoquest.eventcore.IReplayable#getDecorator()
+ */
+ @Override
+ public IReplayDecorator getDecorator() {
+ return null;
+ }
+
+}
Index: trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/autoquest/coverage/CoverageCalculatorObservedTest.java
===================================================================
--- trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/autoquest/coverage/CoverageCalculatorObservedTest.java (revision 922)
+++ trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/autoquest/coverage/CoverageCalculatorObservedTest.java (revision 922)
@@ -0,0 +1,315 @@
+package de.ugoe.cs.autoquest.coverage;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import de.ugoe.cs.autoquest.coverage.CoverageCalculatorObserved;
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.StringEventType;
+import de.ugoe.cs.autoquest.usageprofiles.MockTrieBasedModel;
+
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+import org.junit.*;
+
+import static org.junit.Assert.*;
+
+/**
+ * The class CoverageCalculatorObservedTest contains tests for the
+ * class {@link CoverageCalculatorObserved}.
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class CoverageCalculatorObservedTest {
+
+ Collection> sequencesObserved;
+
+ Set> sequencesCovered;
+ Set> sequencesCovered2;
+ Set> sequencesNewPossible;
+
+ MockTrieBasedModel mockProcess;
+
+ @Test
+ public void testCoverageCalculatorObserved_1() throws Exception {
+ int length = 2;
+
+ CoverageCalculatorObserved result = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered, length);
+ assertNotNull(result);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testCoverageCalculatorObserved_2() throws Exception {
+ int length = 2;
+
+ new CoverageCalculatorObserved(null,sequencesCovered, length);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testCoverageCalculatorObserved_3() throws Exception {
+ int length = 2;
+
+ new CoverageCalculatorObserved(sequencesObserved, null, length);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testCoverageCalculatorObserved_4() throws Exception {
+ int length = 0;
+
+ new CoverageCalculatorObserved(sequencesObserved, sequencesCovered, length);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testCoverageCalculatorObserved_5() throws Exception {
+ int length = -1;
+
+ new CoverageCalculatorObserved(sequencesObserved, sequencesCovered, length);
+ }
+
+ @Test
+ public void testCoverageObserved_1() throws Exception {
+ int length = 2;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered, length);
+
+ double result = fixture.getCoverageObserved();
+
+ assertEquals(3.0/6.0, result, 0.0001);
+ }
+
+ @Test
+ public void testCoverageObserved_2() throws Exception {
+ int length = 2;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered2, length);
+
+ double result = fixture.getCoverageObserved();
+
+ assertEquals(2.0/6.0, result, 0.0001);
+ }
+
+ @Test
+ public void testCoverageObservedWeigth_1() throws Exception {
+ int length = 2;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered, length);
+
+ double result = fixture.getCoverageObservedWeigth(mockProcess);
+
+ assertEquals(6.0, result, 0.0001);
+ }
+
+ @Test
+ public void testCoverageObservedWeigth_2() throws Exception {
+ int length = 2;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered2, length);
+
+ double result = fixture.getCoverageObservedWeigth(mockProcess);
+
+ assertEquals(4.0, result, 0.0001);
+ }
+
+ @Test
+ public void testGetNewPercentage_1() throws Exception {
+ int length = 2;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered, length);
+
+ double result = fixture.getNewPercentage();
+
+ assertEquals(1.0/4.0, result, 0.0001);
+ }
+
+ @Test
+ public void testGetNewPercentage_2() throws Exception {
+ int length = 2;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered2, length);
+
+ double result = fixture.getNewPercentage();
+
+ assertEquals(0.0, result, 0.0001);
+ }
+
+ @Test
+ public void testCoveragePossibleNew_1() throws Exception {
+ int length = 3;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesNewPossible, length);
+
+ double result = fixture.getCoveragePossibleNew(mockProcess);
+
+ assertEquals(1.0/11.0, result, 0.0001);
+ }
+
+ @Test
+ public void testCoveragePossibleNew_2() throws Exception {
+ int length = 2;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered, length);
+
+ double result = fixture.getCoveragePossibleNew(mockProcess);
+
+ assertEquals(0.0, result, 0.0001);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class )
+ public void testCoveragePossibleNew_3() throws Exception {
+ int length = 3;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered, length);
+
+ fixture.getCoveragePossibleNew(null);
+ }
+
+ @Test
+ public void testCoveragePossibleNewWeight_1() throws Exception {
+ int length = 3;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesNewPossible, length);
+
+ double result = fixture.getCoveragePossibleNewWeight(mockProcess);
+
+ assertEquals(2.0, result, 0.0001);
+ }
+
+ @Test
+ public void testCoveragePossibleNewWeight_2() throws Exception {
+ int length = 2;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered, length);
+
+ double result = fixture.getCoveragePossibleNewWeight(mockProcess);
+
+ assertEquals(0.0, result, 0.0001);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class )
+ public void testCoveragePossibleNewWeight_3() throws Exception {
+ int length = 3;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered, length);
+
+ fixture.getCoveragePossibleNewWeight(null);
+ }
+
+
+ @Test
+ public void testGetNumObserved_1() throws Exception {
+ int length = 2;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered, length);
+
+ int result = fixture.getNumObserved();
+
+ assertEquals(6, result);
+ }
+
+ @Test
+ public void testGetNumCovered_1() throws Exception {
+ int length = 2;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered, length);
+
+ int result = fixture.getNumCovered();
+
+ assertEquals(4, result);
+ }
+
+ @Test
+ public void testGetNumCovered_2() throws Exception {
+ int length = 2;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered2, length);
+
+ int result = fixture.getNumCovered();
+
+ assertEquals(2, result);
+ }
+
+ @Test
+ public void testGetNumNew_1() throws Exception {
+ int length = 2;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered, length);
+
+ int result = fixture.getNumNew();
+
+ assertEquals(1, result);
+ }
+
+ @Test
+ public void testGetNumNew_2() throws Exception {
+ int length = 2;
+ CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
+ sequencesObserved, sequencesCovered2, length);
+
+ int result = fixture.getNumNew();
+
+ assertEquals(0, result);
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ sequencesObserved = new LinkedList>();
+ List sequence1 = new ArrayList();
+ sequence1.add(new Event(new StringEventType("a")));
+ sequence1.add(new Event(new StringEventType("b")));
+ sequence1.add(new Event(new StringEventType("r")));
+ sequence1.add(new Event(new StringEventType("a")));
+ List sequence2 = new ArrayList();
+ sequence2.add(new Event(new StringEventType("c")));
+ sequence2.add(new Event(new StringEventType("a")));
+ sequence2.add(new Event(new StringEventType("d")));
+ sequence2.add(new Event(new StringEventType("a")));
+ sequence2.add(new Event(new StringEventType("b")));
+ sequence2.add(new Event(new StringEventType("r")));
+ sequence2.add(new Event(new StringEventType("a")));
+ sequencesObserved.add(sequence1);
+ sequencesObserved.add(sequence2);
+
+ sequencesCovered = new LinkedHashSet>();
+ List tmpList = new ArrayList();
+ tmpList.add(new Event(new StringEventType("a")));
+ tmpList.add(new Event(new StringEventType("b")));
+ tmpList.add(new Event(new StringEventType("r")));
+ sequencesCovered.add(tmpList);
+ tmpList = new ArrayList();
+ tmpList.add(new Event(new StringEventType("b")));
+ tmpList.add(new Event(new StringEventType("r")));
+ tmpList.add(new Event(new StringEventType("a")));
+ tmpList.add(new Event(new StringEventType("e")));
+ sequencesCovered.add(tmpList);
+
+ sequencesCovered2 = new LinkedHashSet>();
+ tmpList = new ArrayList();
+ tmpList.add(new Event(new StringEventType("a")));
+ tmpList.add(new Event(new StringEventType("b")));
+ tmpList.add(new Event(new StringEventType("r")));
+ sequencesCovered2.add(tmpList);
+
+ sequencesNewPossible = new LinkedHashSet>();
+ tmpList = new ArrayList();
+ tmpList.add(new Event(new StringEventType("r")));
+ tmpList.add(new Event(new StringEventType("a")));
+ tmpList.add(new Event(new StringEventType("b")));
+ sequencesNewPossible.add(tmpList);
+
+ int markovOrder = 2;
+ mockProcess = new MockTrieBasedModel(markovOrder, new Random());
+ mockProcess.train(sequencesObserved);
+ }
+
+ public static void main(String[] args) {
+ new org.junit.runner.JUnitCore()
+ .run(CoverageCalculatorObservedTest.class);
+ }
+
+}
Index: trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/autoquest/coverage/CoverageCalculatorProcessTest.java
===================================================================
--- trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/autoquest/coverage/CoverageCalculatorProcessTest.java (revision 922)
+++ trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/autoquest/coverage/CoverageCalculatorProcessTest.java (revision 922)
@@ -0,0 +1,238 @@
+package de.ugoe.cs.autoquest.coverage;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+import de.ugoe.cs.autoquest.coverage.CoverageCalculatorProcess;
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.StringEventType;
+import de.ugoe.cs.autoquest.usageprofiles.MockTrieBasedModel;
+
+import org.junit.*;
+
+import static org.junit.Assert.*;
+
+/**
+ * The class CoverageCalculatorProcessTest contains tests for the
+ * class {@link CoverageCalculatorProcess}.
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class CoverageCalculatorProcessTest {
+
+ Set> sequencesCovered;
+ Set> sequencesCovered2;
+ MockTrieBasedModel mockProcess;
+
+ @Test
+ public void testCoverageCalculatorProcess_1() throws Exception {
+ int length = 2;
+
+ CoverageCalculatorProcess result = new CoverageCalculatorProcess(
+ mockProcess, sequencesCovered, length);
+ assertNotNull(result);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testCoverageCalculatorProcess_2() throws Exception {
+ int length = 2;
+
+ new CoverageCalculatorProcess(null,sequencesCovered, length);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testCoverageCalculatorProcess_3() throws Exception {
+ int length = 2;
+
+ new CoverageCalculatorProcess(mockProcess, null, length);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testCoverageCalculatorProcess_4() throws Exception {
+ int length = 0;
+
+ new CoverageCalculatorProcess(mockProcess, sequencesCovered, length);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testCoverageCalculatorProcess_5() throws Exception {
+ int length = -1;
+
+ new CoverageCalculatorProcess(mockProcess, sequencesCovered, length);
+ }
+
+ @Test
+ public void testGetCoverageAllNoWeight_1() throws Exception {
+ int length = 2;
+ CoverageCalculatorProcess fixture = new CoverageCalculatorProcess(
+ mockProcess, sequencesCovered, length);
+
+ double result = fixture.getCoverageAllNoWeight();
+
+ assertEquals(3.0 / 49.0, result, 0.0001);
+ }
+
+ @Test
+ public void testGetCoverageAllNoWeight_2() throws Exception {
+ int length = 2;
+ CoverageCalculatorProcess fixture = new CoverageCalculatorProcess(
+ mockProcess, sequencesCovered2, length);
+
+ double result = fixture.getCoverageAllNoWeight();
+
+ assertEquals(2.0 / 49.0, result, 0.0001);
+ }
+
+ @Test
+ public void testGetCoveragePossibleNoWeight_1() throws Exception {
+ int length = 2;
+ CoverageCalculatorProcess fixture = new CoverageCalculatorProcess(
+ mockProcess, sequencesCovered, length);
+
+ double result = fixture.getCoveragePossibleNoWeight();
+
+ assertEquals(3.0 / 9.0, result, 0.0001);
+ }
+
+ @Test
+ public void testGetCoveragePossibleNoWeight_2() throws Exception {
+ int length = 2;
+ CoverageCalculatorProcess fixture = new CoverageCalculatorProcess(
+ mockProcess, sequencesCovered2, length);
+
+ double result = fixture.getCoveragePossibleNoWeight();
+
+ assertEquals(2.0 / 9.0, result, 0.0001);
+ }
+
+ @Test
+ public void testGetCoveragePossibleWeight_1() throws Exception {
+ int length = 2;
+ CoverageCalculatorProcess fixture = new CoverageCalculatorProcess(
+ mockProcess, sequencesCovered, length);
+
+ double result = fixture.getCoveragePossibleWeight();
+
+ assertEquals(6.0, result, 0.0001);
+ }
+
+ @Test
+ public void testGetCoveragePossibleWeight_2() throws Exception {
+ int length = 2;
+ CoverageCalculatorProcess fixture = new CoverageCalculatorProcess(
+ mockProcess, sequencesCovered2, length);
+
+ double result = fixture.getCoveragePossibleWeight();
+
+ assertEquals(4.0, result, 0.0001);
+ }
+
+ @Test
+ public void testGetNumCovered_1() throws Exception {
+ int length = 2;
+ CoverageCalculatorProcess fixture = new CoverageCalculatorProcess(
+ mockProcess, sequencesCovered, length);
+
+ int result = fixture.getNumCovered();
+
+ assertEquals(3, result);
+ }
+
+ @Test
+ public void testGetNumCovered_2() throws Exception {
+ int length = 2;
+ CoverageCalculatorProcess fixture = new CoverageCalculatorProcess(
+ mockProcess, sequencesCovered2, length);
+
+ int result = fixture.getNumCovered();
+
+ assertEquals(2, result);
+ }
+
+ @Test
+ public void testGetNumPossible_1() throws Exception {
+ int length = 2;
+ CoverageCalculatorProcess fixture = new CoverageCalculatorProcess(
+ mockProcess, sequencesCovered, length);
+
+ int result = fixture.getNumPossible();
+
+ assertEquals(9, result);
+ }
+
+ @Test
+ public void testSetSequences_1() throws Exception {
+ int length = 2;
+ CoverageCalculatorProcess fixture = new CoverageCalculatorProcess(
+ mockProcess, sequencesCovered, length);
+
+ fixture.setSequences(sequencesCovered2);
+
+ // testing indirectly if sequences were changed
+ assertEquals(2, fixture.getNumCovered());
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testSetSequences_2() throws Exception {
+ int length = 2;
+ CoverageCalculatorProcess fixture = new CoverageCalculatorProcess(
+ mockProcess, sequencesCovered, length);
+
+ fixture.setSequences(null);
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ Collection> sequences = new LinkedList>();
+ List sequence1 = new ArrayList();
+ sequence1.add(new Event(new StringEventType("a")));
+ sequence1.add(new Event(new StringEventType("b")));
+ sequence1.add(new Event(new StringEventType("r")));
+ sequence1.add(new Event(new StringEventType("a")));
+ List sequence2 = new ArrayList();
+ sequence2.add(new Event(new StringEventType("c")));
+ sequence2.add(new Event(new StringEventType("a")));
+ sequence2.add(new Event(new StringEventType("d")));
+ sequence2.add(new Event(new StringEventType("a")));
+ sequence2.add(new Event(new StringEventType("b")));
+ sequence2.add(new Event(new StringEventType("r")));
+ sequence2.add(new Event(new StringEventType("a")));
+ sequences.add(sequence1);
+ sequences.add(sequence2);
+
+ sequencesCovered = new LinkedHashSet>();
+ List tmpList = new ArrayList();
+ tmpList.add(new Event(new StringEventType("a")));
+ tmpList.add(new Event(new StringEventType("b")));
+ tmpList.add(new Event(new StringEventType("r")));
+ sequencesCovered.add(tmpList);
+ tmpList = new ArrayList();
+ tmpList.add(new Event(new StringEventType("b")));
+ tmpList.add(new Event(new StringEventType("r")));
+ tmpList.add(new Event(new StringEventType("a")));
+ sequencesCovered.add(tmpList);
+
+ sequencesCovered2 = new LinkedHashSet>();
+ tmpList = new ArrayList();
+ tmpList.add(new Event(new StringEventType("a")));
+ tmpList.add(new Event(new StringEventType("b")));
+ tmpList.add(new Event(new StringEventType("r")));
+ sequencesCovered2.add(tmpList);
+
+ int markovOrder = 2;
+ mockProcess = new MockTrieBasedModel(markovOrder, new Random());
+ mockProcess.train(sequences);
+ }
+
+ public static void main(String[] args) {
+ new org.junit.runner.JUnitCore()
+ .run(CoverageCalculatorProcessTest.class);
+ }
+}
Index: trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/autoquest/coverage/SequenceToolsTest.java
===================================================================
--- trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/autoquest/coverage/SequenceToolsTest.java (revision 922)
+++ trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/autoquest/coverage/SequenceToolsTest.java (revision 922)
@@ -0,0 +1,203 @@
+package de.ugoe.cs.autoquest.coverage;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Random;
+import java.util.Set;
+
+import de.ugoe.cs.autoquest.coverage.SequenceTools;
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.StringEventType;
+import de.ugoe.cs.autoquest.usageprofiles.FirstOrderMarkovModel;
+import de.ugoe.cs.autoquest.usageprofiles.IStochasticProcess;
+import de.ugoe.cs.autoquest.usageprofiles.MockTrieBasedModel;
+
+import org.junit.*;
+
+import static org.junit.Assert.*;
+
+/**
+ * The class SequenceToolsTest contains tests for the class {@link SequenceTools}.
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class SequenceToolsTest {
+
+ Collection> sequences;
+ Set> subSequences;
+ MockTrieBasedModel mockProcess;
+
+ @Test
+ public void testContainedSubSequences_1()
+ throws Exception {
+ int length = 2;
+
+ Set> result = SequenceTools.containedSubSequences(sequences, length);
+
+ assertNotNull(result);
+ assertTrue(result.containsAll(subSequences));
+ assertEquals(subSequences.size(), result.size());
+ }
+
+ @Test
+ public void testContainedSubSequences_2()
+ throws Exception {
+ int length = 2;
+
+ Set> result = SequenceTools.containedSubSequences(null, length);
+ assertNotNull(result);
+ assertTrue(result.isEmpty());
+ }
+
+ @Test(expected=java.lang.IllegalArgumentException.class)
+ public void testContainedSubSequences_3()
+ throws Exception {
+ int length = 0;
+
+ SequenceTools.containedSubSequences(sequences, length);
+ }
+
+ @Test(expected=java.lang.IllegalArgumentException.class)
+ public void testContainedSubSequences_4()
+ throws Exception {
+ int length = -1;
+
+ SequenceTools.containedSubSequences(sequences, length);
+ }
+
+ @Test
+ public void testGenerateWeights_1()
+ throws Exception {
+ Map, Double> result = SequenceTools.generateWeights(mockProcess, subSequences);
+
+ assertNotNull(result);
+ Set, Double>> entrySet = result.entrySet();
+ assertEquals(subSequences.size(),entrySet.size());
+ for( Entry, Double> entry : entrySet ) {
+ assertEquals(Double.valueOf(2.0d), entry.getValue());
+ assertTrue(subSequences.contains(entry.getKey()));
+ }
+ }
+
+ @Test
+ public void testGenerateWeights_2()
+ throws Exception {
+ Map, Double> result = SequenceTools.generateWeights(null, subSequences);
+
+ Set, Double>> entrySet = result.entrySet();
+ assertEquals(subSequences.size(),entrySet.size());
+ for( Entry, Double> entry : entrySet ) {
+ assertEquals(Double.valueOf(0.0d), entry.getValue());
+ assertTrue(subSequences.contains(entry.getKey()));
+ }
+ }
+
+ @Test
+ public void testGenerateWeights_3()
+ throws Exception {
+ Map, Double> result = SequenceTools.generateWeights(mockProcess, null);
+
+ assertNotNull(result);
+ assertTrue(result.isEmpty());
+ }
+
+ @Test
+ public void testNumSequences_1()
+ throws Exception {
+ int length = 2;
+ int expected = 49;
+
+ long result = SequenceTools.numSequences(mockProcess, length);
+
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void testNumSequences_2()
+ throws Exception {
+ int length = 2;
+ int expected = 49;
+
+ long result = SequenceTools.numSequences(mockProcess, length);
+
+ assertEquals(expected, result);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class )
+ public void testNumSequences_3()
+ throws Exception {
+ int length = 0;
+
+ SequenceTools.numSequences(mockProcess, length);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class )
+ public void testNumSequences_4()
+ throws Exception {
+ IStochasticProcess process = new FirstOrderMarkovModel(new Random());
+ int length = -1;
+
+ SequenceTools.numSequences(process, length);
+ }
+
+ @Before
+ public void setUp()
+ throws Exception {
+ sequences = new LinkedList>();
+ List sequence1 = new ArrayList();
+ sequence1.add(new Event(new StringEventType("a")));
+ sequence1.add(new Event(new StringEventType("b")));
+ sequence1.add(new Event(new StringEventType("r")));
+ sequence1.add(new Event(new StringEventType("a")));
+ List sequence2 = new ArrayList();
+ sequence2.add(new Event(new StringEventType("c")));
+ sequence2.add(new Event(new StringEventType("a")));
+ sequence2.add(new Event(new StringEventType("d")));
+ sequence2.add(new Event(new StringEventType("a")));
+ sequence2.add(new Event(new StringEventType("b")));
+ sequence2.add(new Event(new StringEventType("r")));
+ sequence2.add(new Event(new StringEventType("a")));
+ sequences.add(sequence1);
+ sequences.add(sequence2);
+
+ subSequences = new LinkedHashSet>();
+ List tmpList = new ArrayList();
+ tmpList.add(new Event(new StringEventType("a")));
+ tmpList.add(new Event(new StringEventType("b")));
+ subSequences.add(tmpList);
+ tmpList = new ArrayList();
+ tmpList.add(new Event(new StringEventType("b")));
+ tmpList.add(new Event(new StringEventType("r")));
+ subSequences.add(tmpList);
+ tmpList = new ArrayList();
+ tmpList.add(new Event(new StringEventType("r")));
+ tmpList.add(new Event(new StringEventType("a")));
+ subSequences.add(tmpList);
+ tmpList = new ArrayList();
+ tmpList.add(new Event(new StringEventType("c")));
+ tmpList.add(new Event(new StringEventType("a")));
+ subSequences.add(tmpList);
+ tmpList = new ArrayList();
+ tmpList.add(new Event(new StringEventType("a")));
+ tmpList.add(new Event(new StringEventType("d")));
+ subSequences.add(tmpList);
+ tmpList = new ArrayList();
+ tmpList.add(new Event(new StringEventType("d")));
+ tmpList.add(new Event(new StringEventType("a")));
+ subSequences.add(tmpList);
+
+ int markovOrder = 2;
+ mockProcess = new MockTrieBasedModel(markovOrder, new Random());
+ mockProcess.train(sequences);
+ }
+
+ public static void main(String[] args) {
+ new org.junit.runner.JUnitCore().run(SequenceToolsTest.class);
+ }
+}
Index: trunk/autoquest-core-coverage/src/main/java/de/ugoe/cs/autoquest/coverage/CoverageCalculatorObserved.java
===================================================================
--- trunk/autoquest-core-coverage/src/main/java/de/ugoe/cs/autoquest/coverage/CoverageCalculatorObserved.java (revision 922)
+++ trunk/autoquest-core-coverage/src/main/java/de/ugoe/cs/autoquest/coverage/CoverageCalculatorObserved.java (revision 922)
@@ -0,0 +1,258 @@
+package de.ugoe.cs.autoquest.coverage;
+
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.usageprofiles.IStochasticProcess;
+
+/**
+ *
+ * This class calculates various types of sequence coverage in relation to a collection of observed
+ * sequences.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class CoverageCalculatorObserved {
+
+ /**
+ *
+ * Sequences for which the coverage is calculated.
+ *
+ */
+ private final Collection> sequences;
+
+ /**
+ *
+ * Observed sequences that are baseline for the coverage calculation.
+ *
+ */
+ private final Collection> observedSequences;
+
+ /**
+ *
+ * Length of the subsequences in relation to which the covarage is calculated.
+ *
+ */
+ private final int length;
+
+ /**
+ *
+ * All subsequences of {@link #length} of {@link #sequences}.
+ *
+ */
+ private Collection> subSeqsGenerated = null;
+
+ /**
+ *
+ * All subsequences of {@link #length} of {@link #observedSequences}.
+ *
+ */
+ private Collection> subSeqsObserved = null;
+
+ /**
+ *
+ * Constructor. Creates a new CoverageCalculatorObserved for given collections of observed
+ * sequences and generated sequences.
+ *
+ *
+ * @param observedSequences
+ * observed sequences in relation to which the coverage is calculated; must not be
+ * null
+ * @param sequences
+ * sequences for which the coverage is calculated; must not be null
+ * @param length
+ * length of the subsequences for which the coverage is analyzed; must be >0
+ * @throws IllegalArgumentException
+ * thrown if observedSequences or sequences is null or length less than or equal to
+ * 0
+ */
+ public CoverageCalculatorObserved(Collection> observedSequences,
+ Collection> sequences,
+ int length)
+ {
+ if (observedSequences == null) {
+ throw new IllegalArgumentException("observed sequences must not be null");
+ }
+ if (sequences == null) {
+ throw new IllegalArgumentException("sequences must not be null");
+ }
+ if (length <= 0) {
+ throw new IllegalArgumentException("length must be >0; actual value: " + length);
+ }
+ this.observedSequences = observedSequences;
+ this.sequences = sequences;
+ this.length = length;
+ }
+
+ /**
+ *
+ * Calculates the percentage of subsequences of length k that occur, with reference to those
+ * that were observed.
+ *
+ *
+ * @return coverage percentage
+ */
+ public double getCoverageObserved() {
+ createSubSeqs();
+ Collection> subSeqsObservedCopy =
+ new LinkedHashSet>(subSeqsObserved);
+ subSeqsObservedCopy.retainAll(subSeqsGenerated);
+ return ((double) subSeqsObservedCopy.size()) / subSeqsObserved.size();
+ }
+
+ /**
+ *
+ * Calculates the weight of subsequences of length k that occur, with reference to those that
+ * were observed.
+ *
+ *
+ * @param process
+ * stochastic process in reference to which the weight is calculated
+ * @return coverage percentage
+ */
+
+ public double getCoverageObservedWeigth(IStochasticProcess process) {
+ createSubSeqs();
+ Map, Double> weightMap =
+ SequenceTools.generateWeights(process, subSeqsObserved);
+
+ Collection> subSeqsObservedCopy =
+ new LinkedHashSet>(subSeqsObserved);
+ subSeqsObservedCopy.retainAll(subSeqsGenerated);
+ double weight = 0.0d;
+ for (List subSeq : subSeqsObservedCopy) {
+ weight += weightMap.get(subSeq);
+ }
+ return weight;
+ }
+
+ /**
+ *
+ * Calculates the percentage of generated subsequences of length k that occur and have not been
+ * observed, with reference to all generated subsequences.
+ *
+ *
+ * @return coverage percentage
+ */
+ public double getNewPercentage() {
+ createSubSeqs();
+ Collection> subSeqsGeneratedCopy =
+ new LinkedHashSet>(subSeqsGenerated);
+ subSeqsGeneratedCopy.removeAll(subSeqsObserved);
+ return ((double) subSeqsGeneratedCopy.size()) / subSeqsGenerated.size();
+ }
+
+ /**
+ *
+ * Calculates the percentage of generated subsequences of length k that occur and have not been
+ * observed, with references to all possible new subsequences.
+ *
+ *
+ * @param process
+ * stochastic process which is used to determine which subsequences are possible
+ * @return coverage percentage
+ * @throws IllegalArgumentException
+ * thrown if process is null
+ */
+ public double getCoveragePossibleNew(IStochasticProcess process) {
+ if (process == null) {
+ throw new IllegalArgumentException("process must not be null");
+ }
+ createSubSeqs();
+ Collection> subSeqsGeneratedCopy =
+ new LinkedHashSet>(subSeqsGenerated);
+ Collection> subSeqsPossible = process.generateSequences(length);
+ subSeqsGeneratedCopy.removeAll(subSeqsObserved);
+ subSeqsPossible.removeAll(subSeqsObserved);
+ int possibleSize = subSeqsPossible.size();
+ subSeqsPossible.retainAll(subSeqsGeneratedCopy);
+ return ((double) subSeqsPossible.size()) / possibleSize;
+ }
+
+ /**
+ *
+ * Calculates the weight of generated subsequences of length k that occur and have not been
+ * observed, with references to all possible new subsequences.
+ *
+ *
+ * @param process
+ * stochastic process which is used to determine the weights and which subsequences
+ * are possible
+ * @return coverage percentage
+ * @throws IllegalArgumentException
+ * thrown if process is null
+ */
+ public double getCoveragePossibleNewWeight(IStochasticProcess process) {
+ if (process == null) {
+ throw new IllegalArgumentException("process must not be null");
+ }
+ createSubSeqs();
+ Collection> subSeqsGeneratedCopy =
+ new LinkedHashSet>(subSeqsGenerated);
+ Collection> subSeqsPossible = process.generateSequences(length);
+ subSeqsGeneratedCopy.removeAll(subSeqsObserved);
+ subSeqsPossible.removeAll(subSeqsObserved);
+ Map, Double> weightMap =
+ SequenceTools.generateWeights(process, subSeqsPossible);
+ double weight = 0.0d;
+ for (List subSeq : subSeqsGeneratedCopy) {
+ Double currentWeight = weightMap.get(subSeq);
+ if (currentWeight != null) {
+ weight += currentWeight;
+ }
+ }
+ return weight;
+ }
+
+ /**
+ *
+ * Returns the number of covered subsequences of length k.
+ *
+ *
+ * @return number of covered subsequences
+ */
+ public int getNumObserved() {
+ createSubSeqs();
+ return subSeqsObserved.size();
+ }
+
+ /**
+ *
+ * Returns the number of covered subsequences of length k.
+ *
+ *
+ * @return number of covered subsequences
+ */
+ public int getNumCovered() {
+ createSubSeqs();
+ return subSeqsGenerated.size();
+ }
+
+ public int getNumNew() {
+ createSubSeqs();
+ Collection> subSeqsGeneratedCopy =
+ new LinkedHashSet>(subSeqsGenerated);
+ subSeqsGeneratedCopy.removeAll(subSeqsObserved);
+ return subSeqsGeneratedCopy.size();
+ }
+
+ /**
+ *
+ * Helper function that calcuates the subsequences of length k that have been observed and
+ * generated.
+ *
+ */
+ private void createSubSeqs() {
+ if (subSeqsObserved == null) {
+ subSeqsObserved = SequenceTools.containedSubSequences(observedSequences, length);
+ }
+ if (subSeqsGenerated == null) {
+ subSeqsGenerated = SequenceTools.containedSubSequences(sequences, length);
+ }
+ }
+}
Index: trunk/autoquest-core-coverage/src/main/java/de/ugoe/cs/autoquest/coverage/CoverageCalculatorProcess.java
===================================================================
--- trunk/autoquest-core-coverage/src/main/java/de/ugoe/cs/autoquest/coverage/CoverageCalculatorProcess.java (revision 922)
+++ trunk/autoquest-core-coverage/src/main/java/de/ugoe/cs/autoquest/coverage/CoverageCalculatorProcess.java (revision 922)
@@ -0,0 +1,203 @@
+package de.ugoe.cs.autoquest.coverage;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.usageprofiles.IStochasticProcess;
+
+/**
+ *
+ * This class calculates various types of sequence coverage in relation to a stochastic process.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class CoverageCalculatorProcess {
+
+ /**
+ *
+ * Stochastic process that is the foundation for probabilistic coverages and coverages with
+ * reference to all possible sequences.
+ *
+ */
+ private final IStochasticProcess process;
+
+ /**
+ *
+ * Sequences for which the coverage is calculated.
+ *
+ */
+ private Collection> sequences;
+
+ /**
+ *
+ * Length of the subsequences in relation to which the coverage is calculated.
+ *
+ */
+ private final int length;
+
+ /**
+ *
+ * All subsequences of {@link #length} of {@link #sequences}.
+ *
+ */
+ private Collection> containedSubSeqs = null;
+
+ /**
+ *
+ * All subsequences of {@link #length} that can be generated by {@link #process}.
+ *
+ */
+ private Collection> allPossibleSubSeqs = null;
+
+ /**
+ *
+ * The probabilities of all subsequences of {@link #length} according to {@link #process}.
+ *
+ */
+ private Map, Double> subSeqWeights = null;
+
+ /**
+ *
+ * Constructor. Creates a new CoverageCalculatorProcess for a given stochastic process and
+ * generated sequences.
+ *
+ *
+ * @param process
+ * stochastic process used for coverage calculations; must not be null
+ * @param sequences
+ * sequences for which the coverage is calculated; must not be null
+ * @param length
+ * length of the subsequences for which the coverage is analyzed; must be >0
+ * @throws IllegalArgumentException
+ * thrown if process or sequences is null or length less than or equal to 0
+ */
+ public CoverageCalculatorProcess(IStochasticProcess process,
+ Collection> sequences,
+ int length)
+ {
+ if (process == null) {
+ throw new IllegalArgumentException("process must not be null");
+ }
+ if (sequences == null) {
+ throw new IllegalArgumentException("sequences must not be null");
+ }
+ if (length <= 0) {
+ throw new IllegalArgumentException("length must be >0; actual value: " + length);
+ }
+ this.process = process;
+ this.sequences = sequences;
+ this.length = length;
+ }
+
+ /**
+ *
+ * Calculates the percentage of subsequences of length k that occur, including those that cannot
+ * be generated by {@link #process}.
+ *
+ *
+ * @return coverage percentage
+ */
+ public double getCoverageAllNoWeight() {
+ if (containedSubSeqs == null) {
+ containedSubSeqs = SequenceTools.containedSubSequences(sequences, length);
+ }
+ return ((double) containedSubSeqs.size()) / SequenceTools.numSequences(process, length);
+ }
+
+ /**
+ *
+ * Calculates the percentage of subsequences of length k that occur and can generated by
+ * {@link #process}.
+ *
+ *
+ * @return coverage percentage
+ */
+ public double getCoveragePossibleNoWeight() {
+ if (containedSubSeqs == null) {
+ containedSubSeqs = SequenceTools.containedSubSequences(sequences, length);
+ }
+ if (allPossibleSubSeqs == null) {
+ allPossibleSubSeqs = process.generateSequences(length);
+ }
+ return ((double) containedSubSeqs.size()) / allPossibleSubSeqs.size();
+ }
+
+ /**
+ *
+ * Calculates the weight of the subsequences that occur with relation to {@link #process}, i.e.,
+ * the mass of the subsequence probability covered by the subsequences.
+ *
+ *
+ * @return coverage weight
+ */
+ public double getCoveragePossibleWeight() {
+ if (containedSubSeqs == null) {
+ containedSubSeqs = SequenceTools.containedSubSequences(sequences, length);
+ }
+ if (allPossibleSubSeqs == null) {
+ allPossibleSubSeqs = process.generateSequences(length);
+ }
+ if (subSeqWeights == null) {
+ subSeqWeights = SequenceTools.generateWeights(process, allPossibleSubSeqs);
+ }
+ double weight = 0.0;
+ for (List subSeq : containedSubSeqs) {
+ Double curWeight = subSeqWeights.get(subSeq);
+ if (curWeight != null) {
+ weight += curWeight;
+ }
+ }
+ return weight;
+ }
+
+ /**
+ *
+ * Returns the number of covered subsequences of length k.
+ *
+ *
+ * @return number of covered subsequences
+ */
+ public int getNumCovered() {
+ if (containedSubSeqs == null) {
+ containedSubSeqs = SequenceTools.containedSubSequences(sequences, length);
+ }
+ return containedSubSeqs.size();
+ }
+
+ /**
+ *
+ * Returns the number of possible subsequences of length k according to the stochastic process.
+ *
+ *
+ * @return number of possible subsequences
+ */
+ public int getNumPossible() {
+ if (allPossibleSubSeqs == null) {
+ allPossibleSubSeqs = process.generateSequences(length);
+ }
+ return allPossibleSubSeqs.size();
+ }
+
+ /**
+ *
+ * Sets a new collection of sequences for which the coverage is analyzed.
+ *
+ *
+ * @param newSequences
+ * new collection of sequences
+ * @throws IllegalArgumentException
+ * thrown is newSequences is null
+ */
+ public void setSequences(Collection> newSequences) {
+ if (newSequences == null) {
+ throw new IllegalArgumentException("sequences must not be null");
+ }
+ this.sequences = newSequences;
+ containedSubSeqs = null;
+ }
+
+}
Index: trunk/autoquest-core-coverage/src/main/java/de/ugoe/cs/autoquest/coverage/SequenceTools.java
===================================================================
--- trunk/autoquest-core-coverage/src/main/java/de/ugoe/cs/autoquest/coverage/SequenceTools.java (revision 922)
+++ trunk/autoquest-core-coverage/src/main/java/de/ugoe/cs/autoquest/coverage/SequenceTools.java (revision 922)
@@ -0,0 +1,143 @@
+package de.ugoe.cs.autoquest.coverage;
+
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.usageprofiles.IStochasticProcess;
+
+/**
+ *
+ * This class gathers some helper functions to work with sequences.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class SequenceTools {
+
+ /**
+ *
+ * Private constructor to prevent initializing of the class.
+ *
+ */
+ private SequenceTools() {
+
+ }
+
+ /**
+ *
+ * Calculates the weights for all sequences passed to this function as defined by the stochastic
+ * process and stores them in a {@link Map}. The weights are normalized, i.e., the sum of all
+ * weights contained in this map is 1.
+ *
+ *
+ * @param process
+ * process used for weight calculation
+ * @param sequences
+ * sequences for which the weights are calculated
+ * @return {@link Map} of weights
+ */
+ public static Map, Double> generateWeights(IStochasticProcess process,
+ Collection> sequences)
+ {
+ Map, Double> subSeqWeights = new LinkedHashMap, Double>();
+ if (sequences != null && !sequences.isEmpty()) {
+ if (process != null) {
+ double sum = 0.0;
+ for (List sequence : sequences) {
+ double prob = process.getProbability(sequence);
+ subSeqWeights.put(sequence, prob);
+ sum += prob;
+ }
+ if (sum < 1.0) {
+ for (Map.Entry, Double> entry : subSeqWeights.entrySet()) {
+ entry.setValue(entry.getValue() / sum);
+ }
+ }
+ }
+ else {
+ for (List sequence : sequences) {
+ subSeqWeights.put(sequence, 0.0d);
+ }
+ }
+ }
+ return subSeqWeights;
+ }
+
+ /**
+ *
+ * Calculates the number of all existing sequences of a given length, regardless whether they
+ * are possible or not.
+ *
+ *
+ * @param process
+ * stochastic process whose symbols are the basis for this calculation
+ * @param length
+ * lenght of the sequences
+ * @return numStates^length
+ * @throws IllegalArgumentException
+ * thrown if length less or equal to 0
+ */
+ public static long numSequences(IStochasticProcess process, int length) {
+ if (length <= 0) {
+ throw new IllegalArgumentException("length must be a positive integer");
+ }
+ long result = 0;
+ if (process != null) {
+ result = (long) Math.pow(process.getNumSymbols(), length);
+ }
+ return result;
+ }
+
+ /**
+ *
+ * Creates a {@link Set} of all subsequences of a given length that are contained in a sequence
+ * collection.
+ *
+ *
+ * @param sequences
+ * sequences from which the subsequences are extracted
+ * @param length
+ * length of the subsequences
+ * @return {@link Set} of all subsequences
+ * @throws IllegalArgumentException
+ * thrown if length less or equal to 0
+ */
+ public static Set> containedSubSequences(Collection> sequences,
+ int length)
+ {
+ if (length <= 0) {
+ throw new IllegalArgumentException("length must be a positive integer");
+ }
+ Set> containedSubSeqs = new LinkedHashSet>();
+ if (sequences != null) {
+ for (List sequence : sequences) {
+ List subSeq = new LinkedList();
+ boolean minLengthReached = false;
+ for (Event event : sequence) {
+ subSeq.add(event);
+ if (!minLengthReached) {
+ if (subSeq.size() == length) {
+ minLengthReached = true;
+ }
+ }
+ else {
+ subSeq.remove(0);
+ }
+ if (minLengthReached) {
+ if (!containedSubSeqs.contains(subSeq)) {
+ containedSubSeqs.add(new LinkedList(subSeq));
+ }
+ }
+ }
+ }
+ }
+ return containedSubSeqs;
+ }
+}
Index: trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/SequenceInstanceOfTest.java
===================================================================
--- trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/SequenceInstanceOfTest.java (revision 922)
+++ trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/SequenceInstanceOfTest.java (revision 922)
@@ -0,0 +1,102 @@
+package de.ugoe.cs.autoquest;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.*;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import de.ugoe.cs.autoquest.SequenceInstanceOf;
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+
+
+/**
+ * The class SequenceInstanceOfTest contains tests for the
+ * class {@link SequenceInstanceOf}.
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class SequenceInstanceOfTest {
+
+ @Test
+ public void TestIsCollectionOfSequences_1() throws Exception {
+ Collection> sequences = new LinkedList>();
+ List sequence1 = new ArrayList();
+ sequence1.add(new Event(mock(IEventType.class)));
+ sequences.add(sequence1);
+
+ boolean result = SequenceInstanceOf.isCollectionOfSequences(sequences);
+ assertTrue(result);
+ }
+
+ @Test
+ public void TestIsCollectionOfSequences_2() throws Exception {
+ Collection> sequences = new LinkedList>();
+ List sequence1 = new ArrayList();
+ sequences.add(sequence1);
+
+ boolean result = SequenceInstanceOf.isCollectionOfSequences(sequences);
+ assertFalse(result);
+ }
+
+ @Test
+ public void TestIsCollectionOfSequences_3() throws Exception {
+ Collection> sequences = new LinkedList>();
+
+ boolean result = SequenceInstanceOf.isCollectionOfSequences(sequences);
+ assertFalse(result);
+ }
+
+ @Test
+ public void TestIsCollectionOfSequences_4() throws Exception {
+ boolean result = SequenceInstanceOf.isCollectionOfSequences(null);
+ assertFalse(result);
+ }
+
+ @Test
+ public void TestIsCollectionOfSequences_5() throws Exception {
+ boolean result = SequenceInstanceOf.isCollectionOfSequences(new Object());
+ assertFalse(result);
+ }
+
+ @Test
+ public void TestIsEventSequence_1() throws Exception {
+ List sequence = new ArrayList();
+ sequence.add(new Event(mock(IEventType.class)));
+
+ boolean result = SequenceInstanceOf.isEventSequence(sequence);
+ assertTrue(result);
+ }
+
+ @Test
+ public void TestIsEventSequence_2() throws Exception {
+ List sequence = new ArrayList();
+
+ boolean result = SequenceInstanceOf.isEventSequence(sequence);
+ assertFalse(result);
+ }
+
+ @Test
+ public void TestIsEventSequence_3() throws Exception {
+ boolean result = SequenceInstanceOf.isEventSequence(null);
+ assertFalse(result);
+ }
+
+ @Test
+ public void TestIsEventSequence_4() throws Exception {
+ boolean result = SequenceInstanceOf.isEventSequence(new Object());
+ assertFalse(result);
+ }
+
+
+
+ public static void main(String[] args) {
+ new org.junit.runner.JUnitCore().run(SequenceInstanceOfTest.class);
+ }
+}
Index: trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/EventTest.java
===================================================================
--- trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/EventTest.java (revision 922)
+++ trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/EventTest.java (revision 922)
@@ -0,0 +1,304 @@
+package de.ugoe.cs.autoquest.eventcore;
+
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.*;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+import de.ugoe.cs.autoquest.eventcore.IReplayable;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * The class EventTest contains tests for the class {@link Event}.
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class EventTest {
+
+ @Test
+ public void testEvent_1() throws Exception {
+ Event result = new Event(mock(IEventType.class));
+
+ assertNotNull(result);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testEvent_2() throws Exception {
+ new Event(null);
+ }
+
+ /*
+ @Test
+ public void testEquals_1() throws Exception {
+ IEventType type1 = mock(IEventType.class);
+ IEventType type2 = mock(IEventType.class);
+ // when(type1.equals(type2)).thenReturn(true);
+ Event fixture = new Event(type1);
+ Event other = new Event(type2);
+
+ boolean result = fixture.equals(other);
+
+ assertTrue(result);
+ }
+
+ @Test
+ public void testEquals_2() throws Exception {
+ String type1 = "typeString1";
+ String type2 = "typeString2";
+ Event fixture = new Event(type1);
+ Event other = new Event(type2);
+
+ boolean result = fixture.equals(other);
+
+ assertFalse(result);
+ }
+
+ @Test
+ public void testEquals_3() throws Exception {
+ String type1 = "typeString";
+ String type2 = "typeString";
+ String target1 = "target";
+ String target2 = "target";
+ Event fixture = new Event(type1);
+ fixture.target = target1;
+ Event other = new Event(type2);
+ other.target = target2;
+
+ boolean result = fixture.equals(other);
+
+ assertTrue(result);
+ }
+
+ @Test
+ public void testEquals_4() throws Exception {
+ String type1 = "typeString1";
+ String type2 = "typeString2";
+ String target1 = "target";
+ String target2 = "target";
+ Event fixture = new Event(type1);
+ fixture.target = target1;
+ Event other = new Event(type2);
+ other.target = target2;
+
+ boolean result = fixture.equals(other);
+
+ assertFalse(result);
+ }
+
+ @Test
+ public void testEquals_5() throws Exception {
+ String type1 = "typeString";
+ String type2 = "typeString";
+ String target1 = "target1";
+ String target2 = "target2";
+ Event fixture = new Event(type1);
+ fixture.target = target1;
+ Event other = new Event(type2);
+ other.target = target2;
+
+ boolean result = fixture.equals(other);
+
+ assertFalse(result);
+ }
+
+ @Test
+ public void testEquals_6() throws Exception {
+ String type = "typeString";
+ Event fixture = new Event(type);
+
+ boolean result = fixture.equals(fixture);
+
+ assertTrue(result);
+ }
+
+ @Test
+ public void testEqualsContract() throws Exception {
+ EqualsVerifier.forClass(Event.class).suppress(Warning.NONFINAL_FIELDS)
+ .withRedefinedSubclass(ReplayableEvent.class).verify();
+ }
+ */
+
+ @Test
+ public void testGetTarget_1() throws Exception {
+ IEventType type = mock(IEventType.class);
+ IEventTarget target = mock(IEventTarget.class);
+
+ Event fixture = new Event(type);
+ fixture.setTarget(target);
+
+ IEventTarget result = fixture.getTarget();
+
+ assertSame(target, result);
+ }
+
+
+
+ @Test
+ public void testGetTarget_2() throws Exception {
+ IEventType type = mock(IEventType.class);
+ IEventTarget target = mock(IEventTarget.class);
+
+ Event fixture = new Event(type, target);
+
+ IEventTarget result = fixture.getTarget();
+
+ assertSame(target, result);
+ }
+
+ @Test
+ public void testGetTarget_3() throws Exception {
+ IEventType type = mock(IEventType.class);
+
+ Event fixture = new Event(type);
+
+ IEventTarget result = fixture.getTarget();
+
+ assertNull(result);
+ }
+
+ @Test
+ public void testGetType_1() throws Exception {
+ IEventType type = mock(IEventType.class);
+
+ Event fixture = new Event(type);
+
+ IEventType result = fixture.getType();
+
+ assertEquals(type, result);
+ }
+
+ @Test
+ public void testSetTarget_1() throws Exception {
+ IEventType type = mock(IEventType.class);
+ IEventTarget target = mock(IEventTarget.class);
+
+ Event fixture = new Event(type);
+
+ boolean result = fixture.setTarget(target);
+
+ assertTrue(result);
+ assertEquals(target, fixture.getTarget());
+ }
+
+ @Test
+ public void testSetTarget_2() throws Exception {
+ IEventType type = mock(IEventType.class);
+ IEventTarget target1 = mock(IEventTarget.class);
+ IEventTarget target2 = mock(IEventTarget.class);
+
+ Event fixture = new Event(type);
+
+ fixture.setTarget(target1);
+ boolean result = fixture.setTarget(target2);
+
+ assertFalse(result);
+ assertEquals(target1, fixture.target);
+ }
+
+ @Test
+ public void testSetTarget_3() throws Exception {
+ IEventType type = mock(IEventType.class);
+ IEventTarget target1 = mock(IEventTarget.class);
+ IEventTarget target2 = mock(IEventTarget.class);
+
+ Event fixture = new Event(type, target1);
+
+ boolean result = fixture.setTarget(target2);
+
+ assertFalse(result);
+ assertEquals(target1, fixture.target);
+ }
+
+ @Test
+ public void testGetId_1() throws Exception {
+ IEventType type = mock(IEventType.class);
+ when(type.toString()).thenReturn("typeString");
+ IEventTarget target = mock(IEventTarget.class);
+ when(target.getStringIdentifier()).thenReturn("targetString");
+
+ Event fixture = new Event(type, target);
+
+ String result = fixture.toString();
+
+ assertEquals("typeString.targetString", result);
+ }
+
+ @Test
+ public void testGetId_2() throws Exception {
+ IEventType type = mock(IEventType.class);
+ when(type.toString()).thenReturn("typeString");
+
+ Event fixture = new Event(type);
+
+ String result = fixture.toString();
+
+ assertEquals("typeString", result);
+ }
+
+ @Test
+ public void testAddReplayable_1() throws Exception {
+ IReplayable replayable = mock(IReplayable.class);
+
+ Event fixture = new Event(mock(IEventType.class));
+ fixture.addReplayable(replayable);
+
+ assertEquals(1, fixture.getReplayables().size());
+ assertEquals(replayable, fixture.getReplayables().get(0));
+ }
+
+ @Test
+ public void testAddReplayEvent_2() throws Exception {
+ IReplayable replayable1 = mock(IReplayable.class);
+ IReplayable replayable2 = mock(IReplayable.class);
+
+ Event fixture = new Event(mock(IEventType.class));
+ fixture.addReplayable(replayable1);
+ fixture.addReplayable(replayable2);
+
+ assertEquals(2, fixture.getReplayables().size());
+ assertEquals(replayable1, fixture.getReplayables().get(0));
+ assertEquals(replayable2, fixture.getReplayables().get(1));
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testAddReplayEvent_fixture_3() throws Exception {
+ Event fixture = new Event(mock(IEventType.class));
+ fixture.addReplayable(null);
+ }
+
+ @Test
+ public void testAddReplaySequence_1() throws Exception {
+ IReplayable replayable1 = mock(IReplayable.class);
+ IReplayable replayable2 = mock(IReplayable.class);
+
+ List replayableSequences = new LinkedList();
+ replayableSequences.add(replayable1);
+ replayableSequences.add(replayable2);
+
+ Event fixture = new Event(mock(IEventType.class));
+
+ fixture.addReplayableSequence(replayableSequences);
+
+ assertEquals(2, fixture.getReplayables().size());
+ assertEquals(replayable1, fixture.getReplayables().get(0));
+ assertEquals(replayable2, fixture.getReplayables().get(1));
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testAddReplaySequence_2() throws Exception {
+ Event fixture = new Event(mock(IEventType.class));
+
+ fixture.addReplayableSequence(null);
+ }
+
+ public static void main(String[] args) {
+ new org.junit.runner.JUnitCore().run(EventTest.class);
+ }
+}
Index: trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/gui/KeyInteractionCorrectorTest.java
===================================================================
--- trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/gui/KeyInteractionCorrectorTest.java (revision 922)
+++ trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/gui/KeyInteractionCorrectorTest.java (revision 922)
@@ -0,0 +1,440 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.logging.Level;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.mockito.Mockito.*;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.gui.KeyInteractionCorrector;
+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.MouseButtonUp;
+import de.ugoe.cs.autoquest.eventcore.gui.MouseClick;
+import de.ugoe.cs.autoquest.eventcore.gui.KeyInteractionCorrector.CleanupMode;
+import de.ugoe.cs.autoquest.eventcore.gui.MouseButtonInteraction.Button;
+import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
+import de.ugoe.cs.autoquest.keyboardmaps.VirtualKey;
+import de.ugoe.cs.util.console.Console;
+import de.ugoe.cs.util.console.TextConsole;
+
+/**
+ * @author Patrick Harms, Steffen Herbold
+ */
+public class KeyInteractionCorrectorTest {
+
+ @Test
+ public void testSortKeyInteractions_1() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector();
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // Normal pressing and releasing of A and B
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_B), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_B), guiElement));
+
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_B), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @Test
+ public void testSortKeyInteractions_2() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector();
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // A is pressed and not released before B is pressed
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_B), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_B), guiElement));
+
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_B), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @Test
+ public void testSortKeyInteractions_3() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector();
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // SHIFT is pressed and released after all keys are pressed
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_B), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_B), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+
+ expected.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_B), guiElement));
+ expected.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @Test
+ public void testSortKeyInteractions_4() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector();
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // SHIFT is released before the last key is released
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_B), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_B), guiElement));
+
+ expected.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_B), guiElement));
+ expected.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @Test
+ public void testSortKeyInteractions_5() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector();
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // SHIFT is released before all other keys are released
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_B), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_C), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_B), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_C), guiElement));
+
+ expected.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_B), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_C), guiElement));
+ expected.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @Test
+ public void testSortKeyInteractions_6() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector();
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // SHIFT, CTRL and ALT are pressed and released after all keys are pressed
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.CONTROL), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.ALT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_B), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_B), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.ALT), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.CONTROL), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+
+ expected.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ expected.add(new Event(new KeyPressed(VirtualKey.CONTROL), guiElement));
+ expected.add(new Event(new KeyPressed(VirtualKey.ALT), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_B), guiElement));
+ expected.add(new Event(new KeyReleased(VirtualKey.ALT), guiElement));
+ expected.add(new Event(new KeyReleased(VirtualKey.CONTROL), guiElement));
+ expected.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @Test
+ public void testSortKeyInteractions_7() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector();
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // now SHIFT, CTRL and ALT are released before the last key is released
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.CONTROL), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.ALT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_B), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.ALT), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.CONTROL), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_B), guiElement));
+
+ expected.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ expected.add(new Event(new KeyPressed(VirtualKey.CONTROL), guiElement));
+ expected.add(new Event(new KeyPressed(VirtualKey.ALT), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_B), guiElement));
+ expected.add(new Event(new KeyReleased(VirtualKey.ALT), guiElement));
+ expected.add(new Event(new KeyReleased(VirtualKey.CONTROL), guiElement));
+ expected.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @Test
+ public void testSortKeyInteractions_8() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector();
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // SHIFT, CTRL and ALT are released in another order and before some other keys are
+ // released
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.CONTROL), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.ALT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_B), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_C), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.ALT), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.CONTROL), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_B), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_C), guiElement));
+
+ expected.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ expected.add(new Event(new KeyPressed(VirtualKey.CONTROL), guiElement));
+ expected.add(new Event(new KeyPressed(VirtualKey.ALT), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_B), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_C), guiElement));
+ expected.add(new Event(new KeyReleased(VirtualKey.ALT), guiElement));
+ expected.add(new Event(new KeyReleased(VirtualKey.CONTROL), guiElement));
+ expected.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @Test
+ public void testSortKeyInteractions_9() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector();
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // holding of A
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @Test
+ public void testSortKeyInteractions_10() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector();
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // holding of shift and meanwhile pressing of A
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+
+ expected.add(new Event(new KeyPressed(VirtualKey.SHIFT), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyReleased(VirtualKey.SHIFT), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @Test
+ public void testSortKeyInteractions_11() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector();
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // Check if keyboard focus change is moved in front of a sequence in case it is in between a
+ // pressed
+ // released pair
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyboardFocusChange(), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+
+ expected.add(new Event(new KeyboardFocusChange(), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @Test
+ public void testSortKeyInteractions_12() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector();
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // Check if mouse events stay where they are
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new MouseButtonDown(Button.LEFT), guiElement));
+ input.add(new Event(new MouseButtonUp(Button.LEFT), guiElement));
+ input.add(new Event(new MouseClick(Button.LEFT), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new MouseButtonDown(Button.LEFT), guiElement));
+ expected.add(new Event(new MouseButtonUp(Button.LEFT), guiElement));
+ expected.add(new Event(new MouseClick(Button.LEFT), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @Test
+ public void testSortKeyInteractions_13() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector(CleanupMode.REMOVAL);
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // Check if mouse events stay where they are
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_B), guiElement));
+
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @Test
+ public void testSortKeyInteractions_14() {
+ List input = new LinkedList();
+ List expected = new LinkedList();
+
+ KeyInteractionCorrector sorter = new KeyInteractionCorrector(CleanupMode.ADDITION);
+
+ IGUIElement guiElement = mock(IGUIElement.class);
+
+ // Check if mouse events stay where they are
+ input.add(new Event(new KeyPressed(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_A), guiElement));
+ input.add(new Event(new KeyReleased(VirtualKey.LETTER_B), guiElement));
+
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_A), guiElement));
+ expected.add(new Event(new KeyTyped(VirtualKey.LETTER_B), guiElement));
+
+ List output = sorter.sortKeyInteractions(input);
+
+ assertEquals(expected, output);
+ }
+
+ @BeforeClass
+ public static void setUpBeforeClass() {
+ Console.reset();
+ Console.getInstance().registerTraceListener(new TextConsole(Level.INFO));
+ }
+}
Index: trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/gui/MouseClickCondenserTest.java
===================================================================
--- trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/gui/MouseClickCondenserTest.java (revision 922)
+++ trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/gui/MouseClickCondenserTest.java (revision 922)
@@ -0,0 +1,110 @@
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+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.MouseClickCondenser;
+import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
+import de.ugoe.cs.autoquest.test.DummyGUIElement;
+import de.ugoe.cs.autoquest.test.DummyInteraction;
+
+/**
+ * @author Patrick Harms
+ */
+public class MouseClickCondenserTest {
+
+ /** */
+ private List events = new ArrayList();
+
+ /**
+ *
+ */
+ @Test
+ public void testMouseClickInOneSequenceElement() {
+ MouseButtonInteraction.Button leftBtn = MouseButtonInteraction.Button.LEFT;
+ MouseButtonInteraction.Button middleBtn = MouseButtonInteraction.Button.MIDDLE;
+ MouseButtonInteraction.Button rightBtn = MouseButtonInteraction.Button.RIGHT;
+
+ IGUIElement element1 = new DummyGUIElement("elem1");
+ IGUIElement element2 = new DummyGUIElement("elem2");
+
+ simulateEvent(new MouseButtonDown(leftBtn), element1);
+ simulateEvent(new MouseButtonUp(leftBtn), element1);
+ simulateEvent(new MouseClick(leftBtn), element1);
+ assertCondensedMouseClicks("elem1");
+
+ simulateEvent(new DummyInteraction("bla", 1), element1);
+ simulateEvent(new DummyInteraction("bli", 1), element1);
+ simulateEvent(new MouseButtonDown(middleBtn), element1);
+ simulateEvent(new MouseButtonUp(middleBtn), element1);
+ simulateEvent(new MouseClick(middleBtn), element1);
+ simulateEvent(new DummyInteraction("blo", 1), element1);
+ simulateEvent(new DummyInteraction("blu", 1), element1);
+ assertCondensedMouseClicks("elem1", "", "", "elem1", "", "");
+
+ simulateEvent(new DummyInteraction("bla", 1), element2);
+ simulateEvent(new DummyInteraction("bli", 1), element2);
+ simulateEvent(new MouseButtonDown(rightBtn), element2);
+ simulateEvent(new MouseButtonUp(rightBtn), element2);
+ simulateEvent(new MouseClick(rightBtn), element2);
+ simulateEvent(new DummyInteraction("blo", 1), element2);
+ simulateEvent(new DummyInteraction("blu", 1), element2);
+ assertCondensedMouseClicks("elem1", "", "", "elem1", "", "", "", "", "elem2", "", "");
+
+ simulateEvent(new MouseButtonDown(leftBtn), element1);
+ simulateEvent(new MouseButtonUp(leftBtn), element1);
+ simulateEvent(new MouseClick(leftBtn), element2);
+ assertCondensedMouseClicks("elem1", "", "", "elem1", "", "", "", "", "elem2", "", "",
+ "", "", "elem2");
+
+ simulateEvent(new MouseButtonDown(middleBtn), element1);
+ simulateEvent(new MouseButtonUp(middleBtn), element1);
+ simulateEvent(new MouseClick(rightBtn), element1);
+ simulateEvent(new DummyInteraction("bla", 1), element2);
+ assertCondensedMouseClicks("elem1", "", "", "elem1", "", "", "", "", "elem2", "", "",
+ "", "", "elem2", "", "", "elem1", "");
+ }
+
+ /**
+ *
+ */
+ private void simulateEvent(IEventType eventType, IGUIElement guiElement) {
+ events.add(new Event(eventType, guiElement));
+ }
+
+ /**
+ *
+ */
+ private void assertCondensedMouseClicks(String... clickedTargets) {
+ MouseClickCondenser condenser = new MouseClickCondenser();
+ List result = condenser.condenseMouseClicks(events);
+
+ assertEquals(clickedTargets.length, result.size());
+
+ for (int i = 0; i < clickedTargets.length; i++) {
+ String clickedTarget = clickedTargets[i];
+
+ if ((clickedTarget != null) && (!"".equals(clickedTarget))) {
+ assertTrue(result.get(i).getType() instanceof MouseClick);
+ assertTrue(result.get(i).getTarget() instanceof DummyGUIElement);
+ assertEquals
+ (clickedTarget, ((DummyGUIElement) result.get(i).getTarget()).getStringIdentifier());
+ }
+ else {
+ assertFalse(result.get(i).getType() instanceof MouseClick);
+ }
+ }
+ }
+}
Index: trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/gui/TextInputDetectorTest.java
===================================================================
--- trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/gui/TextInputDetectorTest.java (revision 922)
+++ trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/gui/TextInputDetectorTest.java (revision 922)
@@ -0,0 +1,222 @@
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+import de.ugoe.cs.autoquest.eventcore.gui.KeyPressed;
+import de.ugoe.cs.autoquest.eventcore.gui.KeyReleased;
+import de.ugoe.cs.autoquest.eventcore.gui.MouseClick;
+import de.ugoe.cs.autoquest.eventcore.gui.TextInput;
+import de.ugoe.cs.autoquest.eventcore.gui.TextInputDetector;
+import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
+import de.ugoe.cs.autoquest.keyboardmaps.VirtualKey;
+import de.ugoe.cs.autoquest.test.DummyGUIElement;
+import de.ugoe.cs.autoquest.test.DummyTextField;
+
+/**
+ * @author Patrick Harms
+ */
+public class TextInputDetectorTest {
+
+ /** */
+ private List events = new ArrayList();
+
+ /**
+ *
+ */
+ @Test
+ public void testSimpleTextEntry() {
+ IGUIElement element1 = new DummyTextField("elem1");
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_A), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_A), element1);
+ assertTextInput("a");
+
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_B), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_B), element1);
+ assertTextInput("ab");
+
+ simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_C), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_C), element1);
+ simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1);
+ assertTextInput("abC");
+
+ simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_D), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_D), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_E), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_E), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_F), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_F), element1);
+ simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1);
+ assertTextInput("abCDEF");
+
+ simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1);
+ simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_G), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_G), element1);
+ simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1);
+ simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1);
+ assertTextInput("abCDEFg");
+
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testTextEntryOnDifferentGuiElements() {
+ IGUIElement element1 = new DummyTextField("elem1");
+ IGUIElement element2 = new DummyTextField("elem2");
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_A), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_A), element1);
+ assertTextInput("a");
+
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_B), element2);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_B), element2);
+ assertTextInput("a", "b");
+
+ simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_C), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_C), element1);
+ simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1);
+ assertTextInput("a", "b", "C");
+
+ simulateEvent(new KeyPressed(VirtualKey.SHIFT), element2);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_D), element2);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_D), element2);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_E), element2);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_E), element2);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_F), element2);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_F), element2);
+ simulateEvent(new KeyReleased(VirtualKey.SHIFT), element2);
+ assertTextInput("a", "b", "C", "DEF");
+
+ simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1);
+ simulateEvent(new KeyPressed(VirtualKey.SHIFT), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_G), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_G), element1);
+ simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1);
+ simulateEvent(new KeyReleased(VirtualKey.SHIFT), element1);
+ assertTextInput("a", "b", "C", "DEF", "g");
+
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testUsageOfBackspace() {
+ IGUIElement element1 = new DummyTextField("elem1");
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_A), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_A), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_B), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_B), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_C), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_C), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_D), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_D), element1);
+ simulateEvent(new KeyPressed(VirtualKey.BACK_SPACE), element1);
+ simulateEvent(new KeyReleased(VirtualKey.BACK_SPACE), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_E), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_E), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_F), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_F), element1);
+ assertTextInput("abcef");
+
+ simulateEvent(new KeyPressed(VirtualKey.BACK_SPACE), element1);
+ simulateEvent(new KeyReleased(VirtualKey.BACK_SPACE), element1);
+ simulateEvent(new KeyPressed(VirtualKey.BACK_SPACE), element1);
+ simulateEvent(new KeyReleased(VirtualKey.BACK_SPACE), element1);
+ simulateEvent(new KeyPressed(VirtualKey.BACK_SPACE), element1);
+ simulateEvent(new KeyReleased(VirtualKey.BACK_SPACE), element1);
+ assertTextInput("ab");
+
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testOtherInteractionsInBetween() {
+ IGUIElement element1 = new DummyTextField("elem1");
+ IGUIElement element2 = new DummyGUIElement("elem2");
+ IGUIElement element3 = new DummyGUIElement("elem3");
+
+ simulateEvent(new MouseClick(MouseClick.Button.LEFT), element2);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_A), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_A), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_B), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_B), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_C), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_C), element1);
+ assertTextInput("", "abc");
+
+ simulateEvent(new MouseClick(MouseClick.Button.LEFT), element2);
+ simulateEvent(new MouseClick(MouseClick.Button.LEFT), element3);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_A), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_A), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_B), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_B), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_C), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_C), element1);
+ simulateEvent(new MouseClick(MouseClick.Button.LEFT), element3);
+ assertTextInput("", "abc", "", "", "abc", "");
+
+ simulateEvent(new MouseClick(MouseClick.Button.LEFT), element2);
+ simulateEvent(new MouseClick(MouseClick.Button.LEFT), element3);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_A), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_A), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_B), element1);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_B), element1);
+ simulateEvent(new KeyPressed(VirtualKey.LETTER_C), element1);
+ simulateEvent(new MouseClick(MouseClick.Button.LEFT), element3);
+ simulateEvent(new KeyReleased(VirtualKey.LETTER_C), element1);
+
+ // the pressing of the c is not completed. So it must be included in the resulting
+ // text input event but it may only be followed by the mouse click. The subsequent release
+ // of the c key is ignored and results in a removal of the event.
+ assertTextInput("", "abc", "", "", "abc", "", "", "", "abc", "");
+ }
+
+ /**
+ *
+ */
+ private void simulateEvent(IEventType eventType, IGUIElement guiElement) {
+ events.add(new Event(eventType, guiElement));
+ }
+
+ /**
+ *
+ */
+ private void assertTextInput(String... enteredTexts) {
+ TextInputDetector detector = new TextInputDetector();
+ List result = detector.detectTextInputs(events);
+
+ assertEquals(enteredTexts.length, result.size());
+
+ for (int i = 0; i < enteredTexts.length; i++) {
+ String enteredText = enteredTexts[i];
+
+ if ((enteredText != null) && (!"".equals(enteredText))) {
+ assertTrue(result.get(i).getType() instanceof TextInput);
+ assertNotNull(((TextInput) result.get(i).getType()).getEnteredText());
+ assertEquals(enteredText, ((TextInput) result.get(i).getType()).getEnteredText());
+
+ assertNotNull(((TextInput) result.get(i).getType()).getTextInputEvents());
+ assertTrue(((TextInput) result.get(i).getType()).getTextInputEvents().size() > 0);
+ //assertTrue
+ // ((((TextInput) result.get(i).getType()).getTextInputEvents().size() % 2) == 0);
+ }
+ else {
+ assertFalse(result.get(i).getType() instanceof TextInput);
+ }
+ }
+ }
+}
Index: trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/guimodel/AbstractDefaultGUIElementTest.java
===================================================================
--- trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/guimodel/AbstractDefaultGUIElementTest.java (revision 922)
+++ trunk/autoquest-core-events-test/src/test/java/de/ugoe/cs/autoquest/eventcore/guimodel/AbstractDefaultGUIElementTest.java (revision 922)
@@ -0,0 +1,136 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.eventcore.guimodel.AbstractDefaultGUIElement;
+import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
+import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElementSpec;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @version $Revision: $ $Date: 24.08.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+public class AbstractDefaultGUIElementTest {
+
+ /**
+ *
+ * TODO: comment
+ *
+ */
+ @Test
+ public void testRegisteringEqualGuiElements() {
+ IGUIElement guiElement1 = new AbstractDefaultGUIElementTestImpl();
+ IGUIElement guiElement2 = new AbstractDefaultGUIElementTestImpl();
+
+ assertCompletelyUnequal(guiElement1, guiElement2);
+
+ guiElement1.addEqualGUIElement(guiElement2);
+ assertCompletelyEqual(guiElement1, guiElement2);
+
+ IGUIElement guiElement3 = new AbstractDefaultGUIElementTestImpl();
+
+ assertCompletelyEqual(guiElement1, guiElement2);
+ assertCompletelyUnequal(guiElement1, guiElement3);
+ assertCompletelyUnequal(guiElement2, guiElement3);
+
+ guiElement1.addEqualGUIElement(guiElement3);
+ assertCompletelyEqual(guiElement1, guiElement2, guiElement3);
+
+ IGUIElement guiElement4 = new AbstractDefaultGUIElementTestImpl();
+
+ assertCompletelyEqual(guiElement1, guiElement2, guiElement3);
+ assertCompletelyUnequal(guiElement1, guiElement4);
+ assertCompletelyUnequal(guiElement2, guiElement4);
+ assertCompletelyUnequal(guiElement3, guiElement4);
+
+ guiElement3.addEqualGUIElement(guiElement4);
+ assertCompletelyEqual(guiElement1, guiElement2, guiElement3, guiElement4);
+ }
+
+ /**
+ *
+ *
+ *
+ */
+ private void assertCompletelyUnequal(IGUIElement... guiElements) {
+ for (int i = 0; i < guiElements.length; i++) {
+ for (int j = i + 1; j < guiElements.length; j++) {
+ assertFalse(guiElements[i].equals(guiElements[j]));
+ assertFalse(guiElements[j].equals(guiElements[i]));
+ assertNotSame(guiElements[i].hashCode(), guiElements[j].hashCode());
+ }
+ }
+ }
+
+ /**
+ *
+ *
+ *
+ */
+ private void assertCompletelyEqual(IGUIElement... guiElements) {
+ for (int i = 0; i < guiElements.length; i++) {
+ for (int j = i; j < guiElements.length; j++) {
+ assertTrue(guiElements[i].equals(guiElements[j]));
+ assertTrue(guiElements[j].equals(guiElements[i]));
+ assertEquals(guiElements[i].hashCode(), guiElements[j].hashCode());
+ }
+ }
+ }
+
+ /**
+ *
+ * TODO comment
+ *
+ *
+ * @version $Revision: $ $Date: 24.08.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+ public class AbstractDefaultGUIElementTestImpl extends AbstractDefaultGUIElement
+ implements IGUIElement
+ {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param specification
+ * @param parent
+ */
+ public AbstractDefaultGUIElementTestImpl() {
+ super(null, null);
+ }
+
+ /** */
+ private static final long serialVersionUID = 1L;
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.eventcore.IEventTarget#getPlatform()
+ */
+ @Override
+ public String getPlatform() {
+ return "TEST";
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement#updateSpecification(de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElementSpec)
+ */
+ @Override
+ public void updateSpecification(IGUIElementSpec furtherSpec) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public String getStringIdentifier() {
+ return "DUMMY";
+ }
+
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/IReplayDecorator.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/IReplayDecorator.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/IReplayDecorator.java (revision 922)
@@ -0,0 +1,55 @@
+package de.ugoe.cs.autoquest;
+
+import java.io.Serializable;
+
+/**
+ *
+ * This interface defines the structure of decorators used when writing replay
+ * files.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public interface IReplayDecorator extends Serializable {
+
+ /**
+ *
+ * Header of the file. Called at the beginning of the writing.
+ *
+ *
+ * @return file header
+ */
+ String getHeader();
+
+ /**
+ *
+ * Footer of the file. Called at the end of the writing.
+ *
+ *
+ * @return file footer
+ */
+ String getFooter();
+
+ /**
+ *
+ * Session Header. Called before each session.
+ *
+ *
+ * @param sessionId
+ * id of the session
+ * @return session header
+ */
+ String getSessionHeader(int sessionId);
+
+ /**
+ *
+ * Session Footer. Called after each session.
+ *
+ *
+ * @param sessionId
+ * id of the session
+ * @return session footer
+ */
+ String getSessionFooter(int sessionId);
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/SequenceInstanceOf.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/SequenceInstanceOf.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/SequenceInstanceOf.java (revision 922)
@@ -0,0 +1,79 @@
+package de.ugoe.cs.autoquest;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+
+/**
+ *
+ * Helper class that can be used to determine if an object is a sequence or a
+ * collection of sequences. {@code instanceof} does not work, because of
+ * the type erasure of generics.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class SequenceInstanceOf {
+
+ /**
+ *
+ * Private constructor to prevent initializing of the class.
+ *
+ */
+ private SequenceInstanceOf() {
+
+ }
+
+ /**
+ *
+ * Checks if an object is of type {@link Collection}<{@link List}<
+ * {@link Event}<?>>>.
+ *
+ *
+ * @param obj
+ * object that is checked
+ * @return true, if the obj is of type {@link Collection}<{@link List}
+ * < {@link Event}<?>>>; false otherwise
+ */
+ public static boolean isCollectionOfSequences(Object obj) {
+ try {
+ if (obj instanceof Collection) {
+ Object listObj = ((Collection) obj).iterator().next();
+ if (listObj instanceof List) {
+ if (((List) listObj).iterator().next() instanceof Event) {
+ return true;
+ }
+ }
+ }
+ } catch (NoSuchElementException e) {
+ }
+ return false;
+ }
+
+ /**
+ *
+ * Checks if an object is of type {@link List}<{@link Event}
+ * <?>>.
+ *
+ *
+ * @param obj
+ * object that is checked
+ * @return true, if obj is of type {@link List}<{@link Event}
+ * <?>>; false otherwise
+ */
+ public static boolean isEventSequence(Object obj) {
+ try {
+ if (obj instanceof List) {
+ if (((List) obj).iterator().next() instanceof Event) {
+ return true;
+ }
+ }
+ } catch (NoSuchElementException e) {
+ }
+ return false;
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/Event.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/Event.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/Event.java (revision 922)
@@ -0,0 +1,251 @@
+package de.ugoe.cs.autoquest.eventcore;
+
+import java.io.Serializable;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ *
+ * Base class for all events. An event is described by its {@link #type} and its {@link #target}.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ *
+ * @param
+ * Can be used to declare that events belong to a specific platform without subclassing.
+ */
+public class Event implements Serializable {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Global start event that can be used to indicate the start of a sequence.
+ *
+ */
+ public static final Event STARTEVENT = new Event(new StringEventType("START"));
+
+ /**
+ *
+ * Global end event that can be used to indicate the end of a sequence.
+ */
+ public static final Event ENDEVENT = new Event(new StringEventType("END"));
+
+ /**
+ *
+ * Type of the event.
+ *
+ */
+ protected IEventType type;
+
+ /**
+ *
Target of the event.
+ */
+ protected IEventTarget target = null;
+
+ /**
+ *
+ * List of {@link IReplayable}s of type T that describes the replay of an event. The
+ * {@link IReplayable}s can be interpreted as sub-events on the platform level that
+ * make up the abstract event.
+ *
+ */
+ protected List replay = new LinkedList();
+
+ /**
+ *
+ * Constructor. Creates a new Event with a given type. The type must not be null.
+ *
+ *
+ * @param type
+ * type of the event
+ */
+ public Event(IEventType type) {
+ if (type == null) {
+ throw new IllegalArgumentException("Event type must not be null");
+ }
+ this.type = type;
+ }
+
+ /**
+ *
+ * Constructor. Creates a new Event with a given type and target. The type must not be null.
+ *
+ *
+ * @param type
+ * type of the event
+ * @param target
+ * target of the event
+ */
+ public Event(IEventType type, IEventTarget target) {
+ this(type);
+ this.target = target;
+ }
+
+ /**
+ *
+ * Two events are equal, if their {@link #type} and {@link #target} are equal.
+ *
+ *
+ * See {@link Object#equals(Object)} for further information.
+ *
+ *
+ * @param other
+ * Event that is compared to this
+ * @return true, if events are equal, false otherwise
+ */
+ @Override
+ public boolean equals(Object other) {
+ if (this == other) {
+ return true;
+ }
+ if (other instanceof Event) {
+ Event otherEvent = (Event) other;
+ if (target != null) {
+ return type.equals(otherEvent.type) && target.equals(otherEvent.target);
+ }
+ else {
+ return type.equals(otherEvent.type) && otherEvent.target == null;
+ }
+ }
+ return false;
+ }
+
+ /**
+ *
+ * Returns {@link #getId()} as String representation of the event.
+ *
+ *
+ * @return String representation of the event
+ */
+ @Override
+ public String toString() {
+ return getId();
+ }
+
+ /**
+ *
+ * Returns the {@link #target} of the event.
+ *
+ *
+ * @return {@link #target} of the event
+ */
+ public IEventTarget getTarget() {
+ return target;
+ }
+
+ /**
+ *
+ * Returns the {@link #type} of the event.
+ *
+ *
+ * @return {@link #type} of the event
+ */
+ public IEventType getType() {
+ return type;
+ }
+
+ /**
+ *
+ * Returns the combination of {@link #type} and {@link #target} as id.
+ *
+ *
+ * @return string of the form (type,target)
+ */
+ public String getId() {
+ String id = type.toString();
+ if( target!=null ) {
+ id += "." + target.getStringIdentifier();
+ }
+ return id;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ int multiplier = 17;
+ int hash = 42;
+ if (type != null) {
+ hash = multiplier * hash + type.hashCode();
+ }
+ if (target != null) {
+ hash = multiplier * hash + target.hashCode();
+ }
+ return hash;
+ }
+
+ /**
+ *
+ * Sets the target of the event. Once set, the target cannot be changed.
+ *
+ *
+ * @param target
+ * target of the event
+ * @return true, if target was changed, false otherwise
+ */
+ public boolean setTarget(IEventTarget target) {
+ if (this.target != null) {
+ return false;
+ }
+ this.target = target;
+ return true;
+ }
+
+ /**
+ *
+ * Adds a new {@link IReplayable} of type T to the replay sequence.
+ *
+ *
+ * @param replayable
+ * element that is added to the sequence
+ * @throws IllegalArgumentException
+ * thrown is replayable is null
+ */
+ public void addReplayable(IReplayable replayable) {
+ if (replayable == null) {
+ throw new IllegalArgumentException("replayble must not be null");
+ }
+ replay.add(replayable);
+ }
+
+ /**
+ *
+ * Adds a {@link List}ist of {@link IReplayable} to the replay sequence.
+ *
+ *
+ * @param generatedReplaySeq
+ * {@link List} that is added to the sequence
+ * @throws IllegalArgumentException
+ * thrown if generatedReplaySeq is null
+ */
+ public void addReplayableSequence(List generatedReplaySeq) {
+ if (generatedReplaySeq == null) {
+ throw new IllegalArgumentException("generatedReplaySeq must not be null");
+ }
+ replay.addAll(generatedReplaySeq);
+ }
+
+ /**
+ *
+ * Returns a the list of replay events.
+ *
+ *
+ * The return value is a copy of the list used internally!
+ *
+ *
+ * @return list of replay events.
+ */
+ public List getReplayables() {
+ return new LinkedList(replay);
+ }
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/IEventTarget.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/IEventTarget.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/IEventTarget.java (revision 922)
@@ -0,0 +1,36 @@
+
+package de.ugoe.cs.autoquest.eventcore;
+
+import java.io.Serializable;
+
+/**
+ *
+ * Common interface for event targets. An event target can, e.g., be an element of a GUI or Web
+ * server. A concrete event-driven software platform can define its event targets through the
+ * implementation of this interface.
+ *
+ *
+ * @version 1.0
+ * @author Steffen Herbold
+ */
+public interface IEventTarget extends Serializable {
+
+ /**
+ *
+ * Returns the name of event-driven software platform to which the target belongs.
+ *
+ *
+ * @return name of the platform
+ */
+ public String getPlatform();
+
+ /**
+ *
+ * Returns a string identifier of the target. This is very convenient for visualizations of
+ * events.
+ *
+ *
+ * @return target identifier
+ */
+ public String getStringIdentifier();
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/IEventType.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/IEventType.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/IEventType.java (revision 922)
@@ -0,0 +1,26 @@
+
+package de.ugoe.cs.autoquest.eventcore;
+
+import java.io.Serializable;
+
+/**
+ *
+ * Common interface for event types. An event type can be, e.g., a mouse click, a keyboard
+ * interactions in case of GUI platforms or a HTTP request in case of a Web application.
+ *
+ *
+ * @version 1.0
+ * @author Steffen Herbold
+ */
+public interface IEventType extends Serializable {
+
+ /**
+ *
+ * Returns the name of the event type.
+ *
+ *
+ * @return name of the event type
+ */
+ public String getName();
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/IReplayable.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/IReplayable.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/IReplayable.java (revision 922)
@@ -0,0 +1,37 @@
+package de.ugoe.cs.autoquest.eventcore;
+
+import java.io.Serializable;
+
+import de.ugoe.cs.autoquest.IReplayDecorator;
+
+/**
+ *
+ * This interface is used by {@link ReplayableEvent}to describe how events can
+ * be replayed. It can be used to define a sequence of fine-grained platform
+ * events that make up an abstract event.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public interface IReplayable extends Serializable {
+
+ /**
+ *
+ * Returns a string to be written to the replay script that describes the
+ * replayable platform event.
+ *
+ *
+ * @return string for the replay script
+ */
+ String getReplay();
+
+ /**
+ *
+ * Returns the replay decorator associated with the replayable. Returns null if no replay decorator is associated with the replayable.
+ *
+ *
+ * @return replay decorator
+ */
+ IReplayDecorator getDecorator();
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/StringEventType.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/StringEventType.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/StringEventType.java (revision 922)
@@ -0,0 +1,89 @@
+package de.ugoe.cs.autoquest.eventcore;
+
+/**
+ *
+ * A simple event type that is identified by a string.
+ *
+ *
+ * @version $Revision: $ $Date: Aug 16, 2012$
+ * @author 2012, last modified by $Author: sherbold$
+ */
+public class StringEventType implements IEventType {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * String that identifies the event type.
+ *
+ */
+ private String str;
+
+ /**
+ *
+ * Constructor. Creates a new StringEventType. str must not be null.
+ *
+ *
+ * @param str
+ * string that identifies the event type
+ * @throws IllegalArgumentException
+ * thrown if str is null
+ */
+ public StringEventType(String str) throws IllegalArgumentException {
+ if (str == null) {
+ throw new IllegalArgumentException("str must not be null");
+ }
+ this.str = str;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.autoquest.eventcore.IEventType#getName()
+ */
+ @Override
+ public String getName() {
+ return "StringEventType";
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return str;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return str.hashCode();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object other) {
+ if (other == this) {
+ return true;
+ }
+ if (other instanceof StringEventType) {
+ return str.equals(((StringEventType) other).str);
+ }
+ return false;
+ }
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/IInteraction.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/IInteraction.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/IInteraction.java (revision 922)
@@ -0,0 +1,34 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+
+/**
+ *
+ * An interaction is a special event type which represents the interaction of a user with an element
+ * of a GUI. An example is a mouse click on a button.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IInteraction extends IEventType {
+ /**
+ *
+ * Determines whether an event type starts a logical sequence, i.e., a task.
+ *
+ *
+ * @return true if a logical sequence is started; false otherwise
+ */
+ public boolean startsLogicalSequence();
+
+ /**
+ *
+ * Determines whether an event type finishes a logical sequence, i.e., a task.
+ *
+ *
+ * @return true if a logical sequence is finished; false otherwise
+ */
+ public boolean finishesLogicalSequence();
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyInteraction.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyInteraction.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyInteraction.java (revision 922)
@@ -0,0 +1,54 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+import de.ugoe.cs.autoquest.keyboardmaps.VirtualKey;
+
+/**
+ *
+ * Base class for all keyboard interaction event types.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public abstract class KeyInteraction implements IInteraction {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * the key associated with the interaction
+ *
+ */
+ private VirtualKey key;
+
+ /**
+ *
+ * Constructor. Creates a new KeyInteraction.
+ *
+ *
+ * @param key
+ * key associated with the interaction
+ */
+ public KeyInteraction(VirtualKey key) {
+ super();
+ this.key = key;
+ }
+
+ /**
+ *
+ * Returns the key associated with the interaction.
+ *
+ *
+ * @return the key
+ */
+ public VirtualKey getKey() {
+ return key;
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyInteractionCorrector.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyInteractionCorrector.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyInteractionCorrector.java (revision 922)
@@ -0,0 +1,279 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Set;
+import java.util.logging.Level;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.keyboardmaps.VirtualKey;
+import de.ugoe.cs.util.console.Console;
+
+/**
+ *
+ * This class provides the functionality to sort and clean up all key interactions in a log. In
+ * particular:
+ *
+ * - In case a combination key (e.g., shift, alt, control) is held down, multiple
+ * {@link KeyPressed} events are logged, even though only the first one is of importance. This class
+ * removes all {@link KeyPressed} events for combination keys except the first.
+ * - In case a normal key is held down, multiple {@link KeyPressed} events are logged, but there
+ * is only one {@link KeyReleased} event. This class adds a {@link KeyReleased} event for all such
+ * {@link KeyPressed} events.
+ * - Due to message filtering of applications, it is possible that a {@link KeyReleased} event
+ * without a preceding {@link KeyPressed} event is logged. This class either adds the missing
+ * {@link KeyPressed} right in front of the {@link KeyReleased} or removes the {@link KeyReleased}
+ * depending on the {@link #mode}.
+ *
- As a result of steps 2-3, we have always a matching {@link KeyPressed}/{@link KeyReleased}
+ * pairs for all normal keys. This class replaces these pairs with a {@link KeyTyped} event at the
+ * position of the {@link KeyPressed} event.
+ * - Sometimes combination keys are not released in the same order they have been pressed. This
+ * class ensures that the {@link KeyReleased} are in the opposite order of the {@link KeyPressed}
+ * events for all combination keys.
+ *
+ *
+ *
+ * @version 1.0
+ * @author Steffen Herbold
+ */
+public class KeyInteractionCorrector {
+
+ /**
+ *
+ * Describes the clean-up mode.
+ *
+ *
+ * @version 1.0
+ * @author Steffen Herbold
+ */
+ public static enum CleanupMode {
+ /**
+ *
+ * Single {@link KeyReleased} are removed from the sequence.
+ *
+ */
+ REMOVAL,
+
+ /**
+ *
+ * {@link KeyPressed} events are added to single {@link KeyReleased} events
+ *
+ */
+ ADDITION
+ };
+
+ /**
+ *
+ *
+ *
+ */
+ private final CleanupMode mode;
+
+ /**
+ *
+ * Constructor. Creates a new {@link KeyInteractionCorrector} with {@link #mode}=
+ * {@link CleanupMode#ADDITION}.
+ *
+ */
+ public KeyInteractionCorrector() {
+ this(CleanupMode.ADDITION);
+ }
+
+ /**
+ *
+ * Constructor. Creates a new {@link KeyInteractionCorrector}.
+ *
+ *
+ * @param mode
+ * {@link #mode} of the instance
+ */
+ public KeyInteractionCorrector(CleanupMode mode) {
+ this.mode = mode;
+ }
+
+ /**
+ *
+ * Sorts and cleans up key interactions according to the class specification (@see
+ * {@link KeyInteractionCorrector} class comment).
+ *
+ *
+ * This method returns a sorted copy of a sequence, the sequence itself is not changed.
+ *
+ *
+ * @param sequence
+ * sequence which is sorted
+ * @return sorted copy of sequence
+ */
+ public List sortKeyInteractions(final List sequence) {
+ List sortedSequence = new LinkedList(sequence);
+
+ handleIncompleteKeyPairs(sortedSequence);
+ sortCombinationKeyPairs(sortedSequence);
+
+ return sortedSequence;
+ }
+
+ /**
+ *
+ * Performs tasks 1-4 defined in the class description. Operations are performed in-place on the
+ * passed sequence.
+ *
+ *
+ * @param sequence
+ * sequence which is sorted
+ */
+ private void sortCombinationKeyPairs(List sequence) {
+ LinkedList pressedCombinationKeys = new LinkedList();
+
+ for (int i = 0; i < sequence.size(); i++) {
+ Event event = sequence.get(i);
+ if (event.getType() instanceof KeyPressed) {
+ final VirtualKey key = ((KeyPressed) event.getType()).getKey();
+ if (key.isCombinationKey()) {
+ pressedCombinationKeys.add(key);
+ }
+ }
+ if (event.getType() instanceof KeyReleased) {
+ final VirtualKey key = ((KeyReleased) event.getType()).getKey();
+ if (key.isCombinationKey()) {
+ /*
+ * if( pressedCombinationKeys.isEmpty() ) { Console.traceln(Level.INFO, "" + i);
+ * for( int j=i-30 ; j<=i ; j++ ) { Console.traceln(Level.INFO,
+ * sequence.get(i).toString()); } }
+ */
+ if (key.equals(pressedCombinationKeys.getLast())) {
+ pressedCombinationKeys.removeLast();
+ }
+ else {
+ // look-ahead to find new position
+ int offset;
+ for (offset = 1; offset + i < sequence.size(); offset++) {
+ Event lookaheadEvent = sequence.get(i + offset);
+ if (lookaheadEvent.getType() instanceof KeyReleased) {
+ if (((KeyReleased) lookaheadEvent.getType()).getKey()
+ .equals(pressedCombinationKeys.getLast()))
+ {
+ break;
+ }
+ }
+ }
+ sequence.add(i + offset + 1, event);
+ sequence.remove(i);
+ i--;
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ *
+ * Performs task 5 defined in the class description. Operations are performed in-place on the
+ * passed sequence.
+ *
+ *
+ * @param sequence
+ * sequence which is sorted
+ */
+ private void handleIncompleteKeyPairs(List sequence) {
+ Set pressedKeys = new HashSet();
+ int firstPressedIndex = -1;
+
+ Set pressedCombinationKeysSession = new HashSet();
+
+ for (int i = 0; i < sequence.size(); i++) {
+ Event event = sequence.get(i);
+ if (event.getType() instanceof KeyboardFocusChange) {
+ if (firstPressedIndex != -1) {
+ sequence.remove(i);
+ sequence.add(firstPressedIndex, event);
+ }
+ }
+
+ if (event.getType() instanceof KeyPressed) {
+ if (pressedKeys.isEmpty()) {
+ firstPressedIndex = i;
+ }
+ VirtualKey key = ((KeyPressed) event.getType()).getKey();
+ if (!key.isCombinationKey()) {
+ ListIterator iter = sequence.listIterator(i);
+ iter.next();
+ iter.set(new Event(new KeyTyped(key), event.getTarget()));
+ }
+ else {
+ pressedCombinationKeysSession.add(key);
+ if (pressedKeys.contains(key)) {
+ sequence.remove(i);
+ i--;
+ }
+ }
+ pressedKeys.add(key);
+ }
+ if (event.getType() instanceof KeyReleased) {
+ VirtualKey key = ((KeyReleased) event.getType()).getKey();
+ if (!key.isCombinationKey()) {
+ if (pressedKeys.contains(key)) {
+ sequence.remove(i);
+ i--;
+ }
+ else {
+ // found KeyReleased event without KeyPressed
+ switch (mode)
+ {
+ case REMOVAL:
+ sequence.remove(i);
+ i--;
+ break;
+ case ADDITION:
+ ListIterator iter = sequence.listIterator(i);
+ iter.next();
+ iter.set(new Event(new KeyTyped(key), event.getTarget()));
+ break;
+ default:
+ throw new AssertionError(
+ "reached source code that should be unreachable");
+ }
+ }
+ }
+ else {
+ if (!pressedKeys.contains(key)) {
+ if (pressedCombinationKeysSession.contains(key)) {
+ Console.traceln(Level.SEVERE, "Found a " + key +
+ " KeyReleased event without a KeyPressed event." +
+ "The event will be dropped and the session is possibly faulty.");
+ sequence.remove(i);
+ i--;
+ }
+ else {
+ Console
+ .traceln(Level.SEVERE,
+ "Found a " +
+ key +
+ " KeyReleased event without a KeyPressed event." +
+ "Since no KeyPressed of key " +
+ key +
+ " has been part of the session " +
+ "till now, we assume that the key has been pressed since the beginning " +
+ "of the session and add a KeyPressed event for " +
+ key + " to the start " + "of the session.");
+ sequence.add(0, new Event(new KeyPressed(key), event.getTarget()));
+ i++;
+ }
+ }
+ }
+ pressedKeys.remove(key);
+ if (pressedKeys.isEmpty()) {
+ firstPressedIndex = -1;
+ }
+ }
+ }
+ if (!pressedKeys.isEmpty()) {
+ Console
+ .traceln(Level.WARNING,
+ "There was probably a failure during the handling of incomplete key event pairs.");
+ }
+ }
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyInteractionTargetCorrector.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyInteractionTargetCorrector.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyInteractionTargetCorrector.java (revision 922)
@@ -0,0 +1,68 @@
+// Module : $RCSfile: KeyInteractionTargetCorrector.java,v $
+// Version : $Revision: 0.0 $ $Author: pharms $ $Date: 29.08.2012 $
+// Project : quest-core-events
+// Creation : 2012 by pharms
+// Copyright : Patrick Harms, 2012
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
+
+/**
+ *
+ * This class iterates the provided sequence and sets the target of all key interaction events
+ * to the GUI element having the current keyboard focus. The current keyboard focus is determined
+ * either by keyboard focus events or by using the target of the first key interaction in the
+ * provided sequence. Events changing the keyboard focus are discarded herewith.
+ *
+ *
+ * @version $Revision: $ $Date: 29.08.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+public class KeyInteractionTargetCorrector {
+
+ /**
+ *
+ * This method performs the work described in the description of the class. A new list is
+ * instantiated and returned. This list is filled with the events provided by the sequence
+ * being the parameter of the method except for key interaction events. Those are replaced
+ * by a new event with the identical event type but the corrected event target.
+ *
+ *
+ * @param sequence the event sequence to correct the key interactions targets in
+ *
+ * @return the resulting sequence, in which key interactions have the correct target, i.e.
+ * the GUI element having the keyboard focus
+ */
+ public List correctKeyInteractionTargets(List sequence) {
+ List resultingSequence = new LinkedList();
+ IGUIElement currentKeyboardFocusGUIElement = null;
+
+ for (Event event : sequence) {
+ if (event.getTarget() instanceof IGUIElement) {
+ if (event.getType() instanceof KeyboardFocusChange) {
+ currentKeyboardFocusGUIElement = (IGUIElement) event.getTarget();
+ event = null;
+ }
+ else if (event.getType() instanceof KeyInteraction) {
+ if (currentKeyboardFocusGUIElement == null) {
+ currentKeyboardFocusGUIElement = (IGUIElement) event.getTarget();
+ }
+
+ if (!currentKeyboardFocusGUIElement.equals(event.getTarget())) {
+ event = new Event(event.getType(), currentKeyboardFocusGUIElement);
+ }
+ }
+ }
+
+ if (event != null) {
+ resultingSequence.add(event);
+ }
+ }
+
+ return resultingSequence;
+ }
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyPressed.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyPressed.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyPressed.java (revision 922)
@@ -0,0 +1,97 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+import de.ugoe.cs.autoquest.keyboardmaps.VirtualKey;
+
+/**
+ *
+ * Event type for pressing down a key.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public class KeyPressed extends KeyInteraction {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Constructor. Creates a new {@link KeyPressed} event type.
+ *
+ *
+ * @see KeyInteraction#KeyInteraction(VirtualKey)
+ */
+ public KeyPressed(VirtualKey key) {
+ super(key);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#getName()
+ */
+ public String getName() {
+ return "KeyPressed " + super.getKey();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return "pressing key " + super.getKey();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#startsLogicalSequence()
+ */
+ public boolean startsLogicalSequence() {
+ // TODO handle lock keys correctly
+ return super.getKey().isCombinationKey();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#finishesLogicalSequence()
+ */
+ public boolean finishesLogicalSequence() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object other) {
+ if (other instanceof KeyPressed) {
+ return (super.getKey() == ((KeyPressed) other).getKey());
+ }
+ else {
+ return false;
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return super.getKey().hashCode();
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyReleased.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyReleased.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyReleased.java (revision 922)
@@ -0,0 +1,94 @@
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+import de.ugoe.cs.autoquest.keyboardmaps.VirtualKey;
+
+/**
+ *
+ * Event type for releasing a key.
+ *
+ *
+ * @version 1.0
+ * @author Steffen Herbold
+ */
+public class KeyReleased extends KeyInteraction {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Constructor. Creates a new {@link KeyReleased} event type.
+ *
+ *
+ * @see KeyInteraction#KeyInteraction(VirtualKey)
+ */
+ public KeyReleased(VirtualKey key) {
+ super(key);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#getName()
+ */
+ public String getName() {
+ return "KeyReleased " + super.getKey();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return "releasing key " + super.getKey();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#startsLogicalSequence()
+ */
+ public boolean startsLogicalSequence() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#finishesLogicalSequence()
+ */
+ public boolean finishesLogicalSequence() {
+ // TODO handle lock keys correctly
+ return super.getKey().isCombinationKey();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object other) {
+ if (other instanceof KeyReleased) {
+ return (super.getKey() == ((KeyReleased) other).getKey());
+ }
+ else {
+ return false;
+ }
+ }
+
+ /* (non-Javadoc)
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return super.getKey().hashCode();
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyTyped.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyTyped.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyTyped.java (revision 922)
@@ -0,0 +1,98 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+import de.ugoe.cs.autoquest.keyboardmaps.VirtualKey;
+
+/**
+ *
+ * Event type for typing a key, i.e., pressing and releasing it right away.
+ *
+ *
+ * @version 1.0
+ * @author Steffen Herbold
+ */
+public class KeyTyped extends KeyInteraction {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Constructor. Creates a new {@link KeyTyped} event type.
+ *
+ *
+ * @see KeyInteraction#KeyInteraction(VirtualKey)
+ */
+ public KeyTyped(VirtualKey key) {
+ super(key);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#getName()
+ */
+ public String getName() {
+ return "KeyTyped " + super.getKey();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return "typed key " + super.getKey();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#startsLogicalSequence()
+ */
+ public boolean startsLogicalSequence() {
+ // TODO handle lock keys correctly
+ return super.getKey().isCombinationKey();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#finishesLogicalSequence()
+ */
+ public boolean finishesLogicalSequence() {
+ // TODO handle lock keys correctly
+ return super.getKey().isCombinationKey();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object other) {
+ if (other instanceof KeyTyped) {
+ return (super.getKey() == ((KeyTyped) other).getKey());
+ }
+ else {
+ return false;
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return super.getKey().hashCode();
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyboardFocusChange.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyboardFocusChange.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/KeyboardFocusChange.java (revision 922)
@@ -0,0 +1,83 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+/**
+ *
+ * Event type for keyboard focus changes. The target of the respective event has obtained the
+ * keyboard focus of the application.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public class KeyboardFocusChange implements IInteraction {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#getName()
+ */
+ public String getName() {
+ return "KeyboardFocusChange";
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.userinteraction.Interaction#startsLogicalSequence()
+ */
+ @Override
+ public boolean startsLogicalSequence() {
+ return true;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.userinteraction.Interaction#finishesLogicalSequence()
+ */
+ @Override
+ public boolean finishesLogicalSequence() {
+ return true;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return "keyboard focus changed";
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof KeyboardFocusChange) {
+ return true;
+ }
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return getClass().hashCode();
+ }
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseButtonDown.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseButtonDown.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseButtonDown.java (revision 922)
@@ -0,0 +1,114 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+/**
+ *
+ * Event type for pressing a mouse button.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public class MouseButtonDown extends MouseButtonInteraction {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Constructor. Creates a new {@link MouseButtonDown} event type.
+ *
+ *
+ * @see MouseButtonInteraction#MouseButtonInteraction(Button)
+ */
+ public MouseButtonDown(Button button) {
+ super(button);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#getName()
+ */
+ public String getName() {
+ if (super.getButton() == Button.LEFT) {
+ return "LeftMouseButtonDown";
+ }
+ else if (super.getButton() == Button.MIDDLE) {
+ return "MiddleMouseButtonDown";
+ }
+ else if (super.getButton() == Button.RIGHT) {
+ return "RightMouseButtonDown";
+ }
+ else {
+ return "UnknownMouseButtonDown";
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ if (super.getButton() == Button.LEFT) {
+ return "left mouse button down";
+ }
+ else if (super.getButton() == Button.MIDDLE) {
+ return "middle mouse button down";
+ }
+ else if (super.getButton() == Button.RIGHT) {
+ return "right mouse button down";
+ }
+ else {
+ return "unknown mouse button down";
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#startsLogicalSequence()
+ */
+ public boolean startsLogicalSequence() {
+ return true;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#finishesLogicalSequence()
+ */
+ public boolean finishesLogicalSequence() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof MouseButtonDown) {
+ return getButton().equals(((MouseButtonDown) obj).getButton());
+ }
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return getButton().hashCode();
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseButtonInteraction.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseButtonInteraction.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseButtonInteraction.java (revision 922)
@@ -0,0 +1,85 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+/**
+ *
+ * Base class for all mouse interaction event types.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public abstract class MouseButtonInteraction extends MouseInteraction {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Describes the pressed mouse button.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+ public static enum Button {
+ LEFT, MIDDLE, RIGHT, X;
+ }
+
+ /**
+ *
+ * The button used for mouse interaction
+ *
+ */
+ private Button button;
+
+ /**
+ *
+ * Constructor. Creates a new {@link MouseButtonInteraction}
+ *
+ *
+ * @param button
+ * the button associated with the interaction
+ */
+ public MouseButtonInteraction(Button button) {
+ this.button = button;
+ }
+
+ /**
+ *
+ * Returns the button associated with the interaction.
+ *
+ *
+ * @return the button
+ */
+ public Button getButton() {
+ return button;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof MouseButtonInteraction) {
+ return getButton().equals(((MouseButtonInteraction) obj).getButton());
+ }
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return getButton().hashCode();
+ }
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseButtonUp.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseButtonUp.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseButtonUp.java (revision 922)
@@ -0,0 +1,113 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+/**
+ *
+ * Event type for releasing a mouse button.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public class MouseButtonUp extends MouseButtonInteraction {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Constructor. Creates a new {@link MouseButtonUp} event type.
+ *
+ *
+ * @see MouseButtonInteraction#MouseButtonInteraction(Button)
+ */
+ public MouseButtonUp(Button button) {
+ super(button);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#getName()
+ */
+ public String getName() {
+ if (super.getButton() == Button.LEFT) {
+ return "LeftMouseButtonUp";
+ }
+ else if (super.getButton() == Button.MIDDLE) {
+ return "MiddleMouseButtonUp";
+ }
+ else if (super.getButton() == Button.RIGHT) {
+ return "RightMouseButtonUp";
+ }
+ else {
+ return "UnknownMouseButtonUp";
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ if (super.getButton() == Button.LEFT) {
+ return "left mouse button up";
+ }
+ else if (super.getButton() == Button.MIDDLE) {
+ return "middle mouse button up";
+ }
+ else if (super.getButton() == Button.RIGHT) {
+ return "right mouse button up";
+ }
+ else {
+ return "unknown mouse button up";
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#startsLogicalSequence()
+ */
+ public boolean startsLogicalSequence() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#finishesLogicalSequence()
+ */
+ public boolean finishesLogicalSequence() {
+ return true;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof MouseButtonUp) {
+ return getButton().equals(((MouseButtonUp) obj).getButton());
+ }
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return getButton().hashCode();
+ }
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseClick.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseClick.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseClick.java (revision 922)
@@ -0,0 +1,113 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+/**
+ *
+ * Event type for a mouse click, i.e., pressing and releasing it right away.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public class MouseClick extends MouseButtonInteraction {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Constructor. Creates a new {@link MouseClick} event type.
+ *
+ *
+ * @see MouseButtonInteraction#MouseButtonInteraction(Button)
+ */
+ public MouseClick(Button button) {
+ super(button);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#getName()
+ */
+ public String getName() {
+ if (super.getButton() == Button.LEFT) {
+ return "LeftMouseClick";
+ }
+ else if (super.getButton() == Button.MIDDLE) {
+ return "MiddleMouseClick";
+ }
+ else if (super.getButton() == Button.RIGHT) {
+ return "RightMouseClick";
+ }
+ else {
+ return "UnknownMouseButtonClick";
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ if (super.getButton() == Button.LEFT) {
+ return "left mouse click";
+ }
+ else if (super.getButton() == Button.MIDDLE) {
+ return "middle mouse click";
+ }
+ else if (super.getButton() == Button.RIGHT) {
+ return "right mouse click";
+ }
+ else {
+ return "unknown mouse button click";
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#startsLogicalSequence()
+ */
+ public boolean startsLogicalSequence() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#finishesLogicalSequence()
+ */
+ public boolean finishesLogicalSequence() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof MouseClick) {
+ return getButton().equals(((MouseClick) obj).getButton());
+ }
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return getButton().hashCode();
+ }
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseClickCondenser.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseClickCondenser.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseClickCondenser.java (revision 922)
@@ -0,0 +1,107 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+
+/**
+ *
+ * This class condenses mouse clicks, i.e. it reduces a sequence of mouse button down, mouse button
+ * up and mouse click with the same button on the same event target to a single mouse click with
+ * that button on that target. The mouse button down and mouse button up events are discarded. For
+ * this, it iterates the provided sequence and identifies any match of the named event sequence
+ * pattern. This match is condensed to the mouse click event.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public class MouseClickCondenser {
+
+ /**
+ *
+ * This method performs the work described in the description of the class. A new list is
+ * instantiated and returned. This list is filled with the events provided by the sequence being
+ * the parameter of the method except for mouse button down and mouse button up events which are
+ * followed by a mouse click event with the same button on the same target.
+ *
+ *
+ * @param sequence
+ * the event sequence to condense the mouse clicks in
+ *
+ * @return the resulting sequence, in which mouse clicks are condensed to single mouse click
+ * events
+ */
+ public List condenseMouseClicks(List sequence) {
+ List resultingSequence = new LinkedList();
+
+ int index = 0;
+ while (index < sequence.size()) // -2 because we don't need to go to the end
+ {
+ if ((index + 2) < sequence.size()) {
+ Event mouseButtonDown = sequence.get(index);
+ Event mouseButtonUp = sequence.get(index + 1);
+ Event mouseClick = sequence.get(index + 2);
+ if (mouseClickSequenceFound(mouseButtonDown, mouseButtonUp, mouseClick)) {
+ // skip the mouse button down and mouse button up event
+ index += 2;
+ }
+ }
+
+ resultingSequence.add(sequence.get(index));
+ index++;
+ }
+
+ return resultingSequence;
+ }
+
+ /**
+ *
+ */
+ private boolean mouseClickSequenceFound(Event mouseButtonDown,
+ Event mouseButtonUp,
+ Event mouseClick)
+ {
+ // check the first in a row of three for validity
+ if (!(mouseButtonDown.getType() instanceof MouseButtonDown)) {
+ return false;
+ }
+
+ // check the second node for validity
+ if (!(mouseButtonUp.getType() instanceof MouseButtonUp)) {
+ return false;
+ }
+
+ IEventTarget eventTarget = mouseButtonDown.getTarget();
+
+ if (!eventTarget.equals(mouseButtonUp.getTarget())) {
+ return false;
+ }
+
+ MouseButtonInteraction.Button button =
+ ((MouseButtonDown) mouseButtonDown.getType()).getButton();
+
+ if (!button.equals(((MouseButtonUp) mouseButtonUp.getType()).getButton())) {
+ return false;
+ }
+
+ // check the third node for validity
+ if (!(mouseClick.getType() instanceof MouseClick)) {
+ return false;
+ }
+
+ if (!eventTarget.equals(mouseClick.getTarget())) {
+ return false;
+ }
+
+ if (!button.equals(((MouseClick) mouseClick.getType()).getButton())) {
+ return false;
+ }
+
+ return true;
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseDoubleClick.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseDoubleClick.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseDoubleClick.java (revision 922)
@@ -0,0 +1,114 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+/**
+ *
+ * Event type for a double click, i.e., pressing the mouse, releasing it, pressing it, and releasing
+ * it again right away.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public class MouseDoubleClick extends MouseButtonInteraction {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Constructor. Creates a new {@link MouseDoubleClick} event type.
+ *
+ *
+ * @see MouseButtonInteraction#MouseButtonInteraction(Button)
+ */
+ public MouseDoubleClick(Button button) {
+ super(button);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#getName()
+ */
+ public String getName() {
+ if (super.getButton() == Button.LEFT) {
+ return "LeftMouseDoubleClick";
+ }
+ else if (super.getButton() == Button.MIDDLE) {
+ return "MiddleMouseDoubleClick";
+ }
+ else if (super.getButton() == Button.RIGHT) {
+ return "RightMouseDoubleClick";
+ }
+ else {
+ return "UnknownMouseButtonDoubleClick";
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ if (super.getButton() == Button.LEFT) {
+ return "left mouse double click";
+ }
+ else if (super.getButton() == Button.MIDDLE) {
+ return "middle mouse double click";
+ }
+ else if (super.getButton() == Button.RIGHT) {
+ return "right mouse double click";
+ }
+ else {
+ return "unknown mouse button double click";
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#startsLogicalSequence()
+ */
+ public boolean startsLogicalSequence() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#finishesLogicalSequence()
+ */
+ public boolean finishesLogicalSequence() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof MouseDoubleClick) {
+ return getButton().equals(((MouseDoubleClick) obj).getButton());
+ }
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return getButton().hashCode();
+ }
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseInteraction.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseInteraction.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/MouseInteraction.java (revision 922)
@@ -0,0 +1,20 @@
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+/**
+ *
+ * Base class for all mouse interaction event types.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public abstract class MouseInteraction implements IInteraction {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/TextInput.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/TextInput.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/TextInput.java (revision 922)
@@ -0,0 +1,211 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+import java.util.Collections;
+import java.util.List;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+
+/**
+ *
+ * A text input represents a list of key events that together represent entering text into a text
+ * field or text area.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms, Steffen Herbold
+ */
+public class TextInput implements IInteraction {
+
+ /**
+ *
+ * Defines how the {@link TextInput}s are evaluated as equal.
+ *
+ *
+ * @version 1.0
+ * @author Steffen Herbold
+ */
+ public enum TextEquality {
+ /**
+ *
+ * Two text inputs are equal if their {@link TextInput#textInputEvents} are equal.
+ *
+ */
+ LEXICAL,
+ /**
+ *
+ * Two text inputs are equal if their {@link TextInput#enteredText}s are equal.
+ *
+ */
+ SYNTACTICAL,
+ /**
+ *
+ * All text inputs are equal.
+ *
+ */
+ SEMANTICAL
+ };
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * The text resulting from the text input events.
+ *
+ */
+ private String enteredText;
+
+ /**
+ *
+ * The text input events that caused the entering of the text.
+ *
+ */
+ private List textInputEvents;
+
+ /**
+ *
+ * Defines how this TextInput event evaluates the equality.
+ *
+ */
+ private final TextEquality equalityType;
+
+ /**
+ *
+ * Constructor. Creates a new {@link TextInput} with {@link TextEquality#LEXICAL} equality.
+ *
+ *
+ * @param enteredText
+ * text resulting from the inputs
+ * @param textInputEvents
+ * text input events of which this input consists
+ */
+ public TextInput(String enteredText, List textInputEvents) {
+ this(enteredText, textInputEvents, TextEquality.LEXICAL);
+ }
+
+ /**
+ *
+ * Constructor. Creates a new {@link TextInput}..
+ *
+ *
+ * @param enteredText
+ * text resulting from the inputs
+ * @param textInputEvents
+ * text input events of which this input consists
+ * @param equalityType
+ * defines how this event evaluates the equality (@see {@link TextEquality})
+ */
+ public TextInput(String enteredText, List textInputEvents, TextEquality equalityType) {
+ this.enteredText = enteredText;
+ this.textInputEvents = textInputEvents;
+ this.equalityType = equalityType;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#getName()
+ */
+ public String getName() {
+ return "TextInput(\"" + enteredText + "\")";
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return "text input \"" + enteredText + "\"";
+ }
+
+ /**
+ *
+ * Returns the entered text.
+ *
+ *
+ * @return the entered text
+ */
+ public String getEnteredText() {
+ return enteredText;
+ }
+
+ /**
+ *
+ * Returns the events of which this {@link TextInput} consists. The returned list is immutable.
+ *
+ *
+ * @return the textInputEvents
+ */
+ public List getTextInputEvents() {
+ return Collections.unmodifiableList(textInputEvents);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#startsLogicalSequence()
+ */
+ public boolean startsLogicalSequence() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#finishesLogicalSequence()
+ */
+ public boolean finishesLogicalSequence() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ else if (obj instanceof TextInput) {
+ switch (equalityType)
+ {
+ case LEXICAL:
+ return textInputEvents.equals(((TextInput) obj).textInputEvents);
+ case SYNTACTICAL:
+ return enteredText.equals(((TextInput) obj).enteredText);
+ case SEMANTICAL:
+ return true;
+ default:
+ throw new AssertionError("reached source code that should be unreachable");
+ }
+ }
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ int hashCode = getClass().hashCode();
+ if (equalityType == TextEquality.LEXICAL) {
+ hashCode += enteredText.hashCode() + textInputEvents.size();
+ }
+ else if (equalityType == TextEquality.SYNTACTICAL) {
+ hashCode += enteredText.hashCode();
+ }
+ return hashCode;
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/TextInputDetector.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/TextInputDetector.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/TextInputDetector.java (revision 922)
@@ -0,0 +1,330 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Locale;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.eventcore.gui.KeyInteraction;
+import de.ugoe.cs.autoquest.eventcore.gui.KeyPressed;
+import de.ugoe.cs.autoquest.eventcore.gui.KeyReleased;
+import de.ugoe.cs.autoquest.eventcore.gui.TextInput.TextEquality;
+import de.ugoe.cs.autoquest.eventcore.guimodel.ITextArea;
+import de.ugoe.cs.autoquest.eventcore.guimodel.ITextField;
+import de.ugoe.cs.autoquest.keyboardmaps.KeyboardMap;
+import de.ugoe.cs.autoquest.keyboardmaps.KeyboardMapFactory;
+import de.ugoe.cs.autoquest.keyboardmaps.VirtualKey;
+
+/**
+ *
+ * The text input detector iterates a list of events and searches for subsequent key events. Those
+ * are replaced by a single text input event representing the text entered through the key events.
+ * The replacement is only done, if the key events have a text field or text area as target
+ *
+ *
+ * @version $Revision: $ $Date: 18.03.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class TextInputDetector {
+
+ /** the keyboard map to use for character recognition */
+ private KeyboardMap keyboardMap = KeyboardMapFactory.createKeyboardMap(Locale.GERMAN);
+
+ /** the keys pressed in parallel */
+ List pressedKeys = new ArrayList();
+
+ private final TextEquality textEqualityType;
+
+ /**
+ *
+ * Constructor. Creates a new TextInputDectector that generates {@link TextInput} with
+ * {@link TextEquality#LEXICAL} equality.
+ *
+ *
+ */
+ public TextInputDetector() {
+ this(TextEquality.LEXICAL);
+ }
+
+ /**
+ *
+ * Constructor. Creates a new TextInputDectector that generates {@link TextInput} with a given
+ * {@link TextEquality} type.
+ *
+ *
+ * @param textEqualityType
+ * equality type of the generated events
+ */
+ public TextInputDetector(TextEquality textEqualityType) {
+ this.textEqualityType = textEqualityType;
+ }
+
+ /**
+ *
+ * in the provided list of events, this method detects any event sequences that consists of key
+ * interactions and replaces them with a single text input interaction. This contains the
+ * entered text as well as the replaced key interaction events
+ *
+ *
+ * @param sequence
+ * the event sequence to search for text input events
+ *
+ * @return the resulting sequence, in which key interactions on text fields and areas are
+ * reduced to text input interactions
+ */
+ public List detectTextInputs(List sequence) {
+ List resultingSequence = new LinkedList();
+
+ int textEntryStartIndex = -1;
+ IEventTarget lastEventTarget = null;
+
+ int index = 0;
+ Event currentEvent = null;
+ Event textInputEvent = null;
+ while (index < sequence.size()) {
+ currentEvent = sequence.get(index);
+ textInputEvent = null;
+
+ if (isKeyInteraction(currentEvent) && isDataInputEventTarget(currentEvent.getTarget()))
+ {
+ if (textEntryStartIndex < 0) {
+ textEntryStartIndex = index;
+ lastEventTarget = currentEvent.getTarget();
+ }
+ else if (!lastEventTarget.equals(currentEvent.getTarget())) {
+ textInputEvent =
+ handleTextEntrySequence(sequence, textEntryStartIndex, index - 1,
+ lastEventTarget);
+
+ textEntryStartIndex = index;
+ lastEventTarget = currentEvent.getTarget();
+ }
+ currentEvent = null;
+ }
+ else {
+ if (textEntryStartIndex >= 0) {
+ textInputEvent =
+ handleTextEntrySequence(sequence, textEntryStartIndex, index - 1,
+ lastEventTarget);
+
+ textEntryStartIndex = -1;
+ lastEventTarget = null;
+ }
+
+ }
+
+ if (textInputEvent != null) {
+ resultingSequence.add(textInputEvent);
+ }
+
+ if (currentEvent != null) {
+ resultingSequence.add(currentEvent);
+ }
+
+ index++;
+ }
+
+ if (textEntryStartIndex >= 0) {
+ textInputEvent =
+ handleTextEntrySequence(sequence, textEntryStartIndex, sequence.size() - 1,
+ lastEventTarget);
+
+ if (textInputEvent != null) {
+ resultingSequence.add(textInputEvent);
+ }
+ }
+
+ return resultingSequence;
+ }
+
+ /**
+ *
+ * returns true if the provide event is a key interaction; false else
+ *
+ *
+ * @param event
+ * the even to check
+ *
+ * @return as described
+ */
+ private boolean isKeyInteraction(Event event) {
+ return (event.getType() instanceof KeyInteraction);
+ }
+
+ /**
+ *
+ * creates a single text input event as replacement for key interactions being part of the
+ * subsequence of events denoted by the start and end index in the provide event sequence. If no
+ * text was entered, because the subsequence only contained key released events, then no text
+ * input event is generated (the method returns null).
+ *
+ *
+ * @param sequence
+ * the event sequence of which the subsequence is analyzed
+ * @param startIndex
+ * the start index in the event sequence from which the analysis should start
+ * (inclusive)
+ * @param endIndex
+ * the end index in the event sequence where the analysis should end (inclusive)
+ * @param eventTarget
+ * the event target to be used for the new event
+ *
+ * @return a text input event representing the text input resulting from the events of the
+ * provided subsequence
+ *
+ * @throws IllegalArgumentException
+ * if the denoted subsequence contains other events than key interactions
+ */
+ private Event handleTextEntrySequence(List sequence,
+ int startIndex,
+ int endIndex,
+ IEventTarget eventTarget)
+ {
+ List textInputEvents = new ArrayList();
+
+ String enteredText = determineEnteredText(sequence, startIndex, endIndex, textInputEvents);
+
+ if ((enteredText != null) && (!"".equals(enteredText))) {
+ TextInput textInput = new TextInput(enteredText, textInputEvents, textEqualityType);
+ return new Event(textInput, eventTarget);
+ }
+ else {
+ return null;
+ }
+ }
+
+ /**
+ *
+ * check if an event target is a data input field, i.e. a text field or a text area
+ *
+ *
+ * @param eventTarget
+ * the event target to check
+ *
+ * @return true, if it is a text field or a text area ; false else
+ */
+ private boolean isDataInputEventTarget(IEventTarget eventTarget) {
+ return ((eventTarget instanceof ITextField) || (eventTarget instanceof ITextArea));
+ }
+
+ /**
+ *
+ * determines the text entered in the event subsequence denoted by the start and end index of
+ * the provided event sequence. The method records any pressed and released key interaction as
+ * well as combinations of pressed key interactions (such as shift + letter) and determines the
+ * respective character. All identified characters are then combined to the entered text. The
+ * method also identifies the usage of the back space. The enter key is ignored for text fields
+ * in which pressing the enter key results in finishing the text entry. All analyzed key
+ * interaction events are stored in the provided text input events result list. If the
+ * subsequence only contains key released events, no text was entered and the returned text is
+ * null.
+ *
+ *
+ * @param sequence
+ * the event sequence of which the subsequence is analyzed
+ * @param startIndex
+ * the start index in the event sequence from which the analysis should start
+ * (inclusive)
+ * @param endIndex
+ * the end index in the event sequence where the analysis should end (inclusive)
+ * @param textInputEvents
+ * a buffer to contain any key interaction event analyzed (in out)
+ *
+ * @return the text entered through the interaction events of the denoted subsequence
+ *
+ * @throws IllegalArgumentException
+ * if the denoted sequence contains other events than key interactions
+ */
+ private String determineEnteredText(List sequence,
+ int startIndex,
+ int endIndex,
+ List textInputEvents)
+ throws IllegalArgumentException
+ {
+ Event event;
+ StringBuffer enteredText = new StringBuffer();
+
+ for (int i = startIndex; i <= endIndex; i++) {
+ event = sequence.get(i);
+
+ if (event.getType() instanceof KeyPressed || event.getType() instanceof KeyTyped) {
+ VirtualKey key = ((KeyInteraction) event.getType()).getKey();
+
+ pressedKeys.add(key);
+
+ if (key == VirtualKey.BACK_SPACE) {
+ if (enteredText.length() > 0) {
+ enteredText.deleteCharAt(enteredText.length() - 1);
+ }
+ }
+ else if (key == VirtualKey.ENTER) {
+ // text fields only contain one line of code. Therefore the return is ignored.
+ if (!(event.getTarget() instanceof ITextField)) {
+ enteredText.append(getCharacter(key, pressedKeys));
+ }
+ }
+ else {
+ char theChar = getCharacter(key, pressedKeys);
+ if (theChar != Character.UNASSIGNED) {
+ enteredText.append(theChar);
+ }
+ }
+ }
+ else if (event.getType() instanceof KeyReleased || event.getType() instanceof KeyTyped)
+ {
+ pressedKeys.remove(((KeyInteraction) event.getType()).getKey());
+ }
+ else {
+ throw new IllegalArgumentException(
+ "the subsequence denoted by the indexes contains other interactions than "
+ + "just key strokes");
+ }
+
+ textInputEvents.add(event);
+ }
+
+ if (enteredText.length() > 0) {
+ return enteredText.toString();
+ }
+ else {
+ return null;
+ }
+ }
+
+ /**
+ *
+ * determines the character matching the pressed key depending on other keys pressed in parallel
+ * such as the shift key.
+ *
+ *
+ * @param key
+ * the key for which the character shall be determined
+ * @param pressedKeys
+ * the list of other keys pressed in parallel
+ *
+ * @return the character resulting from the combination of pressed keys
+ */
+ private char getCharacter(VirtualKey key, List pressedKeys) {
+ boolean numlock = false;
+ boolean shift = false;
+ boolean altgr = false;
+
+ for (VirtualKey pressedKey : pressedKeys) {
+ if (pressedKey.isShiftKey()) {
+ shift = !shift;
+ }
+ else if (pressedKey == VirtualKey.ALT_GRAPH) {
+ altgr = !altgr;
+ }
+ else if (pressedKey == VirtualKey.NUM_LOCK) {
+ numlock = !numlock;
+ }
+ }
+
+ return keyboardMap.getCharacterFor(key, numlock, shift, altgr, false);
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/TextSelection.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/TextSelection.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/TextSelection.java (revision 922)
@@ -0,0 +1,81 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+/**
+ *
+ * Event type for selecting text.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public class TextSelection implements IInteraction {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#getName()
+ */
+ public String getName() {
+ return "TextSelection";
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return "text selection";
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#startsLogicalSequence()
+ */
+ public boolean startsLogicalSequence() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#finishesLogicalSequence()
+ */
+ public boolean finishesLogicalSequence() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof TextSelection) {
+ return true;
+ }
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return getClass().hashCode();
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/ValueSelection.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/ValueSelection.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/gui/ValueSelection.java (revision 922)
@@ -0,0 +1,115 @@
+
+package de.ugoe.cs.autoquest.eventcore.gui;
+
+/**
+ *
+ * Event type for selecting a value.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public class ValueSelection implements IInteraction {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * The selected value.
+ *
+ */
+ private T selectedValue;
+
+ /**
+ *
+ * Constructor. Creates a new ValueSelection.
+ *
+ *
+ * @param selectedValue
+ * the selected value
+ */
+ public ValueSelection(T selectedValue) {
+ this.selectedValue = selectedValue;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#getName()
+ */
+ public String getName() {
+ return "ValueSelection";
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return "select value";
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#startsLogicalSequence()
+ */
+ public boolean startsLogicalSequence() {
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.attef.userinteraction.Interaction#finishesLogicalSequence()
+ */
+ public boolean finishesLogicalSequence() {
+ return false;
+ }
+
+ /**
+ *
+ * Returns the selected value associated with this event.
+ *
+ *
+ * @return the selectedValue
+ */
+ public T getSelectedValue() {
+ return selectedValue;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if ((obj == null) || (!(obj instanceof ValueSelection))) {
+ return false;
+ }
+
+ ValueSelection otherValueSelection = (ValueSelection) obj;
+
+ return ((otherValueSelection != null) && ((selectedValue == otherValueSelection.selectedValue) || ((selectedValue != null) && (selectedValue
+ .equals(otherValueSelection.selectedValue)))));
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return selectedValue.hashCode();
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/AbstractDefaultGUIElement.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/AbstractDefaultGUIElement.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/AbstractDefaultGUIElement.java (revision 922)
@@ -0,0 +1,268 @@
+
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+import java.util.IdentityHashMap;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ *
+ * Skeletal implementation for GUI elements.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public abstract class AbstractDefaultGUIElement implements IGUIElement {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ public static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * The reference to equal GUI element manager (needed to preserve singleton behavior, even
+ * though the objects are not singleton).
+ *
+ */
+ private static final EqualGUIElementManager equalGUIElementManager =
+ new EqualGUIElementManager();
+
+ /**
+ *
+ * Specification of the GUI element
+ *
+ */
+ private final IGUIElementSpec specification;
+
+ /**
+ *
+ * Reference to the parent element
+ *
+ */
+ private final IGUIElement parent;
+
+ /**
+ *
+ * Constructor. Creates a new AbstractDefaultGUIElement.
+ *
+ *
+ * @param specification
+ * specification of the created GUI element
+ * @param parent
+ * parent of the created GUI element; null means the element is a top-level window
+ */
+ public AbstractDefaultGUIElement(IGUIElementSpec specification, IGUIElement parent) {
+ this.specification = specification;
+ this.parent = parent;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.guimodel.GUIElement#getSpecification()
+ */
+ @Override
+ public IGUIElementSpec getSpecification() {
+ return specification;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement#getParent()
+ */
+ @Override
+ public IGUIElement getParent() {
+ return parent;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement#addEqualGUIElement(IGUIElement)
+ */
+ @Override
+ public void addEqualGUIElement(IGUIElement equalElement) {
+ equalGUIElementManager.addEqualGUIElements(this, equalElement);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see GUIElement#equals(GUIElement)
+ */
+ public final boolean equals(Object other) {
+ // implement final, as GUI elements are all singletons and they equal only if they are the
+ // same object or if they are in the list of equal GUI elements
+ return super.equals(other) || equalGUIElementManager.equals(this, other);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public final int hashCode() {
+ // implement final, as GUI elements are all singletons and they equal only if they are the
+ // same object. If there are several GUI element objects that represent the same GUI element
+ // then they are stored in the list of equal elements. In this case, the hash code of the
+ // list is unique within the system
+ return equalGUIElementManager.hashCode(this);
+ }
+
+ /**
+ *
+ * This internal helper class manages equal GUI elements. This is necessary, as we often first
+ * identify many GUI elements as different and later use a heuristic to determine that they are
+ * the same. This class provides the means to preserve the singleton behavior of the GUI
+ * elements after we merge two GUI elements.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+ private static class EqualGUIElementManager {
+
+ /**
+ *
+ * The internal map of GUI elements mapping each registered element to its equal variants.
+ * We use the {@link IdentityHashMap} as a normal hash map would not work because of the
+ * changing of the hash code of GUI elements at runtime.
+ *
+ */
+ private IdentityHashMap> identityHashMap =
+ new IdentityHashMap>();
+
+ /**
+ *
+ * Adds a new equals relationship between two {@link IGUIElement}s to the equality manager.
+ *
+ *
+ * @param guiElement1
+ * first equal GUI element
+ * @param guiElement2
+ * second equal GUI element
+ */
+ private synchronized void addEqualGUIElements(IGUIElement guiElement1,
+ IGUIElement guiElement2)
+ {
+ List list1 = identityHashMap.get(guiElement1);
+ List list2 = identityHashMap.get(guiElement2);
+
+ if (list1 == null) {
+ if (list2 == null) {
+ list2 = new LinkedList();
+ list2.add(guiElement1);
+ list2.add(guiElement2);
+ identityHashMap.put(guiElement1, list2);
+ identityHashMap.put(guiElement2, list2);
+ }
+ else {
+ addIfNotContained(list2, guiElement1);
+ identityHashMap.put(guiElement1, list2);
+ }
+ }
+ else {
+ if (list2 == null) {
+ addIfNotContained(list1, guiElement2);
+ identityHashMap.put(guiElement2, list1);
+ }
+ else if (list1 != list2) {
+ list1.addAll(list2);
+ identityHashMap.put(guiElement2, list1);
+ }
+ // else
+ // in this case, both GUI elements should already be registered with the same
+ // lists.
+ }
+ }
+
+ /**
+ *
+ * Returns the object hash of a {@link IGUIElement}.
+ *
+ *
+ * @param guiElement
+ * gui element whose object hash is determined
+ * @return the object hash
+ */
+ private synchronized int hashCode(IGUIElement guiElement) {
+ return System.identityHashCode(getEqualElementsList(guiElement));
+ }
+
+ /**
+ *
+ * Determines the equality of two {@link IGUIElement}s based on the information of the
+ * identify manager. Two elements are equal, if they have been added as equal using
+ * {@link #addEqualGUIElements(IGUIElement, IGUIElement)}.
+ *
+ *
+ * @param guiElement
+ * GUI element to which the object is compared
+ * @param other
+ * object that is compared to the GUI element
+ * @return
+ */
+ private synchronized boolean equals(IGUIElement guiElement, Object other) {
+ if (other instanceof IGUIElement) {
+ for (IGUIElement candidate : getEqualElementsList(guiElement)) {
+ if (candidate == other) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ *
+ * Returns the equal {@link IGUIElement} of a given {@link IGUIElement}.
+ *
+ *
+ * @param guiElement
+ * GUI element of which the equal elements are returned
+ * @return the equal GUI elements
+ */
+ private List getEqualElementsList(IGUIElement guiElement) {
+ List returnValue = identityHashMap.get(guiElement);
+
+ if (returnValue == null) {
+ returnValue = new LinkedList();
+ returnValue.add(guiElement);
+ identityHashMap.put(guiElement, returnValue);
+ }
+
+ return returnValue;
+ }
+
+ /**
+ *
+ * Adds {@link IGUIElement} as equal to a list of {@link IGUIElement} if and only if it is
+ * not already contained.
+ *
+ *
+ * @param equalElementsList
+ * list of {@link IGUIElement} to which the GUI element is added
+ * @param guiElement
+ * GUI element to be added
+ */
+ private void addIfNotContained(List equalElementsList, IGUIElement guiElement)
+ {
+ for (IGUIElement candidate : equalElementsList) {
+ if (candidate == guiElement) {
+ return;
+ }
+ }
+
+ equalElementsList.add(guiElement);
+ }
+
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/GUIElementFactory.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/GUIElementFactory.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/GUIElementFactory.java (revision 922)
@@ -0,0 +1,262 @@
+
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Properties;
+import java.util.logging.Level;
+
+import de.ugoe.cs.util.console.Console;
+
+/**
+ *
+ * Creates {@link IGUIElement}s from a given specification. Implemented as singleton.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public class GUIElementFactory implements IGUIElementFactory {
+
+ /**
+ *
+ * Instance of the class (singleton)
+ *
+ */
+ private static GUIElementFactory instance = new GUIElementFactory();
+
+ /**
+ *
+ * Constructor. Creates a new GUIElementFactory. Private to preserve singleton property.
+ *
+ */
+ private GUIElementFactory() {}
+
+ /**
+ *
+ * Returns the instance of this class.
+ *
+ *
+ * @return the instance
+ */
+ public static synchronized GUIElementFactory getInstance() {
+ return instance;
+ }
+
+ /**
+ *
+ * A property mapping that defines to which Java class is created given the type of the GUI
+ * element found in the specification.
+ *
+ */
+ private Properties mappingsFromConfiguration;
+
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElementFactory#instantiateGUIElement(de.ugoe.cs.autoquest
+ * .eventcore.guimodel.IGUIElementSpec, de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement)
+ */
+ @Override
+ public IGUIElement instantiateGUIElement(IGUIElementSpec specification, IGUIElement parent)
+ throws GUIModelConfigurationException
+ {
+ Properties mappings = getMappingsFromConfiguration();
+ IGUIElement guiElement = null;
+
+ String className = mappings.getProperty(specification.getType());
+ if (className != null) {
+ try {
+ Class clazz = this.getClass().getClassLoader().loadClass(className);
+
+ if (!IGUIElement.class.isAssignableFrom(clazz)) {
+ Console.traceln(Level.WARNING, "configured GUI element representing class " +
+ className + " is no valid GUIElement derivate.");
+
+ return null;
+ }
+
+ Constructor constructor = null;
+ Class parentClass = (parent == null) ? null : parent.getClass();
+
+ // search for a constructor, that perfectly matches the types
+ for (Constructor candidate : clazz.getConstructors()) {
+ if ((parentClass != null) && (candidate.getParameterTypes().length == 2) &&
+ (candidate.getParameterTypes()[0].equals(specification.getClass())) &&
+ (candidate.getParameterTypes()[1].equals(parentClass)))
+ {
+ constructor = candidate;
+ break;
+ }
+ else if (parentClass == null) {
+ if ((candidate.getParameterTypes().length >= 1) &&
+ (candidate.getParameterTypes()[0].equals(specification.getClass())))
+ {
+ constructor = candidate;
+ break;
+ }
+ }
+ }
+
+ if (constructor == null) {
+ // search for an assignable constructor
+ for (Constructor candidate : clazz.getConstructors()) {
+ if ((candidate.getParameterTypes().length == 2) &&
+ (candidate.getParameterTypes()[0].isInstance(specification)) &&
+ (candidate.getParameterTypes()[1].isInstance(parent)))
+ {
+ constructor = candidate;
+ break;
+ }
+ }
+
+ }
+
+ if (constructor != null) {
+ guiElement = (IGUIElement) constructor.newInstance(specification, parent);
+ }
+ else {
+ throw new NoSuchMethodException
+ ("no constructor with two parameters and assignable parameter types for " +
+ specification.getClass() + " and " +
+ (parent != null ? parent.getClass() : "null") + " found in class " +
+ clazz);
+ }
+
+ }
+ catch (ClassNotFoundException e) {
+ Console.traceln(Level.WARNING, "configured GUI element representing class " +
+ className + " can not be loaded.");
+ throw new GUIModelConfigurationException
+ ("configured GUI element representing class " + className +
+ " can not be loaded.", e);
+ }
+ catch (SecurityException e) {
+ Console.traceln(Level.WARNING, "configured GUI element representing class " +
+ className + " can not be instantiated due to security reasons.");
+ throw new GUIModelConfigurationException
+ ("configured GUI element representing class " + className +
+ " can not be instantiated due to security reasons.", e);
+ }
+ catch (NoSuchMethodException e) {
+ Console.traceln(Level.WARNING, "configured GUI element representing class " +
+ className + " does not provide an appropriate constructor.");
+ throw new GUIModelConfigurationException
+ ("configured GUI element representing class " + className +
+ " does not provide an appropriate constructor.", e);
+ }
+ catch (IllegalArgumentException e) {
+ Console.traceln(Level.WARNING, "configured GUI element representing class " +
+ className + " does not provide an appropriate constructor " +
+ "accepting the provided parameters.");
+ throw new GUIModelConfigurationException
+ ("configured GUI element representing class " + className + " does not " +
+ "provide an appropriate constructor accepting the provided parameters.", e);
+ }
+ catch (InstantiationException e) {
+ Console.traceln(Level.WARNING, "configured GUI element representing class " +
+ className + " can not be instantiated.");
+ throw new GUIModelConfigurationException
+ ("configured GUI element representing class " + className +
+ " can not be instantiated.", e);
+ }
+ catch (IllegalAccessException e) {
+ Console.traceln(Level.WARNING, "configured GUI element representing class " +
+ className + " can not be instantiated.");
+ throw new GUIModelConfigurationException
+ ("configured GUI element representing class " + className +
+ " can not be instantiated.", e);
+ }
+ catch (InvocationTargetException e) {
+ Console.traceln(Level.WARNING, "configured GUI element representing class " +
+ className + " can not be instantiated.");
+ throw new GUIModelConfigurationException
+ ("configured GUI element representing class " + className +
+ " can not be instantiated.", e);
+ }
+ }
+
+ if (guiElement == null ) {
+ Console.traceln(Level.WARNING, "no class representing GUI elements of type " +
+ specification.getType() + " found. Please extend GUI element " +
+ "mapping files.");
+ throw new GUIModelConfigurationException
+ ("no class representing GUI elements of type " + specification.getType() +
+ " found. Please extend GUI element mapping files");
+ }
+
+ return guiElement;
+ }
+
+ /**
+ *
+ * Loads the mappings for GUI elements. All files that start with "guimapping", end
+ * with ".txt", and are located in the folter "data/guimappings" (relative
+ * to the working directory) are loaded.
+ *
+ *
+ * @return loaded GUI mappings
+ */
+ private synchronized Properties getMappingsFromConfiguration()
+ throws GUIModelConfigurationException
+ {
+ if (mappingsFromConfiguration != null) {
+ return mappingsFromConfiguration;
+ }
+ else {
+ mappingsFromConfiguration = new Properties();
+
+ File mappingsFolder = new File("data/guimappings");
+ File[] children = mappingsFolder.listFiles();
+
+ if (children != null) {
+ for (File mappingsFile : children) {
+ if (!mappingsFile.isDirectory() &&
+ mappingsFile.getName().startsWith("guimapping") &&
+ mappingsFile.getName().endsWith(".txt"))
+ {
+ InputStream inStream = null;
+ try {
+ inStream = new FileInputStream(mappingsFile);
+ mappingsFromConfiguration.load(inStream);
+ }
+ catch (FileNotFoundException e) {
+ throw new GUIModelConfigurationException(
+ "could not read mapping configuration file " +
+ mappingsFile, e);
+ }
+ catch (IOException e) {
+ throw new GUIModelConfigurationException(
+ "could not read mapping configuration file " +
+ mappingsFile, e);
+ }
+ finally {
+ if (inStream != null) {
+ try {
+ inStream.close();
+ }
+ catch (IOException e) {
+ // ignore
+ }
+ }
+ }
+ }
+ }
+ }
+ else {
+ throw new GUIModelConfigurationException(
+ "no GUI mappings file provided in folder " +
+ mappingsFolder);
+ }
+
+ return mappingsFromConfiguration;
+ }
+ }
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/GUIModel.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/GUIModel.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/GUIModel.java (revision 922)
@@ -0,0 +1,585 @@
+
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.logging.Level;
+
+import de.ugoe.cs.util.console.Console;
+
+/**
+ *
+ * A GUI model is a tree of {@link IGUIElements} and represents a complete GUI of a software. It is
+ * platform independent. It may have several root nodes, as some GUIs are made up of several Frames
+ * being independent from each other. The GUI model is filled using the
+ * {@link #integratePath(List, IGUIElementFactory)} method.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms, Steffen Herbold
+ */
+public class GUIModel {
+
+ /**
+ *
+ * The root node of the tree not provided externally.
+ *
+ */
+ private TreeNode root = new TreeNode();
+
+ /**
+ *
+ * A list with all nodes currently known
+ *
+ */
+ private List allNodes = new ArrayList();
+
+ /**
+ *
+ * Integrates a path of GUI elements into the GUI model. The GUI model itself is a tree and
+ * therefore a set of different paths through the tree that start with a root node and end with
+ * a leaf node. Such a path can be added to the tree. The method checks, if any of the GUI
+ * elements denoted by the path already exists. If so, it reuses it. It may therefore also
+ * return an existing GUI element being the leaf node of the provided path. If a GUI element of
+ * the path does not exist yet, it creates a new one using the provided GUI element factory.
+ *
+ *
+ * If a GUI element specification describes an existing GUI element or not is determined through
+ * comparing the GUI element specifications of the existing GUI elements with the ones provided
+ * in the path. The comparison is done using the
+ * {@link IGUIElementSpec#getSimilarity(IGUIElementSpec)} method. The comparison is only done on
+ * the correct levels. I.e. the currently known root elements of the tree are only compared to
+ * the first element in the path. If the correct one is found or created, its children are
+ * compared only to the second specification in the path, and so on.
+ *
+ *
+ * The returned GUI elements are singletons. I.e. it is tried to return always the identical
+ * object for the same denoted element. However, while creating the GUI model, the similarity of
+ * GUI elements may change. Therefore, the method might determine, that two formerly different
+ * nodes are now similar. (This may happen, e.g. if GUI elements do not have initial names which
+ * are set afterwards. Therefore, first they are handled differently and later they can be
+ * identified as being the same.) In such a case, there are already several GUI element objects
+ * instantiated for the same GUI element. The singleton paradigm gets broken. Therefore, such
+ * GUI element objects are registered with each other, so that their equal method can determine
+ * equality again correctly, although the objects are no singletons anymore.
+ *
+ *
+ * @param guiElementPath
+ * the path to integrate into the model
+ * @param guiElementFactory
+ * the GUI element factory to be used for instantiating GUI element objects
+ *
+ * @return The GUI element object representing the GUI element denoted by the provided path
+ *
+ * @throws GUIModelException
+ * thrown in cases such as the GUI element object could not be instantiated
+ * @throws IllegalArgumentException
+ * if the provided path is invalid.
+ */
+ public IGUIElement integratePath(List guiElementPath,
+ IGUIElementFactory guiElementFactory)
+ throws GUIModelException, IllegalArgumentException
+ {
+ if ((guiElementPath == null) || (guiElementPath.size() <= 0)) {
+ throw new IllegalArgumentException("GUI element path must contain at least one element");
+ }
+
+ List remainingPath = new LinkedList();
+
+ for (IGUIElementSpec spec : guiElementPath) {
+ remainingPath.add(spec);
+ }
+
+ return integratePath(root, remainingPath, guiElementFactory);
+ }
+
+ /**
+ *
+ * Returns all children of the provided GUI element or null, if it does not have any or the node
+ * is unknown.
+ *
+ *
+ * @param guiElement
+ * the GUI element of which the children shall be returned
+ *
+ * @return As described
+ */
+ public List getChildren(IGUIElement guiElement) {
+ List result = null;
+ for (TreeNode node : allNodes) {
+ if (node.guiElement.equals(guiElement)) {
+ if (result == null) {
+ result = new ArrayList();
+
+ if (node.children != null) {
+ for (TreeNode child : node.children) {
+ result.add(child.guiElement);
+ }
+ }
+ }
+ else {
+ Console
+ .traceln(Level.SEVERE,
+ "Multiple nodes in the internal GUI model match the same GUI element. "
+ + "This should not be the case and the GUI model is probably invalid.");
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * Returns the parent GUI element of the provided GUI element or null, if it does not have a
+ * parent (i.e. if it is a root node) or if the node is unknown.
+ *
+ *
+ * @param guiElement
+ * the GUI element of which the parent shall be returned
+ *
+ * @return As described
+ */
+ public IGUIElement getParent(IGUIElement guiElement) {
+ IGUIElement parent = null;
+
+ for (TreeNode node : allNodes) {
+ for (TreeNode child : node.children) {
+ if (child.guiElement.equals(guiElement)) {
+ if (parent != null) {
+ parent = node.guiElement;
+ }
+ else {
+ Console
+ .traceln(Level.SEVERE,
+ "Multiple nodes in the internal GUI model match the same GUI element. "
+ + "This should not be the case and the GUI model is probably invalid.");
+ }
+ }
+ }
+ }
+
+ return parent;
+ }
+
+ /**
+ *
+ * Returns all root GUI elements of the model or an empty list, if the model is empty
+ *
+ *
+ * @return As described
+ */
+ public List getRootElements() {
+ List roots = new ArrayList();
+
+ if (root.children != null) {
+ for (TreeNode rootChild : root.children) {
+ roots.add(rootChild.guiElement);
+ }
+ }
+
+ return roots;
+ }
+
+ /**
+ *
+ * dumps the GUI model to the provided stream. Each node is represented through its toString()
+ * method. If a node has children, those are dumped indented and surrounded by braces.
+ *
+ *
+ * @param out
+ * The stream to dump the textual representation of the model to
+ * @param encoding
+ * The encoding to be used while dumping
+ */
+ public void dump(OutputStream out, String encoding) {
+ PrintStream stream;
+
+ if (out instanceof PrintStream) {
+ stream = (PrintStream) out;
+ }
+ else {
+ String enc = encoding == null ? "UTF-8" : encoding;
+ try {
+ stream = new PrintStream(out, true, enc);
+ }
+ catch (UnsupportedEncodingException e) {
+ throw new IllegalArgumentException("encodind " + enc + " not supported");
+ }
+ }
+
+ for (IGUIElement root : getRootElements()) {
+ dumpGUIElement(stream, root, "");
+ }
+ }
+
+ /**
+ *
+ * By calling this method, the GUIModel is traversed and similar nodes are merged.
+ *
+ *
+ */
+ public void condenseModel() {
+ mergeSubTree(root);
+ }
+
+ /**
+ *
+ * Merges the tree nodes of two GUI elements. The GUI elements need to have the same parent.
+ *
+ *
+ * @param guiElement1
+ * the first merge GUI element
+ * @param guiElement2
+ * the second merge GUI element
+ * @throws IllegalArgumentException
+ * thrown if the two GUI elements do not have the same parent
+ */
+ public void mergeGUIElements(IGUIElement guiElement1, IGUIElement guiElement2)
+ throws IllegalArgumentException
+ {
+ // check if both nodes have the same parent
+ IGUIElement parentElement = guiElement1.getParent();
+ if (parentElement != null && !parentElement.equals(guiElement2.getParent())) {
+ throw new IllegalArgumentException("can only merge nodes with the same parent");
+ }
+
+ // get the TreeNode of the parent of the GUI elements
+ TreeNode parent = findNode(parentElement);
+
+ // get the TreeNodes for both GUI elements
+ TreeNode node1 = findNode(guiElement1);
+ TreeNode node2 = findNode(guiElement2);
+
+ if (node1 == null || node2 == null) {
+ throw new IllegalArgumentException(
+ "Error while merging nodes: one element is not part of the GUI model!");
+ }
+
+ TreeNode replacement = mergeTreeNodes(node1, node2);
+
+ if (parent != null) {
+ // remove node1 and node2 from the parent's children and add the replacement instead
+ // assumes that there are no duplicates of node1 and node2
+ if (parent.children != null) {
+ parent.children.set(parent.children.indexOf(node1), replacement);
+ parent.children.remove(node2);
+ }
+ }
+
+ }
+
+ /**
+ *
+ * internally integrates a path as the children of the provided parent node. This method is
+ * recursive and calls itself, for the child of the parent node, that matches the first element
+ * in the remaining path.
+ *
+ *
+ * @param parentNode
+ * the parent node to add children for
+ * @param guiElementPath
+ * the path of children to be created starting with the parent node
+ * @param guiElementFactory
+ * the GUI element factory to be used for instantiating GUI element objects
+ *
+ * @return The GUI element object representing the GUI element denoted by the provided path
+ *
+ * @throws GUIModelException
+ * thrown in cases such as the GUI element object could not be instantiated
+ */
+ private IGUIElement integratePath(TreeNode parentNode,
+ List remainingPath,
+ IGUIElementFactory guiElementFactory)
+ throws GUIModelException
+ {
+ IGUIElementSpec specToIntegrateElementFor = remainingPath.remove(0);
+
+ TreeNode child = findEqualChild(parentNode, specToIntegrateElementFor);
+ if (child == null) {
+ IGUIElement newElement =
+ guiElementFactory.instantiateGUIElement(specToIntegrateElementFor,
+ parentNode.guiElement);
+
+ child = parentNode.addChild(newElement);
+ }
+
+ if (remainingPath.size() > 0) {
+ return integratePath(child, remainingPath, guiElementFactory);
+ }
+ else {
+ return child.guiElement;
+ }
+ }
+
+ /**
+ *
+ * Searches the children of a tree node to see if the {@link IGUIElementSpec} of equals the
+ * specification of the {@link TreeNode#guiElement} of the child. If a match is found, the child
+ * is returned.
+ *
+ *
+ * @param parentNode
+ * parent node whose children are searched
+ * @param specToMatch
+ * specification that is searched for
+ * @return matching child node or null if no child matches
+ */
+ private TreeNode findEqualChild(TreeNode parentNode, IGUIElementSpec specToMatch) {
+ if (parentNode.children != null) {
+ for (TreeNode child : parentNode.children) {
+ if (specToMatch.equals(child.guiElement.getSpecification())) {
+ return child;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ *
+ * Merges all similar nodes in the sub-tree of the GUI model defined by the subTreeRoot.
+ *
+ *
+ * The merging order is a bottom-up. This means, that we first call mergeSubTree recursively for
+ * the grand children of the subTreeRoot, before we merge subTreeRoot.
+ *
+ *
+ * The merging strategy is top-down. This means, that every time we merge two child nodes, we
+ * call mergeSubTree recursively for all children of the merged nodes in order to check if we
+ * can merge the children, too.
+ *
+ *
+ * @param subTreeRoot
+ * root node of the sub-tree that is merged
+ */
+ private void mergeSubTree(TreeNode subTreeRoot) {
+ if (subTreeRoot.children == null || subTreeRoot.children.isEmpty()) {
+ return;
+ }
+
+ // lets first merge the grand children of the parentNode
+ for (TreeNode child : subTreeRoot.children) {
+ mergeSubTree(child);
+ }
+
+ boolean performedMerge;
+
+ do {
+ performedMerge = false;
+ for (int i = 0; !performedMerge && i < subTreeRoot.children.size(); i++) {
+ IGUIElementSpec elemSpec1 =
+ subTreeRoot.children.get(i).guiElement.getSpecification();
+ for (int j = i + 1; !performedMerge && j < subTreeRoot.children.size(); j++) {
+ IGUIElementSpec elemSpec2 =
+ subTreeRoot.children.get(j).guiElement.getSpecification();
+ if (elemSpec1.getSimilarity(elemSpec2)) {
+ TreeNode replacement =
+ mergeTreeNodes(subTreeRoot.children.get(i), subTreeRoot.children.get(j));
+
+ subTreeRoot.children.set(i, replacement);
+ subTreeRoot.children.remove(j);
+ performedMerge = true;
+ i--;
+ break;
+ }
+ }
+ }
+ }
+ while (performedMerge);
+ }
+
+ /**
+ *
+ * merges two nodes with each other. Merging means registering the GUI element objects with each
+ * other for equality checks. Further it add all children of both nodes to a new replacing node.
+ * Afterwards, all similar nodes of the replacement node are merged as well.
+ *
+ *
+ * @param treeNode1
+ * the first of the two nodes to be merged
+ * @param treeNode2
+ * the second of the two nodes to be merged
+ * @return a tree node being the merge of the two provided nodes.
+ */
+ private TreeNode mergeTreeNodes(TreeNode treeNode1, TreeNode treeNode2) {
+ // the following two lines are needed to preserve the references to the existing GUI
+ // elements. If two elements are the same, one should be deleted to make the elements
+ // singletons again. However, there may exist references to both objects. To preserve
+ // these, we simply register the equal GUI elements with each other so that an equals
+ // check can return true.
+ treeNode1.guiElement.addEqualGUIElement(treeNode2.guiElement);
+ treeNode2.guiElement.addEqualGUIElement(treeNode1.guiElement);
+
+ // and now a replacement node that is the merge of treeNode1 and treeNode2 is created
+ TreeNode replacement = new TreeNode();
+ replacement.guiElement = treeNode1.guiElement;
+ if (treeNode1.children != null) {
+ for (TreeNode child : treeNode1.children) {
+ replacement.addChildNode(child);
+ }
+ }
+ if (treeNode2.children != null) {
+ for (TreeNode child : treeNode2.children) {
+ replacement.addChildNode(child);
+ }
+ }
+
+ mergeSubTree(replacement);
+
+ replacement.guiElement.updateSpecification(treeNode2.guiElement.getSpecification());
+
+ // finally, update the known nodes list
+ // if you don't do this getChildren will return wrong things and very bad things happen!
+ allNodes.remove(treeNode1);
+ allNodes.remove(treeNode2);
+ allNodes.add(replacement);
+
+ return replacement;
+ }
+
+ /**
+ *
+ * dumps a GUI element to the stream. A dump contains the toString() representation of the GUI
+ * element as well as a indented list of its children surrounded by braces.
+ *
+ *
+ * @param out
+ * {@link PrintStream} where the guiElement is dumped to
+ * @param guiElement
+ * the guiElement whos string represenation is dumped
+ * @param indent
+ * indent string of the dumping
+ */
+ private void dumpGUIElement(PrintStream out, IGUIElement guiElement, String indent) {
+ out.print(indent);
+ out.print(guiElement);
+
+ List children = getChildren(guiElement);
+
+ if ((children != null) && (children.size() > 0)) {
+ out.println(" {");
+
+ for (IGUIElement child : children) {
+ dumpGUIElement(out, child, indent + " ");
+ }
+
+ out.print(indent);
+ out.print("}");
+ }
+
+ out.println();
+ }
+
+ /**
+ *
+ * Retrieves the TreeNode associated with a GUI element. Returns null if no such TreeNode is
+ * found.
+ *
+ *
+ * @param element
+ * the GUI element
+ * @return associated TreeNode; null if no such node exists
+ */
+ private TreeNode findNode(IGUIElement element) {
+ if (element == null) {
+ return null;
+ }
+
+ TreeNode result = null;
+ for (TreeNode node : allNodes) {
+ if (node.guiElement.equals(element)) {
+ if (result == null) {
+ result = node;
+ }
+ else {
+ Console
+ .traceln(Level.SEVERE,
+ "Multiple nodes in the internal GUI model match the same GUI element. "
+ + "This should not be the case and the GUI model is probably invalid.");
+ }
+ }
+ }
+ return result;
+ }
+
+ /**
+ *
+ * Used internally for building up the tree of GUI elements.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms, Steffen Herbold
+ */
+ private class TreeNode {
+
+ /**
+ *
+ * GUI element associated with the TreeNode.
+ *
+ */
+ private IGUIElement guiElement;
+
+ /**
+ *
+ * Children of the TreeNode.
+ *
+ */
+ private List children;
+
+ /**
+ *
+ * Adds a child to the current node while keeping all lists of nodes up to date
+ *
+ *
+ * @param guiElement
+ * GUI element that will be associated with the new child
+ * @return the added child
+ */
+ private TreeNode addChild(IGUIElement guiElement) {
+ if (children == null) {
+ children = new ArrayList();
+ }
+
+ TreeNode child = new TreeNode();
+ child.guiElement = guiElement;
+ children.add(child);
+
+ allNodes.add(child);
+
+ return child;
+ }
+
+ /**
+ *
+ *
+ * Adds a TreeNode as child to the current node. This way, the whole sub-tree is added.
+ *
+ *
+ * @param node
+ * child node that is added
+ * @return node that has been added
+ */
+ private TreeNode addChildNode(TreeNode node) {
+ if (children == null) {
+ children = new ArrayList();
+ }
+ children.add(node);
+ return node;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return guiElement.toString();
+ }
+ }
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/GUIModelConfigurationException.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/GUIModelConfigurationException.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/GUIModelConfigurationException.java (revision 922)
@@ -0,0 +1,69 @@
+
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Exception that is thrown if there is a failure during the creation of a {@link IGUIElement} by
+ * the {@link GUIElementFactory}.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public class GUIModelConfigurationException extends GUIModelException {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Constructor. Creates a new GUIModelConfigurationException.
+ *
+ */
+ public GUIModelConfigurationException() {
+ super();
+ }
+
+ /**
+ *
+ * Constructor. Creates a new GUIModelConfigurationException.
+ *
+ *
+ * @param message
+ * message of the exception
+ */
+ public GUIModelConfigurationException(String message) {
+ super(message);
+ }
+
+ /**
+ *
+ * Constructor. Creates a new GUIModelConfigurationException.
+ *
+ *
+ * @param cause
+ * cause of the exception
+ */
+ public GUIModelConfigurationException(Throwable cause) {
+ super(cause);
+ }
+
+ /**
+ *
+ * Constructor. Creates a new GUIModelConfigurationException.
+ *
+ *
+ * @param message
+ * message of the exception
+ * @param cause
+ * cause of the exception
+ */
+ public GUIModelConfigurationException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/GUIModelException.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/GUIModelException.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/GUIModelException.java (revision 922)
@@ -0,0 +1,68 @@
+
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Exception that is thrown if there are problems with the {@link GUIModel}.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public class GUIModelException extends Exception {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Constructor. Creates a new GUIModelException.
+ *
+ */
+ public GUIModelException() {
+ super();
+ }
+
+ /**
+ *
+ * Constructor. Creates a new GUIModelException.
+ *
+ *
+ * @param message
+ * message of the exception
+ */
+ public GUIModelException(String message) {
+ super(message);
+ }
+
+ /**
+ *
+ * Constructor. Creates a new GUIModelException.
+ *
+ *
+ * @param cause
+ * cause of the exception
+ */
+ public GUIModelException(Throwable cause) {
+ super(cause);
+ }
+
+ /**
+ *
+ * Constructor. Creates a new GUIModelException.
+ *
+ *
+ * @param message
+ * message of the exception
+ * @param cause
+ * cause of the exception
+ */
+ public GUIModelException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IButton.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IButton.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IButton.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a button
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IButton extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ICanvas.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ICanvas.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ICanvas.java (revision 922)
@@ -0,0 +1,14 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a canvas, i.e. something to display data or
+ * media
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface ICanvas extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ICheckBox.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ICheckBox.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ICheckBox.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a check box
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface ICheckBox extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IComboBox.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IComboBox.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IComboBox.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a combo box
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IComboBox extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IDialog.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IDialog.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IDialog.java (revision 922)
@@ -0,0 +1,14 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a dialog
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IDialog extends IGUIElement
+{
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IFrame.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IFrame.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IFrame.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a frame or window
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IFrame extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IGUIElement.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IGUIElement.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IGUIElement.java (revision 922)
@@ -0,0 +1,75 @@
+
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+
+/**
+ *
+ * Common interface for all GUI elements.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IGUIElement extends IEventTarget {
+
+ /**
+ *
+ * Returns the specification of the GUI element.
+ *
+ *
+ * @return the specification
+ */
+ public IGUIElementSpec getSpecification();
+
+ /**
+ *
+ * Returns the parent of the GUI element.
+ *
+ *
+ * @return the parent
+ */
+ public IGUIElement getParent();
+
+ /**
+ *
+ * Defines that {@link IGUIElement} implementations have to define equals.
+ *
+ *
+ * @see Object#equals(Object)
+ */
+ @Override
+ public boolean equals(Object other);
+
+ /**
+ *
+ * Defines that {@link IGUIElement} implementations have to define hashCode.
+ *
+ *
+ * @see Object#hashCode()
+ */
+ @Override
+ public int hashCode();
+
+ /**
+ *
+ * Updates the specification of a GUI element with another specification, e.g., to add further
+ * known names of the GUI element.
+ *
+ *
+ * @param furtherSpec
+ * additional specification
+ */
+ public void updateSpecification(IGUIElementSpec furtherSpec);
+
+ /**
+ *
+ * The {@link IGUIElement} that is passed by this function is equal to the current GUI element
+ * and will hereafter be treated as such.
+ *
+ *
+ * @param guiElement
+ * GUI element that is equal
+ */
+ public void addEqualGUIElement(IGUIElement equalElement);
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IGUIElementFactory.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IGUIElementFactory.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IGUIElementFactory.java (revision 922)
@@ -0,0 +1,29 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Common interface for GUI element factories.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IGUIElementFactory {
+
+ /**
+ *
+ * Instantiates a new {@link IGUIElement} from a given specification.
+ *
+ *
+ * @param specification
+ * specification of the new GUI element
+ * @param parent
+ * parent of the new GUI element
+ * @return created GUI element
+ * @throws GUIModelConfigurationException
+ * thrown if there is a problem during the creation of the GUI element
+ */
+ public IGUIElement instantiateGUIElement(IGUIElementSpec specification, IGUIElement parent)
+ throws GUIModelConfigurationException;
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IGUIElementSpec.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IGUIElementSpec.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IGUIElementSpec.java (revision 922)
@@ -0,0 +1,56 @@
+
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+import java.io.Serializable;
+
+/**
+ *
+ * Common interface for GUI element specifications.
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IGUIElementSpec extends Serializable {
+
+ /**
+ *
+ * Returns a string represenation of the GUI element type that this specification represents.
+ *
+ *
+ * @return
+ */
+ public String getType();
+
+ /**
+ *
+ * Evaluates if two GUI specifications are similar. Similar means that a heuristic determines
+ * that the two GUI specifications describe the same GUI element.
+ *
+ *
+ * @param other
+ * specification whose similarity to this is evaluated
+ * @return true if the specifications are similar; false otherwise
+ */
+ public boolean getSimilarity(IGUIElementSpec other);
+
+ /**
+ *
+ * Defines that {@link IGUIElement} implementations have to define equals.
+ *
+ *
+ * @see Object#equals(Object)
+ */
+ @Override
+ public boolean equals(Object other);
+
+ /**
+ *
+ * Defines that {@link IGUIElement} implementations have to define hashCode.
+ *
+ *
+ * @see Object#hashCode()
+ */
+ @Override
+ public int hashCode();
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IListBox.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IListBox.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IListBox.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a list or list box
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IListBox extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IMenu.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IMenu.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IMenu.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a menu
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IMenu extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IMenuBar.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IMenuBar.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IMenuBar.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a menu bar
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IMenuBar extends IMenu {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IMenuButton.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IMenuButton.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IMenuButton.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a button in a menu
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IMenuButton extends IButton {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IPanel.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IPanel.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IPanel.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a panel for structuring GUI content
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IPanel extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IRadioButton.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IRadioButton.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IRadioButton.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a radio button
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IRadioButton extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IScrollBar.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IScrollBar.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IScrollBar.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a scroll bar of a scroll pane
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IScrollBar extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IScrollPane.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IScrollPane.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IScrollPane.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a scroll pane
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IScrollPane extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IShape.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IShape.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IShape.java (revision 922)
@@ -0,0 +1,14 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent any kind of shape not covered by the other
+ * marker interfaces
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IShape extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ISplitPane.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ISplitPane.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ISplitPane.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a split pane
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface ISplitPane extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITabbedPane.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITabbedPane.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITabbedPane.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a tabbed pane
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface ITabbedPane extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITable.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITable.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITable.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a table
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface ITable extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITextArea.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITextArea.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITextArea.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a multi line text area
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface ITextArea extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITextField.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITextField.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITextField.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a single line text field
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface ITextField extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IToolBar.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IToolBar.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/IToolBar.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a tool bar
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface IToolBar extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITrackBar.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITrackBar.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITrackBar.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a track bar
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface ITrackBar extends IGUIElement {
+
+}
Index: trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITree.java
===================================================================
--- trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITree.java (revision 922)
+++ trunk/autoquest-core-events/src/main/java/de/ugoe/cs/autoquest/eventcore/guimodel/ITree.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.eventcore.guimodel;
+
+/**
+ *
+ * Marker interface for GUI elements that represent a tree view
+ *
+ *
+ * @version 1.0
+ * @author Patrick Harms
+ */
+public interface ITree extends IGUIElement {
+
+}
Index: trunk/autoquest-core-tasktrees-test/.settings/org.eclipse.m2e.core.prefs
===================================================================
--- trunk/autoquest-core-tasktrees-test/.settings/org.eclipse.m2e.core.prefs (revision 921)
+++ trunk/autoquest-core-tasktrees-test/.settings/org.eclipse.m2e.core.prefs (revision 922)
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/manager/TaskTreeManagerTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/manager/TaskTreeManagerTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/manager/TaskTreeManagerTest.java (revision 922)
@@ -0,0 +1,471 @@
+package de.ugoe.cs.autoquest.tasktrees.manager;
+
+import java.util.logging.Level;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker;
+import de.ugoe.cs.autoquest.tasktrees.manager.ComponentManager;
+import de.ugoe.cs.autoquest.tasktrees.manager.TaskTreeManager;
+import de.ugoe.cs.autoquest.test.DummyGUIElement;
+import de.ugoe.cs.autoquest.test.DummyInteraction;
+import de.ugoe.cs.util.console.TextConsole;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: $
+ * @author 2011, last modified by $Author: $
+ */
+public class TaskTreeManagerTest {
+
+ /** */
+ TaskTreeManager manager;
+
+ /**
+ *
+ */
+ @Before
+ public void setUp() {
+ new TextConsole(Level.FINEST);
+ manager = new TaskTreeManager();
+ }
+
+ /**
+ *
+ */
+ @After
+ public void tearDown() {
+ manager = null;
+ ComponentManager.clearInstance();
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testOneEventOnOneElement() {
+ simulateEvent(new DummyInteraction("bla", 1), new DummyGUIElement("elem1"));
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence {" +
+ " Event bla {}" +
+ "}", manager.getTaskTree());
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testManyEventsOnOneElement() {
+ IEventTarget eventTarget = new DummyGUIElement("elem1");
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget);
+ simulateEvent(new DummyInteraction("blu", 1), eventTarget);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blo {}" +
+ " Event blu {}" +
+ " Event bla {}" +
+ "}", manager.getTaskTree());
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testOneEventOnManyElements() {
+ IEventTarget eventTarget1 = new DummyGUIElement("elem1");
+ IEventTarget eventTarget2 = new DummyGUIElement("elem2");
+ IEventTarget eventTarget3 = new DummyGUIElement("elem3");
+ IEventTarget eventTarget4 = new DummyGUIElement("elem4");
+ IEventTarget eventTarget5 = new DummyGUIElement("elem5");
+ IEventTarget eventTarget6 = new DummyGUIElement("elem6");
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget1);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget2);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget3);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget5);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget6);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence0 {" +
+ " Sequence sequence1 {" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence2 {" +
+ " Event bli {}" +
+ " }" +
+ " Sequence sequence3 {" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence4 {" +
+ " Event bli {}" +
+ " }" +
+ " Sequence sequence5 {" +
+ " Event blo {}" +
+ " }" +
+ " Sequence sequence6 {" +
+ " Event bla {}" +
+ " }" +
+ "}", manager.getTaskTree());
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testManyEventsOnManyElements() {
+ IEventTarget eventTarget1 = new DummyGUIElement("elem1");
+ IEventTarget eventTarget2 = new DummyGUIElement("elem2");
+ IEventTarget eventTarget3 = new DummyGUIElement("elem3");
+ IEventTarget eventTarget4 = new DummyGUIElement("elem4");
+ IEventTarget eventTarget5 = new DummyGUIElement("elem5");
+ IEventTarget eventTarget6 = new DummyGUIElement("elem6");
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget1);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget1);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget1);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget2);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget2);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget3);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget5);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget6);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget6);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget6);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget6);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence0 {" +
+ " Sequence sequence1 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence2 {" +
+ " Event bli {}" +
+ " Event blo {}" +
+ " }" +
+ " Sequence sequence3 {" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence4 {" +
+ " Event bli {}" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blo {}" +
+ " }" +
+ " Sequence sequence5 {" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence6 {" +
+ " Event bli {}" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blo {}" +
+ " }" +
+ "}", manager.getTaskTree());
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testEventIterationDetection() throws Exception {
+ IEventTarget eventTarget1 = new DummyGUIElement("elem1");
+ IEventType event1 = new DummyInteraction("bla", 1);
+ simulateEvent(event1, eventTarget1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Event bla {}" +
+ "}", manager.getTaskTree());
+
+ simulateEvent(event1, eventTarget1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Event bla {}" +
+ " }" +
+ "}", manager.getTaskTree());
+
+ simulateEvent(event1, eventTarget1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Event bla {}" +
+ " }" +
+ "}", manager.getTaskTree());
+
+ for (int i = 0; i < 10; i++) {
+ simulateEvent(event1, eventTarget1);
+ }
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Event bla {}" +
+ " }" +
+ "}", manager.getTaskTree());
+
+ // now test with preceding and trailing other interactions
+ IEventType event2 = new DummyInteraction("bli", 1);
+ IEventType event3 = new DummyInteraction("blup", 1);
+
+ simulateEvent(event2, eventTarget1);
+ simulateEvent(event3, eventTarget1);
+ for (int i = 0; i < 10; i++) {
+ simulateEvent(event1, eventTarget1);
+ }
+ simulateEvent(event3, eventTarget1);
+ simulateEvent(event2, eventTarget1);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Event bla {}" +
+ " }" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " Iteration iteration2 {" +
+ " Event bla {}" +
+ " }" +
+ " Event blup {}" +
+ " Event bli {}" +
+ "}", manager.getTaskTree());
+
+ // now test with iterations of iterations
+
+ for (int i = 0; i < 10; i++) {
+ for (int j = 0; j < 5; j++) {
+ simulateEvent(event1, eventTarget1);
+ }
+ for (int j = 0; j < 5; j++) {
+ simulateEvent(event2, eventTarget1);
+ }
+ for (int j = 0; j < 5; j++) {
+ simulateEvent(event3, eventTarget1);
+ }
+ }
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence0 {" +
+ " Iteration iteration0 {" +
+ " Event bla {}" +
+ " }" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " Iteration iteration1 {" +
+ " Event bla {}" +
+ " }" +
+ " Event blup {}" +
+ " Event bli {}" +
+ " Iteration iteration2 {" +
+ " Sequence sequence1 {" +
+ " Iteration iteration3 {" +
+ " Event bla {}" +
+ " }" +
+ " Iteration iteration4 {" +
+ " Event bli {}" +
+ " }" +
+ " Iteration iteration5 {" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " }" +
+ "}", manager.getTaskTree());
+
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testSequenceIterationDetection() throws Exception {
+ IEventTarget eventTarget1 = new DummyGUIElement("elem1");
+ IEventType event1 = new DummyInteraction("bla", 1);
+ IEventType event2 = new DummyInteraction("bli", 1);
+ IEventType event3 = new DummyInteraction("blup", 1);
+ simulateEvent(event1, eventTarget1);
+ simulateEvent(event2, eventTarget1);
+ simulateEvent(event3, eventTarget1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ "}", manager.getTaskTree());
+
+ simulateEvent(event1, eventTarget1);
+ simulateEvent(event2, eventTarget1);
+ simulateEvent(event3, eventTarget1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Sequence sequence2 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ "}", manager.getTaskTree());
+
+ simulateEvent(event1, eventTarget1);
+ simulateEvent(event2, eventTarget1);
+ simulateEvent(event3, eventTarget1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Sequence sequence2 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ "}", manager.getTaskTree());
+
+ for (int i = 0; i < 10; i++) {
+ simulateEvent(event1, eventTarget1);
+ simulateEvent(event2, eventTarget1);
+ simulateEvent(event3, eventTarget1);
+ }
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Sequence sequence2 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ "}", manager.getTaskTree());
+
+ // now test with preceding and trailing other interactions
+ IEventType event4 = new DummyInteraction("ble", 1);
+ IEventType event5 = new DummyInteraction("blo", 1);
+ IEventType event6 = new DummyInteraction("blu", 1);
+ simulateEvent(event4, eventTarget1);
+ simulateEvent(event5, eventTarget1);
+ simulateEvent(event6, eventTarget1);
+ for (int i = 0; i < 10; i++) {
+ simulateEvent(event1, eventTarget1);
+ simulateEvent(event2, eventTarget1);
+ simulateEvent(event3, eventTarget1);
+ }
+ simulateEvent(event6, eventTarget1);
+ simulateEvent(event5, eventTarget1);
+ simulateEvent(event4, eventTarget1);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Sequence sequence2 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " Event ble {}" +
+ " Event blo {}" +
+ " Event blu {}" +
+ " Iteration iteration2 {" +
+ " Sequence sequence3 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " Event blu {}" +
+ " Event blo {}" +
+ " Event ble {}" +
+ "}", manager.getTaskTree());
+
+ // now test with iterations of iterations
+ for (int i = 0; i < 10; i++) {
+ for (int j = 0; j < 5; j++) {
+ simulateEvent(event1, eventTarget1);
+ simulateEvent(event2, eventTarget1);
+ simulateEvent(event3, eventTarget1);
+ }
+ for (int j = 0; j < 5; j++) {
+ simulateEvent(event2, eventTarget1);
+ simulateEvent(event1, eventTarget1);
+ simulateEvent(event3, eventTarget1);
+ }
+ for (int j = 0; j < 5; j++) {
+ simulateEvent(event1, eventTarget1);
+ simulateEvent(event2, eventTarget1);
+ simulateEvent(event3, eventTarget1);
+ }
+ }
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Sequence sequence2 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " Event ble {}" +
+ " Event blo {}" +
+ " Event blu {}" +
+ " Iteration iteration2 {" +
+ " Sequence sequence3 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " Event blu {}" +
+ " Event blo {}" +
+ " Event ble {}" +
+ " Iteration iteration3 {" +
+ " Sequence sequence4 {" +
+ " Iteration iteration4 {" +
+ " Sequence sequence4 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " Iteration iteration5 {" +
+ " Sequence sequence5 {" +
+ " Event bli {}" +
+ " Event bla {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " Iteration iteration6 {" +
+ " Sequence sequence6 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " }" +
+ " }" +
+ "}", manager.getTaskTree());
+ }
+
+ /**
+ *
+ */
+ private void simulateEvent(IEventType eventType, IEventTarget eventTarget) {
+ manager.handleNewEvent(new Event(eventType, eventTarget));
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/EventTaskComparisonRuleTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/EventTaskComparisonRuleTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/EventTaskComparisonRuleTest.java (revision 922)
@@ -0,0 +1,68 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+import de.ugoe.cs.autoquest.eventcore.StringEventType;
+import de.ugoe.cs.autoquest.tasktrees.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;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+import de.ugoe.cs.autoquest.test.DummyGUIElement;
+
+/**
+ * @author Patrick Harms
+ */
+public class EventTaskComparisonRuleTest {
+
+ /**
+ *
+ */
+ @Test
+ public void test() {
+ ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+
+ EventTaskComparisonRule rule = new EventTaskComparisonRule();
+
+ // test the identity check
+ IEventType eventType1 = new StringEventType("eventType1");
+ IEventTarget eventTarget1 = new DummyGUIElement("elem1");
+ ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+
+ assertEquals(NodeEquality.IDENTICAL, rule.compare(task1, task1));
+
+ ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task2, task1));
+
+ IEventType eventType2 = new StringEventType("eventType2");
+ task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1));
+
+ IEventTarget eventTarget2 = new DummyGUIElement("elem2");
+ task2 = treeNodeFactory.createNewEventTask(eventType1, eventTarget2);
+
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1));
+
+ task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1));
+
+ ISelection selection = treeNodeFactory.createNewSelection();
+ assertNull(rule.compare(task1, selection));
+ assertNull(rule.compare(selection, task1));
+ assertNull(rule.compare(task2, selection));
+ assertNull(rule.compare(selection, task2));
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/GUIEventTaskComparisonRuleTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/GUIEventTaskComparisonRuleTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/GUIEventTaskComparisonRuleTest.java (revision 922)
@@ -0,0 +1,133 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+import de.ugoe.cs.autoquest.eventcore.StringEventType;
+import de.ugoe.cs.autoquest.eventcore.gui.KeyboardFocusChange;
+import de.ugoe.cs.autoquest.eventcore.gui.TextInput;
+import de.ugoe.cs.autoquest.eventcore.gui.ValueSelection;
+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;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+import de.ugoe.cs.autoquest.test.DummyGUIElement;
+
+/**
+ * @author Patrick Harms
+ */
+public class GUIEventTaskComparisonRuleTest {
+
+ /**
+ *
+ */
+ @Test
+ public void test() {
+ ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+
+ GUIEventTaskComparisonRule rule = new GUIEventTaskComparisonRule();
+
+ // test the identity check
+ IEventType eventType1 = new StringEventType("blub");
+ IEventTarget eventTarget1 = new DummyGUIElement("elem1");
+ ITaskTreeNode task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+
+ assertNull(rule.compare(task1, task1));
+
+ eventType1 = new KeyboardFocusChange();
+ task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+
+ assertEquals(NodeEquality.IDENTICAL, rule.compare(task1, task1));
+
+ // test lexical equality for interaction events which are no value selections or text inputs
+ IEventType eventType2 = new KeyboardFocusChange();
+ ITaskTreeNode task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task2, task1));
+
+ // test equality of value selections
+ eventType1 = new ValueSelection("value1");
+ task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1));
+
+ eventType2 = new ValueSelection("value1");
+ task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+
+ assertEquals(NodeEquality.SYNTACTICALLY_EQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.SYNTACTICALLY_EQUAL, rule.compare(task2, task1));
+
+ eventType2 = new ValueSelection("value2");
+ task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+
+ assertEquals(NodeEquality.SEMANTICALLY_EQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.SEMANTICALLY_EQUAL, rule.compare(task2, task1));
+
+ // test equality of text inputs
+ List textInputEvents1 = new ArrayList();
+ textInputEvents1.add(new Event(eventType1, eventTarget1));
+ eventType1 = new TextInput("enteredText1", textInputEvents1);
+ task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1));
+
+ eventType2 = new TextInput("enteredText1", textInputEvents1);
+ task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task2, task1));
+
+ List textInputEvents2 = new ArrayList();
+ textInputEvents2.add(new Event(eventType2, eventTarget1));
+ eventType2 = new TextInput("enteredText1", textInputEvents2);
+ task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+
+ assertEquals(NodeEquality.SYNTACTICALLY_EQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.SYNTACTICALLY_EQUAL, rule.compare(task2, task1));
+
+ eventType2 = new TextInput("enteredText2", textInputEvents2);
+ task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget1);
+
+ assertEquals(NodeEquality.SEMANTICALLY_EQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.SEMANTICALLY_EQUAL, rule.compare(task2, task1));
+
+ // now ensure unequality for all combinations, if the event targets do not match
+ IEventTarget eventTarget2 = new DummyGUIElement("elem2");
+ eventType1 = new KeyboardFocusChange();
+ task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+ task2 = treeNodeFactory.createNewEventTask(eventType2, eventTarget2);
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1));
+
+ eventType1 = new ValueSelection("value1");
+ task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+ task2 = treeNodeFactory.createNewEventTask(eventType1, eventTarget2);
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1));
+
+ eventType1 = new TextInput("enteredText1", textInputEvents1);
+ task1 = treeNodeFactory.createNewEventTask(eventType1, eventTarget1);
+ task2 = treeNodeFactory.createNewEventTask(eventType1, eventTarget2);
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task1, task2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(task2, task1));
+
+ ISelection selection = treeNodeFactory.createNewSelection();
+ assertNull(rule.compare(task1, selection));
+ assertNull(rule.compare(selection, task1));
+ assertNull(rule.compare(task2, selection));
+ assertNull(rule.compare(selection, task2));
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/IterationComparisonRuleTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/IterationComparisonRuleTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/IterationComparisonRuleTest.java (revision 922)
@@ -0,0 +1,95 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.IterationComparisonRule;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+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.TaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+
+/**
+ * @author Patrick Harms
+ */
+public class IterationComparisonRuleTest {
+
+ /**
+ *
+ */
+ @Test
+ public void test() {
+ NodeEqualityRuleManager manager = new NodeEqualityRuleManager();
+ manager.init();
+
+ ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+ ITaskTreeBuilder treeBuilder = new TaskTreeBuilder();
+
+ IterationComparisonRule rule = new IterationComparisonRule(manager);
+
+ ITaskTreeNode task1 = new TaskTreeNode("task1");
+ ITaskTreeNode task2 = new TaskTreeNode("task2");
+
+ assertNull(rule.compare(task1, task2));
+
+ IIteration iteration1 = treeNodeFactory.createNewIteration();
+ assertEquals(NodeEquality.IDENTICAL, rule.compare(iteration1, iteration1));
+
+ IIteration iteration2 = treeNodeFactory.createNewIteration();
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1));
+
+ treeBuilder.setChild(iteration1, task1);
+
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(iteration1, iteration2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(iteration2, iteration1));
+
+ treeBuilder.setChild(iteration2, task1);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1));
+
+ treeBuilder.setChild(iteration1, task2);
+
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(iteration1, iteration2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(iteration2, iteration1));
+
+ treeBuilder.setChild(iteration2, task2);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1));
+
+ ISelection selection1 = treeNodeFactory.createNewSelection();
+ treeBuilder.addChild(selection1, task2);
+ treeBuilder.setChild(iteration1, selection1);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1));
+
+ ISelection selection2 = treeNodeFactory.createNewSelection();
+ treeBuilder.addChild(selection2, task2);
+ treeBuilder.setChild(iteration2, selection2);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, iteration2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration2, iteration1));
+
+ assertNull(rule.compare(iteration1, selection1));
+ assertNull(rule.compare(selection1, iteration1));
+ assertNull(rule.compare(iteration2, selection1));
+ assertNull(rule.compare(selection1, iteration2));
+
+ assertNull(rule.compare(iteration1, selection2));
+ assertNull(rule.compare(selection2, iteration1));
+ assertNull(rule.compare(iteration2, selection2));
+ assertNull(rule.compare(selection2, iteration2));
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndIterationComparisonRuleTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndIterationComparisonRuleTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndIterationComparisonRuleTest.java (revision 922)
@@ -0,0 +1,59 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeAndIterationComparisonRule;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+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.TaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+
+/**
+ * @author Patrick Harms
+ */
+public class NodeAndIterationComparisonRuleTest {
+
+ /**
+ *
+ */
+ @Test
+ public void test() {
+ NodeEqualityRuleManager manager = new NodeEqualityRuleManager();
+ manager.init();
+
+ ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+ ITaskTreeBuilder treeBuilder = new TaskTreeBuilder();
+
+ NodeAndIterationComparisonRule rule = new NodeAndIterationComparisonRule(manager);
+
+ ITaskTreeNode task1 = new TaskTreeNode("task1");
+
+ assertNull(rule.compare(task1, task1));
+
+ IIteration iteration1 = treeNodeFactory.createNewIteration();
+ assertNull(rule.compare(iteration1, iteration1));
+ assertNull(rule.compare(task1, iteration1));
+ assertNull(rule.compare(iteration1, task1));
+
+ treeBuilder.setChild(iteration1, task1);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, task1));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, iteration1));
+
+ ISelection selection1 = treeNodeFactory.createNewSelection();
+ treeBuilder.addChild(selection1, task1);
+ treeBuilder.setChild(iteration1, selection1);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(iteration1, task1));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, iteration1));
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndSelectionComparisonRuleTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndSelectionComparisonRuleTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndSelectionComparisonRuleTest.java (revision 922)
@@ -0,0 +1,59 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeAndSelectionComparisonRule;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+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.TaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+
+/**
+ * @author Patrick Harms
+ */
+public class NodeAndSelectionComparisonRuleTest {
+
+ /**
+ *
+ */
+ @Test
+ public void test() {
+ NodeEqualityRuleManager manager = new NodeEqualityRuleManager();
+ manager.init();
+
+ ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+ ITaskTreeBuilder treeBuilder = new TaskTreeBuilder();
+
+ NodeAndSelectionComparisonRule rule = new NodeAndSelectionComparisonRule(manager);
+
+ ITaskTreeNode task1 = new TaskTreeNode("task1");
+
+ assertNull(rule.compare(task1, task1));
+
+ ISelection selection1 = treeNodeFactory.createNewSelection();
+ assertNull(rule.compare(selection1, selection1));
+ assertNull(rule.compare(task1, selection1));
+ assertNull(rule.compare(selection1, task1));
+
+ treeBuilder.addChild(selection1, task1);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection1, task1));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, selection1));
+
+ selection1 = treeNodeFactory.createNewSelection();
+ ISelection selection2 = treeNodeFactory.createNewSelection();
+ treeBuilder.addChild(selection2, task1);
+ treeBuilder.addChild(selection1, selection2);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection1, task1));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(task1, selection1));
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeEqualityTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeEqualityTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeEqualityTest.java (revision 922)
@@ -0,0 +1,50 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
+
+/**
+ * @author Patrick Harms
+ */
+public class NodeEqualityTest {
+
+ /**
+ *
+ */
+ @Test
+ public void test() {
+ assertTrue(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.IDENTICAL));
+ assertTrue(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL));
+ assertTrue(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL));
+ assertTrue(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL));
+ assertFalse(NodeEquality.IDENTICAL.isAtLeast(NodeEquality.UNEQUAL));
+
+ assertFalse(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.IDENTICAL));
+ assertTrue(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL));
+ assertTrue(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL));
+ assertTrue(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL));
+ assertFalse(NodeEquality.LEXICALLY_EQUAL.isAtLeast(NodeEquality.UNEQUAL));
+
+ assertFalse(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.IDENTICAL));
+ assertFalse(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL));
+ assertTrue(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL));
+ assertTrue(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL));
+ assertFalse(NodeEquality.SYNTACTICALLY_EQUAL.isAtLeast(NodeEquality.UNEQUAL));
+
+ assertFalse(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.IDENTICAL));
+ assertFalse(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL));
+ assertFalse(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL));
+ assertTrue(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL));
+ assertFalse(NodeEquality.SEMANTICALLY_EQUAL.isAtLeast(NodeEquality.UNEQUAL));
+
+ assertFalse(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.IDENTICAL));
+ assertFalse(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.LEXICALLY_EQUAL));
+ assertFalse(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL));
+ assertFalse(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL));
+ assertTrue(NodeEquality.UNEQUAL.isAtLeast(NodeEquality.UNEQUAL));
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SelectionComparisonRuleTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SelectionComparisonRuleTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SelectionComparisonRuleTest.java (revision 922)
@@ -0,0 +1,89 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.SelectionComparisonRule;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+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.TaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+
+/**
+ * @author Patrick Harms
+ */
+public class SelectionComparisonRuleTest {
+
+ /**
+ *
+ */
+ @Test
+ public void test() {
+ NodeEqualityRuleManager manager = new NodeEqualityRuleManager();
+ manager.init();
+
+ ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+ ITaskTreeBuilder treeBuilder = new TaskTreeBuilder();
+
+ SelectionComparisonRule rule = new SelectionComparisonRule(manager);
+
+ ITaskTreeNode task1 = new TaskTreeNode("task1");
+ ITaskTreeNode task2 = new TaskTreeNode("task2");
+
+ assertNull(rule.compare(task1, task2));
+
+ ISelection selection1 = treeNodeFactory.createNewSelection();
+ assertEquals(NodeEquality.IDENTICAL, rule.compare(selection1, selection1));
+
+ ISelection selection2 = treeNodeFactory.createNewSelection();
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection2, selection1));
+
+ treeBuilder.addChild(selection1, task1);
+
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(selection1, selection2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(selection2, selection1));
+
+ treeBuilder.addChild(selection2, task1);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection2, selection1));
+
+ treeBuilder.addChild(selection1, task2);
+
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(selection1, selection2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(selection2, selection1));
+
+ treeBuilder.addChild(selection2, task2);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection2, selection1));
+
+ ISelection selection3 = treeNodeFactory.createNewSelection();
+ treeBuilder.addChild(selection3, task2);
+ treeBuilder.addChild(selection3, task1);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection1, selection3));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection3, selection1));
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection2, selection3));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(selection3, selection2));
+
+ ISequence sequence = treeNodeFactory.createNewSequence();
+ assertNull(rule.compare(selection1, sequence));
+ assertNull(rule.compare(sequence, selection1));
+ assertNull(rule.compare(selection2, sequence));
+ assertNull(rule.compare(sequence, selection2));
+ assertNull(rule.compare(selection3, sequence));
+ assertNull(rule.compare(sequence, selection3));
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SequenceComparisonRuleTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SequenceComparisonRuleTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SequenceComparisonRuleTest.java (revision 922)
@@ -0,0 +1,88 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.SequenceComparisonRule;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+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.TaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+
+/**
+ * @author Patrick Harms
+ */
+public class SequenceComparisonRuleTest {
+
+ /**
+ *
+ */
+ @Test
+ public void test() {
+ NodeEqualityRuleManager manager = new NodeEqualityRuleManager();
+ manager.init();
+
+ ITaskTreeNodeFactory treeNodeFactory = new TaskTreeNodeFactory();
+ ITaskTreeBuilder treeBuilder = new TaskTreeBuilder();
+
+ SequenceComparisonRule rule = new SequenceComparisonRule(manager);
+
+ ITaskTreeNode task1 = new TaskTreeNode("task1");
+ ITaskTreeNode task2 = new TaskTreeNode("task2");
+
+ assertNull(rule.compare(task1, task2));
+
+ ISequence sequence1 = treeNodeFactory.createNewSequence();
+ assertEquals(NodeEquality.IDENTICAL, rule.compare(sequence1, sequence1));
+
+ ISequence sequence2 = treeNodeFactory.createNewSequence();
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1));
+
+ treeBuilder.addChild(sequence1, task1);
+
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence1, sequence2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence2, sequence1));
+
+ treeBuilder.addChild(sequence2, task1);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1));
+
+ treeBuilder.addChild(sequence1, task2);
+
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence1, sequence2));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence2, sequence1));
+
+ treeBuilder.addChild(sequence2, task2);
+
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence1, sequence2));
+ assertEquals(NodeEquality.LEXICALLY_EQUAL, rule.compare(sequence2, sequence1));
+
+ ISequence sequence3 = treeNodeFactory.createNewSequence();
+ treeBuilder.addChild(sequence3, task2);
+ treeBuilder.addChild(sequence3, task1);
+
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence1, sequence3));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence3, sequence1));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence2, sequence3));
+ assertEquals(NodeEquality.UNEQUAL, rule.compare(sequence3, sequence2));
+
+ ISelection selection = treeNodeFactory.createNewSelection();
+ assertNull(rule.compare(sequence1, selection));
+ assertNull(rule.compare(selection, sequence1));
+ assertNull(rule.compare(sequence2, selection));
+ assertNull(rule.compare(selection, sequence2));
+ assertNull(rule.compare(sequence3, selection));
+ assertNull(rule.compare(selection, sequence3));
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java (revision 922)
@@ -0,0 +1,80 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+
+import org.junit.Before;
+
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.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;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+import de.ugoe.cs.util.console.TextConsole;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 28.04.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class AbstractTemporalRelationshipTC {
+
+ /** */
+ private List events;
+
+ /** */
+ private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder();
+
+ /** */
+ private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory();
+
+ /** */
+ private NodeEqualityRuleManager nodeEqualityRuleManager =
+ Utilities.getNodeEqualityRuleManagerForTests();
+
+ /**
+ *
+ */
+ @Before
+ public void setUp() {
+ new TextConsole(Level.FINEST);
+ events = new ArrayList();
+ }
+
+ /**
+ *
+ */
+ protected void simulateEvent(IEventType eventType, IEventTarget eventTarget) {
+ events.add(taskTreeNodeFactory.createNewEventTask(eventType, eventTarget));
+ }
+
+ /**
+ *
+ * @return
+ */
+ protected ITaskTree getTaskTree() {
+ ISequence sequence = taskTreeNodeFactory.createNewSequence();
+
+ for (IEventTask task : events) {
+ taskTreeBuilder.addChild(sequence, task);
+ }
+
+ TemporalRelationshipRuleManager ruleManager =
+ new TemporalRelationshipRuleManager(nodeEqualityRuleManager);
+
+ ruleManager.init();
+ ruleManager.applyRules(sequence, taskTreeBuilder, taskTreeNodeFactory, true);
+
+ return taskTreeNodeFactory.createTaskTree(sequence);
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRuleTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRuleTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRuleTest.java (revision 922)
@@ -0,0 +1,212 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker;
+import de.ugoe.cs.autoquest.test.DummyGUIElement;
+import de.ugoe.cs.autoquest.test.DummyInteraction;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: $
+ * @author 2011, last modified by $Author: $
+ */
+public class DefaultGuiElementSequenceDetectionRuleTest extends AbstractTemporalRelationshipTC {
+
+ /**
+ *
+ */
+ @Test
+ public void testOneInteractionOnOneElement() {
+ simulateEvent(new DummyInteraction("bla", 1), new DummyGUIElement("elem1"));
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence {" +
+ " Event bla {}" +
+ "}", getTaskTree());
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testManyInteractionsOnOneElement() {
+ IEventTarget eventTarget = new DummyGUIElement("elem1");
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget);
+ simulateEvent(new DummyInteraction("blu", 1), eventTarget);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blo {}" +
+ " Event blu {}" +
+ " Event bla {}" +
+ "}", getTaskTree());
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testOneInteractionOnManyElements() {
+ IEventTarget eventTarget1 = new DummyGUIElement("elem1");
+ IEventTarget eventTarget2 = new DummyGUIElement("elem2");
+ IEventTarget eventTarget3 = new DummyGUIElement("elem3");
+ IEventTarget eventTarget4 = new DummyGUIElement("elem4");
+ IEventTarget eventTarget5 = new DummyGUIElement("elem5");
+ IEventTarget eventTarget6 = new DummyGUIElement("elem6");
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget1);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget2);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget3);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget5);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget6);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence0 {" +
+ " Sequence sequence1 {" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence2 {" +
+ " Event bli {}" +
+ " }" +
+ " Sequence sequence3 {" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence4 {" +
+ " Event bli {}" +
+ " }" +
+ " Sequence sequence5 {" +
+ " Event blo {}" +
+ " }" +
+ " Sequence sequence6 {" +
+ " Event bla {}" +
+ " }" +
+ "}", getTaskTree());
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testManyInteractionsOnManyElementsWithoutHierarchy() {
+ IEventTarget eventTarget1 = new DummyGUIElement("elem1");
+ IEventTarget eventTarget2 = new DummyGUIElement("elem2");
+ IEventTarget eventTarget3 = new DummyGUIElement("elem3");
+ IEventTarget eventTarget4 = new DummyGUIElement("elem4");
+ IEventTarget eventTarget5 = new DummyGUIElement("elem5");
+ IEventTarget eventTarget6 = new DummyGUIElement("elem6");
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget1);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget1);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget1);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget2);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget2);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget3);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget5);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget6);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget6);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget6);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget6);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence0 {" +
+ " Sequence sequence1 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence2 {" +
+ " Event bli {}" +
+ " Event blo {}" +
+ " }" +
+ " Sequence sequence3 {" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence4 {" +
+ " Event bli {}" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blo {}" +
+ " }" +
+ " Sequence sequence5 {" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence6 {" +
+ " Event bli {}" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blo {}" +
+ " }" +
+ "}", getTaskTree());
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testManyInteractionsOnManyElementsWithHierarchy() {
+ DummyGUIElement parentA = new DummyGUIElement("A");
+ DummyGUIElement parentB = new DummyGUIElement("B", parentA);
+ DummyGUIElement parentC = new DummyGUIElement("C", parentB);
+ DummyGUIElement parentF = new DummyGUIElement("F", parentB);
+ DummyGUIElement parentH = new DummyGUIElement("H", parentA);
+ DummyGUIElement parentI = new DummyGUIElement("I", parentH);
+
+ DummyGUIElement eventTargetD = new DummyGUIElement("D", parentC);
+ DummyGUIElement eventTargetE = new DummyGUIElement("E", parentC);
+ DummyGUIElement eventTargetG = new DummyGUIElement("G", parentF);
+ DummyGUIElement eventTargetJ = new DummyGUIElement("J", parentI);
+
+ simulateEvent(new DummyInteraction("1", 1), eventTargetD);
+ simulateEvent(new DummyInteraction("2", 1), eventTargetD);
+ simulateEvent(new DummyInteraction("3", 1), eventTargetE);
+ simulateEvent(new DummyInteraction("4", 1), eventTargetD);
+ simulateEvent(new DummyInteraction("5", 1), eventTargetG);
+ simulateEvent(new DummyInteraction("6", 1), eventTargetG);
+ simulateEvent(new DummyInteraction("7", 1), eventTargetD);
+ simulateEvent(new DummyInteraction("8", 1), eventTargetJ);
+ simulateEvent(new DummyInteraction("9", 1), eventTargetG);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence0 {" +
+ " Sequence sequence1 {" +
+ " Sequence sequence2 {" +
+ " Sequence sequence3 {" +
+ " Event 1 {}" +
+ " Event 2 {}" +
+ " }" +
+ " Sequence sequence4 {" +
+ " Event 3 {}" +
+ " }" +
+ " Sequence sequence5 {" +
+ " Event 4 {}" +
+ " }" +
+ " }" +
+ " Sequence sequence6 {" +
+ " Event 5 {}" +
+ " Event 6 {}" +
+ " }" +
+ " Sequence sequence7 {" +
+ " Event 7 {}" +
+ " }" +
+ " }" +
+ " Sequence sequence8 {" +
+ " Event 8 {}" +
+ " }" +
+ " Sequence sequence9 {" +
+ " Event 9 {}" +
+ " }" +
+ "}", getTaskTree());
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRuleTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRuleTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRuleTest.java (revision 922)
@@ -0,0 +1,153 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker;
+import de.ugoe.cs.autoquest.test.DummyGUIElement;
+import de.ugoe.cs.autoquest.test.DummyInteraction;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: $
+ * @author 2011, last modified by $Author: $
+ */
+public class DefaultGuiEventSequenceDetectionRuleTest extends AbstractTemporalRelationshipTC {
+
+ /**
+ *
+ */
+ @Test
+ public void testOneInteractionOnOneElement() {
+ simulateEvent(new DummyInteraction("bla", 1), new DummyGUIElement("elem1"));
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence {" +
+ " Event bla {}" +
+ "}", getTaskTree());
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testManyInteractionsOnOneElement() {
+ IEventTarget eventTarget = new DummyGUIElement("elem1");
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget);
+ simulateEvent(new DummyInteraction("blu", 1), eventTarget);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blo {}" +
+ " Event blu {}" +
+ " Event bla {}" +
+ "}", getTaskTree());
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testOneInteractionOnManyElements() {
+ IEventTarget eventTarget1 = new DummyGUIElement("elem1");
+ IEventTarget eventTarget2 = new DummyGUIElement("elem2");
+ IEventTarget eventTarget3 = new DummyGUIElement("elem3");
+ IEventTarget eventTarget4 = new DummyGUIElement("elem4");
+ IEventTarget eventTarget5 = new DummyGUIElement("elem5");
+ IEventTarget eventTarget6 = new DummyGUIElement("elem6");
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget1);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget2);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget3);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget5);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget6);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence0 {" +
+ " Sequence sequence1 {" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence2 {" +
+ " Event bli {}" +
+ " }" +
+ " Sequence sequence3 {" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence4 {" +
+ " Event bli {}" +
+ " }" +
+ " Sequence sequence5 {" +
+ " Event blo {}" +
+ " }" +
+ " Sequence sequence6 {" +
+ " Event bla {}" +
+ " }" +
+ "}", getTaskTree());
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testManyInteractionsOnManyElements() {
+ IEventTarget eventTarget1 = new DummyGUIElement("elem1");
+ IEventTarget eventTarget2 = new DummyGUIElement("elem2");
+ IEventTarget eventTarget3 = new DummyGUIElement("elem3");
+ IEventTarget eventTarget4 = new DummyGUIElement("elem4");
+ IEventTarget eventTarget5 = new DummyGUIElement("elem5");
+ IEventTarget eventTarget6 = new DummyGUIElement("elem6");
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget1);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget1);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget1);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget2);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget2);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget3);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget4);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget5);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget6);
+ simulateEvent(new DummyInteraction("bla", 1), eventTarget6);
+ simulateEvent(new DummyInteraction("bli", 1), eventTarget6);
+ simulateEvent(new DummyInteraction("blo", 1), eventTarget6);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence0 {" +
+ " Sequence sequence1 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence2 {" +
+ " Event bli {}" +
+ " Event blo {}" +
+ " }" +
+ " Sequence sequence3 {" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence4 {" +
+ " Event bli {}" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blo {}" +
+ " }" +
+ " Sequence sequence5 {" +
+ " Event bla {}" +
+ " }" +
+ " Sequence sequence6 {" +
+ " Event bli {}" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blo {}" +
+ " }" +
+ "}", getTaskTree());
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java (revision 922)
@@ -0,0 +1,301 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker;
+import de.ugoe.cs.autoquest.test.DummyGUIElement;
+import de.ugoe.cs.autoquest.test.DummyInteraction;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 28.04.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class DefaultIterationDetectionRuleTest extends AbstractTemporalRelationshipTC {
+
+ /**
+ *
+ */
+ @Test
+ public void testInteractionIterationDetection() throws Exception {
+ IEventTarget element1 = new DummyGUIElement("elem1");
+ IEventType event1 = new DummyInteraction("bla", 1);
+ simulateEvent(event1, element1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Event bla {}" +
+ "}", getTaskTree());
+
+ simulateEvent(event1, element1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Event bla {}" +
+ " }" +
+ "}", getTaskTree());
+
+ simulateEvent(event1, element1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Event bla {}" +
+ " }" +
+ "}", getTaskTree());
+
+ for (int i = 0; i < 10; i++) {
+ simulateEvent(event1, element1);
+ }
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Event bla {}" +
+ " }" +
+ "}", getTaskTree());
+
+ // now test with preceding and trailing other events
+ IEventType event2 = new DummyInteraction("bli", 1);
+ IEventType event3 = new DummyInteraction("blup", 1);
+
+ simulateEvent(event2, element1);
+ simulateEvent(event3, element1);
+ for (int i = 0; i < 10; i++) {
+ simulateEvent(event1, element1);
+ }
+ simulateEvent(event3, element1);
+ simulateEvent(event2, element1);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Event bla {}" +
+ " }" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " Iteration iteration2 {" +
+ " Event bla {}" +
+ " }" +
+ " Event blup {}" +
+ " Event bli {}" +
+ "}", getTaskTree());
+
+ // now test with iterations of iterations
+
+ for (int i = 0; i < 10; i++) {
+ for (int j = 0; j < 5; j++) {
+ simulateEvent(event1, element1);
+ }
+ for (int j = 0; j < 5; j++) {
+ simulateEvent(event2, element1);
+ }
+ for (int j = 0; j < 5; j++) {
+ simulateEvent(event3, element1);
+ }
+ }
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Event bla {}" +
+ " }" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " Iteration iteration2 {" +
+ " Event bla {}" +
+ " }" +
+ " Event blup {}" +
+ " Event bli {}" +
+ " Iteration iteration3 {" +
+ " Sequence sequence2 {" +
+ " Iteration iteration4 {" +
+ " Event bla {}" +
+ " }" +
+ " Iteration iteration5 {" +
+ " Event bli {}" +
+ " }" +
+ " Iteration iteration6 {" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " }" +
+ "}", getTaskTree());
+
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testSequenceIterationDetection() throws Exception {
+ IEventTarget element1 = new DummyGUIElement("elem1");
+ IEventType event1 = new DummyInteraction("bla", 1);
+ IEventType event2 = new DummyInteraction("bli", 1);
+ IEventType event3 = new DummyInteraction("blup", 1);
+ simulateEvent(event1, element1);
+ simulateEvent(event2, element1);
+ simulateEvent(event3, element1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ "}", getTaskTree());
+
+ simulateEvent(event1, element1);
+ simulateEvent(event2, element1);
+ simulateEvent(event3, element1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Sequence sequence2 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ "}", getTaskTree());
+
+ simulateEvent(event1, element1);
+ simulateEvent(event2, element1);
+ simulateEvent(event3, element1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Sequence sequence2 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ "}", getTaskTree());
+
+ for (int i = 0; i < 10; i++) {
+ simulateEvent(event1, element1);
+ simulateEvent(event2, element1);
+ simulateEvent(event3, element1);
+ }
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Sequence sequence2 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ "}", getTaskTree());
+
+ // now test with preceding and trailing other events
+ IEventType event4 = new DummyInteraction("ble", 1);
+ IEventType event5 = new DummyInteraction("blo", 1);
+ IEventType event6 = new DummyInteraction("blu", 1);
+ simulateEvent(event4, element1);
+ simulateEvent(event5, element1);
+ simulateEvent(event6, element1);
+ for (int i = 0; i < 10; i++) {
+ simulateEvent(event1, element1);
+ simulateEvent(event2, element1);
+ simulateEvent(event3, element1);
+ }
+ simulateEvent(event6, element1);
+ simulateEvent(event5, element1);
+ simulateEvent(event4, element1);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Sequence sequence2 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " Event ble {}" +
+ " Event blo {}" +
+ " Event blu {}" +
+ " Iteration iteration2 {" +
+ " Sequence sequence3 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " Event blu {}" +
+ " Event blo {}" +
+ " Event ble {}" +
+ "}", getTaskTree());
+
+ // now test with iterations of iterations
+ for (int i = 0; i < 10; i++) {
+ for (int j = 0; j < 5; j++) {
+ simulateEvent(event1, element1);
+ simulateEvent(event2, element1);
+ simulateEvent(event3, element1);
+ }
+ for (int j = 0; j < 5; j++) {
+ simulateEvent(event2, element1);
+ simulateEvent(event1, element1);
+ simulateEvent(event3, element1);
+ }
+ for (int j = 0; j < 5; j++) {
+ simulateEvent(event1, element1);
+ simulateEvent(event2, element1);
+ simulateEvent(event3, element1);
+ }
+ }
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration iteration1 {" +
+ " Sequence sequence2 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " Event ble {}" +
+ " Event blo {}" +
+ " Event blu {}" +
+ " Iteration iteration2 {" +
+ " Sequence sequence3 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " Event blu {}" +
+ " Event blo {}" +
+ " Event ble {}" +
+ " Iteration iteration3 {" +
+ " Sequence sequence4 {" +
+ " Iteration iteration4 {" +
+ " Sequence sequence4 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " Iteration iteration5 {" +
+ " Sequence sequence5 {" +
+ " Event bli {}" +
+ " Event bla {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " Iteration iteration6 {" +
+ " Sequence sequence6 {" +
+ " Event bla {}" +
+ " Event bli {}" +
+ " Event blup {}" +
+ " }" +
+ " }" +
+ " }" +
+ " }" +
+ "}", getTaskTree());
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java (revision 922)
@@ -0,0 +1,161 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.eventcore.gui.ValueSelection;
+import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
+import de.ugoe.cs.autoquest.eventcore.guimodel.ITrackBar;
+import de.ugoe.cs.autoquest.tasktrees.TaskTreeChecker;
+import de.ugoe.cs.autoquest.test.DummyGUIElement;
+import de.ugoe.cs.autoquest.test.DummyInteraction;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 28.04.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class TrackBarSelectionDetectionRuleTest extends AbstractTemporalRelationshipTC {
+
+ /**
+ *
+ */
+ @Test
+ public void testSimpleDetection() throws Exception {
+ IGUIElement element1 = new DummyTrackBar();
+ simulateEvent(new ValueSelection(1), element1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration interation1 {" +
+ " Selection selection1 {" +
+ " Event ValueSelection {}" +
+ " }" +
+ " }" +
+ "}", getTaskTree());
+
+ simulateEvent(new ValueSelection(2), element1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration interation1 {" +
+ " Selection selection1 {" +
+ " Event ValueSelection {}" +
+ " Event ValueSelection {}" +
+ " }" +
+ " }" +
+ "}", getTaskTree());
+
+ simulateEvent(new ValueSelection(3), element1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration interation1 {" +
+ " Selection selection1 {" +
+ " Event ValueSelection {}" +
+ " Event ValueSelection {}" +
+ " Event ValueSelection {}" +
+ " }" +
+ " }" +
+ "}", getTaskTree());
+
+ simulateEvent(new ValueSelection(2), element1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration interation1 {" +
+ " Selection selection1 {" +
+ " Event ValueSelection {}" +
+ " Event ValueSelection {}" +
+ " Event ValueSelection {}" +
+ " }" +
+ " }" +
+ "}", getTaskTree());
+
+ simulateEvent(new ValueSelection(3), element1);
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration interation1 {" +
+ " Selection selection1 {" +
+ " Event ValueSelection {}" +
+ " Event ValueSelection {}" +
+ " Event ValueSelection {}" +
+ " }" +
+ " }" +
+ "}", getTaskTree());
+
+ }
+
+ /**
+ *
+ */
+ @Test
+ public void testComplexDetection() throws Exception {
+ IGUIElement element1 = new DummyTrackBar();
+ simulateEvent(new ValueSelection(1), element1);
+ simulateEvent(new ValueSelection(2), element1);
+ simulateEvent(new ValueSelection(3), element1);
+ simulateEvent(new ValueSelection(1), element1);
+ simulateEvent(new DummyInteraction("bla", 1), element1);
+ simulateEvent(new DummyInteraction("bla", 2), element1);
+ simulateEvent(new ValueSelection(2), element1);
+ simulateEvent(new ValueSelection(1), element1);
+ simulateEvent(new DummyInteraction("bla", 3), element1);
+ simulateEvent(new ValueSelection(3), element1);
+ simulateEvent(new ValueSelection(2), element1);
+ simulateEvent(new ValueSelection(3), element1);
+ simulateEvent(new DummyInteraction("bla", 1), element1);
+ simulateEvent(new DummyInteraction("bla", 2), element1);
+ simulateEvent(new ValueSelection(1), element1);
+ simulateEvent(new ValueSelection(1), element1);
+
+ new TaskTreeChecker().assertTaskTree
+ ("Sequence sequence1 {" +
+ " Iteration interation1 {" +
+ " Selection selection1 {" +
+ " Event ValueSelection {}" +
+ " Event ValueSelection {}" +
+ " Event ValueSelection {}" +
+ " }" +
+ " }" +
+ " Event bla {}" +
+ " Event bla {}" +
+ " Iteration interation2 {" +
+ " Selection selection2 {" +
+ " Event ValueSelection {}" +
+ " Event ValueSelection {}" +
+ " }" +
+ " }" +
+ " Event bla {}" +
+ " Iteration interation3 {" +
+ " Selection selection3 {" +
+ " Event ValueSelection {}" +
+ " Event ValueSelection {}" +
+ " }" +
+ " }" +
+ " Event bla {}" +
+ " Event bla {}" +
+ " Iteration interation4 {" +
+ " Selection selection4 {" +
+ " Event ValueSelection {}" +
+ " }" +
+ " }" +
+ "}", getTaskTree());
+ }
+
+ /**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 28.04.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+ public class DummyTrackBar extends DummyGUIElement implements ITrackBar {
+
+ /** */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ */
+ public DummyTrackBar() {
+ super("DummyTrackBar");
+ }
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/testutils/Utilities.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/testutils/Utilities.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/testutils/Utilities.java (revision 922)
@@ -0,0 +1,30 @@
+package de.ugoe.cs.autoquest.tasktrees.testutils;
+
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 02.04.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class Utilities {
+
+ /** */
+ private static final NodeEqualityRuleManager NODE_EQUALITY_RULE_MANAGER =
+ new NodeEqualityRuleManager();
+
+ static {
+ NODE_EQUALITY_RULE_MANAGER.init();
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public static NodeEqualityRuleManager getNodeEqualityRuleManagerForTests() {
+ return NODE_EQUALITY_RULE_MANAGER;
+ }
+
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeImplTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeImplTest.java (revision 922)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeImplTest.java (revision 922)
@@ -0,0 +1,466 @@
+package de.ugoe.cs.autoquest.tasktrees.treeimpl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeInfo;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.NodeInfo;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+import de.ugoe.cs.autoquest.test.DummyGUIElement;
+import de.ugoe.cs.autoquest.test.DummyInteraction;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 02.04.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class TaskTreeImplTest {
+
+ /** */
+ private static final int MAX_TREE_DEPTH = 15;
+
+ /** */
+ private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder();
+
+ /** */
+ private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory();
+
+ /**
+ * @throws Exception
+ *
+ */
+ @Test
+ public void testRandomTrees() throws Exception {
+ int noOfTrees = 10;
+ int noOfMaxChildren = 8;
+ int maxDepth = MAX_TREE_DEPTH;
+
+ for (int i = 0; i < noOfTrees; i++) {
+ System.err.println("iteration " + (i + 1) + ":");
+ System.err.println(" creating tree");
+ Map treeInfos =
+ new HashMap();
+ ITaskTreeNode rootNode = createTree(noOfMaxChildren, maxDepth, treeInfos);
+ System.err.println(" creating task tree");
+ ITaskTree taskTree = taskTreeNodeFactory.createTaskTree(rootNode);
+
+ System.err.println(" validating task tree");
+ assertEquals(rootNode, taskTree.getRoot());
+ assertMapsEqual(treeInfos, taskTree.getTaskMap());
+ }
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param treeInfos
+ * @param taskMap
+ */
+ private void assertMapsEqual(Map map1,
+ Map map2)
+ {
+ try {
+ if (map1 == null) {
+ assertNull(map2);
+ return;
+ }
+
+ assertEquals(map1.size(), map2.size());
+
+ for (Map.Entry entry : map1.entrySet()) {
+ ITaskTreeNodeInfo value2 = map2.get(entry.getKey());
+ assertNotNull(value2);
+ assertEquals(entry.getValue().getTask(), value2.getTask());
+ assertEquals(entry.getValue().getNoOfOccurencesInTree(),
+ value2.getNoOfOccurencesInTree());
+ }
+ }
+ catch (AssertionError e) {
+ dumpMap(map1);
+ dumpMap(map2);
+ throw e;
+ }
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param map2
+ */
+ private void dumpMap(Map map) {
+ System.err.println();
+
+ if (map == null) {
+ System.err.println("map is null");
+ }
+ else {
+ System.err.println("map:");
+ for (Map.Entry entry : map.entrySet()) {
+ System.err.print(" ");
+ System.err.print(entry.getKey());
+ for (int i = entry.getKey().toString().length(); i < 49; i++) {
+ System.err.print(" ");
+ }
+ System.err.print(" : ");
+ System.err.println(entry.getValue());
+ }
+ }
+
+ System.err.println();
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param noOfMaxChildren
+ * @param maxDepth
+ * @param treeInfos
+ * @return
+ */
+ private ITaskTreeNode createTree(int maxNoOfChildren,
+ int maxDepth,
+ Map treeInfos)
+ throws Exception
+ {
+ /*
+ * for (int i = 0; i < (MAX_TREE_DEPTH + 1 - maxDepth); i++) { System.err.print(" "); }
+ */
+
+ ITaskTreeNode tree;
+
+ // integrating the maximum depth here assures, that either something between 0 and 8 will
+ // be the type, or if the max depth decreases near 0 only event tasks will be created
+ // to finish the tree creation
+ int type = (int) (Math.random() * (Math.min(8, maxDepth)));
+
+ switch (type)
+ {
+ case 0: {
+ // System.err.print("creating new event task ");
+ tree = createNewEventTask(treeInfos);
+ break;
+ }
+ case 1: {
+ // System.err.print("reusing event task ");
+ tree = reuseEventTask(treeInfos);
+ break;
+ }
+ case 2: {
+ // System.err.println("creating new sequence {");
+ tree = createNewSequence(maxNoOfChildren, maxDepth, treeInfos);
+ break;
+ }
+ case 3: {
+ // System.err.println("reusing sequence {");
+ tree = reuseSequence(maxNoOfChildren, maxDepth, treeInfos);
+ break;
+ }
+ case 4: {
+ // System.err.println("creating new selection {");
+ tree = createNewSelection(maxNoOfChildren, maxDepth, treeInfos);
+ break;
+ }
+ case 5: {
+ // System.err.println("reusing selection {");
+ tree = reuseSelection(maxNoOfChildren, maxDepth, treeInfos);
+ break;
+ }
+ case 6: {
+ // System.err.println("creating new iteration {");
+ tree = createNewIteration(maxNoOfChildren, maxDepth, treeInfos);
+ break;
+ }
+ case 7: {
+ // System.err.println("reusing iteration {");
+ tree = reuseIteration(maxNoOfChildren, maxDepth, treeInfos);
+ break;
+ }
+ default: {
+ // System.err.print("creating new event task per default ");
+ tree = createNewEventTask(treeInfos);
+ }
+ }
+
+ /*
+ * if (!(tree instanceof InteractionTask)) { for (int i = 0; i < (MAX_TREE_DEPTH + 1 -
+ * maxDepth); i++) { System.err.print(" "); }
+ *
+ * System.err.print("} "); }
+ *
+ * System.err.println(tree);
+ */
+
+ return tree;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param treeInfos
+ * @return
+ */
+ private IEventTask createNewEventTask(Map treeInfos)
+ throws Exception
+ {
+ Thread.sleep(2);
+ long id = System.currentTimeMillis();
+ IEventTask task =
+ taskTreeNodeFactory.createNewEventTask(new DummyInteraction("interaction" + id, 1),
+ new DummyGUIElement("elem" + id));
+
+ treeInfos.put(task, new NodeInfo(task));
+
+ return task;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param treeInfos
+ * @return
+ */
+ private IEventTask reuseEventTask(Map treeInfos)
+ throws Exception
+ {
+ int noOfEventTasks = 0;
+
+ for (Map.Entry entry : treeInfos.entrySet()) {
+ if (entry.getKey() instanceof IEventTask) {
+ noOfEventTasks++;
+ }
+ }
+
+ if (noOfEventTasks > 0) {
+ noOfEventTasks = (int) (Math.random() * noOfEventTasks);
+
+ for (Map.Entry entry : treeInfos.entrySet()) {
+ if (entry.getKey() instanceof IEventTask) {
+ if (--noOfEventTasks <= 0) {
+ return (IEventTask) entry.getKey();
+ }
+ }
+ }
+ }
+ else {
+ return createNewEventTask(treeInfos);
+ }
+
+ throw new RuntimeException("this is an implementation error");
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param treeInfos
+ * @return
+ */
+ private ISequence createNewSequence(int maxNoOfChildren,
+ int maxDepth,
+ Map treeInfos)
+ throws Exception
+ {
+ ISequence sequence = taskTreeNodeFactory.createNewSequence();
+
+ int noOfChildren = (int) (Math.random() * maxNoOfChildren);
+
+ for (int i = 0; i < noOfChildren; i++) {
+ ITaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos);
+
+ // through first removing an existing parent it is assured, that a parent is recorded
+ // only once. This is needed, because parent may be reused in a tree as well, but we
+ // always
+ // iterate the whole tree
+ ((NodeInfo) treeInfos.get(child)).removeParent(sequence);
+ ((NodeInfo) treeInfos.get(child)).addParent(sequence);
+ taskTreeBuilder.addChild(sequence, child);
+ }
+
+ treeInfos.put(sequence, new NodeInfo(sequence));
+ return sequence;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param treeInfos
+ * @return
+ */
+ private ISequence reuseSequence(int maxNoOfChildren,
+ int maxDepth,
+ Map treeInfos)
+ throws Exception
+ {
+ int noOfSequences = 0;
+
+ for (Map.Entry entry : treeInfos.entrySet()) {
+ if (entry.getKey() instanceof ISequence) {
+ noOfSequences++;
+ }
+ }
+
+ if (noOfSequences > 0) {
+ noOfSequences = (int) (Math.random() * noOfSequences);
+
+ for (Map.Entry entry : treeInfos.entrySet()) {
+ if (entry.getKey() instanceof ISequence) {
+ if (--noOfSequences <= 0) {
+ return (ISequence) entry.getKey();
+ }
+ }
+ }
+ }
+ else {
+ return createNewSequence(maxNoOfChildren, maxDepth, treeInfos);
+ }
+
+ throw new RuntimeException("this is an implementation error");
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param treeInfos
+ * @return
+ */
+ private ISelection createNewSelection(int maxNoOfChildren,
+ int maxDepth,
+ Map treeInfos)
+ throws Exception
+ {
+ ISelection selection = taskTreeNodeFactory.createNewSelection();
+
+ int noOfChildren = (int) (Math.random() * maxNoOfChildren);
+
+ for (int i = 0; i < noOfChildren; i++) {
+ ITaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos);
+
+ // through first removing an existing parent it is assured, that a parent is recorded
+ // only once. This is needed, because parent may be reused in a tree as well, but we
+ // always
+ // iterate the whole tree
+ ((NodeInfo) treeInfos.get(child)).removeParent(selection);
+ ((NodeInfo) treeInfos.get(child)).addParent(selection);
+ taskTreeBuilder.addChild(selection, child);
+ }
+
+ treeInfos.put(selection, new NodeInfo(selection));
+ return selection;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param treeInfos
+ * @return
+ */
+ private ISelection reuseSelection(int maxNoOfChildren,
+ int maxDepth,
+ Map treeInfos)
+ throws Exception
+ {
+ int noOfSelections = 0;
+
+ for (Map.Entry entry : treeInfos.entrySet()) {
+ if (entry.getKey() instanceof ISelection) {
+ noOfSelections++;
+ }
+ }
+
+ if (noOfSelections > 0) {
+ noOfSelections = (int) (Math.random() * noOfSelections);
+
+ for (Map.Entry entry : treeInfos.entrySet()) {
+ if (entry.getKey() instanceof ISelection) {
+ if (--noOfSelections <= 0) {
+ return (ISelection) entry.getKey();
+ }
+ }
+ }
+ }
+ else {
+ return createNewSelection(maxNoOfChildren, maxDepth, treeInfos);
+ }
+
+ throw new RuntimeException("this is an implementation error");
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param treeInfos
+ * @return
+ */
+ private IIteration createNewIteration(int maxNoOfChildren,
+ int maxDepth,
+ Map treeInfos)
+ throws Exception
+ {
+ IIteration iteration = taskTreeNodeFactory.createNewIteration();
+
+ ITaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos);
+
+ // through first removing an existing parent it is assured, that a parent is recorded
+ // only once. This is needed, because parent may be reused in a tree as well, but we always
+ // iterate the whole tree
+ ((NodeInfo) treeInfos.get(child)).removeParent(iteration);
+ ((NodeInfo) treeInfos.get(child)).addParent(iteration);
+ taskTreeBuilder.setChild(iteration, child);
+
+ treeInfos.put(iteration, new NodeInfo(iteration));
+ return iteration;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param treeInfos
+ * @return
+ */
+ private IIteration reuseIteration(int maxNoOfChildren,
+ int maxDepth,
+ Map treeInfos)
+ throws Exception
+ {
+ int noOfIterations = 0;
+
+ for (Map.Entry entry : treeInfos.entrySet()) {
+ if (entry.getKey() instanceof IIteration) {
+ noOfIterations++;
+ }
+ }
+
+ if (noOfIterations > 0) {
+ noOfIterations = (int) (Math.random() * noOfIterations);
+
+ for (Map.Entry entry : treeInfos.entrySet()) {
+ if (entry.getKey() instanceof IIteration) {
+ if (--noOfIterations <= 0) {
+ return (IIteration) entry.getKey();
+ }
+ }
+ }
+ }
+ else {
+ return createNewIteration(maxNoOfChildren, maxDepth, treeInfos);
+ }
+
+ throw new RuntimeException("this is an implementation error");
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/.settings/org.eclipse.m2e.core.prefs
===================================================================
--- trunk/autoquest-core-tasktrees/.settings/org.eclipse.m2e.core.prefs (revision 921)
+++ trunk/autoquest-core-tasktrees/.settings/org.eclipse.m2e.core.prefs (revision 922)
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/manager/ComponentManager.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/manager/ComponentManager.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/manager/ComponentManager.java (revision 922)
@@ -0,0 +1,107 @@
+package de.ugoe.cs.autoquest.tasktrees.manager;
+
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
+import de.ugoe.cs.autoquest.tasktrees.temporalrelation.TemporalRelationshipRuleManager;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 12.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class ComponentManager {
+
+ /** */
+ private static ComponentManager instance;
+
+ /** */
+ private TemporalRelationshipRuleManager temporalRelationshipRuleManager;
+
+ /** */
+ private NodeEqualityRuleManager nodeEqualityRuleManager;
+
+ /** */
+ private ITaskTreeBuilder taskTreeBuilder;
+
+ /** */
+ private ITaskTreeNodeFactory taskTreeNodeFactory;
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public static TemporalRelationshipRuleManager getTemporalRelationshipRuleManager() {
+ return getInstance().temporalRelationshipRuleManager;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public static NodeEqualityRuleManager getNodeEqualityRuleManager() {
+ return getInstance().nodeEqualityRuleManager;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public static ITaskTreeBuilder getDefaultTaskTreeBuilder() {
+ return getInstance().taskTreeBuilder;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public static ITaskTreeNodeFactory getDefaultTaskTreeNodeFactory() {
+ return getInstance().taskTreeNodeFactory;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public static synchronized void clearInstance() {
+ instance = null;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ private static synchronized ComponentManager getInstance() {
+ if (instance == null) {
+ instance = new ComponentManager();
+ instance.init();
+ }
+ return instance;
+ }
+
+ /**
+ * TODO: comment
+ *
+ */
+ private void init() {
+ nodeEqualityRuleManager = new NodeEqualityRuleManager();
+ nodeEqualityRuleManager.init();
+
+ temporalRelationshipRuleManager =
+ new TemporalRelationshipRuleManager(nodeEqualityRuleManager);
+ temporalRelationshipRuleManager.init();
+
+ taskTreeBuilder = new TaskTreeBuilder();
+ taskTreeNodeFactory = new TaskTreeNodeFactory();
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/manager/TaskTreeManager.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/manager/TaskTreeManager.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/manager/TaskTreeManager.java (revision 922)
@@ -0,0 +1,119 @@
+package de.ugoe.cs.autoquest.tasktrees.manager;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.logging.Level;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.gui.KeyboardFocusChange;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
+import de.ugoe.cs.util.console.Console;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: $
+ * @author 2011, last modified by $Author: $
+ */
+public class TaskTreeManager {
+
+ /** */
+ private static final int MAX_EVENTS_TILL_RULE_APPLICATION = 100;
+
+ /** */
+ private ITaskTreeBuilder taskTreeBuilder = ComponentManager.getDefaultTaskTreeBuilder();
+
+ /** */
+ private ITaskTreeNodeFactory taskTreeNodeFactory =
+ ComponentManager.getDefaultTaskTreeNodeFactory();
+
+ /** */
+ private int eventsTillRuleApplication = MAX_EVENTS_TILL_RULE_APPLICATION;
+
+ /** */
+ private ISequence rootSequence;
+
+ /**
+ * TODO: comment
+ *
+ */
+ public TaskTreeManager() {
+ rootSequence = taskTreeNodeFactory.createNewSequence();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param sequences
+ * @return
+ */
+ public synchronized ITaskTree createTaskTree(Collection> sequences) {
+
+ for (List sequence : sequences) {
+ for (Event event : sequence) {
+ handleNewEvent(event);
+ }
+ }
+
+ return getTaskTree();
+ }
+
+ /**
+ *
+ */
+ public void handleNewEvent(Event event) {
+ handleEventTask(taskTreeNodeFactory.createNewEventTask(event.getType(), event.getTarget()));
+ }
+
+ /**
+ *
+ */
+ public synchronized ITaskTree getTaskTree() {
+ Console.traceln(Level.INFO, "applying temporal relationship generation rules");
+
+ ISequence currentRootSequence = rootSequence.clone();
+ ComponentManager.getTemporalRelationshipRuleManager().applyRules
+ (currentRootSequence, taskTreeBuilder, taskTreeNodeFactory, true);
+
+ return taskTreeNodeFactory.createTaskTree(currentRootSequence);
+ }
+
+ /**
+ * adds the task to the current or the new sequence. The decision depends on the type of task.
+ * If the task finishes the current sequence, the sequence is marked as finished If the task
+ * does not start a new sequence, it is added to the current sequence, before it is marked s
+ * finished. Otherwise it is added to a new sequence.
+ */
+ private synchronized void handleEventTask(IEventTask eventTask) {
+ if (!(eventTask.getEventType() instanceof KeyboardFocusChange)) {
+ Console.traceln(Level.INFO, "handling interaction event task \"" + eventTask + "\"");
+ addTaskToSequence(eventTask);
+ }
+ }
+
+ /**
+ *
+ */
+ private void addTaskToSequence(ITaskTreeNode task)
+ {
+ taskTreeBuilder.addChild(rootSequence, task);
+
+ if (--eventsTillRuleApplication == 0) {
+ eventsTillRuleApplication = MAX_EVENTS_TILL_RULE_APPLICATION;
+
+ Console.traceln(Level.INFO, "applying temporal relationship generation rules");
+ ComponentManager.getTemporalRelationshipRuleManager().applyRules(rootSequence,
+ taskTreeBuilder,
+ taskTreeNodeFactory,
+ false);
+ }
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/EventTaskComparisonRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/EventTaskComparisonRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/EventTaskComparisonRule.java (revision 922)
@@ -0,0 +1,44 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ *
+ * This rule identifies two task tree nodes as lexically equal, if they are both event tasks and
+ * if their respective event types and targets equal.
+ *
+ *
+ * @author Patrick Harms
+ */
+public class EventTaskComparisonRule implements NodeComparisonRule {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode)
+ */
+ @Override
+ public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) {
+ if ((!(node1 instanceof IEventTask)) || (!(node2 instanceof IEventTask))) {
+ return null;
+ }
+
+ if (node1 == node2) {
+ return NodeEquality.IDENTICAL;
+ }
+
+ IEventTask task1 = (IEventTask) node1;
+ IEventTask task2 = (IEventTask) node2;
+
+ if (task1.getEventType().equals(task2.getEventType()) &&
+ task1.getEventTarget().equals(task2.getEventTarget()))
+ {
+ return NodeEquality.LEXICALLY_EQUAL;
+ }
+ else {
+ return NodeEquality.UNEQUAL;
+ }
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/GUIEventTaskComparisonRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/GUIEventTaskComparisonRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/GUIEventTaskComparisonRule.java (revision 922)
@@ -0,0 +1,147 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import de.ugoe.cs.autoquest.eventcore.gui.IInteraction;
+import de.ugoe.cs.autoquest.eventcore.gui.TextInput;
+import de.ugoe.cs.autoquest.eventcore.gui.ValueSelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ *
+ * This rule compares GUI event tasks (i.e. it is more concrete, than the
+ * {@link EventTaskComparisonRule}). Two GUI event tasks are only equal if their event type and
+ * target are equal. The returned equality is even more fine-grained for events whose type is
+ * {@link TextInput} and {@link ValueSelection}. For text inputs, lexical equality is returned if
+ * the same text is entered using the same key interactions. Syntactical equality is returned if
+ * the same text is entered using different key interactions. Semantical equality is returned if
+ * different text is entered, but into the same event target. Value selections are syntactically
+ * equal, if the same value is selected. Otherwise they are semantically equal.
+ *
+ *
+ * @author Patrick Harms
+ */
+public class GUIEventTaskComparisonRule implements NodeComparisonRule {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode)
+ */
+ @Override
+ public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) {
+ if ((!(node1 instanceof IEventTask)) || (!(node2 instanceof IEventTask))) {
+ return null;
+ }
+
+ IEventTask task1 = (IEventTask) node1;
+ IEventTask task2 = (IEventTask) node2;
+
+ if ((!(task1.getEventType() instanceof IInteraction)) ||
+ (!(task2.getEventType() instanceof IInteraction)))
+ {
+ return null;
+ }
+
+ if (node1 == node2) {
+ return NodeEquality.IDENTICAL;
+ }
+
+ if (!task1.getEventTarget().equals(task2.getEventTarget())) {
+ return NodeEquality.UNEQUAL;
+ }
+
+ IInteraction interaction1 = (IInteraction) task1.getEventType();
+ IInteraction interaction2 = (IInteraction) task2.getEventType();
+
+ return compareInteractions(interaction1, interaction2);
+ }
+
+ /**
+ *
+ * compares two interactions. The method delegates two
+ * {@link #compareTextInputs(TextInput, TextInput)} and
+ * {@link #compareValueSelections(ValueSelection, ValueSelection)} for text inputs and value
+ * selections. Otherwise it uses the equal method of the interactions for comparison. In this
+ * case, if the interactions equal method returns true, this method returns lexical equality.
+ *
+ *
+ * @param interaction1 the first interaction to compare
+ * @param interaction2 the second interaction to compare
+ *
+ * @return as described
+ */
+ private NodeEquality compareInteractions(IInteraction interaction1, IInteraction interaction2) {
+ if (interaction1 == interaction2) {
+ return NodeEquality.LEXICALLY_EQUAL;
+ }
+ else if ((interaction1 instanceof TextInput) && (interaction2 instanceof TextInput)) {
+ return compareTextInputs((TextInput) interaction1, (TextInput) interaction2);
+ }
+ else if ((interaction1 instanceof ValueSelection) &&
+ (interaction2 instanceof ValueSelection))
+ {
+ return compareValueSelections
+ ((ValueSelection) interaction1, (ValueSelection) interaction2);
+ }
+ else if (interaction1.equals(interaction2)) {
+ return NodeEquality.LEXICALLY_EQUAL;
+ }
+ else {
+ return NodeEquality.UNEQUAL;
+ }
+ }
+
+ /**
+ *
+ * compares two text inputs. If both text inputs have the same entered text and text input
+ * events, they are lexically equal. If they only have the same entered text, they are
+ * syntactically equal. If they are only both text inputs, they are semantically equal.
+ * (the equality of the event targets is checked beforehand).
+ *
+ *
+ * @param interaction1 the first text input to compare
+ * @param interaction2 the second text input to compare
+ *
+ * @return as described
+ */
+ private NodeEquality compareTextInputs(TextInput interaction1, TextInput interaction2) {
+ if (interaction1.getEnteredText().equals(interaction2.getEnteredText())) {
+ if (interaction1.getTextInputEvents().equals(interaction2.getTextInputEvents())) {
+ return NodeEquality.LEXICALLY_EQUAL;
+ }
+ else {
+ return NodeEquality.SYNTACTICALLY_EQUAL;
+ }
+ }
+ else {
+ return NodeEquality.SEMANTICALLY_EQUAL;
+ }
+ }
+
+ /**
+ *
+ * compares two value selections. If both value selections have the same selected value, they
+ * are syntactically equal, otherwise they are semantically equal.
+ * (the equality of the event targets is checked beforehand).
+ *
+ *
+ * @param interaction1 the first value selection to compare
+ * @param interaction2 the second value selection to compare
+ *
+ * @return as described
+ */
+ private NodeEquality compareValueSelections(ValueSelection interaction1,
+ ValueSelection interaction2)
+ {
+ Object value1 = interaction1.getSelectedValue();
+ Object value2 = interaction2.getSelectedValue();
+
+ if ((value1 == value2) || ((value1 != null) && (value1.equals(value2)))) {
+ return NodeEquality.SYNTACTICALLY_EQUAL;
+ }
+ else {
+ return NodeEquality.SEMANTICALLY_EQUAL;
+ }
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/IterationComparisonRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/IterationComparisonRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/IterationComparisonRule.java (revision 922)
@@ -0,0 +1,191 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ *
+ * This class is capable of comparing Iterations. Iterations equal at distinct levels
+ * in distinct situations. The following table shows the results of the comparison for the
+ * specific situations (the parameters are commutative). In any other situation, the comparison
+ * returns NodeEquality.UNEQUAL:
+ *
+ *
+ *
+ *
+ * | iteration 1 |
+ * iteration 2 |
+ * comparison result |
+ *
+ *
+ * | any iteration |
+ * any iteration with a child that is lexically equal to the child of iteration 1 |
+ * NodeEquality.LEXICALLY_EQUAL |
+ *
+ *
+ * | any iteration |
+ * any iteration with a child that is syntactically equal to the child of iteration 1 |
+ * NodeEquality.SYNTACTICALLY_EQUAL |
+ *
+ *
+ * | any iteration |
+ * any iteration with a child that is semantically equal to the child of iteration 1 |
+ * NodeEquality.SEMANTICALLY_EQUAL |
+ *
+ *
+ * | an iteration with a selection of syntactically equal children |
+ * an iteration with a child that is syntactically equal to the children of the child
+ * selection of iteration 1 |
+ * NodeEquality.SYNTACTICALLY_EQUAL |
+ *
+ *
+ * | an iteration with a selection of syntactically equal children |
+ * an iteration with a selection of syntactically equal children that are all syntactically
+ * equal to the selection of children of iteration 1 |
+ * NodeEquality.SYNTACTICALLY_EQUAL |
+ *
+ *
+ * | an iteration with a selection of semantically equal children |
+ * an iteration with a child that is semantically equal to the children of the child
+ * selection of iteration 1 |
+ * NodeEquality.SEMANTICALLY_EQUAL |
+ *
+ *
+ * | an iteration with a selection of semantically equal children |
+ * an iteration with a selection of semantically equal children that are all semantically
+ * equal to the selection of children of iteration 1 |
+ * NodeEquality.SEMANTICALLY_EQUAL |
+ *
+ *
+ *
+ * @version $Revision: $ $Date: 19.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class IterationComparisonRule implements NodeComparisonRule {
+
+ /** the rule manager for internally comparing task tree nodes */
+ private NodeEqualityRuleManager mRuleManager;
+
+ /**
+ *
+ * simple constructor to provide the rule with the node equality rule manager to be able
+ * to perform comparisons of the children of provided task tree nodes
+ *
+ *
+ * @param ruleManager the rule manager for comparing task tree nodes
+ */
+ IterationComparisonRule(NodeEqualityRuleManager ruleManager) {
+ super();
+ mRuleManager = ruleManager;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode)
+ */
+ @Override
+ public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) {
+ if ((!(node1 instanceof IIteration)) || (!(node2 instanceof IIteration))) {
+ return null;
+ }
+
+ if (node1 == node2) {
+ return NodeEquality.IDENTICAL;
+ }
+
+ // if both iterations do not have children, they are equal although this doesn't make sense
+ if ((node1.getChildren().size() == 0) && (node2.getChildren().size() == 0)) {
+ return NodeEquality.LEXICALLY_EQUAL;
+ }
+ else if ((node1.getChildren().size() == 0) || (node2.getChildren().size() == 0)) {
+ return NodeEquality.UNEQUAL;
+ }
+
+ ITaskTreeNode child1 = node1.getChildren().get(0);
+ ITaskTreeNode child2 = node2.getChildren().get(0);
+
+ // iterations may have 3 different structures.
+ // 1. they have one child, which is the iterated one
+ // 2. they have a sequence of children, which is iterated
+ // 3. they have a selection of different iterated variants (usually the variants are
+ // semantically equal)
+ //
+ // the permutations of the three variants in combination must be checked
+
+ // check if both nodes are the same variants of iterations and if their children are equal.
+ // This condition matches, if both iterations are the same variants of iteration. I.e. three
+ // combinations of the permutation are handled herewith.
+ NodeEquality nodeEquality = mRuleManager.applyRules(child1, child2);
+
+ if (nodeEquality.isAtLeast(NodeEquality.SEMANTICALLY_EQUAL)) {
+ // prevent, that identical is returned, because the iterations itself are not identical
+ // although the iterated tasks are
+ if (nodeEquality == NodeEquality.IDENTICAL) {
+ return NodeEquality.LEXICALLY_EQUAL;
+ }
+ else {
+ return nodeEquality;
+ }
+ }
+
+ // compare one iteration with a single node as a child and another one with a selection of
+ // semantically equal nodes
+ return selectionChildrenSemanticallyEqualNode(child1, child2);
+
+ // all other combinations (i.e. sequence with single child and sequence with selection)
+ // can not match
+ }
+
+ /**
+ *
+ * compares two task tree nodes. One of them must be a selection, the other one can be any task
+ * tree node. The method returns a node equality that is not NodeEquality.UNEQUAL
+ * if the other node is at least semantically equal to the children of the selection. It
+ * returns more concrete equalities, if the equality between the other node and the children
+ * of the selection is more concrete.
+ *
+ *
+ * @param taskTreeNode the first task tree node to compare
+ * @param taskTreeNode2 the second task tree node to compare
+ *
+ * @return as described
+ */
+ private NodeEquality selectionChildrenSemanticallyEqualNode(ITaskTreeNode taskTreeNode,
+ ITaskTreeNode taskTreeNode2)
+ {
+ ISelection selection = null;
+ ITaskTreeNode node = null;
+ if (taskTreeNode instanceof ISelection) {
+ selection = (ISelection) taskTreeNode;
+ node = taskTreeNode2;
+ }
+ else if (taskTreeNode2 instanceof ISelection) {
+ selection = (ISelection) taskTreeNode2;
+ node = taskTreeNode;
+ }
+ else {
+ return NodeEquality.UNEQUAL;
+ }
+
+ // Iterations, where one has a selection and the other one not can at most be syntactically
+ // equal but not identical
+ NodeEquality commonDenominatorForAllComparisons = NodeEquality.SYNTACTICALLY_EQUAL;
+
+ for (ITaskTreeNode child : selection.getChildren()) {
+ NodeEquality nodeEquality = mRuleManager.applyRules(node, child);
+
+ if ((nodeEquality == null) || (nodeEquality == NodeEquality.UNEQUAL))
+ {
+ return NodeEquality.UNEQUAL;
+ }
+
+ commonDenominatorForAllComparisons =
+ commonDenominatorForAllComparisons.getCommonDenominator(nodeEquality);
+ }
+
+ return commonDenominatorForAllComparisons;
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndIterationComparisonRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndIterationComparisonRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndIterationComparisonRule.java (revision 922)
@@ -0,0 +1,86 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ *
+ * This class is capable of comparing any task tree node which is not an iteration with an
+ * iteration. This is needed, because iterations may iterate exactly that node. In this
+ * case, the iteration would be equal to that node if it was executed exactly once. The rule
+ * returns lexically equal, it the child of the iteration is lexically equal to the node
+ * or if the child of the iteration is a selection and this selections contains a lexically equal
+ * node. The same applies for syntactical and semantical equality.
+ *
+
+ * @author Patrick Harms
+ */
+public class NodeAndIterationComparisonRule implements NodeComparisonRule {
+
+ /** the rule manager for internally comparing task tree nodes */
+ private NodeEqualityRuleManager mRuleManager;
+
+ /**
+ *
+ * simple constructor to provide the rule with the node equality rule manager to be able
+ * to perform comparisons of the children of provided task tree nodes
+ *
+ *
+ * @param ruleManager the rule manager for comparing task tree nodes
+ */
+ NodeAndIterationComparisonRule(NodeEqualityRuleManager ruleManager) {
+ super();
+ mRuleManager = ruleManager;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode)
+ */
+ @Override
+ public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) {
+ IIteration iteration = null;
+ ITaskTreeNode node = null;
+
+ if (node1 instanceof IIteration) {
+ if (node2 instanceof IIteration) {
+ // the rule is not responsible for two iterations
+ return null;
+ }
+
+ iteration = (IIteration) node1;
+ node = node2;
+ }
+ else if (node2 instanceof IIteration) {
+ if (node1 instanceof IIteration) {
+ // the rule is not responsible for two iterations
+ return null;
+ }
+
+ iteration = (IIteration) node2;
+ node = node1;
+ }
+ else {
+ return null;
+ }
+
+ // now, that we found the iteration and the node, lets compare the child of the iteration
+ // with the node.
+ if (iteration.getChildren().size() < 1) {
+ return null;
+ }
+
+ NodeEquality nodeEquality = mRuleManager.applyRules(iteration.getChildren().get(0), node);
+
+ // although the subtask may be identical to the node, we can not return identical, as
+ // the iteration is not identical to the node, but at most lexically equal
+ if (nodeEquality == NodeEquality.IDENTICAL) {
+ return NodeEquality.LEXICALLY_EQUAL;
+ }
+ else {
+ return nodeEquality;
+ }
+
+ }
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndSelectionComparisonRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndSelectionComparisonRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeAndSelectionComparisonRule.java (revision 922)
@@ -0,0 +1,99 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ *
+ * This class is capable of comparing any task tree node which is not a selection with a
+ * selection. This is needed, because selections may contain exactly that node. Therefore, if
+ * this node is selected out of a selection the selection is equal to the node itself.
+ * The rule returns lexically equal, it the selection contains a lexically equal node. The same
+ * applies for syntactical and semantical equality.
+ *
+
+ * @author Patrick Harms
+ */
+public class NodeAndSelectionComparisonRule implements NodeComparisonRule {
+
+ /** the rule manager for internally comparing task tree nodes */
+ private NodeEqualityRuleManager mRuleManager;
+
+ /**
+ *
+ * simple constructor to provide the rule with the node equality rule manager to be able
+ * to perform comparisons of the children of provided task tree nodes
+ *
+ *
+ * @param ruleManager the rule manager for comparing task tree nodes
+ */
+ NodeAndSelectionComparisonRule(NodeEqualityRuleManager ruleManager) {
+ super();
+ mRuleManager = ruleManager;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode)
+ */
+ @Override
+ public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) {
+ ISelection selection = null;
+ ITaskTreeNode node = null;
+
+ if (node1 instanceof ISelection) {
+ if (node2 instanceof ISelection) {
+ // the rule is not responsible for two iterations
+ return null;
+ }
+
+ selection = (ISelection) node1;
+ node = node2;
+ }
+ else if (node2 instanceof ISelection) {
+ if (node1 instanceof ISelection) {
+ // the rule is not responsible for two iterations
+ return null;
+ }
+
+ selection = (ISelection) node2;
+ node = node1;
+ }
+ else {
+ return null;
+ }
+
+ // now, that we found the iteration and the node, lets compare the child of the iteration
+ // with the node.
+ if (selection.getChildren().size() < 1) {
+ return null;
+ }
+
+ NodeEquality mostConcreteNodeEquality = null;
+
+ for (ITaskTreeNode child : selection.getChildren()) {
+ NodeEquality nodeEquality = mRuleManager.applyRules(child, node);
+
+ if (nodeEquality != NodeEquality.UNEQUAL) {
+ if (mostConcreteNodeEquality == null) {
+ mostConcreteNodeEquality = nodeEquality;
+ }
+ else {
+ mostConcreteNodeEquality =
+ mostConcreteNodeEquality.getCommonDenominator(nodeEquality);
+ }
+ }
+ }
+
+ // although the subtask may be identical to the node, we can not return identical, as
+ // the selection is not identical to the node, but at most lexically equal
+ if (mostConcreteNodeEquality == NodeEquality.IDENTICAL) {
+ return NodeEquality.LEXICALLY_EQUAL;
+ }
+ else {
+ return mostConcreteNodeEquality;
+ }
+
+ }
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeComparisonRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeComparisonRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeComparisonRule.java (revision 922)
@@ -0,0 +1,30 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ *
+ * A node comparison rule is used by the {@link NodeEqualityRuleManager} to compare task tree
+ * nodes with each other. It provides one method to be called for a comparison.
+ *
+ *
+ * @version $Revision: $ $Date: 19.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public interface NodeComparisonRule {
+
+ /**
+ *
+ * compares two nodes with each other. The result of the method is either a node equality or
+ * null. If it is null, it means, that the rule is not able to correctly compare the two given
+ * nodes
+ *
+ *
+ * @param node1 the first task tree node to compare
+ * @param node2 the second task tree node to compare
+ *
+ * @return as described
+ */
+ public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2);
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeEquality.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeEquality.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeEquality.java (revision 922)
@@ -0,0 +1,113 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+/**
+ *
+ * A node equality denotes, how equal two task tree nodes are. There are different equality levels
+ * which are similar to the usual design levels of GUI design. These levels are
+ *
+ * - conceptual design: defines the concepts to be edited using a GUI
+ * - semantical design: defines the possible functions for editing the concepts
+ * - syntactical design: defines, which steps are needed to execute the functions
+ * - lexical design: defines on the key stroke level, how the steps for executing a function
+ * can be performed
+ *
+ * It is not possible to compare two task nodes conceptually. But the other design levels can be
+ * identified and compared.
+ *
+ *
+ * Nodes can be identical. This is the case if in the java virtual machine, their comparison
+ * using the == operator or the equals method return true.
+ *
+ *
+ * Nodes are lexically equal, if they represent the same events on a key stroke level to be
+ * carried out to execute the task. Identical nodes are also syntactically equal.
+ *
+ *
+ * Nodes are syntactically equal, if they differ in their events on key stroke level, but the
+ * syntactical result is the same. For example, entering the text "hello" into a text field can
+ * be done by entering the letters in their correct order, but also by copying the text into the
+ * text field. The syntactical result is the same: The text hello was entered. But the tasks
+ * lexically differ because the events on key stroke level are different. On the other hand,
+ * lexically equal nodes are also syntactically equal.
+ *
+ *
+ * Task tree nodes are semantically equal, if they execute the same function for editing the
+ * concepts. An example are a click on a button and a short cut, both executing the same function.
+ * These task tree nodes are syntactically and, therefore, also lexically different, but
+ * semantically equal. Syntactically equal task tree nodes are always also semantically equal.
+ *
+ *
+ * @version $Revision: $ $Date: 19.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public enum NodeEquality {
+ IDENTICAL,
+ LEXICALLY_EQUAL,
+ SYNTACTICALLY_EQUAL,
+ SEMANTICALLY_EQUAL,
+ UNEQUAL;
+
+ /**
+ *
+ * Checks for the current node equality, if it is at least identical to the
+ * provided one or even more concrete. As an example, the node equality identical also
+ * indicates, that the nodes are e.g. lexically, syntactically and semantically equal.
+ * Therefore, the method called on IDENTICAL with SEMANTICALLY_EQUAL
+ * as parameter will return true. If this method is called on SYNTACTICALLY_EQUAL
+ * with the parameter IDENTICAL instead, it returns false;
+ *
+ *
+ * @param nodeEquality the node equality to compare with.
+ *
+ * @return as described
+ */
+ public boolean isAtLeast(NodeEquality nodeEquality)
+ {
+ switch (nodeEquality) {
+ case IDENTICAL:
+ return
+ (this == IDENTICAL);
+ case LEXICALLY_EQUAL:
+ return
+ (this == IDENTICAL) ||
+ (this == LEXICALLY_EQUAL);
+ case SYNTACTICALLY_EQUAL:
+ return
+ (this == IDENTICAL) ||
+ (this == LEXICALLY_EQUAL) ||
+ (this == SYNTACTICALLY_EQUAL);
+ case SEMANTICALLY_EQUAL:
+ return
+ (this == IDENTICAL) ||
+ (this == LEXICALLY_EQUAL) ||
+ (this == SYNTACTICALLY_EQUAL) ||
+ (this == SEMANTICALLY_EQUAL);
+ case UNEQUAL:
+ return
+ (this == UNEQUAL);
+ default :
+ return false;
+ }
+ }
+
+ /**
+ *
+ * returns the common denominator of this node equality and the provided one. I.e. if one
+ * equality is e.g. syntactical and the other one only semantical, then semantical is returned.
+ *
+ *
+ * @param equality the equality, to compare this with
+ * @return
+ */
+ public NodeEquality getCommonDenominator(NodeEquality otherEquality) {
+ if (this.isAtLeast(otherEquality)) {
+ return otherEquality;
+ }
+ else if (otherEquality.isAtLeast(this)) {
+ return this;
+ }
+ else {
+ return NodeEquality.UNEQUAL;
+ }
+ }
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeEqualityRuleManager.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeEqualityRuleManager.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeEqualityRuleManager.java (revision 922)
@@ -0,0 +1,84 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ *
+ * The node equality rule manager is capable of comparing task tree nodes based on its internal list
+ * of comparison rules. The current list of rules contains the {@link NodeIdentityRule}, the
+ * {@link IterationComparisonRule}, the {@link SequenceComparisonRule}, and
+ * {@link SelectionComparisonRule}. These rules are asked for comparing the two provided task tree
+ * nodes in the mentioned order. If a rule returns a node equality other than null, this equality is
+ * returned. Otherwise the next rule is asked.
+ *
+ *
+ * @version $Revision: $ $Date: 19.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class NodeEqualityRuleManager {
+
+ /** */
+ private List mRuleIndex = null;
+
+ /**
+ *
+ * initializes the node equality rule manager by filling the internal list of comparison rules.
+ * This method must be called before any other method is called on the rule manager.
+ *
+ */
+ public void init() {
+ mRuleIndex = new ArrayList();
+ mRuleIndex.add(new NodeIdentityRule());
+ mRuleIndex.add(new GUIEventTaskComparisonRule());
+ mRuleIndex.add(new EventTaskComparisonRule());
+ mRuleIndex.add(new IterationComparisonRule(this));
+ mRuleIndex.add(new SequenceComparisonRule(this));
+ mRuleIndex.add(new SelectionComparisonRule(this));
+ mRuleIndex.add(new NodeAndIterationComparisonRule(this));
+ mRuleIndex.add(new NodeAndSelectionComparisonRule(this));
+ }
+
+ /**
+ *
+ * this method performs a comparison of the two provided task tree nodes. It iterates its
+ * internal comparison rules. If the first rule returns a node equality other than null,
+ * this equality is returned. Otherwise the next rule is tried. If no rule returns an equality
+ * NodeEquality.UNEQUAL is returned.
+ *
+ *
+ * @param node1 the first task tree node to be compared
+ * @param node2 the second task tree node to be compared
+ *
+ * @return as described
+ *
+ * @throws IllegalStateException in the case, the {@link #init()} method was not called on the
+ * manager before a call to this method.
+ */
+ public NodeEquality applyRules(ITaskTreeNode node1, ITaskTreeNode node2)
+ throws IllegalStateException
+ {
+ if (mRuleIndex == null) {
+ throw new IllegalStateException("not initialized");
+ }
+
+ // LOG.info("checking for equality of " + node1 + " and " + node2);
+ NodeEquality nodeEquality = null;
+
+ for (NodeComparisonRule rule : mRuleIndex) {
+ nodeEquality = rule.compare(node1, node2);
+
+ if (nodeEquality != null) {
+ // LOG.warning("used rule " + rule + " for equality check");
+ return nodeEquality;
+ }
+ }
+
+ // LOG.warning("no rule could be applied --> handling nodes as unequal");
+
+ return NodeEquality.UNEQUAL;
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeIdentityRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeIdentityRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/NodeIdentityRule.java (revision 922)
@@ -0,0 +1,32 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ *
+ * This comparison rule returns NodeEquality.IDENTICAL if the comparison of the two
+ * task tree nodes using the == operator or the equals method return true.
+ * Else it returns null to denote, that it can not compare the nodes.
+ *
+ *
+ * @version $Revision: $ $Date: 19.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class NodeIdentityRule implements NodeComparisonRule {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode)
+ */
+ @Override
+ public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) {
+ if (node1 == node2) {
+ return NodeEquality.IDENTICAL;
+ }
+ else {
+ return null;
+ }
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SelectionComparisonRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SelectionComparisonRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SelectionComparisonRule.java (revision 922)
@@ -0,0 +1,116 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ *
+ * this node comparison rule is capable of comparing selections. If both selections do not have
+ * children, they are treated as identical. If they have children, each child of both selections
+ * is compared to each child of the respective other selection. The resulting equality is the most
+ * concrete one of all these comparisons. I.e. if all children are at least lexically equal, then
+ * the selections are lexically equal. If all children are at least syntactically equal, then the
+ * selections are syntactically equal. If all children are at least semantically equal, then the
+ * selections are semantically equal. If only one of the selections has children, then the
+ * selections are unequal.
+ *
+ *
+ * @version $Revision: $ $Date: 19.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class SelectionComparisonRule implements NodeComparisonRule {
+
+ /** the rule manager for internally comparing task tree nodes */
+ private NodeEqualityRuleManager mRuleManager;
+
+ /**
+ *
+ * simple constructor to provide the rule with the node equality rule manager to be able
+ * to perform comparisons of the children of provided task tree nodes
+ *
+ *
+ * @param ruleManager the rule manager for comparing task tree nodes
+ */
+ SelectionComparisonRule(NodeEqualityRuleManager ruleManager) {
+ super();
+ mRuleManager = ruleManager;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode)
+ */
+ @Override
+ public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) {
+ if ((!(node1 instanceof ISelection)) || (!(node2 instanceof ISelection))) {
+ return null;
+ }
+
+ if (node1 == node2) {
+ return NodeEquality.IDENTICAL;
+ }
+
+ // if both sequences do not have children, they are identical. If only one of them has
+ // children, they are unequal.
+ if ((node1.getChildren().size() == 0) && (node2.getChildren().size() == 0)) {
+ return NodeEquality.LEXICALLY_EQUAL;
+ }
+ else if ((node1.getChildren().size() == 0) || (node2.getChildren().size() == 0)) {
+ return NodeEquality.UNEQUAL;
+ }
+
+ NodeEquality selectionEquality = NodeEquality.LEXICALLY_EQUAL;
+
+ // compare each child of selection one with each child of selection two
+ NodeEquality childEquality;
+ NodeEquality currentEquality;
+ for (ITaskTreeNode child1 : node1.getChildren()) {
+ childEquality = null;
+ for (ITaskTreeNode child2 : node2.getChildren()) {
+ currentEquality = mRuleManager.applyRules(child1, child2);
+ if ((currentEquality != null) && (currentEquality != NodeEquality.UNEQUAL)) {
+ if (childEquality == null) {
+ childEquality = currentEquality;
+ }
+ else {
+ childEquality = childEquality.getCommonDenominator(currentEquality);
+ }
+ }
+ }
+
+ if (childEquality != null) {
+ selectionEquality = selectionEquality.getCommonDenominator(childEquality);
+ }
+ else {
+ return NodeEquality.UNEQUAL;
+ }
+ }
+
+ // compare each child of selection two with each child of selection one
+ for (ITaskTreeNode child2 : node2.getChildren()) {
+ childEquality = null;
+ for (ITaskTreeNode child1 : node1.getChildren()) {
+ currentEquality = mRuleManager.applyRules(child1, child2);
+ if ((currentEquality != null) && (currentEquality != NodeEquality.UNEQUAL)) {
+ if (childEquality == null) {
+ childEquality = currentEquality;
+ }
+ else {
+ childEquality = childEquality.getCommonDenominator(currentEquality);
+ }
+ }
+ }
+
+ if (childEquality != null) {
+ selectionEquality = selectionEquality.getCommonDenominator(childEquality);
+ }
+ else {
+ return NodeEquality.UNEQUAL;
+ }
+ }
+
+ return selectionEquality;
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SequenceComparisonRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SequenceComparisonRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/nodeequality/SequenceComparisonRule.java (revision 922)
@@ -0,0 +1,76 @@
+package de.ugoe.cs.autoquest.tasktrees.nodeequality;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ *
+ * This rule is capable of comparing sequences. If both sequences do not have children, they are
+ * treated as lexically equal. Sequences are lexically equal, if they have the same number and
+ * order of lexically equal children. The rule can not decide, if two sequences are syntactically
+ * or semantically equal.
+ *
+ *
+ * @version $Revision: $ $Date: 19.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class SequenceComparisonRule implements NodeComparisonRule {
+
+ /** the rule manager for internally comparing task tree nodes */
+ private NodeEqualityRuleManager mRuleManager;
+
+ /**
+ *
+ * simple constructor to provide the rule with the node equality rule manager to be able
+ * to perform comparisons of the children of provided task tree nodes
+ *
+ *
+ * @param ruleManager the rule manager for comparing task tree nodes
+ */
+ SequenceComparisonRule(NodeEqualityRuleManager ruleManager) {
+ super();
+ mRuleManager = ruleManager;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode)
+ */
+ @Override
+ public NodeEquality compare(ITaskTreeNode node1, ITaskTreeNode node2) {
+ if ((!(node1 instanceof ISequence)) || (!(node2 instanceof ISequence))) {
+ return null;
+ }
+
+ if (node1 == node2) {
+ return NodeEquality.IDENTICAL;
+ }
+
+ // if both sequences do not have children, they are equal although this doesn't make sense
+ if ((node1.getChildren().size() == 0) && (node2.getChildren().size() == 0)) {
+ return NodeEquality.LEXICALLY_EQUAL;
+ }
+
+ if (node1.getChildren().size() != node2.getChildren().size()) {
+ return NodeEquality.UNEQUAL;
+ }
+
+ NodeEquality resultingEquality = NodeEquality.LEXICALLY_EQUAL;
+ for (int i = 0; i < node1.getChildren().size(); i++) {
+ ITaskTreeNode child1 = node1.getChildren().get(i);
+ ITaskTreeNode child2 = node2.getChildren().get(i);
+
+ NodeEquality nodeEquality = mRuleManager.applyRules(child1, child2);
+
+ if ((nodeEquality == null) || (nodeEquality == NodeEquality.UNEQUAL)) {
+ return NodeEquality.UNEQUAL;
+ }
+
+ resultingEquality = resultingEquality.getCommonDenominator(nodeEquality);
+ }
+
+ return resultingEquality;
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultEventTargetSequenceDetectionRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultEventTargetSequenceDetectionRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultEventTargetSequenceDetectionRule.java (revision 922)
@@ -0,0 +1,153 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 18.03.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class DefaultEventTargetSequenceDetectionRule implements TemporalRelationshipRule {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode,
+ * TaskTreeBuilder, TaskTreeNodeFactory)
+ */
+ @Override
+ public RuleApplicationResult apply(ITaskTreeNode parent,
+ ITaskTreeBuilder builder,
+ ITaskTreeNodeFactory nodeFactory,
+ boolean finalize)
+ {
+ if (!(parent instanceof ISequence)) {
+ return null;
+ }
+
+ RuleApplicationResult result = new RuleApplicationResult();
+
+ IEventTarget currentEventTarget = null;
+ int startingIndex = -1;
+
+ int index = 0;
+ while (index < parent.getChildren().size()) {
+ ITaskTreeNode child = parent.getChildren().get(index);
+
+ IEventTarget eventTarget = determineEventTarget(child);
+
+ if (((eventTarget == null) && (currentEventTarget != null)) ||
+ ((eventTarget != null) && (!eventTarget.equals(currentEventTarget))))
+ {
+ if (startingIndex < 0) {
+ startingIndex = index;
+ currentEventTarget = eventTarget;
+ }
+ else {
+ int endIndex = index - 1;
+
+ // only reduce to a sequence, if it is not a sequence with only one child
+ // or if this child is not a sequence itself
+ if ((startingIndex != endIndex) ||
+ (!(parent.getChildren().get(startingIndex) instanceof ISequence)))
+ {
+ handleEventTargetSequence
+ (parent, startingIndex, endIndex, builder, nodeFactory, result);
+
+ result.setRuleApplicationStatus
+ (RuleApplicationStatus.RULE_APPLICATION_FINISHED);
+ return result;
+ }
+ else {
+ // here a new sequence on a new target begins
+ startingIndex = index;
+ currentEventTarget = eventTarget;
+ }
+ }
+ }
+
+ index++;
+ }
+
+ if (startingIndex > -1) {
+ int endIndex = parent.getChildren().size() - 1;
+
+ if (finalize) {
+ // only reduce to a sequence, if it is not a sequence with only one child
+ // or if this child is not a sequence itself
+ if ((startingIndex > 0) &&
+ ((startingIndex != endIndex) ||
+ (!(parent.getChildren().get(startingIndex) instanceof ISequence))))
+ {
+ handleEventTargetSequence
+ (parent, startingIndex, endIndex, builder, nodeFactory, result);
+
+ result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED);
+ }
+ }
+ else {
+ result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE);
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param child
+ * @return
+ */
+ private IEventTarget determineEventTarget(ITaskTreeNode node) {
+ if (node instanceof IEventTask) {
+ return ((IEventTask) node).getEventTarget();
+ }
+ else {
+ IEventTarget commonTarget = null;
+
+ for (ITaskTreeNode child : node.getChildren()) {
+ if (commonTarget == null) {
+ commonTarget = determineEventTarget(child);
+ }
+ else {
+ if (!commonTarget.equals(determineEventTarget(child))) {
+ return null;
+ }
+ }
+ }
+
+ return commonTarget;
+ }
+ }
+
+ /**
+ * TODO: comment
+ *
+ */
+ private void handleEventTargetSequence(ITaskTreeNode parent,
+ int startIndex,
+ int endIndex,
+ ITaskTreeBuilder builder,
+ ITaskTreeNodeFactory nodeFactory,
+ RuleApplicationResult result)
+ {
+ ISequence sequence = nodeFactory.createNewSequence();
+
+ for (int i = startIndex; i <= endIndex; i++) {
+ builder.addChild(sequence, parent.getChildren().get(startIndex));
+ builder.removeChild((ISequence) parent, startIndex);
+ }
+
+ builder.addChild((ISequence) parent, startIndex, sequence);
+
+ result.addNewlyCreatedParentNode(sequence);
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiElementSequenceDetectionRule.java (revision 922)
@@ -0,0 +1,345 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 18.03.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class DefaultGuiElementSequenceDetectionRule implements TemporalRelationshipRule {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode,
+ * TaskTreeBuilder, TaskTreeNodeFactory)
+ */
+ @Override
+ public RuleApplicationResult apply(ITaskTreeNode parent,
+ ITaskTreeBuilder builder,
+ ITaskTreeNodeFactory nodeFactory,
+ boolean finalize)
+ {
+ if (!(parent instanceof ISequence)) {
+ return null;
+ }
+
+ RuleApplicationResult result = new RuleApplicationResult();
+
+ IGUIElement lastGuiElement = null;
+ int index = 0;
+ while (index < parent.getChildren().size()) {
+ ITaskTreeNode child = parent.getChildren().get(index);
+ IGUIElement currentGuiElement = getGUIElement(child);
+ if ((index > 0) && (!lastGuiElement.equals(currentGuiElement))) {
+ ReducableCommonDenominator commonDenominator =
+ getNextReducableCommonDenominator(parent, index - 1);
+
+ if (commonDenominator != null) {
+ // condense only if not all children would be condensed or if we can be sure,
+ // that there will be no further child that should be included in the condensed
+ // sequence
+ if ((commonDenominator.noOfTasks < parent.getChildren().size()) &&
+ (!isOnGuiElementPath(commonDenominator.commonGuiElement, currentGuiElement)))
+ {
+ condenseTasksToSequence(parent, index, commonDenominator.noOfTasks,
+ builder, nodeFactory, result);
+
+ result.setRuleApplicationStatus
+ (RuleApplicationStatus.RULE_APPLICATION_FINISHED);
+ return result;
+ }
+ else {
+ // the common denominator is on the parent path of the next GUI element.
+ // Therefore, the current sequences is not finished yet. So break up.
+ result.setRuleApplicationStatus
+ (RuleApplicationStatus.RULE_APPLICATION_FEASIBLE);
+ }
+ }
+ }
+
+ lastGuiElement = currentGuiElement;
+ index++;
+ }
+
+ ReducableCommonDenominator commonDenominator =
+ getNextReducableCommonDenominator(parent, parent.getChildren().size() - 1);
+
+ if ((commonDenominator != null) &&
+ (commonDenominator.noOfTasks < parent.getChildren().size()))
+ {
+ if (finalize) {
+ condenseTasksToSequence
+ (parent, index, commonDenominator.noOfTasks, builder, nodeFactory, result);
+
+ result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED);
+
+ return result;
+ }
+ else {
+ result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE);
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param guiElement
+ * @param detectedTasks
+ * @param parent
+ * @param index
+ * @param builder
+ * @param nodeFactory
+ * @return
+ */
+ private void condenseTasksToSequence(ITaskTreeNode parent,
+ int parentIndex,
+ int noOfTasks,
+ ITaskTreeBuilder builder,
+ ITaskTreeNodeFactory nodeFactory,
+ RuleApplicationResult result)
+ {
+ ISequence newSequence = nodeFactory.createNewSequence();
+ for (int i = 0; i < noOfTasks; i++) {
+ builder.addChild(newSequence, parent.getChildren().get(parentIndex - noOfTasks));
+ // remove exactly the same number of children from the parent.
+ builder.removeChild((ISequence) parent, parentIndex - noOfTasks);
+ }
+
+ builder.addChild((ISequence) parent, parentIndex - noOfTasks, newSequence);
+ result.addNewlyCreatedParentNode(newSequence);
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param detectedTasks
+ * @return
+ */
+ private ReducableCommonDenominator getNextReducableCommonDenominator(ITaskTreeNode parent,
+ int childIndex)
+ {
+ ReducableCommonDenominator commonDenominator = null;
+
+ // a common denominator can only exist for at least two task tree nodes
+ if (childIndex > 0) {
+ // start with the last one
+ int pos = childIndex;
+
+ commonDenominator = new ReducableCommonDenominator();
+
+ // check for further predecessors, if they match the same common denominator
+ IGUIElement currentCommonDenominator = null;
+ do {
+ if (--pos < 0) {
+ currentCommonDenominator = null;
+ }
+ else {
+ currentCommonDenominator = getCommonDenominator
+ (getGUIElement(parent.getChildren().get(pos)),
+ getGUIElement(parent.getChildren().get(pos + 1)));
+ }
+
+ if (commonDenominator.commonGuiElement == null) {
+ commonDenominator.commonGuiElement = currentCommonDenominator;
+ }
+ }
+ while ((commonDenominator.commonGuiElement != null) &&
+ (commonDenominator.commonGuiElement.equals(currentCommonDenominator)));
+
+ if (commonDenominator.commonGuiElement != null) {
+ // pos points to the last element, that has not the same common denominator.
+ // This one must be subtracted from the task number as well
+ commonDenominator.noOfTasks = childIndex - pos;
+ }
+ else {
+ commonDenominator = null;
+ }
+ }
+
+ return commonDenominator;
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param child
+ * @return
+ */
+ private IGUIElement getGUIElement(ITaskTreeNode node) {
+ List terminalGUIElements = new ArrayList();
+ getTerminalGUIElements(node, terminalGUIElements);
+ return getCommonDenominator(terminalGUIElements);
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param detectedTaskGroups
+ * @return
+ */
+ /*private IGUIElement getCommonDenominator(Stack detectedTasks, int start) {
+ List allGUIElements = new ArrayList();
+
+ for (int i = start; i < detectedTasks.size(); i++) {
+ allGUIElements.add(detectedTasks.get(i).commonGuiElement);
+ }
+
+ return getCommonDenominator(allGUIElements);
+ }*/
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param child
+ * @return
+ */
+ private IGUIElement getCommonDenominator(IGUIElement guiElement1, IGUIElement guiElement2) {
+ List allGUIElements = new ArrayList();
+ allGUIElements.add(guiElement1);
+ allGUIElements.add(guiElement2);
+ return getCommonDenominator(allGUIElements);
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param child
+ * @return
+ */
+ private IGUIElement getCommonDenominator(List guiElements) {
+ IGUIElement commonDenominator = null;
+
+ if (guiElements.size() > 0) {
+ List commonDenominatorPath = new ArrayList();
+
+ // create a reference list using the first GUI element
+ IGUIElement guiElement = guiElements.get(0);
+ while (guiElement != null) {
+ commonDenominatorPath.add(0, guiElement);
+ guiElement = guiElement.getParent();
+ }
+
+ // for each other GUI element, check the reference list for the first element in the
+ // path, that is not common to the current one, and delete it as well as it subsequent
+ // siblings
+ List currentPath = new ArrayList();
+ for (int i = 1; i < guiElements.size(); i++) {
+ currentPath.clear();
+ guiElement = guiElements.get(i);
+ while (guiElement != null) {
+ currentPath.add(0, guiElement);
+ guiElement = guiElement.getParent();
+ }
+
+ // determine the index of the first unequal path element
+ int index = 0;
+ while ((index < commonDenominatorPath.size()) && (index < currentPath.size()) &&
+ commonDenominatorPath.get(index).equals(currentPath.get(index)))
+ {
+ index++;
+ }
+
+ // remove all elements from the common denonimator path, that do not match
+ while (index < commonDenominatorPath.size()) {
+ commonDenominatorPath.remove(index);
+ }
+ }
+
+ if (commonDenominatorPath.size() > 0) {
+ commonDenominator = commonDenominatorPath.get(commonDenominatorPath.size() - 1);
+ }
+ }
+
+ return commonDenominator;
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param child
+ * @return
+ */
+ private void getTerminalGUIElements(ITaskTreeNode node, List terminalGUIElements) {
+ if (node instanceof IEventTask) {
+ if (((IEventTask) node).getEventTarget() instanceof IGUIElement) {
+ terminalGUIElements.add((IGUIElement) ((IEventTask) node).getEventTarget());
+ }
+ }
+ else {
+ for (ITaskTreeNode child : node.getChildren()) {
+ getTerminalGUIElements(child, terminalGUIElements);
+ }
+ }
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param currentCommonDenominator
+ * @param guiElement
+ * @return
+ */
+ private boolean isOnGuiElementPath(IGUIElement potentialPathElement, IGUIElement child) {
+ IGUIElement guiElement = child;
+
+ while (guiElement != null) {
+ if (guiElement.equals(potentialPathElement)) {
+ return true;
+ }
+ guiElement = guiElement.getParent();
+ }
+
+ return false;
+ }
+
+ /**
+ *
+ */
+ private static class ReducableCommonDenominator {
+
+ /** the GUI element being the common denominator */
+ private IGUIElement commonGuiElement;
+
+ /** the number of tasks that match the common denominator */
+ private int noOfTasks;
+
+ /* (non-Javadoc)
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return noOfTasks + " tasks on " + commonGuiElement;
+ }
+
+ }
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultGuiEventSequenceDetectionRule.java (revision 922)
@@ -0,0 +1,118 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import de.ugoe.cs.autoquest.eventcore.gui.IInteraction;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 18.03.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class DefaultGuiEventSequenceDetectionRule implements TemporalRelationshipRule {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode,
+ * TaskTreeBuilder, TaskTreeNodeFactory)
+ */
+ @Override
+ public RuleApplicationResult apply(ITaskTreeNode parent,
+ ITaskTreeBuilder builder,
+ ITaskTreeNodeFactory nodeFactory,
+ boolean finalize)
+ {
+ if (!(parent instanceof ISequence)) {
+ return null;
+ }
+
+ RuleApplicationResult result = new RuleApplicationResult();
+ int sequenceStartingIndex = -1;
+
+ int index = 0;
+ while (index < parent.getChildren().size()) {
+ ITaskTreeNode child = parent.getChildren().get(index);
+
+ if ((child instanceof IEventTask) &&
+ (((IEventTask) child).getEventType() instanceof IInteraction))
+ {
+ IInteraction eventType = (IInteraction) ((IEventTask) child).getEventType();
+
+ if (eventType.finishesLogicalSequence() && (sequenceStartingIndex > -1))
+ {
+ // There are several situations in which this implementation may cause infinite
+ // loops. This is because the rule manager will reapply rules until
+ // no rule is applied anymore. A sequence identified in a first iteration will
+ // be identified as a sequence also in a second iteration. As an example
+ // many sequences start with an interaction starting that sequence and end
+ // with an interaction ending that sequence. This will be reidentified as
+ // further subsequence. It must therefore be assured, that a sequence, that
+ // was once identified is not reidentified in a further application of the rule.
+ // For this, the implementation performs a kind of dry run. It creates a list of
+ // children that would belong to an identified sequence. Only if this list is
+ // not a reidentification then a new sequence is created and added to the
+ // parent. If it is a reidentification can be identified, if the list of
+ // children will contain all children of the parent, or if the list of children
+ // only consists of one sequence. Further, an identified sequence must at least
+ // have one child.
+ if (((sequenceStartingIndex != 0) ||
+ (index != (parent.getChildren().size() - 1))) &&
+ (((index - sequenceStartingIndex) > 0) ||
+ (((index - sequenceStartingIndex) == 0) &&
+ (!eventType.startsLogicalSequence()))))
+ {
+ boolean allNewChildrenAreSequences = true;
+
+ for (int j = sequenceStartingIndex;
+ ((allNewChildrenAreSequences) && (j < index)); j++)
+ {
+ allNewChildrenAreSequences &=
+ (parent.getChildren().get(j) instanceof ISequence);
+ }
+
+ if (!allNewChildrenAreSequences) {
+ ISequence sequence = nodeFactory.createNewSequence();
+
+ for (int j = sequenceStartingIndex; j < index; j++) {
+ builder.addChild
+ (sequence, parent.getChildren().get(sequenceStartingIndex));
+ builder.removeChild((ISequence) parent, sequenceStartingIndex);
+ }
+
+ if (!eventType.startsLogicalSequence()) {
+ builder.addChild
+ (sequence, parent.getChildren().get(sequenceStartingIndex));
+ builder.removeChild((ISequence) parent, sequenceStartingIndex);
+ }
+
+ builder.addChild((ISequence) parent, sequenceStartingIndex, sequence);
+
+ result.addNewlyCreatedParentNode(sequence);
+ result.setRuleApplicationStatus
+ (RuleApplicationStatus.RULE_APPLICATION_FINISHED);
+ return result;
+ }
+ }
+ }
+
+ if (eventType.startsLogicalSequence()) {
+ sequenceStartingIndex = index;
+ }
+ }
+
+ index++;
+ }
+
+ if (sequenceStartingIndex >= 0) {
+ result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE);
+ }
+
+ return result;
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultIterationDetectionRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultIterationDetectionRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/DefaultIterationDetectionRule.java (revision 922)
@@ -0,0 +1,727 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
+
+/**
+ *
+ * iterations in a list of nodes are equal subsequences following each other directly. The
+ * subsequences can be of any length depending on the type of equality they need to have. If the
+ * subsequences have to be lexically equal, then they have to have the same length if they only
+ * contain event tasks. As an example entering text can be done through appropriate keystrokes or
+ * through pasting the text. As a result, two syntactically different sequences are semantically
+ * equal. If both follow each other, then they are an iteration of semantically equal children.
+ * But they are not lexically equal.
+ *
+ *
+ * This class determines equal subsequences following each other. It is provided with a minimal node
+ * equality the equal nodes should have. Through this, it is possible to find e.g. lexically
+ * equal subsequence through a first application of this rule and semantically equal children to
+ * a later application of this rule. This is used by the {@link TemporalRelationshipRuleManager}
+ * which instantiates this rule three times, each with a different minimal equality.
+ *
+ *
+ * The equal subsequences are determined through trial and error. This algorithm has a high effort
+ * as it tries in the worst case all possible combinations of sub lists in all possible parts of
+ * the list of children of a provided parent node. The steps for each trial are.
+ *
+ * - for all possible subparts of the children of the provided parent
+ *
+ * - for all possible first sublists in the subpart
+ *
+ * - for all succeeding next sublists in this part
+ *
+ * - check if this sublist is equal to all previously identified sublist in this part
+ *
+ *
+ * -
+ * if a combination of sublists is found in this subpart which are all equal to each other
+ * at the provided minimal equality level, an iteration in this subpart was found.
+ *
+ *
+ * - merge the identified equal sublists to an iteration
+ *
+ *
+ *
+ * The algorithm tries to optimize if all children are event tasks and if the sublists shall be
+ * lexically equal. In this case, the sublist all have to have the same length. The trial and
+ * error reduces to a minimum of possible sublists.
+ *
+ *
+ * @author Patrick Harms
+ */
+public class DefaultIterationDetectionRule implements TemporalRelationshipRule {
+
+ /**
+ *
+ * the node equality manager needed for comparing task tree nodes with each other
+ *
+ */
+ private NodeEqualityRuleManager nodeEqualityRuleManager;
+
+ /**
+ *
+ * the minimal node equality two identified sublists need to have to consider them as equal
+ * and to create an iteration for
+ *
+ */
+ private NodeEquality minimalNodeEquality;
+
+ /**
+ *
+ * instantiates the rule and initializes it with a node equality rule manager and the minimal
+ * node equality identified sublist must have to consider them as iterated.
+ *
+ */
+ DefaultIterationDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager,
+ NodeEquality minimalNodeEquality)
+ {
+ super();
+ this.nodeEqualityRuleManager = nodeEqualityRuleManager;
+ this.minimalNodeEquality = minimalNodeEquality;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see TemporalRelationshipRule#apply(TaskTreeNode, TaskTreeBuilder, TaskTreeNodeFactory)
+ */
+ @Override
+ public RuleApplicationResult apply(ITaskTreeNode parent,
+ ITaskTreeBuilder treeBuilder,
+ ITaskTreeNodeFactory nodeFactory,
+ boolean finalize)
+ {
+ if (!(parent instanceof ISequence)) {
+ return null;
+ }
+
+ if (!finalize) {
+ // the rule is always feasible as iterations may occur at any time
+ RuleApplicationResult result = new RuleApplicationResult();
+ result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE);
+ return result;
+ }
+
+ // parent must already have at least 2 children
+ if ((parent.getChildren() == null) || (parent.getChildren().size() < 2)) {
+ return null;
+ }
+
+
+ // to find longer iterations first, start with long sequences
+ SubSequences subSequences = getEqualSubsequences(parent, treeBuilder, nodeFactory);
+
+ if (subSequences != null) {
+ RuleApplicationResult result = new RuleApplicationResult();
+
+ mergeEqualNodes(subSequences.equalVariants, treeBuilder, nodeFactory);
+ IIteration newIteration = createIterationBasedOnIdentifiedVariants
+ (subSequences, treeBuilder, nodeFactory, result);
+
+ determineNewlyCreatedParentTasks(parent, newIteration, result);
+
+ // remove iterated children
+ for (int j = subSequences.start; j < subSequences.end; j++) {
+ treeBuilder.removeChild((ISequence) parent, subSequences.start);
+ }
+
+ // add the new iteration instead
+ treeBuilder.addChild((ISequence) parent, subSequences.start, newIteration);
+
+ result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED);
+ return result;
+ }
+
+ return null;
+ }
+
+ /**
+ *
+ * this method initiates the trial and error algorithm denoted in the description of this class.
+ * Its main purpose is the selection of a subpart of all children in the parent node in which
+ * equal sublists shall be searched. It is important, to always find the last iterations in a
+ * part first. The reason for this are iterations of iterations. If we always found the first
+ * iteration in a subpart first, then this may be an iteration of iterations. However, there
+ * may be subsequent iterations to be included in this iteration. But these iterations are not
+ * found yet, as they occur later in the sequence. Therefore, if we always find the last
+ * iteration in a sequence first, iterations of iterations are identified, last.
+ *
+ *
+ * @param parent the parent node in which iterations of children shall be found
+ * @param treeBuilder the tree builder that can be used for connecting task tree nodes
+ * @param nodeFactory the node factory that can be used for instantiating task tree nodes
+ *
+ * @return the iterated subsequences identified in a specific part (contains the equal
+ * subsequences as well as the start (inclusive) and end (exclusive) index of the
+ * subpart in which the sequences were found)
+ */
+ private SubSequences getEqualSubsequences(ITaskTreeNode parent,
+ ITaskTreeBuilder treeBuilder,
+ ITaskTreeNodeFactory nodeFactory)
+ {
+ SubSequences subSequences = null;
+
+ FIND_ITERATION:
+ for (int end = parent.getChildren().size(); end > 0; end--) {
+ for (int start = 0; start < end; start++) {
+ boolean useEqualSublistLengths = equalSublistLengthsCanBeUsed(parent, start, end);
+
+ subSequences = new SubSequences();
+ subSequences.start = start;
+
+ boolean foundFurtherVariants = findFurtherVariants
+ (subSequences, parent, start, end, treeBuilder, nodeFactory,
+ useEqualSublistLengths);
+
+ if (foundFurtherVariants) {
+ break FIND_ITERATION;
+ }
+ else {
+ subSequences = null;
+ }
+ }
+ }
+
+ return subSequences;
+ }
+
+ /**
+ *
+ * for optimization purposes, we check if the length of the sublists to be identified as
+ * iterations has to be the same for any sublist. This only applies, if the minimum node
+ * equality to be checked for is lexical equality. If the children of the parent are all event
+ * tasks, then sublists can only be lexically equal, if they all have the same length.
+ * Therefore we check, if the minimal node equality is lexical equality. And if so, we also
+ * check if all children of the parent in which an iteration shall be searched for are event
+ * tasks.
+ *
+ *
+ * @param parent the parent node to search for iterations of its children
+ * @param start the beginning of the subpart (inclusive) to be considered
+ * @param end the end of the subpart (exclusive) to be considered
+ *
+ * @return true, if the sublists must have the same lengths, false else
+ */
+ private boolean equalSublistLengthsCanBeUsed(ITaskTreeNode parent, int start, int end) {
+ boolean equalLengthsCanBeUsed = minimalNodeEquality.isAtLeast(NodeEquality.LEXICALLY_EQUAL);
+
+ if (equalLengthsCanBeUsed) {
+ for (int i = start; i < end; i++) {
+ if (!(parent.getChildren().get(i) instanceof IEventTask)) {
+ equalLengthsCanBeUsed = false;
+ break;
+ }
+ }
+ }
+
+ return equalLengthsCanBeUsed;
+ }
+
+ /**
+ *
+ * this method starts at a specific position in the list of children of the provided parent
+ * and checks, if it finds a further sublist, that matches the already found sublists. If
+ * the sublist lengths must be equal, it only searches for a sublist of the same length of the
+ * already found sublists. The method calls itself if it identifies a further equal sublist but
+ * if the end of the subpart of children is not yet reached.
+ *
+ *
+ * @param subSequences the sublist found so far against which equality of the next
+ * sublist must be checked
+ * @param parent the parent node of which the children are analyzed
+ * @param start the starting index from which to start the next sublist to be
+ * identified
+ * @param end the end index (exclusive) of the current subpart of children
+ * in which iterations are searched for
+ * @param treeBuilder the tree builder that can be used for connecting task tree
+ * nodes
+ * @param nodeFactory the node factory that can be used for instantiating task tree
+ * nodes
+ * @param useEqualSublistLengths true if the sublists to be searched for all need to have the
+ * same length
+ *
+ * @return true if a further equal variant was found, false else
+ */
+ private boolean findFurtherVariants(SubSequences subSequences,
+ ITaskTreeNode parent,
+ int start,
+ int end,
+ ITaskTreeBuilder treeBuilder,
+ ITaskTreeNodeFactory nodeFactory,
+ boolean useEqualSublistLengths)
+ {
+ boolean foundFurtherVariants = (start == end) && (subSequences.equalVariants.size() > 1);
+
+ int minChildCount = 1;
+ int maxChildCount = end - start;
+
+ if (useEqualSublistLengths && (subSequences.equalVariants.size() > 0)) {
+ minChildCount = subSequences.equalVariants.get(0).getChildren().size();
+ maxChildCount = Math.min(minChildCount, maxChildCount);
+ }
+
+ for (int childCount = minChildCount; childCount <= maxChildCount; childCount++) {
+ if (useEqualSublistLengths && (((end - start) % childCount) != 0)) {
+ continue;
+ }
+
+ ISequence furtherVariant = nodeFactory.createNewSequence();
+
+ for (int j = start; j < start + childCount; j++) {
+ treeBuilder.addChild(furtherVariant, parent.getChildren().get(j));
+ }
+
+ boolean allVariantsEqual = true;
+
+ for (ITaskTreeNode equalVariant : subSequences.equalVariants) {
+ NodeEquality nodeEquality =
+ nodeEqualityRuleManager.applyRules(equalVariant, furtherVariant);
+
+ if (!nodeEquality.isAtLeast(minimalNodeEquality)) {
+ allVariantsEqual = false;
+ break;
+ }
+ }
+
+ if (allVariantsEqual) {
+
+ // we found a further variant. Add it to the list of variants and try to find
+ // further variants. Ignore, if none is available
+ int index = subSequences.equalVariants.size();
+ subSequences.equalVariants.add(index, furtherVariant);
+
+ foundFurtherVariants = findFurtherVariants
+ (subSequences, parent, start + childCount, end, treeBuilder, nodeFactory,
+ useEqualSublistLengths);
+
+ if (foundFurtherVariants) {
+ subSequences.end = end;
+ break;
+ }
+ else {
+ subSequences.equalVariants.remove(index);
+ }
+ }
+ }
+
+ return foundFurtherVariants;
+ }
+
+ /**
+ *
+ * this method merges task tree nodes in a list, if they can be merged. for this, it tries
+ * to merge every node with every other node in the provided list using the
+ * {@link #mergeEqualTasks(ITaskTreeNode, ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory)}
+ * method. If a merge is possible, it removes the merged nodes from the list and adds the
+ * merge result.
+ *
+ *
+ * @param nodes the list of nodes to be merged
+ * @param treeBuilder the tree builder that can be used for connecting task tree nodes
+ * @param nodeFactory the node factory that can be used for instantiating task tree nodes
+ */
+ private void mergeEqualNodes(List nodes,
+ ITaskTreeBuilder treeBuilder,
+ ITaskTreeNodeFactory nodeFactory)
+ {
+ int index1 = 0;
+ int index2 = 0;
+ ITaskTreeNode variant1;
+ ITaskTreeNode variant2;
+
+ while (index1 < nodes.size()) {
+ variant1 = nodes.get(index1);
+ index2 = index1 + 1;
+
+ while (index2 < nodes.size()) {
+ variant2 = nodes.get(index2);
+ ITaskTreeNode mergedChild =
+ mergeEqualTasks(variant1, variant2, treeBuilder, nodeFactory);
+
+ if (mergedChild != null) {
+ // if we merged something start from the beginning to perform the next merge
+ nodes.remove(index2);
+ nodes.remove(index1);
+ nodes.add(index1, mergedChild);
+ index1 = -1;
+ break;
+ }
+ else {
+ index2++;
+ }
+ }
+
+ index1++;
+ }
+ }
+
+ /**
+ *
+ * this method merges two equal tasks with each other if possible. If the tasks are lexically
+ * equal, the first of them is returned as merge result. If both tasks are of the same
+ * temporal relationship type, the appropriate merge method is called to merge them. If one
+ * of the nodes is a selection, the other one is added as a variant of this selection.
+ * (However, if both nodes are selections, they are merged using the appropriate merge method.)
+ * If merging is not possible, then a selection of both provided nodes is created and
+ * returned as merge result.
+ *
+ *
+ * @param node1 the first task to be merged
+ * @param node2 the second task to be merged
+ * @param treeBuilder the tree builder that can be used for connecting task tree nodes
+ * @param nodeFactory the node factory that can be used for instantiating task tree nodes
+ *
+ * @return the result of the merge
+ */
+ private ITaskTreeNode mergeEqualTasks(ITaskTreeNode node1,
+ ITaskTreeNode node2,
+ ITaskTreeBuilder treeBuilder,
+ ITaskTreeNodeFactory nodeFactory)
+ {
+ ITaskTreeNode mergeResult = null;
+
+ if ((node1 instanceof ISequence) && (node2 instanceof ISequence)) {
+ mergeResult = mergeEqualSequences
+ ((ISequence) node1, (ISequence) node2, treeBuilder, nodeFactory);
+ }
+ else if ((node1 instanceof ISelection) && (node2 instanceof ISelection)) {
+ mergeResult = mergeEqualSelections
+ ((ISelection) node1, (ISelection) node2, treeBuilder, nodeFactory);
+ }
+ else if ((node1 instanceof IIteration) && (node2 instanceof IIteration)) {
+ mergeResult = mergeEqualIterations
+ ((IIteration) node1, (IIteration) node2, treeBuilder, nodeFactory);
+ }
+ else if (node1 instanceof ISelection) {
+ treeBuilder.addChild((ISelection) node1, node2);
+ mergeResult = node1;
+ }
+ else if (node2 instanceof ISelection) {
+ treeBuilder.addChild((ISelection) node2, node1);
+ mergeResult = node2;
+ }
+ else if (node1 instanceof IIteration) {
+ mergeResult = mergeEqualTasks
+ (((IIteration) node1).getChildren().get(0), node2, treeBuilder, nodeFactory);
+
+ if (mergeResult != null) {
+ IIteration iteration = nodeFactory.createNewIteration();
+ treeBuilder.setChild(iteration, mergeResult);
+ mergeResult = iteration;
+ }
+ }
+ else if (node2 instanceof IIteration) {
+ mergeResult = mergeEqualTasks
+ (((IIteration) node2).getChildren().get(0), node1, treeBuilder, nodeFactory);
+
+ if (mergeResult != null) {
+ IIteration iteration = nodeFactory.createNewIteration();
+ treeBuilder.setChild(iteration, mergeResult);
+ mergeResult = iteration;
+ }
+ }
+ else {
+ NodeEquality nodeEquality = nodeEqualityRuleManager.applyRules(node1, node2);
+
+ if (nodeEquality.isAtLeast(NodeEquality.LEXICALLY_EQUAL)) {
+ mergeResult = node1;
+ }
+ }
+
+ if (mergeResult == null) {
+ mergeResult = nodeFactory.createNewSelection();
+ treeBuilder.addChild((ISelection) mergeResult, node1);
+ treeBuilder.addChild((ISelection) mergeResult, node2);
+ }
+
+ return mergeResult;
+ }
+
+ /**
+ *
+ * merges equal sequences. This is done through trying to merge each node of sequence 1 with
+ * the node in sequence 2 being located at the same position. If not all children can be merged
+ * or if the sequences have different lengths, null is returned to indicate, that merging is
+ * not possible. For merging children, the
+ * {@link #mergeEqualTasks(ITaskTreeNode, ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory)}
+ * method is called.
+ *
+ *
+ * @param sequence1 the first sequence to be merged
+ * @param sequence2 the second sequence to be merged
+ * @param treeBuilder the tree builder that can be used for connecting task tree nodes
+ * @param nodeFactory the node factory that can be used for instantiating task tree nodes
+ *
+ * @return the result of the merge or null if merging was not possible
+ */
+ private ISequence mergeEqualSequences(ISequence sequence1,
+ ISequence sequence2,
+ ITaskTreeBuilder treeBuilder,
+ ITaskTreeNodeFactory nodeFactory)
+ {
+ ISequence mergeResult = null;
+
+ if (sequence1.getChildren().size() == sequence2.getChildren().size()) {
+ mergeResult = nodeFactory.createNewSequence();
+
+ for (int i = 0; i < sequence1.getChildren().size(); i++) {
+ ITaskTreeNode mergedNode = mergeEqualTasks
+ (sequence1.getChildren().get(i), sequence2.getChildren().get(i),
+ treeBuilder, nodeFactory);
+
+ if (mergedNode != null) {
+ treeBuilder.addChild(mergeResult, mergedNode);
+ }
+ else {
+ mergeResult = null;
+ break;
+ }
+ }
+ }
+
+ return mergeResult;
+ }
+
+ /**
+ *
+ * merges equal selections. This is done through trying to merge each node of selections with
+ * each other. For this, the method
+ * {@link #mergeEqualNodes(List, ITaskTreeBuilder, ITaskTreeNodeFactory)} is called with a
+ * join of the child list of both selections.
+ *
+ *
+ * @param selection1 the first selection to be merged
+ * @param selection2 the second selection to be merged
+ * @param treeBuilder the tree builder that can be used for connecting task tree nodes
+ * @param nodeFactory the node factory that can be used for instantiating task tree nodes
+ *
+ * @return the result of the merge which is not null
+ */
+ private ITaskTreeNode mergeEqualSelections(ISelection selection1,
+ ISelection selection2,
+ ITaskTreeBuilder treeBuilder,
+ ITaskTreeNodeFactory nodeFactory)
+ {
+ ISelection mergeResult = nodeFactory.createNewSelection();
+
+ for (int i = 0; i < selection1.getChildren().size(); i++) {
+ treeBuilder.addChild(mergeResult, selection1.getChildren().get(i));
+ }
+
+ for (int i = 0; i < selection2.getChildren().size(); i++) {
+ treeBuilder.addChild(mergeResult, selection2.getChildren().get(i));
+ }
+
+ mergeEqualNodes(mergeResult.getChildren(), treeBuilder, nodeFactory);
+
+ return mergeResult;
+ }
+
+ /**
+ *
+ * merges equal iterations. This is done through merging the children of both iterations. If
+ * this is possible, a resulting iteration with the merge result of the children as its own
+ * child is returned. Otherwise null is returned to indicate that merging was not possible.
+ *
+ *
+ * @param selection1 the first iteration to be merged
+ * @param selection2 the second iteration to be merged
+ * @param treeBuilder the tree builder that can be used for connecting task tree nodes
+ * @param nodeFactory the node factory that can be used for instantiating task tree nodes
+ *
+ * @return the result of the merge or null if merging is not possible
+ */
+ private ITaskTreeNode mergeEqualIterations(IIteration iteration1,
+ IIteration iteration2,
+ ITaskTreeBuilder treeBuilder,
+ ITaskTreeNodeFactory nodeFactory)
+ {
+ ITaskTreeNode mergedChild = mergeEqualTasks
+ (iteration1.getChildren().get(0), iteration2.getChildren().get(0),
+ treeBuilder, nodeFactory);
+
+ IIteration mergeResult = null;
+
+ if (mergedChild != null) {
+ mergeResult = nodeFactory.createNewIteration();
+ treeBuilder.setChild(mergeResult, mergedChild);
+ }
+
+ return mergeResult;
+ }
+
+ /**
+ *
+ * this is a convenience method to create an iteration based on the identified and already
+ * merged iterated subsequences. This method creates the simplest iteration possible. As an
+ * example, if always the same task tree node is iterated, it becomes the child of the
+ * iteration. If a sequence of tasks is iterated, this sequence becomes the child of the
+ * iteration. It several equal sublists or nodes which are not lexically equal are iterated
+ * they become a selection which in turn become the child of the iteration.
+ *
+ *
+ * @param subsequences the identified and already merged equal subsequences
+ * @param treeBuilder the tree builder that can be used for connecting task tree nodes
+ * @param nodeFactory the node factory that can be used for instantiating the iteration
+ *
+ * @return the resulting iteration
+ */
+ private IIteration createIterationBasedOnIdentifiedVariants(SubSequences subsequences,
+ ITaskTreeBuilder treeBuilder,
+ ITaskTreeNodeFactory nodeFactory,
+ RuleApplicationResult result)
+ {
+ IIteration newIteration = nodeFactory.createNewIteration();
+ result.addNewlyCreatedParentNode(newIteration);
+
+ if (subsequences.equalVariants.size() == 1) {
+ // all children are the same. Create an iteration of this child
+ if (subsequences.equalVariants.get(0).getChildren().size() == 1) {
+ // there is only one equal variant and this has only one child. So create an
+ // iteration of this child
+ treeBuilder.setChild
+ (newIteration, subsequences.equalVariants.get(0).getChildren().get(0));
+ }
+ else {
+ // there was an iteration of one equal sequence
+ treeBuilder.setChild(newIteration, subsequences.equalVariants.get(0));
+ result.addNewlyCreatedParentNode(subsequences.equalVariants.get(0));
+ }
+ }
+ else {
+ // there are distinct variants of equal subsequences or children --> create an
+ // iterated selection
+ ISelection selection = nodeFactory.createNewSelection();
+ result.addNewlyCreatedParentNode(selection);
+
+ for (ITaskTreeNode variant : subsequences.equalVariants) {
+ if (variant.getChildren().size() == 1) {
+ treeBuilder.addChild(selection, variant.getChildren().get(0));
+ }
+ else {
+ treeBuilder.addChild(selection, variant);
+ result.addNewlyCreatedParentNode(variant);
+ }
+ }
+
+ treeBuilder.setChild(newIteration, selection);
+ }
+
+ return newIteration;
+ }
+
+ /**
+ *
+ * as the method has to denote all newly created parent nodes this method identifies them by
+ * comparing the existing subtree with the newly created iteration. Only those parent nodes
+ * in the new iteration, which are not already found in the existing sub tree are denoted as
+ * newly created. We do this in this way, as during the iteration detection algorithm, many
+ * parent nodes are created, which may be discarded later. It is easier to identify the
+ * remaining newly created parent nodes through this way than to integrate it into the
+ * algorithm.
+ *
+ *
+ * @param existingSubTree the existing subtree
+ * @param newSubTree the identified iteration
+ * @param result the rule application result into which the newly created parent nodes
+ * shall be stored.
+ */
+ private void determineNewlyCreatedParentTasks(ITaskTreeNode existingSubTree,
+ ITaskTreeNode newSubTree,
+ RuleApplicationResult result)
+ {
+ List existingParentNodes = getParentNodes(existingSubTree);
+ List newParentNodes = getParentNodes(newSubTree);
+
+ boolean foundNode;
+ for (ITaskTreeNode newParentNode : newParentNodes) {
+ foundNode = false;
+ for (ITaskTreeNode existingParentNode : existingParentNodes) {
+ // It is sufficient to compare the references. The algorithm reuses nodes as they
+ // are. So any node existing in the new structure that is also in the old structure
+ // was unchanged an therefore does not need to be handled as a newly created one.
+ // but every node in the new structure that is not included in the old structure
+ // must be treated as a newly created one.
+ if (newParentNode == existingParentNode) {
+ foundNode = true;
+ break;
+ }
+ }
+
+ if (!foundNode) {
+ result.addNewlyCreatedParentNode(newParentNode);
+ }
+ }
+
+ }
+
+ /**
+ *
+ * convenience method to determine all parent nodes existing in a subtree
+ *
+ *
+ * @param subtree the subtree to search for parent nodes in
+ *
+ * @return a list of parent nodes existing in the subtree
+ */
+ private List getParentNodes(ITaskTreeNode subtree) {
+ List parentNodes = new ArrayList();
+
+ if (subtree.getChildren().size() > 0) {
+ parentNodes.add(subtree);
+
+ for (ITaskTreeNode child : subtree.getChildren()) {
+ parentNodes.addAll(getParentNodes(child));
+ }
+ }
+
+ return parentNodes;
+ }
+
+ /**
+ *
+ * used to have a container for equal sublists identified in a sub part of the children of
+ * a parent node.
+ *
+ *
+ * @author Patrick Harms
+ */
+ private static class SubSequences {
+
+ /**
+ *
+ * the beginning of the subpart of the children of the parent node in which the sublists
+ * are found (inclusive)
+ *
+ */
+ public int start;
+
+ /**
+ *
+ * the end of the subpart of the children of the parent node in which the sublists
+ * are found (exclusive)
+ *
+ */
+ public int end;
+
+ /**
+ *
+ * the equal sublists found in the subpart of the children of the parent node
+ *
+ */
+ List equalVariants = new ArrayList();
+
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/RuleApplicationResult.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/RuleApplicationResult.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/RuleApplicationResult.java (revision 922)
@@ -0,0 +1,71 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ *
+ * The rule application result describes the result of applying a {@link TemporalRelationshipRule}
+ * on a task tree node. It contains a {@link RuleApplicationStatus} and a list of all parent
+ * task tree nodes that were created during a rule application. See the description of
+ * {@link TemporalRelationshipRule} for more details.
+ *
+ *
+ * @author Patrick Harms
+ */
+class RuleApplicationResult {
+
+ /** */
+ private RuleApplicationStatus status = RuleApplicationStatus.RULE_NOT_APPLIED;
+
+ /** */
+ private List newParents = new ArrayList();
+
+ /**
+ *
+ * create a rule application result with a status {@link RuleApplicationStatus#RULE_NOT_APPLIED}
+ *
+ */
+ RuleApplicationResult() {
+ // this is the default indicating nothing so far
+ }
+
+ /**
+ *
+ * set the rule application status
+ *
+ */
+ void setRuleApplicationStatus(RuleApplicationStatus status) {
+ this.status = status;
+ }
+
+ /**
+ *
+ * return the rule application status
+ *
+ */
+ RuleApplicationStatus getRuleApplicationStatus() {
+ return status;
+ }
+
+ /**
+ *
+ * add a further parent node created during the rule application
+ *
+ */
+ void addNewlyCreatedParentNode(ITaskTreeNode newParent) {
+ newParents.add(newParent);
+ }
+
+ /**
+ *
+ * return all parent nodes created during the rule application
+ *
+ */
+ List getNewlyCreatedParentNodes() {
+ return newParents;
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/RuleApplicationStatus.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/RuleApplicationStatus.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/RuleApplicationStatus.java (revision 922)
@@ -0,0 +1,15 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+/**
+ *
+ * The rule application status describes the result of applying a {@link TemporalRelationshipRule}
+ * on a task tree node. See the description of {@link TemporalRelationshipRule} for more details.
+ *
+ *
+ * @author Patrick Harms
+ */
+enum RuleApplicationStatus {
+ RULE_APPLICATION_FINISHED,
+ RULE_APPLICATION_FEASIBLE,
+ RULE_NOT_APPLIED;
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TemporalRelationshipRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TemporalRelationshipRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TemporalRelationshipRule.java (revision 922)
@@ -0,0 +1,55 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
+
+/**
+ *
+ * a temporal relation ship is able to detected temporal relationships between the child nodes
+ * of the parent node provided to the
+ * {@link #apply(ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory, boolean)} method. A rule
+ * created temporal relationships between the child nodes, i.e. substructures in the task tree, if
+ * it detects a temporal relationship and it can be sure that it is complete. Incomplete but
+ * detected temporal relationships may occur, if there can be more children expected to be added
+ * to the provided parent node. This could be the case during parsing a interaction log file of
+ * a GUI.
+ *
+ *
+ * @author Patrick Harms
+ */
+interface TemporalRelationshipRule {
+
+ /**
+ *
+ * applies the rule to the given parent node. The provided builder and node factory are used
+ * to create substructures in the task tree for the identified temporal relationships. The
+ * finalize parameter is used to command the rule to finish rule applications, in the case it
+ * is known that no further data will be available.
+ *
+ *
+ * The returned rule application result is null, if the rule can not be applied, i.e. it does not
+ * detect a temporal relationship. It returns a rule application result with a status
+ * {@link RuleApplicationStatus#RULE_APPLICATION_FINISHED} if the rule was applied. The result
+ * contains all newly created parent nodes. It returns a rule application result with status
+ * {@link RuleApplicationStatus#RULE_APPLICATION_FEASIBLE} if the rule would be applicable if
+ * further children would be available in the parent node. This status MUST not be returned if
+ * the finalize parameter is true. In this case the rule must be applied or not.
+ *
+ *
+ * @param parent the parent node with the children to apply the rule on
+ * @param builder the builder to be used for creating substructures for the identified
+ * temporal relationships
+ * @param nodeFactory the node factory to be used for creating substructures for the identified
+ * temporal relationships
+ * @param finalize true, if the rule shall not expect further children to come and that it
+ * should therefore be applied in any case
+ *
+ * @return the rule application result as described.
+ */
+ RuleApplicationResult apply(ITaskTreeNode parent,
+ ITaskTreeBuilder builder,
+ ITaskTreeNodeFactory nodeFactory,
+ boolean finalize);
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TemporalRelationshipRuleManager.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TemporalRelationshipRuleManager.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TemporalRelationshipRuleManager.java (revision 922)
@@ -0,0 +1,221 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
+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.util.console.Console;
+
+/**
+ *
+ * This class is responsible for applying temporal relationship rules on a task tree. Through this,
+ * a flat task tree is restructured to have more depth but to include more temporal relationships
+ * between task tree nodes which are not only a major sequence. I.e. through the application of
+ * rule iterations and selections of task tree nodes are detected. Which kind of temporal relations
+ * between task tree nodes are detected depends on the {@link TemporalRelationshipRule}s known to
+ * this class.
+ *
+ * The class holds references to the appropriate {@link TemporalRelationshipRule}s and calls
+ * their {@link TemporalRelationshipRule#apply(ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory, boolean)}
+ * method for each node in the task tree it is needed for. The general behavior of this class is
+ * the following:
+ *
+ * -
+ * An instance of this class is created using the constructor and calling the
+ * {@link #init()} method afterwards
+ *
+ * -
+ * then the {@link #applyRules(ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory, boolean)}
+ * method is called for a so far unstructured task tree node
+ *
+ * -
+ * the class iterates its internal list of rules and calls their
+ * {@link TemporalRelationshipRule#apply(ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory, boolean)}
+ * method.
+ *
+ * -
+ * the class evaluates the rule application result
+ *
+ * -
+ * if a rule returns a rule application result that is null, the next rule is tried
+ *
+ * -
+ * if a rule returns that it would be feasible if more data was available and the rule
+ * application shall not be finalized (see finalize parameter of the applyRules method)
+ * the rule application is broken up
+ *
+ * -
+ * if a rule returns, that it was applied, the same rule is applied again until it returns
+ * null or feasible. For each newly created parent node provided in the rule application
+ * result, the {@link #applyRules(ITaskTreeNode, ITaskTreeBuilder, ITaskTreeNodeFactory, boolean)}
+ * method is called.
+ *
+ *
+ *
+ *
+ * Through this, all rules are tried to be applied at least once to the provided parent node and
+ * all parent nodes created during the rule application.
+ *
+ *
+ * @author Patrick Harms
+ */
+public class TemporalRelationshipRuleManager {
+
+ /**
+ *
+ * the node equality manager needed by the rules to compare task tree nodes with each other
+ *
+ */
+ private NodeEqualityRuleManager nodeEqualityRuleManager;
+
+ /**
+ *
+ * the temporal relationship rule known to the manager. The rules are applied in the order
+ * they occur in this list.
+ *
+ */
+ private List rules = new ArrayList();
+
+ /**
+ *
+ * initialize the manager with a node equality rule manager to be used by the known rules
+ * for task tree node comparison.
+ *
+ */
+ public TemporalRelationshipRuleManager(NodeEqualityRuleManager nodeEqualityRuleManager) {
+ super();
+ this.nodeEqualityRuleManager = nodeEqualityRuleManager;
+ }
+
+ /**
+ *
+ * initialized the temporal relationship rule manager by instantiating the known rules and
+ * providing them with a reference to the node equality manager or other information they need.
+ *
+ */
+ public void init() {
+ rules.add(new DefaultGuiElementSequenceDetectionRule());
+ rules.add(new DefaultEventTargetSequenceDetectionRule());
+ rules.add(new TrackBarSelectionDetectionRule(nodeEqualityRuleManager));
+ rules.add(new DefaultGuiEventSequenceDetectionRule());
+
+ rules.add(new DefaultIterationDetectionRule
+ (nodeEqualityRuleManager, NodeEquality.LEXICALLY_EQUAL));
+ rules.add(new DefaultIterationDetectionRule
+ (nodeEqualityRuleManager, NodeEquality.SYNTACTICALLY_EQUAL));
+ rules.add(new DefaultIterationDetectionRule
+ (nodeEqualityRuleManager, NodeEquality.SEMANTICALLY_EQUAL));
+ }
+
+ /**
+ *
+ * applies the known rules to the provided parent node. For the creation of further nodes,
+ * the provided builder and node factory are utilized. If the finalize parameter is true, the
+ * rule application is finalized as far as possible without waiting for further data. If it is
+ * false, the rule application is broken up at the first rule returning, that its application
+ * would be feasible.
+ *
+ *
+ * @param parent the parent node to apply the rules on
+ * @param builder the task tree builder to be used for linking task tree nodes with each
+ * other
+ * @param nodeFactory the node factory to be used for instantiating new task tree nodes.
+ * @param finalize used to indicate, if the rule application shall break up if a rule would
+ * be feasible if further data was available, or not.
+ */
+ public void applyRules(ITaskTreeNode parent,
+ ITaskTreeBuilder builder,
+ ITaskTreeNodeFactory nodeFactory,
+ boolean finalize)
+ {
+ applyRules(parent, builder, nodeFactory, finalize, "");
+ }
+
+ /**
+ *
+ * applies the known rules to the provided parent node. For the creation of further nodes,
+ * the provided builder and node factory are utilized. If the finalize parameter is true, the
+ * rule application is finalized as far as possible without waiting for further data. If it is
+ * false, the rule application is broken up at the first rule returning, that its application
+ * would be feasible. The method calls itself for each parent node created through the rule
+ * application. In this case, the finalize parameter is always true.
+ *
+ *
+ * @param parent the parent node to apply the rules on
+ * @param builder the task tree builder to be used for linking task tree nodes with each
+ * other
+ * @param nodeFactory the node factory to be used for instantiating new task tree nodes.
+ * @param finalize used to indicate, if the rule application shall break up if a rule would
+ * be feasible if further data was available, or not.
+ * @param logIndent simply used for loggin purposes to indent the log messages depending
+ * on the recursion depth of calling this method.
+ */
+ private int applyRules(ITaskTreeNode parent,
+ ITaskTreeBuilder builder,
+ ITaskTreeNodeFactory nodeFactory,
+ boolean finalize,
+ String logIndent)
+ {
+ Console.traceln(Level.FINER, logIndent + "applying rules for " + parent);
+
+ int noOfRuleApplications = 0;
+
+ for (TemporalRelationshipRule rule : rules) {
+ RuleApplicationResult result;
+ do {
+ // LOG.info(logIndent + "trying to apply rule " + rule + " on " + parent);
+ result = rule.apply(parent, builder, nodeFactory, finalize);
+
+ if ((result != null) &&
+ (result.getRuleApplicationStatus() ==
+ RuleApplicationStatus.RULE_APPLICATION_FINISHED))
+ {
+ Console.traceln
+ (Level.FINE, logIndent + "applied rule " + rule + " on " + parent);
+ noOfRuleApplications++;
+
+ for (ITaskTreeNode newParent : result.getNewlyCreatedParentNodes()) {
+ noOfRuleApplications +=
+ applyRules(newParent, builder, nodeFactory, true, logIndent + " ");
+ }
+ }
+ }
+ while ((result != null) &&
+ (result.getRuleApplicationStatus() ==
+ RuleApplicationStatus.RULE_APPLICATION_FINISHED));
+
+ if ((!finalize) &&
+ (result != null) &&
+ (result.getRuleApplicationStatus() ==
+ RuleApplicationStatus.RULE_APPLICATION_FEASIBLE))
+ {
+ // in this case, don't go on applying rules, which should not be applied yet
+ break;
+ }
+ }
+
+ if (noOfRuleApplications <= 0) {
+ Console.traceln(Level.INFO, logIndent + "no rules applied --> no temporal " +
+ "relationship generated");
+ }
+
+ return noOfRuleApplications;
+ }
+
+ /**
+ *
+ */
+ /*
+ * private void dumpTask(TaskTreeNode task, String indent) { System.err.print(indent);
+ * System.err.print(task); System.err.println(" ");
+ *
+ * if ((task.getChildren() != null) && (task.getChildren().size() > 0)) { for (TaskTreeNode
+ * child : task.getChildren()) { dumpTask(child, indent + " "); } } }
+ */
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TrackBarSelectionDetectionRule.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TrackBarSelectionDetectionRule.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TrackBarSelectionDetectionRule.java (revision 922)
@@ -0,0 +1,147 @@
+package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
+
+import de.ugoe.cs.autoquest.eventcore.gui.ValueSelection;
+import de.ugoe.cs.autoquest.eventcore.guimodel.ITrackBar;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEquality;
+import de.ugoe.cs.autoquest.tasktrees.nodeequality.NodeEqualityRuleManager;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 28.04.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class TrackBarSelectionDetectionRule implements TemporalRelationshipRule {
+
+ /** */
+ private NodeEqualityRuleManager nodeEqualityRuleManager;
+
+ /**
+ * TODO: comment
+ *
+ */
+ TrackBarSelectionDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager) {
+ super();
+ this.nodeEqualityRuleManager = nodeEqualityRuleManager;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see TemporalRelationshipRule#apply(TaskTreeNode, TaskTreeBuilder, TaskTreeNodeFactory)
+ */
+ @Override
+ public RuleApplicationResult apply(ITaskTreeNode parent,
+ ITaskTreeBuilder builder,
+ ITaskTreeNodeFactory nodeFactory,
+ boolean finalize)
+ {
+ if (!(parent instanceof ISequence)) {
+ return null;
+ }
+
+ RuleApplicationResult result = new RuleApplicationResult();
+
+ int valueSelectionStartIndex = -1;
+
+ int index = 0;
+ while (index < parent.getChildren().size()) {
+ ITaskTreeNode child = parent.getChildren().get(index);
+
+ if ((child instanceof IEventTask) &&
+ (((IEventTask) child).getEventTarget() instanceof ITrackBar) &&
+ (((IEventTask) child).getEventType() instanceof ValueSelection))
+ {
+ if (valueSelectionStartIndex < 0) {
+ // let the show begin
+ valueSelectionStartIndex = index;
+ }
+ }
+ else if (valueSelectionStartIndex >= 0) {
+ // current child is no more value selection. But the preceding tasks were.
+ // Therefore,
+ // create an iteration with the different selectable values as selection children
+ handleValueSelections(valueSelectionStartIndex, index - 1, parent, builder,
+ nodeFactory, result);
+
+ return result;
+ }
+
+ index++;
+ }
+
+ if (valueSelectionStartIndex >= 0) {
+ if (finalize) {
+ handleValueSelections(valueSelectionStartIndex, parent.getChildren().size() - 1,
+ parent, builder, nodeFactory, result);
+ }
+ else {
+ result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE);
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param valueSelectionStartIndex
+ * @param i
+ */
+ private void handleValueSelections(int startIndex,
+ int endIndex,
+ ITaskTreeNode parent,
+ ITaskTreeBuilder builder,
+ ITaskTreeNodeFactory nodeFactory,
+ RuleApplicationResult result)
+ {
+ IIteration iteration = nodeFactory.createNewIteration();
+ result.addNewlyCreatedParentNode(iteration);
+
+ ISelection selection = nodeFactory.createNewSelection();
+ result.addNewlyCreatedParentNode(selection);
+ builder.setChild(iteration, selection);
+
+ for (int i = endIndex - startIndex; i >= 0; i--) {
+ addChildIfNecessary(selection, parent.getChildren().get(startIndex), builder,
+ nodeFactory, result);
+ builder.removeChild((ISequence) parent, startIndex);
+ }
+
+ builder.addChild((ISequence) parent, startIndex, iteration);
+
+ result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED);
+ }
+
+ /**
+ *
+ */
+ private void addChildIfNecessary(ISelection parentSelection,
+ ITaskTreeNode node,
+ ITaskTreeBuilder builder,
+ ITaskTreeNodeFactory nodeFactory,
+ RuleApplicationResult result)
+ {
+ for (int i = 0; i < parentSelection.getChildren().size(); i++) {
+ ITaskTreeNode child = parentSelection.getChildren().get(i);
+
+ // check, if the new node is a variant for the current event task
+ NodeEquality nodeEquality = nodeEqualityRuleManager.applyRules(child, node);
+ if (nodeEquality.isAtLeast(NodeEquality.SYNTACTICALLY_EQUAL)) {
+ return;
+ }
+ }
+
+ // if we did not return in the previous checks, then the node must be added
+ builder.addChild(parentSelection, node);
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/IEventTask.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/IEventTask.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/IEventTask.java (revision 922)
@@ -0,0 +1,31 @@
+package de.ugoe.cs.autoquest.tasktrees.treeifc;
+
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: $
+ * @author 2011, last modified by $Author: $
+ */
+public interface IEventTask extends ITaskTreeNode {
+
+ /**
+ * @return Returns the event type.
+ */
+ public IEventType getEventType();
+
+ /**
+ * @return Returns the event target.
+ */
+ public IEventTarget getEventTarget();
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public IEventTask clone();
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/IIteration.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/IIteration.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/IIteration.java (revision 922)
@@ -0,0 +1,18 @@
+package de.ugoe.cs.autoquest.tasktrees.treeifc;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 21.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public interface IIteration extends ITemporalRelationship {
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public IIteration clone();
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ISelection.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ISelection.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ISelection.java (revision 922)
@@ -0,0 +1,18 @@
+package de.ugoe.cs.autoquest.tasktrees.treeifc;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 21.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public interface ISelection extends ITemporalRelationship {
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public ISelection clone();
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ISequence.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ISequence.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ISequence.java (revision 922)
@@ -0,0 +1,18 @@
+package de.ugoe.cs.autoquest.tasktrees.treeifc;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 21.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public interface ISequence extends ITemporalRelationship {
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public ISequence clone();
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTree.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTree.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTree.java (revision 922)
@@ -0,0 +1,31 @@
+package de.ugoe.cs.autoquest.tasktrees.treeifc;
+
+import java.util.Map;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 21.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public interface ITaskTree extends Cloneable {
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public ITaskTreeNode getRoot();
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public Map getTaskMap();
+
+ /**
+ *
+ */
+ public ITaskTree clone();
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTreeBuilder.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTreeBuilder.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTreeBuilder.java (revision 922)
@@ -0,0 +1,68 @@
+package de.ugoe.cs.autoquest.tasktrees.treeifc;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 21.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public interface ITaskTreeBuilder {
+
+ /**
+ * TODO: comment
+ *
+ * @param sequence
+ * @param task
+ */
+ void addChild(ISequence parent, ITaskTreeNode child);
+
+ /**
+ * TODO: comment
+ *
+ * @param parent
+ * @param index
+ * @param sequence
+ */
+ void addChild(ISequence parent, int index, ITaskTreeNode child);
+
+ /**
+ * TODO: comment
+ *
+ * @param sequence
+ * @param task
+ */
+ void addChild(ISelection parent, ITaskTreeNode child);
+
+ /**
+ * TODO: comment
+ *
+ * @param iteration
+ * @param newChild
+ */
+ void setChild(IIteration iteration, ITaskTreeNode newChild);
+
+ /**
+ * TODO: comment
+ *
+ * @param parent
+ * @param i
+ */
+ void removeChild(ISequence parent, int index);
+
+ /**
+ * TODO: comment
+ *
+ * @param parent
+ * @param i
+ */
+ void removeChild(ISelection parent, ITaskTreeNode child);
+
+ /**
+ * TODO: comment
+ *
+ * @param parent
+ * @param i
+ */
+ void setDescription(ITaskTreeNode node, String description);
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTreeNode.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTreeNode.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTreeNode.java (revision 922)
@@ -0,0 +1,43 @@
+package de.ugoe.cs.autoquest.tasktrees.treeifc;
+
+import java.util.List;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: $
+ * @author 2011, last modified by $Author: $
+ */
+public interface ITaskTreeNode extends Cloneable {
+
+ /**
+ *
+ */
+ public String getName();
+
+ /**
+ *
+ */
+ public String getDescription();
+
+ /**
+ *
+ */
+ public List getChildren();
+
+ /**
+ *
+ */
+ public boolean equals(ITaskTreeNode taskTreeNode);
+
+ /**
+ *
+ */
+ public int hashCode();
+
+ /**
+ *
+ */
+ public ITaskTreeNode clone();
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTreeNodeFactory.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTreeNodeFactory.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTreeNodeFactory.java (revision 922)
@@ -0,0 +1,53 @@
+package de.ugoe.cs.autoquest.tasktrees.treeifc;
+
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 21.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public interface ITaskTreeNodeFactory
+{
+
+ /**
+ * TODO: comment
+ *
+ * @param eventType
+ * @param eventTarget
+ * @return
+ */
+ IEventTask createNewEventTask(IEventType eventType, IEventTarget eventTarget);
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ ISequence createNewSequence();
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ IIteration createNewIteration();
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ ISelection createNewSelection();
+
+ /**
+ * TODO: comment
+ *
+ * @param rootSequence
+ * @return
+ */
+ ITaskTree createTaskTree(ITaskTreeNode root);
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTreeNodeInfo.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTreeNodeInfo.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITaskTreeNodeInfo.java (revision 922)
@@ -0,0 +1,26 @@
+package de.ugoe.cs.autoquest.tasktrees.treeifc;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 21.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public interface ITaskTreeNodeInfo {
+
+ /**
+ *
+ */
+ public ITaskTreeNode getTask();
+
+ /**
+ *
+ */
+ public int getNoOfOccurencesInTree();
+
+ /**
+ *
+ */
+ public long getLastUpdate();
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITemporalRelationship.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITemporalRelationship.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeifc/ITemporalRelationship.java (revision 922)
@@ -0,0 +1,16 @@
+package de.ugoe.cs.autoquest.tasktrees.treeifc;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 12.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public interface ITemporalRelationship extends ITaskTreeNode {
+
+ /**
+ *
+ */
+ public ITemporalRelationship clone();
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/EventTask.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/EventTask.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/EventTask.java (revision 922)
@@ -0,0 +1,83 @@
+package de.ugoe.cs.autoquest.tasktrees.treeimpl;
+
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: $
+ * @author 2011, last modified by $Author: $
+ */
+public class EventTask extends TaskTreeNode implements IEventTask {
+
+ /** */
+ private IEventType eventType;
+
+ /** */
+ private IEventTarget eventTarget;
+
+ /**
+ * @param eventType
+ * @param eventTarget
+ */
+ EventTask(IEventType eventType, IEventTarget eventTarget) {
+ super(eventType.getName() + "(" + eventTarget + ")");
+ super.setDescription(eventType + " on " + eventTarget);
+ this.eventType = eventType;
+ this.eventTarget = eventTarget;
+ }
+
+ /**
+ * @return Returns the interaction.
+ */
+ public IEventType getEventType() {
+ return eventType;
+ }
+
+ /**
+ * @return Returns the GUIElement.
+ */
+ public IEventTarget getEventTarget() {
+ return eventTarget;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.ctte.Task#equals(de.harms.ctte.Task)
+ */
+ @Override
+ public boolean equals(ITaskTreeNode task) {
+ if (!(task instanceof IEventTask)) {
+ return false;
+ }
+
+ IEventType otherType = ((IEventTask) task).getEventType();
+ IEventTarget otherTarget = ((IEventTask) task).getEventTarget();
+
+ if (((eventType == otherType) ||
+ ((eventType != null) && (eventType.equals(otherType)))) &&
+ ((eventTarget == otherTarget) ||
+ ((eventTarget != null) && (eventTarget.equals(otherTarget)))))
+ {
+ return true;
+ }
+
+ return false;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.harms.tasktrees.TreeNode#clone()
+ */
+ @Override
+ public EventTask clone() {
+ // Event type and target are unchangeable and do not need to be cloned
+ return (EventTask) super.clone();
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Iteration.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Iteration.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Iteration.java (revision 922)
@@ -0,0 +1,56 @@
+package de.ugoe.cs.autoquest.tasktrees.treeimpl;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 19.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class Iteration extends TaskTreeNode implements IIteration {
+
+ /**
+ *
+ */
+ Iteration() {
+ super("Iteration");
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNode#addChild(TaskTreeNode)
+ */
+ @Override
+ public void addChild(ITaskTreeNode child) {
+ // adding more children is not allowed
+ throw new UnsupportedOperationException
+ ("iterations may not have a list of children. Use setChild() instead.");
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param selection
+ * @return
+ */
+ public void setChild(ITaskTreeNode child) {
+ if (super.getChildren().size() > 0) {
+ super.removeChild(0);
+ }
+ super.addChild(child);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#clone()
+ */
+ @Override
+ public Iteration clone() {
+ return (Iteration) super.clone();
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/NodeInfo.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/NodeInfo.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/NodeInfo.java (revision 922)
@@ -0,0 +1,90 @@
+package de.ugoe.cs.autoquest.tasktrees.treeimpl;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeInfo;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: $
+ * @author 2011, last modified by $Author: $
+ */
+public class NodeInfo implements ITaskTreeNodeInfo {
+
+ /** */
+ private ITaskTreeNode task;
+
+ /** */
+ private long lastUpdate;
+
+ /** */
+ private List parentNodes = new ArrayList();
+
+ /**
+ * @param node
+ */
+ NodeInfo(ITaskTreeNode task) {
+ this.task = task;
+ lastUpdate = System.currentTimeMillis();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.NodeInfo#getTask()
+ */
+ @Override
+ public ITaskTreeNode getTask() {
+ return task;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeimpl.NodeInfo#getNoOfOccurencesInTree()
+ */
+ @Override
+ public int getNoOfOccurencesInTree() {
+ return parentNodes.size();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeimpl.NodeInfo#getLastUpdate()
+ */
+ @Override
+ public long getLastUpdate() {
+ return lastUpdate;
+ }
+
+ /**
+ * TODO: comment
+ *
+ */
+ void addParent(ITaskTreeNode parent) {
+ parentNodes.add(parent);
+ }
+
+ /**
+ * TODO: comment
+ *
+ */
+ void removeParent(ITaskTreeNode parent) {
+ parentNodes.remove(parent);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public synchronized String toString() {
+ return "NodeInfo(" + task + ", " + parentNodes.size() + " parents)";
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Selection.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Selection.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Selection.java (revision 922)
@@ -0,0 +1,32 @@
+package de.ugoe.cs.autoquest.tasktrees.treeimpl;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 19.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class Selection extends TaskTreeNode implements ISelection {
+
+ /**
+ * TODO: comment
+ *
+ * @param name
+ */
+ Selection() {
+ super("Selection");
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#clone()
+ */
+ @Override
+ public Selection clone() {
+ return (Selection) super.clone();
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Sequence.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Sequence.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/Sequence.java (revision 922)
@@ -0,0 +1,41 @@
+package de.ugoe.cs.autoquest.tasktrees.treeimpl;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 19.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class Sequence extends TaskTreeNode implements ISequence {
+
+ /**
+ * TODO: comment
+ *
+ * @param name
+ */
+ Sequence() {
+ super("Sequence");
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param name
+ */
+ Sequence(String name) {
+ super(name);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeimpl.TaskTreeNodeImpl#clone()
+ */
+ @Override
+ public Sequence clone() {
+ return (Sequence) super.clone();
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTree.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTree.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTree.java (revision 922)
@@ -0,0 +1,107 @@
+package de.ugoe.cs.autoquest.tasktrees.treeimpl;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeInfo;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 21.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class TaskTree implements ITaskTree {
+
+ /** the map of nodes */
+ private Map taskMap;
+
+ /** the root node of the task tree */
+ private ITaskTreeNode rootNode;
+
+ /**
+ * TODO: comment
+ *
+ */
+ TaskTree(ITaskTreeNode rootNode) {
+ this.rootNode = rootNode;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTree#getRoot()
+ */
+ @Override
+ public ITaskTreeNode getRoot() {
+ return rootNode;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTree#getTaskMap()
+ */
+ @Override
+ public synchronized Map getTaskMap() {
+ if (taskMap == null) {
+ taskMap = new HashMap();
+ addNodeToMap(rootNode, null);
+ }
+ return taskMap;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param rootNode
+ */
+ private void addNodeToMap(ITaskTreeNode node, ITaskTreeNode parent) {
+ NodeInfo nodeInfo = (NodeInfo) taskMap.get(node);
+
+ if (nodeInfo == null) {
+ nodeInfo = new NodeInfo(node);
+ taskMap.put(node, nodeInfo);
+ }
+
+ if (parent != null) {
+ // through first removing an existing parent it is assured, that a parent is recorded
+ // only once. This is needed, because parent may be reused in a tree as well, but we
+ // always iterate the whole tree
+ nodeInfo.removeParent(parent);
+ nodeInfo.addParent(parent);
+ }
+
+ for (ITaskTreeNode child : node.getChildren()) {
+ addNodeToMap(child, node);
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#clone()
+ */
+ @Override
+ public TaskTree clone() {
+ TaskTree clone = null;
+ try {
+ clone = (TaskTree) super.clone();
+
+ clone.rootNode = rootNode.clone();
+
+ // the clone will create the task map itself, when it is first retrieved
+ clone.taskMap = null;
+
+ }
+ catch (CloneNotSupportedException e) {
+ // this should never happen. Therefore simply dump the exception
+ e.printStackTrace();
+ }
+
+ return clone;
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeBuilder.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeBuilder.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeBuilder.java (revision 922)
@@ -0,0 +1,152 @@
+package de.ugoe.cs.autoquest.tasktrees.treeimpl;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 21.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class TaskTreeBuilder implements ITaskTreeBuilder {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#addChild(Sequence, TaskTreeNode)
+ */
+ @Override
+ public void addChild(ISequence parent, ITaskTreeNode child) {
+ if (!(parent instanceof Sequence)) {
+ throw new IllegalArgumentException
+ ("illegal type of task tree node provided: " + parent.getClass());
+ }
+
+ addChildInternal(parent, -1, child);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#addChild(Sequence, int, TaskTreeNode)
+ */
+ @Override
+ public void addChild(ISequence parent, int index, ITaskTreeNode child) {
+ if (!(parent instanceof Sequence)) {
+ throw new IllegalArgumentException
+ ("illegal type of task tree node provided: " + parent.getClass());
+ }
+
+ addChildInternal(parent, index, child);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#addChild(Selection, TaskTreeNode)
+ */
+ @Override
+ public void addChild(ISelection parent, ITaskTreeNode child) {
+ if (!(parent instanceof Selection)) {
+ throw new IllegalArgumentException
+ ("illegal type of task tree node provided: " + parent.getClass());
+ }
+
+ addChildInternal(parent, -1, child);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#setChild(Iteration, TaskTreeNode)
+ */
+ @Override
+ public void setChild(IIteration iteration, ITaskTreeNode newChild) {
+ if (!(iteration instanceof Iteration)) {
+ throw new IllegalArgumentException
+ ("illegal type of iteration provided: " + iteration.getClass());
+ }
+
+ if (!(newChild instanceof TaskTreeNode)) {
+ throw new IllegalArgumentException
+ ("illegal type of task tree node provided: " + newChild.getClass());
+ }
+
+ ((Iteration) iteration).setChild(newChild);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#removeChild(Sequence, int)
+ */
+ @Override
+ public void removeChild(ISequence parent, int index) {
+ if (!(parent instanceof TaskTreeNode)) {
+ throw new IllegalArgumentException
+ ("illegal type of task tree node provided: " + parent.getClass());
+ }
+
+ ((TaskTreeNode) parent).removeChild(index);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#removeChild(Selection, TaskTreeNode)
+ */
+ @Override
+ public void removeChild(ISelection parent, ITaskTreeNode child) {
+ if (!(parent instanceof TaskTreeNode)) {
+ throw new IllegalArgumentException
+ ("illegal type of task tree node provided: " + parent.getClass());
+ }
+
+ for (int i = 0; i < parent.getChildren().size(); i++) {
+ if ((parent.getChildren().get(i) == child) ||
+ ((parent.getChildren().get(i) != null) &&
+ (parent.getChildren().get(i).equals(child))))
+ {
+ ((TaskTreeNode) parent).removeChild(i);
+ break;
+ }
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#setDescription(TaskTreeNode, String)
+ */
+ @Override
+ public void setDescription(ITaskTreeNode parent, String description) {
+ if (!(parent instanceof TaskTreeNode)) {
+ throw new IllegalArgumentException
+ ("illegal type of task tree node provided: " + parent.getClass());
+ }
+
+ ((TaskTreeNode) parent).setDescription(description);
+ }
+
+ /**
+ *
+ */
+ private void addChildInternal(ITaskTreeNode parent, int index, ITaskTreeNode child) {
+ if (!(child instanceof TaskTreeNode)) {
+ throw new IllegalArgumentException
+ ("illegal type of task tree node provided: " + child.getClass());
+ }
+
+ if (index > -1) {
+ ((TaskTreeNode) parent).addChild(index, child);
+ }
+ else {
+ ((TaskTreeNode) parent).addChild(child);
+ }
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeNode.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeNode.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeNode.java (revision 922)
@@ -0,0 +1,220 @@
+package de.ugoe.cs.autoquest.tasktrees.treeimpl;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: $
+ * @author 2011, last modified by $Author: $
+ */
+public class TaskTreeNode implements ITaskTreeNode {
+ /** */
+ private static int temporalId = 0;
+
+ /** */
+ private String name;
+
+ /** */
+ private String description;
+
+ /** */
+ private int id;
+
+ /** children */
+ private List children;
+
+ /**
+ *
+ */
+ public TaskTreeNode(String name) {
+ this.name = name;
+ id = getNewId();
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ private static synchronized int getNewId() {
+ if (temporalId == Integer.MAX_VALUE) {
+ temporalId = 0;
+ }
+
+ return temporalId++;
+ }
+
+ /**
+ * @return Returns the name.
+ */
+ public String getName() {
+ return name;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNode#getDescription()
+ */
+ @Override
+ public String getDescription() {
+ return description;
+ }
+
+ /**
+ *
+ */
+ public synchronized List getChildren() {
+ if ((children == null) || (children.size() == 0)) {
+ return new ArrayList();
+ }
+
+ return children.subList(0, children.size());
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.TaskTreeNode#equals(TaskTreeNode)
+ */
+ @Override
+ public boolean equals(ITaskTreeNode taskTreeNode) {
+ if (!this.getClass().isInstance(taskTreeNode)) {
+ return false;
+ }
+
+ if (taskTreeNode.hashCode() != hashCode()) {
+ return false;
+ }
+
+ TaskTreeNode other = (TaskTreeNode) taskTreeNode;
+
+ if (id != other.id) {
+ return false;
+ }
+
+ if (!name.equals(other.name)) {
+ return false;
+ }
+
+ synchronized (other) {
+ if (children == null) {
+ return (other.children == null);
+ }
+ else if (other.children == null) {
+ return (children == null);
+ }
+ else if (other.children.size() != children.size()) {
+ return false;
+ }
+
+ for (int i = 0; i < children.size(); i++) {
+ if (!children.get(i).equals(other.children.get(i))) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public synchronized int hashCode() {
+ return getClass().getSimpleName().hashCode();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public synchronized String toString() {
+ if (children == null) {
+ return name + "(" + id + ")";
+ }
+ else {
+ return name + "(" + id + ", " + children.size() + " children)";
+ }
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param i
+ * @return
+ */
+ void setDescription(String description) {
+ this.description = description;
+ }
+
+ /**
+ *
+ */
+ synchronized void addChild(ITaskTreeNode child) {
+ if (children == null) {
+ children = new ArrayList();
+ }
+
+ children.add(child);
+ }
+
+ /**
+ *
+ */
+ synchronized void addChild(int index, ITaskTreeNode child) {
+ if (children == null) {
+ children = new ArrayList();
+ }
+
+ children.add(index, child);
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param i
+ * @return
+ */
+ synchronized ITaskTreeNode removeChild(int index) {
+ return children.remove(index);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#clone()
+ */
+ @Override
+ public ITaskTreeNode clone() {
+ TaskTreeNode clone = null;
+ try {
+ clone = (TaskTreeNode) super.clone();
+
+ if (children != null) {
+ clone.children = new ArrayList();
+
+ for (ITaskTreeNode child : children) {
+ clone.children.add(child.clone());
+ }
+ }
+
+ }
+ catch (CloneNotSupportedException e) {
+ // this should never happen. Therefore simply dump the exception
+ e.printStackTrace();
+ }
+
+ return clone;
+ }
+
+}
Index: trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeNodeFactory.java
===================================================================
--- trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeNodeFactory.java (revision 922)
+++ trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeNodeFactory.java (revision 922)
@@ -0,0 +1,73 @@
+package de.ugoe.cs.autoquest.tasktrees.treeimpl;
+
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 21.02.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class TaskTreeNodeFactory implements ITaskTreeNodeFactory {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see TaskTreeNodeFactory#createNewEventTask(IEventType, IEventTarget)
+ */
+ @Override
+ public IEventTask createNewEventTask(IEventType eventType, IEventTarget eventTarget) {
+ return new EventTask(eventType, eventTarget);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewSequence()
+ */
+ @Override
+ public ISequence createNewSequence() {
+ return new Sequence();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewIteration()
+ */
+ @Override
+ public IIteration createNewIteration() {
+ return new Iteration();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewSelection()
+ */
+ @Override
+ public ISelection createNewSelection() {
+ return new Selection();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createTaskTree(de.ugoe.cs.tasktree.treeifc
+ * .TaskTreeNode)
+ */
+ @Override
+ public ITaskTree createTaskTree(ITaskTreeNode root) {
+ return new TaskTree(root);
+ }
+
+}
Index: trunk/autoquest-core-testgeneration/src/main/java/de/ugoe/cs/autoquest/testgeneration/DrawFromAllSequencesGenerator.java
===================================================================
--- trunk/autoquest-core-testgeneration/src/main/java/de/ugoe/cs/autoquest/testgeneration/DrawFromAllSequencesGenerator.java (revision 922)
+++ trunk/autoquest-core-testgeneration/src/main/java/de/ugoe/cs/autoquest/testgeneration/DrawFromAllSequencesGenerator.java (revision 922)
@@ -0,0 +1,180 @@
+package de.ugoe.cs.autoquest.testgeneration;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+import java.util.logging.Level;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.usageprofiles.IStochasticProcess;
+import de.ugoe.cs.util.console.Console;
+
+/**
+ *
+ * Generates a test suite by drawing from all possible sequences of a fixed length according to the
+ * probabilities of the sequences in a {@link IStochasticProcess}.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class DrawFromAllSequencesGenerator {
+
+ /**
+ *
+ * Number of sequences in the test suite.
+ *
+ */
+ private final int numSequences;
+
+ /**
+ *
+ * Minimal length of a test sequence.
+ *
+ */
+ private final int minLength;
+
+ /**
+ *
+ * Maximal length of a test sequence.
+ *
+ */
+ private final int maxLength;
+
+ /**
+ *
+ * In case this member is true, only test cases that end in the global end event
+ * {@link Event#ENDEVENT} are generated. If it is false, the end event can be any event.
+ *
+ */
+ private final boolean validEnd;
+
+ /**
+ *
+ * If this member is true, the generated test suite contains all possible sequences and
+ * {@link #numSequences} is ignored.
+ *
+ */
+ private final boolean generateAll;
+
+ /**
+ *
+ * Constructor. Creates a new DrawFromAllSequencesGenerator and ensures the validity of the
+ * parameters:
+ *
+ * - numSequences must at least be 1
+ *
- maxLength must at least be 1
+ *
- minLength must be less than or equal to maxLength
+ *
+ * If one of these conditions is violated an {@link IllegalArgumentException} is thrown.
+ *
+ *
+ * @param numSequences
+ * number of sequences desired for the test suite
+ * @param minLength
+ * minimal length of a test sequence
+ * @param maxLength
+ * maximal length of a test sequence
+ * @param validEnd
+ * defines if test cases have to end with the global end event {@link Event#ENDEVENT}
+ * (see {@link #validEnd})
+ * @param generateAll
+ * if this parameter is true, the test suite contains all possible sequences and
+ * numSequences is ignored
+ */
+ public DrawFromAllSequencesGenerator(int numSequences,
+ int minLength,
+ int maxLength,
+ boolean validEnd,
+ boolean generateAll)
+ {
+ // check validity of the parameters
+ if (numSequences < 1) {
+ throw new IllegalArgumentException("number of sequences must be at least 1 but is " +
+ numSequences);
+ }
+ if (maxLength < 1) {
+ throw new IllegalArgumentException(
+ "maximal allowed length of test cases must be at least 1 but is " +
+ maxLength);
+ }
+ if (minLength > maxLength) {
+ throw new IllegalArgumentException(
+ "minimal allowed length of test cases must be less than or equal to the maximal allowed length (min length: " +
+ minLength + " ; max length: " + maxLength + ")");
+ }
+ this.numSequences = numSequences;
+ this.minLength = minLength;
+ this.maxLength = maxLength;
+ this.validEnd = validEnd;
+ this.generateAll = generateAll;
+ }
+
+ /**
+ *
+ * Generates a test suite by drawing from all possible sequences with valid lengths.
+ *
+ *
+ * @param model
+ * model used to determine the probability of each possible sequence
+ * @return the test suite
+ */
+ public Collection> generateTestSuite(IStochasticProcess model) {
+ if (model == null) {
+ throw new IllegalArgumentException("model must not be null!");
+ }
+
+ Collection> sequences = new LinkedHashSet>();
+ for (int length = minLength; length <= maxLength; length++) {
+ if (validEnd) {
+ sequences.addAll(model.generateValidSequences(length + 2));
+ }
+ else {
+ sequences.addAll(model.generateSequences(length + 1, true));
+ }
+ }
+ Console.traceln(Level.INFO, "" + sequences.size() + " possible");
+ if (!generateAll && numSequences < sequences.size()) {
+ List probabilities = new ArrayList(sequences.size());
+ double probSum = 0.0;
+ for (List sequence : sequences) {
+ double prob = model.getProbability(sequence);
+ probabilities.add(prob);
+ probSum += prob;
+ }
+ Set drawnSequences = new HashSet(numSequences);
+ Random r = new Random();
+ while (drawnSequences.size() < numSequences) {
+ double randVal = r.nextDouble() * probSum;
+ double sum = 0.0d;
+ int index = -1;
+ while (sum < randVal) {
+ index++;
+ double currentProb = probabilities.get(index);
+ sum += currentProb;
+ }
+ if (!drawnSequences.contains(index)) {
+ drawnSequences.add(index);
+ probSum -= probabilities.get(index);
+ probabilities.set(index, 0.0d);
+ }
+ }
+ Collection> retainedSequences = new LinkedList>();
+ int index = 0;
+ for (List sequence : sequences) {
+ if (drawnSequences.contains(index)) {
+ retainedSequences.add(sequence);
+ }
+ index++;
+ }
+ sequences = retainedSequences;
+ }
+ return sequences;
+ }
+
+}
Index: trunk/autoquest-core-testgeneration/src/main/java/de/ugoe/cs/autoquest/testgeneration/HybridGenerator.java
===================================================================
--- trunk/autoquest-core-testgeneration/src/main/java/de/ugoe/cs/autoquest/testgeneration/HybridGenerator.java (revision 922)
+++ trunk/autoquest-core-testgeneration/src/main/java/de/ugoe/cs/autoquest/testgeneration/HybridGenerator.java (revision 922)
@@ -0,0 +1,212 @@
+package de.ugoe.cs.autoquest.testgeneration;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+import java.util.logging.Level;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.usageprofiles.IStochasticProcess;
+import de.ugoe.cs.util.console.Console;
+
+/**
+ *
+ * Generates a test suite with a hybrid approach that is a mixture of random walks and drawing from
+ * all possible sequences.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class HybridGenerator {
+
+ /**
+ *
+ * Number of sequences in the test suite.
+ *
+ */
+ private final int numSequences;
+
+ /**
+ *
+ * Length of a test sequence.
+ *
+ */
+ private final int length;
+
+ /**
+ *
+ * Maximal length where it is possible to generate all sequences and draw from them.
+ *
+ */
+ private final int maxLengthAll;
+
+ /**
+ *
+ * In case this member is true, only test cases that end in the global end event
+ * {@link Event#ENDEVENT} are generated. If it is false, the end event can be any event.
+ *
+ */
+ private final boolean validEnd;
+
+ /**
+ *
+ * Constructor. Creates a new HybridGenerator and ensures the validity of the parameters:
+ *
+ * - numSequences must at least be 1
+ *
- length must be at least 1
+ *
+ * If one of these conditions is violated an {@link IllegalArgumentException} is thrown.
+ *
+ *
+ * @param numSequences
+ * number of sequences desired for the test suite
+ * @param length
+ * length of a test sequence
+ * @param maxLengthAll
+ * maximal length where it is possible to generate all sequences and draw from them
+ * @param validEnd
+ * defines if test cases have to end with the global end event {@link Event#ENDEVENT}
+ * (see {@link #validEnd})
+ */
+ public HybridGenerator(int numSequences, int length, int maxLengthAll, boolean validEnd) {
+ // check validity of the parameters
+ if (numSequences < 1) {
+ throw new IllegalArgumentException("number of sequences must be at least 1 but is " +
+ numSequences);
+ }
+ if (length < 1) {
+ throw new IllegalArgumentException("length of test cases must be at least 1 but is " +
+ length);
+ }
+ this.numSequences = numSequences;
+ this.length = length;
+ this.maxLengthAll = maxLengthAll;
+ this.validEnd = validEnd;
+ }
+
+ /**
+ *
+ * Generates a test suite with a hybrid approach that is a mixture of random walks and drawing
+ * from all possible sequences
+ *
+ *
+ * @param model
+ * model used to determine the probability of each possible sequence
+ * @return the test suite
+ */
+ public Collection> generateTestSuite(IStochasticProcess model) {
+ if (model == null) {
+ throw new IllegalArgumentException("model must not be null!");
+ }
+
+ Collection> sequences = new LinkedHashSet>();
+
+ List> seqsTmp =
+ new ArrayList>(model.generateSequences(maxLengthAll + 1, true));
+
+ Console.traceln(Level.INFO, "" + seqsTmp.size() + " of length " + maxLengthAll + " possible");
+ List probabilities = new ArrayList(seqsTmp.size());
+ double probSum = 0.0;
+ for (List sequence : seqsTmp) {
+ double prob = model.getProbability(sequence);
+ probabilities.add(prob);
+ probSum += prob;
+ }
+
+ Random r = new Random();
+ int j = 0;
+ while (sequences.size() < numSequences && j <= numSequences * 100) {
+ j++;
+ double randVal = r.nextDouble() * probSum;
+ double sum = 0.0d;
+ int index = -1;
+ while (sum < randVal) {
+ index++;
+ double currentProb = probabilities.get(index);
+ sum += currentProb;
+ }
+ List seqTmp = seqsTmp.get(index);
+ if (!Event.ENDEVENT.equals(seqTmp.get(seqTmp.size() - 1))) {
+ List sequence;
+ if (validEnd) {
+ sequence = finishSequence(seqTmp, model, length + 2, validEnd);
+ if (sequence != null && sequence.size() != length + 2) {
+ sequence = null;
+ }
+ }
+ else {
+ sequence = finishSequence(seqTmp, model, length + 1, validEnd);
+ if (sequence != null && sequence.size() != length + 1) {
+ sequence = null;
+ }
+ }
+ if (sequence != null) {
+ sequences.add(sequence);
+ }
+ }
+ }
+
+ return sequences;
+ }
+
+ /**
+ *
+ * Finishes a sequence with a random walk.
+ *
+ *
+ * @param sequence
+ * sequence to be finished
+ * @param model
+ * model used for the random walk
+ * @param length
+ * desired length of the sequence
+ * @param validEnd
+ * if the sequence should end in {@link Event#ENDEVENT}.
+ * @return finished sequence of the desired length
+ */
+ private List finishSequence(List sequence,
+ IStochasticProcess model,
+ int length,
+ boolean validEnd)
+ {
+ Random r = new Random();
+ boolean endFound = false;
+ List sequenceCopy = new LinkedList(sequence);
+ final int maxIter = 30000;
+ int iter = 0;
+ while (!endFound && iter < maxIter) {
+ iter++;
+ sequenceCopy = new LinkedList(sequence);
+ while (!endFound && sequenceCopy.size() <= length) {
+ double randVal = r.nextDouble();
+ double probSum = 0.0;
+ for (Event symbol : model.getEvents()) {
+ probSum += model.getProbability(sequenceCopy, symbol);
+ if (probSum >= randVal) {
+ if (!(Event.STARTEVENT.equals(symbol) || (!validEnd && Event.ENDEVENT
+ .equals(symbol))))
+ {
+ // only add the symbol the sequence if it is not
+ // START
+ // or END
+ sequenceCopy.add(symbol);
+ }
+ endFound =
+ Event.ENDEVENT.equals(symbol) ||
+ (!validEnd && sequenceCopy.size() == length);
+ break;
+ }
+ }
+ }
+ }
+ if (iter == maxIter) {
+ return null;
+ }
+ return sequenceCopy;
+ }
+
+}
Index: trunk/autoquest-core-testgeneration/src/main/java/de/ugoe/cs/autoquest/testgeneration/RandomWalkGenerator.java
===================================================================
--- trunk/autoquest-core-testgeneration/src/main/java/de/ugoe/cs/autoquest/testgeneration/RandomWalkGenerator.java (revision 922)
+++ trunk/autoquest-core-testgeneration/src/main/java/de/ugoe/cs/autoquest/testgeneration/RandomWalkGenerator.java (revision 922)
@@ -0,0 +1,172 @@
+package de.ugoe.cs.autoquest.testgeneration;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.usageprofiles.IStochasticProcess;
+
+/**
+ *
+ * Generates a test suite by randomly walking an {@link IStochasticProcess}.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class RandomWalkGenerator {
+
+ /**
+ *
+ * Number of sequences in the test suite.
+ *
+ */
+ private final int numSequences;
+
+ /**
+ *
+ * Minimal length of a test sequence.
+ *
+ */
+ private final int minLength;
+
+ /**
+ *
+ * Maximal length of a test sequence.
+ *
+ */
+ private final int maxLength;
+
+ /**
+ *
+ * In case this member is true, only test cases that end in the global end event
+ * {@link Event#ENDEVENT} are generated. If it is false, the end event can be any event.
+ *
+ */
+ private final boolean validEnd;
+
+ /**
+ *
+ * Maximal number of random walks performed before aborting the test case generation and
+ * returning a test suite with less than {@link #numSequences} test cases. This can happen if
+ * too many generated random walks have to be discarded because their length is not between
+ * {@link #minLength} and {@link #maxLength}.
+ *
+ */
+ private final long maxIter;
+
+ /**
+ *
+ * Actual number of random walks performed to generate the test suite.
+ *
+ */
+ private long actualIter = -1;
+
+ /**
+ *
+ * Constructor. Creates a new RandomWalkGenerator and ensures the validity of the parameters:
+ *
+ * - numSequences must at least be 1
+ *
- maxLength must at least be 1
+ *
- minLength must be less than or equal to maxLength
+ *
- maxIter must be greater than or equal to numSequences
+ *
+ * If one of these conditions is violated an {@link IllegalArgumentException} is thrown.
+ *
+ *
+ * @param numSequences
+ * number of sequences desired for the test suite
+ * @param minLength
+ * minimal length of a test sequence
+ * @param maxLength
+ * maximal length of a test sequence
+ * @param validEnd
+ * defines if test cases have to end with the global end event {@link Event#ENDEVENT}
+ * (see {@link #validEnd})
+ * @param maxIter
+ * maximal number of random walks before aborting the test case generation (see
+ * {@link #maxIter})
+ */
+ public RandomWalkGenerator(int numSequences,
+ int minLength,
+ int maxLength,
+ boolean validEnd,
+ long maxIter)
+ {
+ // check validity of the parameters
+ if (numSequences < 1) {
+ throw new IllegalArgumentException("number of sequences must be at least 1 but is " +
+ numSequences);
+ }
+ if (maxLength < 1) {
+ throw new IllegalArgumentException(
+ "maximal allowed length of test cases must be at least 1 but is " +
+ maxLength);
+ }
+ if (minLength > maxLength) {
+ throw new IllegalArgumentException(
+ "minimal allowed length of test cases must be less than or equal to the maximal allowed length (min length: " +
+ minLength + " ; max length: " + maxLength + ")");
+ }
+ if (maxIter < numSequences) {
+ throw new IllegalArgumentException(
+ "maximal number of iterations must greater than or equal to the number of sequences (number of sequences: " +
+ numSequences +
+ " ; max iterations: " +
+ maxIter +
+ ")");
+ }
+ this.numSequences = numSequences;
+ this.minLength = minLength;
+ this.maxLength = maxLength;
+ this.validEnd = validEnd;
+ this.maxIter = maxIter;
+ }
+
+ /**
+ *
+ * Generates a test suite by repeatedly randomly walking a stochastic process.
+ *
+ *
+ * @param model
+ * stochastic process which performs the random walks
+ * @return the test suite
+ */
+ public Collection> generateTestSuite(IStochasticProcess model) {
+ if (model == null) {
+ throw new IllegalArgumentException("model must not be null!");
+ }
+
+ Set> sequences = new HashSet>(numSequences);
+ actualIter = 0;
+ while (sequences.size() < numSequences && actualIter < maxIter) {
+ List generatedSequence = model.randomSequence(maxLength, validEnd);
+ if (generatedSequence.size() >= minLength && generatedSequence.size() <= maxLength) {
+ ((List) generatedSequence).add(0, Event.STARTEVENT);
+ if (validEnd) {
+ ((List) generatedSequence).add(Event.ENDEVENT);
+ }
+ sequences.add(generatedSequence);
+ }
+ actualIter++;
+ }
+
+ return sequences;
+ }
+
+ /**
+ *
+ * Returns the actual number of random walks performed during the last call of
+ * {@link #generateTestSuite(IStochasticProcess)} or -1 if
+ * {@link #generateTestSuite(IStochasticProcess)} has not been called yet.
+ *
+ *
+ * @return actual number of random walks or -1 if {@link #generateTestSuite(IStochasticProcess)}
+ * has not been called
+ */
+ public long getActualIter() {
+ return actualIter;
+ }
+}
Index: trunk/autoquest-core-usability-test/.settings/org.eclipse.m2e.core.prefs
===================================================================
--- trunk/autoquest-core-usability-test/.settings/org.eclipse.m2e.core.prefs (revision 921)
+++ trunk/autoquest-core-usability-test/.settings/org.eclipse.m2e.core.prefs (revision 922)
Index: trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/AbstractUsabilityEvaluationTC.java
===================================================================
--- trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/AbstractUsabilityEvaluationTC.java (revision 922)
+++ trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/AbstractUsabilityEvaluationTC.java (revision 922)
@@ -0,0 +1,212 @@
+package de.ugoe.cs.autoquest.usability;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.logging.Level;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.junit.Before;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.gui.TextInput;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+import de.ugoe.cs.autoquest.test.DummyGUIElement;
+import de.ugoe.cs.autoquest.test.DummyInteraction;
+import de.ugoe.cs.autoquest.test.DummyTextField;
+import de.ugoe.cs.autoquest.usability.UsabilityDefect;
+import de.ugoe.cs.autoquest.usability.UsabilityEvaluationResult;
+import de.ugoe.cs.util.console.TextConsole;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 18.07.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+public class AbstractUsabilityEvaluationTC {
+
+ /** */
+ private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder();
+
+ /** */
+ private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory();
+
+ /**
+ *
+ */
+ @Before
+ public void setUp() {
+ new TextConsole(Level.FINEST);
+ }
+
+ /**
+ *
+ */
+ protected ITaskTree createTaskTree(String spec) {
+ Matcher matcher =
+ Pattern.compile("(\\s*(\\w+)\\s*(\\(((\\w*\\s*)*)\\))?\\s*(\\{))|(\\})").matcher(spec);
+
+ if (!matcher.find()) {
+ if (!matcher.hitEnd()) {
+ throw new IllegalArgumentException("could not parse task specification");
+ }
+ }
+
+ return taskTreeNodeFactory.createTaskTree(parseTask(matcher, new int[1]));
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param expectedDefects
+ * @param evaluateUsability
+ */
+ protected void assertUsabilityEvaluationResult(UsabilityDefect[] expectedDefects,
+ UsabilityEvaluationResult evaluationResult)
+ {
+ assertEquals(expectedDefects.length, evaluationResult.getAllDefects().size());
+
+ EXPECTED_DEFECT_ITERATION:
+ for (UsabilityDefect expectedDefect : expectedDefects) {
+ for (UsabilityDefect defect : evaluationResult.getAllDefects()) {
+ if (expectedDefect.equals(defect)) {
+ System.err.println(defect.getParameterizedDescription());
+ continue EXPECTED_DEFECT_ITERATION;
+ }
+ }
+
+ for (UsabilityDefect defect : evaluationResult.getAllDefects()) {
+ System.err.println(defect);
+ }
+
+ fail("expected defect " + expectedDefect + " not found in evaluation result");
+ }
+ }
+
+ /**
+ *
+ */
+ private ITaskTreeNode parseTask(Matcher tokenMatcher, int[] typeNumbers) {
+ String firstToken = tokenMatcher.group();
+
+ if ("}".equals(firstToken)) {
+ throw new IllegalArgumentException("found a closing bracket at an unexpected place");
+ }
+
+ ITaskTreeNode treeNode = instantiateTreeNode(tokenMatcher, typeNumbers);
+
+ if (!tokenMatcher.find()) {
+ throw new IllegalArgumentException("could not parse task specification");
+ }
+
+ firstToken = tokenMatcher.group();
+
+ if (!"}".equals(firstToken)) {
+ ITaskTreeNode child = null;
+
+ do {
+ child = parseTask(tokenMatcher, typeNumbers);
+
+ if (child != null) {
+ addChild(treeNode, child);
+
+ if (!tokenMatcher.find()) {
+ throw new IllegalArgumentException("could not parse task specification");
+ }
+
+ firstToken = tokenMatcher.group();
+
+ if ("}".equals(firstToken)) {
+ break;
+ }
+ }
+
+ }
+ while (child != null);
+
+ }
+
+ return treeNode;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param group
+ * @return
+ */
+ private ITaskTreeNode instantiateTreeNode(Matcher tokenMatcher, int[] typeNumbers) {
+ String type = tokenMatcher.group(2);
+ String additionalInfo = tokenMatcher.group(4);
+
+ if ("Interaction".equals(type)) {
+ return taskTreeNodeFactory.createNewEventTask
+ (new DummyInteraction("dummy", typeNumbers[0]++), new DummyGUIElement("dummy"));
+ }
+ else if ("Sequence".equals(type)) {
+ return taskTreeNodeFactory.createNewSequence();
+ }
+ else if ("Iteration".equals(type)) {
+ return taskTreeNodeFactory.createNewIteration();
+ }
+ else if ("Selection".equals(type)) {
+ return taskTreeNodeFactory.createNewSelection();
+ }
+ else if ("TextInput".equals(type)) {
+ if (additionalInfo == null) {
+ fail("no simulated text provided for text input interactin task");
+ }
+
+ TextInput textInput = new TextInput(additionalInfo, new ArrayList());
+
+ IEventTask task = taskTreeNodeFactory.createNewEventTask
+ (textInput, new DummyTextField(additionalInfo));
+
+ return task;
+ }
+ else {
+ fail("invalid type of task tree node: " + type);
+ return null;
+ }
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param treeNode
+ * @param child
+ */
+ private void addChild(ITaskTreeNode parent, ITaskTreeNode child) {
+ if (parent instanceof ISequence) {
+ taskTreeBuilder.addChild((ISequence) parent, child);
+ }
+ else if (parent instanceof IIteration) {
+ if (parent.getChildren().size() <= 0) {
+ taskTreeBuilder.setChild((IIteration) parent, child);
+ }
+ else {
+ fail("can not add more than one child to an iteration");
+ }
+ }
+ else if (parent instanceof ISelection) {
+ taskTreeBuilder.addChild((ISelection) parent, child);
+ }
+ else {
+ fail("can not add children to parent task tree node of type " +
+ parent.getClass().getName());
+ }
+ }
+
+}
Index: trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/TextInputStatisticsRuleTest.java
===================================================================
--- trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/TextInputStatisticsRuleTest.java (revision 922)
+++ trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/TextInputStatisticsRuleTest.java (revision 922)
@@ -0,0 +1,680 @@
+package de.ugoe.cs.autoquest.usability;
+
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectDescription.TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.HIGH;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.INFO;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.LOW;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.MEDIUM;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.usability.UsabilityDefect;
+import de.ugoe.cs.autoquest.usability.UsabilityDefectDescription;
+import de.ugoe.cs.autoquest.usability.UsabilityEvaluationManager;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 18.07.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+public class TextInputStatisticsRuleTest extends AbstractUsabilityEvaluationTC {
+
+ /**
+ * TODO: comment
+ *
+ */
+ @Test
+ public void testWithDifferentTextInputInteractionsOnly() {
+ UsabilityEvaluationManager manager = new UsabilityEvaluationManager();
+
+ // ===== check =====
+ String spec =
+ "TextInput (bla) {}";
+ UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (bla) {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (a) {}" +
+ " TextInput (b) {}" +
+ " TextInput (c) {}" +
+ " TextInput (d) {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Selection {" +
+ " TextInput (a) {}" +
+ " TextInput (b) {}" +
+ " TextInput (c) {}" +
+ " TextInput (d) {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Iteration {" +
+ " TextInput (bla) {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (a) {}" +
+ " Sequence {" +
+ " TextInput (b) {}" +
+ " TextInput (c) {}" +
+ " TextInput (d) {}" +
+ " TextInput (e) {}" +
+ " }" +
+ " Iteration {" +
+ " TextInput (f) {}" +
+ " }" +
+ " TextInput (g) {}" +
+ " Selection {" +
+ " TextInput (h) {}" +
+ " TextInput (i) {}" +
+ " TextInput (j) {}" +
+ " TextInput (k) {}" +
+ " }" +
+ " Sequence {" +
+ " TextInput (l) {}" +
+ " Sequence {" +
+ " TextInput (m) {}" +
+ " TextInput (n) {}" +
+ " TextInput (o) {}" +
+ " TextInput (p) {}" +
+ " }" +
+ " Iteration {" +
+ " TextInput (q) {}" +
+ " }" +
+ " TextInput (r) {}" +
+ " Selection {" +
+ " TextInput (s) {}" +
+ " TextInput (t) {}" +
+ " TextInput (u) {}" +
+ " TextInput (v) {}" +
+ " }" +
+ " }" +
+ " Selection {" +
+ " TextInput (w) {}" +
+ " Sequence {" +
+ " TextInput (x) {}" +
+ " TextInput (y) {}" +
+ " TextInput (z) {}" +
+ " TextInput (aa) {}" +
+ " }" +
+ " Iteration {" +
+ " TextInput (ab) {}" +
+ " }" +
+ " TextInput (ac) {}" +
+ " Selection {" +
+ " TextInput (ad) {}" +
+ " TextInput (ae) {}" +
+ " TextInput (af) {}" +
+ " TextInput (ag) {}" +
+ " }" +
+ " }" +
+ " TextInput (ah) {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+ }
+
+ /**
+ * TODO: comment
+ *
+ */
+ @Test
+ public void testCombinationsOfTextInputInteractionsAndOtherInteractions() {
+ UsabilityEvaluationManager manager = new UsabilityEvaluationManager();
+
+ // ===== check =====
+ String spec =
+ "Sequence {" +
+ " Interaction {}" +
+ " TextInput (a) {}" +
+ " TextInput (b) {}" +
+ " Interaction {}" +
+ " TextInput (c) {}" +
+ "}";
+
+ UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " Interaction {}" +
+ " TextInput (a) {}" +
+ " Interaction {}" +
+ " Interaction {}" +
+ " TextInput (c) {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(INFO, TEXT_FIELD_INPUT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " Interaction {}" +
+ " TextInput (a) {}" +
+ " Interaction {}" +
+ " Interaction {}" +
+ " Interaction {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[0];
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Selection {" +
+ " Interaction {}" +
+ " TextInput (a) {}" +
+ " TextInput (b) {}" +
+ " Interaction {}" +
+ " TextInput (c) {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (a) {}" +
+ " Sequence {" +
+ " Interaction {}" +
+ " TextInput (b) {}" +
+ " TextInput (c) {}" +
+ " Interaction {}" +
+ " TextInput (d) {}" +
+ " }" +
+ " Iteration {" +
+ " TextInput (e) {}" +
+ " }" +
+ " Interaction {}" +
+ " Selection {" +
+ " Interaction {}" +
+ " TextInput (f) {}" +
+ " TextInput (g) {}" +
+ " Interaction {}" +
+ " TextInput (h) {}" +
+ " TextInput (i) {}" +
+ " }" +
+ " Sequence {" +
+ " TextInput (j) {}" +
+ " Sequence {" +
+ " TextInput (k) {}" +
+ " Interaction {}" +
+ " TextInput (l) {}" +
+ " TextInput (m) {}" +
+ " Interaction {}" +
+ " TextInput (n) {}" +
+ " TextInput (o) {}" +
+ " }" +
+ " Iteration {" +
+ " Interaction {}" +
+ " }" +
+ " Interaction {}" +
+ " Selection {" +
+ " TextInput (p) {}" +
+ " TextInput (q) {}" +
+ " TextInput (r) {}" +
+ " Interaction {}" +
+ " TextInput (s) {}" +
+ " TextInput (t) {}" +
+ " Interaction {}" +
+ " TextInput (u) {}" +
+ " TextInput (v) {}" +
+ " }" +
+ " }" +
+ " Selection {" +
+ " Interaction {}" +
+ " Sequence {" +
+ " TextInput (w) {}" +
+ " Interaction {}" +
+ " TextInput (x) {}" +
+ " TextInput (y) {}" +
+ " Interaction {}" +
+ " }" +
+ " Iteration {" +
+ " TextInput (z) {}" +
+ " }" +
+ " TextInput (aa) {}" +
+ " Selection {" +
+ " TextInput (ab) {}" +
+ " Interaction {}" +
+ " TextInput (ac) {}" +
+ " TextInput (ad) {}" +
+ " Interaction {}" +
+ " TextInput (ae) {}" +
+ " }" +
+ " }" +
+ " Interaction {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (a) {}" +
+ " Sequence {" +
+ " Interaction {}" +
+ " TextInput (b) {}" +
+ " Interaction {}" +
+ " Interaction {}" +
+ " TextInput (c) {}" +
+ " }" +
+ " Iteration {" +
+ " TextInput (d) {}" +
+ " }" +
+ " Interaction {}" +
+ " Selection {" +
+ " Interaction {}" +
+ " TextInput (e) {}" +
+ " Interaction {}" +
+ " Interaction {}" +
+ " TextInput (g) {}" +
+ " Interaction {}" +
+ " }" +
+ " Sequence {" +
+ " TextInput (i) {}" +
+ " Sequence {" +
+ " TextInput (j) {}" +
+ " Interaction {}" +
+ " TextInput (k) {}" +
+ " Interaction {}" +
+ " Interaction {}" +
+ " TextInput (m) {}" +
+ " Interaction {}" +
+ " }" +
+ " Iteration {" +
+ " Interaction {}" +
+ " }" +
+ " Interaction {}" +
+ " Selection {" +
+ " TextInput (o) {}" +
+ " Interaction {}" +
+ " Interaction {}" +
+ " Interaction {}" +
+ " Interaction {}" +
+ " TextInput (s) {}" +
+ " Interaction {}" +
+ " TextInput (t) {}" +
+ " TextInput (u) {}" +
+ " }" +
+ " }" +
+ " Selection {" +
+ " Interaction {}" +
+ " Sequence {" +
+ " TextInput (v) {}" +
+ " Interaction {}" +
+ " Interaction {}" +
+ " TextInput (x) {}" +
+ " Interaction {}" +
+ " }" +
+ " Iteration {" +
+ " TextInput (y) {}" +
+ " }" +
+ " TextInput (z) {}" +
+ " Selection {" +
+ " TextInput (aa) {}" +
+ " Interaction {}" +
+ " TextInput (ab) {}" +
+ " Interaction {}" +
+ " Interaction {}" +
+ " TextInput (ad) {}" +
+ " }" +
+ " }" +
+ " Interaction {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(INFO, TEXT_FIELD_INPUT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+ }
+
+ /**
+ * TODO: comment
+ *
+ */
+ @Test
+ public void testTextEntryRepetitions() {
+ UsabilityEvaluationManager manager = new UsabilityEvaluationManager();
+
+ // ===== check =====
+ String spec =
+ "Sequence {" +
+ " TextInput (a b c) {}" +
+ " Sequence {" +
+ " TextInput (a) {}" +
+ " TextInput (b) {}" +
+ " TextInput (c) {}" +
+ " TextInput (a) {}" +
+ " }" +
+ " Iteration {" +
+ " TextInput (a) {}" +
+ " }" +
+ " TextInput (a) {}" +
+ " Selection {" +
+ " TextInput (b c) {}" +
+ " TextInput (a) {}" +
+ " TextInput (a c) {}" +
+ " TextInput (b a) {}" +
+ " }" +
+ " Sequence {" +
+ " TextInput (b c) {}" +
+ " Sequence {" +
+ " TextInput (d a c) {}" +
+ " TextInput (b b b a) {}" +
+ " TextInput (a a c c) {}" +
+ " TextInput (b b a) {}" +
+ " }" +
+ " }" +
+ " TextInput (d) {}" +
+ "}";
+
+ UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO),
+ new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_REPETITIONS) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (a b c d e f g h i j k l m) {}" +
+ " Sequence {" +
+ " TextInput (a) {}" +
+ " TextInput (b) {}" +
+ " TextInput (c) {}" +
+ " TextInput (d) {}" +
+ " }" +
+ " Iteration {" +
+ " TextInput (e) {}" +
+ " }" +
+ " TextInput (f) {}" +
+ " Selection {" +
+ " TextInput (g) {}" +
+ " TextInput (h) {}" +
+ " TextInput (i) {}" +
+ " TextInput (j) {}" +
+ " }" +
+ " Sequence {" +
+ " TextInput (k) {}" +
+ " Sequence {" +
+ " TextInput (l) {}" +
+ " TextInput (m) {}" +
+ " TextInput (n) {}" +
+ " TextInput (o) {}" +
+ " }" +
+ " }" +
+ " TextInput (p) {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO),
+ new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_REPETITIONS) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (a b c d e f g h i j k l m) {}" +
+ " Sequence {" +
+ " TextInput (a) {}" +
+ " TextInput (b) {}" +
+ " TextInput (c) {}" +
+ " TextInput (d) {}" +
+ " }" +
+ " Iteration {" +
+ " TextInput (e) {}" +
+ " }" +
+ " TextInput (a) {}" +
+ " Selection {" +
+ " TextInput (b) {}" +
+ " TextInput (c) {}" +
+ " TextInput (d) {}" +
+ " TextInput (e) {}" +
+ " }" +
+ " Sequence {" +
+ " TextInput (a) {}" +
+ " Sequence {" +
+ " TextInput (b) {}" +
+ " TextInput (c) {}" +
+ " TextInput (d) {}" +
+ " TextInput (e) {}" +
+ " }" +
+ " }" +
+ " TextInput (f) {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO),
+ new UsabilityDefect(MEDIUM, TEXT_FIELD_INPUT_REPETITIONS) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (a b c d e f g h i j k l m) {}" +
+ " Sequence {" +
+ " TextInput (a) {}" +
+ " TextInput (b) {}" +
+ " TextInput (c) {}" +
+ " TextInput (a) {}" +
+ " }" +
+ " Iteration {" +
+ " TextInput (b) {}" +
+ " }" +
+ " TextInput (c) {}" +
+ " Selection {" +
+ " TextInput (a) {}" +
+ " TextInput (b) {}" +
+ " TextInput (c) {}" +
+ " TextInput (a) {}" +
+ " }" +
+ " Sequence {" +
+ " TextInput (b) {}" +
+ " Sequence {" +
+ " TextInput (c) {}" +
+ " TextInput (a) {}" +
+ " TextInput (b) {}" +
+ " TextInput (c) {}" +
+ " }" +
+ " }" +
+ " TextInput (a) {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO),
+ new UsabilityDefect(MEDIUM, TEXT_FIELD_INPUT_REPETITIONS) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (a b c) {}" +
+ " Sequence {" +
+ " TextInput (a) {}" +
+ " TextInput (b) {}" +
+ " TextInput (c) {}" +
+ " }" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO),
+ new UsabilityDefect(LOW, TEXT_FIELD_INPUT_REPETITIONS) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (a b c) {}" +
+ " Sequence {" +
+ " TextInput (a) {}" +
+ " TextInput (a) {}" +
+ " TextInput (b) {}" +
+ " }" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO),
+ new UsabilityDefect(LOW, TEXT_FIELD_INPUT_REPETITIONS) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (a b c) {}" +
+ " Sequence {" +
+ " TextInput (a) {}" +
+ " TextInput (d) {}" +
+ " TextInput (e) {}" +
+ " }" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO),
+ new UsabilityDefect(INFO, TEXT_FIELD_INPUT_REPETITIONS) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ }
+
+ /**
+ * TODO: comment
+ *
+ */
+ @Test
+ public void testNoLetterOrDigitInput() {
+ UsabilityEvaluationManager manager = new UsabilityEvaluationManager();
+
+ // ===== check =====
+ String spec =
+ "Sequence {" +
+ " TextInput (_a_b_c_) {}" +
+ "}";
+
+ UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO),
+ new UsabilityDefect(HIGH, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (12345_6789012345) {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO),
+ new UsabilityDefect(MEDIUM, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (123456789012345678901234567890_123456789012345) {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO),
+ new UsabilityDefect(LOW, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ // ===== check =====
+ spec =
+ "Sequence {" +
+ " TextInput (1234567890123456789012345678901234567890123456789_01234567890" +
+ "12345678901234567890123456789012345) {}" +
+ "}";
+
+ expectedDefects = new UsabilityDefect[]
+ { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO),
+ new UsabilityDefect(INFO, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) };
+
+ assertUsabilityEvaluationResult
+ (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));
+
+ }
+}
Index: trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/UsabilityDefectDescriptionTest.java
===================================================================
--- trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/UsabilityDefectDescriptionTest.java (revision 922)
+++ trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/UsabilityDefectDescriptionTest.java (revision 922)
@@ -0,0 +1,53 @@
+package de.ugoe.cs.autoquest.usability;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.usability.UsabilityDefectDescription;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 20.07.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+public class UsabilityDefectDescriptionTest {
+
+ /**
+ * TODO: comment
+ *
+ */
+ @Test
+ public void testInitialization() {
+ for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) {
+ assertNotNull(description.toString());
+ assertNotSame("", description.toString());
+ System.err.println(description);
+ }
+ }
+
+ /**
+ * TODO: comment
+ *
+ */
+ @Test
+ public void testParameterization() {
+ for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) {
+ Map parameters = new HashMap();
+
+ for (String parameter : description.getDescriptionParameters()) {
+ parameters.put(parameter, "");
+ }
+
+ assertNotNull(description.toString(parameters));
+ assertNotSame("", description.toString(parameters));
+ System.err.println(description.toString(parameters));
+ }
+ }
+
+}
Index: trunk/autoquest-core-usability/.settings/org.eclipse.m2e.core.prefs
===================================================================
--- trunk/autoquest-core-usability/.settings/org.eclipse.m2e.core.prefs (revision 921)
+++ trunk/autoquest-core-usability/.settings/org.eclipse.m2e.core.prefs (revision 922)
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/TextInputStatisticsRule.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/TextInputStatisticsRule.java (revision 922)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/TextInputStatisticsRule.java (revision 922)
@@ -0,0 +1,400 @@
+package de.ugoe.cs.autoquest.usability;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import de.ugoe.cs.autoquest.eventcore.gui.TextInput;
+import de.ugoe.cs.autoquest.eventcore.guimodel.ITextArea;
+import de.ugoe.cs.autoquest.eventcore.guimodel.ITextField;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 16.07.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+public class TextInputStatisticsRule implements de.ugoe.cs.autoquest.usability.UsabilityEvaluationRule {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.usability.UsabilityEvaluationRule#evaluate(TaskTree)
+ */
+ @Override
+ public UsabilityEvaluationResult evaluate(ITaskTree taskTree) {
+ TextInputStatistics statistics = new TextInputStatistics();
+ calculateStatistics(taskTree.getRoot(), statistics);
+
+ UsabilityEvaluationResult results = new UsabilityEvaluationResult();
+ analyzeStatistics(statistics, results);
+
+ return results;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param statistics
+ * @param results
+ */
+ private void analyzeStatistics(TextInputStatistics statistics,
+ UsabilityEvaluationResult results)
+ {
+ checkTextInputRatio(statistics, results);
+ checkTextFieldEntryRepetitions(statistics, results);
+ checkTextFieldNoLetterOrDigitInputs(statistics, results);
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param statistics
+ * @param results
+ */
+ private void checkTextInputRatio(TextInputStatistics statistics,
+ UsabilityEvaluationResult results)
+ {
+ float allTextFieldInputs =
+ statistics.getNoOfTextFieldInputs() + statistics.getNoOfTextAreaInputs();
+
+ float ratio = allTextFieldInputs / (float) statistics.getNoOfAllEvents();
+
+ UsabilityDefectSeverity severity = null;
+ if (ratio > 0.9) {
+ severity = UsabilityDefectSeverity.HIGH;
+ }
+ else if (ratio > 0.7) {
+ severity = UsabilityDefectSeverity.MEDIUM;
+ }
+ else if (ratio > 0.5) {
+ severity = UsabilityDefectSeverity.LOW;
+ }
+ else if (ratio > 0.3) {
+ severity = UsabilityDefectSeverity.INFO;
+ }
+
+ if (severity != null) {
+ Map parameters = new HashMap();
+ parameters.put("textInputRatio", DecimalFormat.getInstance().format(ratio * 100) + "%");
+
+ results.addDefect
+ (new UsabilityDefect(severity, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO,
+ parameters));
+ }
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param statistics
+ * @param results
+ */
+ private void checkTextFieldEntryRepetitions(TextInputStatistics statistics,
+ UsabilityEvaluationResult results)
+ {
+ Map words = new HashMap();
+ int numberOfRepeatedWords = 0;
+ int maxRepetitions = 0;
+
+ for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) {
+ String[] fragments = statistics.getTextFieldInputFragments(i);
+ for (String fragment : fragments) {
+ if (!"".equals(fragment.trim())) {
+ Integer count = words.get(fragment);
+ if (count == null) {
+ words.put(fragment, 1);
+ }
+ else {
+ count++;
+ words.put(fragment, count);
+ maxRepetitions = Math.max(count, maxRepetitions);
+
+ if (count == 2) {
+ // do not calculate repeated words several times
+ numberOfRepeatedWords++;
+ }
+ }
+ }
+ }
+ }
+
+ UsabilityDefectSeverity severity = null;
+ if ((numberOfRepeatedWords > 10) || (maxRepetitions > 10)) {
+ severity = UsabilityDefectSeverity.HIGH;
+ }
+ else if ((numberOfRepeatedWords > 4) || (maxRepetitions > 4)) {
+ severity = UsabilityDefectSeverity.MEDIUM;
+ }
+ else if ((numberOfRepeatedWords > 2) || (maxRepetitions > 2)) {
+ severity = UsabilityDefectSeverity.LOW;
+ }
+ else if ((numberOfRepeatedWords > 1) || (maxRepetitions > 1)) {
+ severity = UsabilityDefectSeverity.INFO;
+ }
+
+ if (severity != null) {
+ Map parameters = new HashMap();
+ parameters.put("textRepetitionRatio", numberOfRepeatedWords +
+ " repeated tokens, up to " + maxRepetitions + " repetitions per token");
+
+ results.addDefect
+ (new UsabilityDefect(severity,
+ UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS,
+ parameters));
+ }
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param statistics
+ * @param results
+ */
+ private void checkTextFieldNoLetterOrDigitInputs(TextInputStatistics statistics,
+ UsabilityEvaluationResult results)
+ {
+ int allCharactersCount = 0;
+ int noLetterOrDigitCount = 0;
+
+ for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) {
+ String[] fragments = statistics.getTextFieldInputFragments(i);
+ for (String fragment : fragments) {
+ String effectiveFragment = fragment.trim();
+ for (int j = 0; j < effectiveFragment.length(); j++) {
+ if (!Character.isWhitespace(effectiveFragment.charAt(j))) {
+ if (!Character.isLetterOrDigit(effectiveFragment.charAt(j))) {
+ noLetterOrDigitCount++;
+ }
+ allCharactersCount++;
+ }
+ }
+ }
+ }
+
+ float ratio = (float) noLetterOrDigitCount / (float) allCharactersCount;
+
+ UsabilityDefectSeverity severity = null;
+ if (ratio > 0.1) // every 10th sign
+ {
+ severity = UsabilityDefectSeverity.HIGH;
+ }
+ else if (ratio > 0.05) // every 20th sign
+ {
+ severity = UsabilityDefectSeverity.MEDIUM;
+ }
+ else if (ratio > 0.02) // every 50th sign
+ {
+ severity = UsabilityDefectSeverity.LOW;
+ }
+ else if (ratio > 0.01) // every 100th sign
+ {
+ severity = UsabilityDefectSeverity.INFO;
+ }
+
+ if (severity != null) {
+ Map parameters = new HashMap();
+ parameters.put("noLetterOrDigitRatio", allCharactersCount + " entered characters of " +
+ "which " + noLetterOrDigitCount + " were no letter or digit");
+
+ results.addDefect
+ (new UsabilityDefect(severity,
+ UsabilityDefectDescription.TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO,
+ parameters));
+ }
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param taskTree
+ * @param statistics
+ */
+ private void calculateStatistics(ITaskTreeNode node, TextInputStatistics statistics) {
+ if ((node instanceof IEventTask) &&
+ (((IEventTask) node).getEventType() instanceof TextInput))
+ {
+ calculateStatistics((IEventTask) node, statistics);
+ }
+ else {
+ if ((node.getChildren() == null) || (node.getChildren().size() == 0)) {
+ statistics.incrementNoOfOtherEventTasks();
+ }
+ else {
+ for (ITaskTreeNode child : node.getChildren()) {
+ calculateStatistics(child, statistics);
+ }
+ }
+ }
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param taskTree
+ * @param statistics
+ */
+ private void calculateStatistics(IEventTask node, TextInputStatistics statistics) {
+ String[] fragments =
+ determineTextFragments(((TextInput) node.getEventType()).getEnteredText());
+
+ if (node.getEventTarget() instanceof ITextField) {
+ statistics.addTextFieldInput(node, fragments);
+ }
+ else if (node.getEventTarget() instanceof ITextArea) {
+ statistics.addTextAreaInput(node, fragments);
+ }
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param enteredText
+ * @return
+ */
+ private String[] determineTextFragments(String enteredText) {
+ List fragments = new ArrayList();
+
+ StringBuffer fragment = new StringBuffer();
+ char lastChar = 0;
+
+ for (int i = 0; i < enteredText.length(); i++) {
+ char currentChar = enteredText.charAt(i);
+
+ if (!isEqualCharacterType(lastChar, currentChar)) {
+ // the previous fragment ended. so finalize it and start a new one
+ if ((fragment != null) && (fragment.length() > 0)) {
+ fragments.add(fragment.toString());
+ fragment = new StringBuffer();
+ }
+ }
+
+ fragment.append(currentChar);
+ lastChar = currentChar;
+ }
+
+ if ((fragment != null) && (fragment.length() > 0)) {
+ fragments.add(fragment.toString());
+ }
+
+ return fragments.toArray(new String[fragments.size()]);
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param lastChar
+ * @param currentChar
+ * @return
+ */
+ private boolean isEqualCharacterType(char char1, char char2) {
+ return
+ ((char1 == char2) ||
+ (Character.isWhitespace(char1) && Character.isWhitespace(char2)) ||
+ (Character.isDigit(char1) && Character.isDigit(char2)) ||
+ (Character.isLetter(char1) && Character.isLetter(char2)) ||
+ (Character.isJavaIdentifierPart(char1) && Character.isJavaIdentifierPart(char2)));
+ }
+
+ /**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 16.07.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+ public static class TextInputStatistics {
+
+ /** */
+ private List textFieldInputs = new ArrayList();
+
+ /** */
+ private List textAreaInputs = new ArrayList();
+
+ /** */
+ private int otherEventsCount;
+
+ /**
+ * TODO: comment
+ *
+ * @param node
+ * @param fragments
+ *
+ */
+ public void addTextFieldInput(IEventTask node, String[] fragments) {
+ textFieldInputs.add(new Object[] { node, fragments });
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param node
+ * @param fragments
+ *
+ */
+ public void addTextAreaInput(IEventTask node, String[] fragments) {
+ textAreaInputs.add(new Object[] { node, fragments });
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public int getNoOfAllEvents() {
+ return textFieldInputs.size() + textAreaInputs.size() + otherEventsCount;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public int getNoOfTextFieldInputs() {
+ return textFieldInputs.size();
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param i
+ * @return
+ */
+ public String[] getTextFieldInputFragments(int index) {
+ return (String[]) textFieldInputs.get(index)[1];
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public int getNoOfTextAreaInputs() {
+ return textAreaInputs.size();
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param i
+ * @return
+ */
+ public String[] getTextAreaInputFragments(int index) {
+ return (String[]) textAreaInputs.get(index)[1];
+ }
+
+ /**
+ * TODO: comment
+ *
+ */
+ public void incrementNoOfOtherEventTasks() {
+ otherEventsCount++;
+ }
+
+ }
+
+}
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityDefect.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityDefect.java (revision 922)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityDefect.java (revision 922)
@@ -0,0 +1,117 @@
+package de.ugoe.cs.autoquest.usability;
+
+import java.util.Map;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 16.07.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+public class UsabilityDefect {
+
+ /** */
+ private UsabilityDefectSeverity severity;
+
+ /** */
+ private UsabilityDefectDescription description;
+
+ /** */
+ private Map descriptionParameters;
+
+ /**
+ * TODO: comment
+ *
+ * @param medium
+ * @param highTextInputRatio
+ */
+ public UsabilityDefect(UsabilityDefectSeverity severity, UsabilityDefectDescription description)
+ {
+ this(severity, description, null);
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param medium
+ * @param highTextInputRatio
+ */
+ public UsabilityDefect(UsabilityDefectSeverity severity,
+ UsabilityDefectDescription description,
+ Map parameters)
+ {
+ this.severity = severity;
+ this.description = description;
+ this.descriptionParameters = parameters;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public UsabilityDefectSeverity getSeverity() {
+ return severity;
+ }
+
+ /**
+ * @param severity
+ * the severity to set
+ */
+ public void setSeverity(UsabilityDefectSeverity severity) {
+ this.severity = severity;
+ }
+
+ /**
+ * @param description
+ * the description to set
+ */
+ public void setDescription(UsabilityDefectDescription description) {
+ this.description = description;
+ }
+
+ /**
+ *
+ */
+ public String getParameterizedDescription() {
+ return description.toString(descriptionParameters);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof UsabilityDefect) {
+ return
+ (severity == ((UsabilityDefect) obj).severity) &&
+ (description == ((UsabilityDefect) obj).description);
+ }
+ else {
+ return false;
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return severity.hashCode() + description.hashCode();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return "UsabilityDefect(" + severity.name() + ", " + description.name() + ")";
+ }
+
+}
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityDefectDescription.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityDefectDescription.java (revision 922)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityDefectDescription.java (revision 922)
@@ -0,0 +1,191 @@
+package de.ugoe.cs.autoquest.usability;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBElement;
+import javax.xml.bind.Unmarshaller;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 18.07.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+public enum UsabilityDefectDescription {
+
+ TEXT_FIELD_INPUT_RATIO,
+ TEXT_FIELD_INPUT_REPETITIONS,
+ TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO;
+
+ /** */
+ private static final String DEFAULT_MESSAGES_FILE = "defectDescriptions_en.xml";
+
+ /** */
+ private static DefectDescriptions sDefectDescriptions;
+
+ /** */
+ private DefectDescription defectDescription;
+
+ /**
+ * TODO: comment
+ *
+ * @param name
+ * @param ordinal
+ */
+ private UsabilityDefectDescription() {
+ init();
+ }
+
+ /**
+ * TODO: comment
+ *
+ */
+ @SuppressWarnings("unchecked")
+ private void init() {
+ synchronized (this.getClass()) {
+ if (sDefectDescriptions == null) {
+ InputStream inputStream =
+ ClassLoader.getSystemResourceAsStream(DEFAULT_MESSAGES_FILE);
+
+ try {
+ String packageName = DefectDescriptions.class.getPackage().getName();
+ JAXBContext jaxbContext = JAXBContext.newInstance(packageName);
+ Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
+
+ sDefectDescriptions =
+ ((JAXBElement) unmarshaller.unmarshal(inputStream))
+ .getValue();
+ }
+ catch (Exception e) {
+ throw new RuntimeException
+ ("error while initializing usability defect descriptions", e);
+ }
+ finally {
+ if (inputStream != null) {
+ try {
+ inputStream.close();
+ }
+ catch (IOException e) {
+ // ignore
+ }
+ }
+ }
+ }
+ }
+
+ for (DefectDescription description : sDefectDescriptions.getDefectDescription()) {
+ if (this.name().equals(description.getDefectId())) {
+ defectDescription = description;
+ break;
+ }
+ }
+
+ if (defectDescription == null) {
+ throw new RuntimeException
+ ("error while initializing usability defect descriptions. No " +
+ "description text available for description " + this.name());
+ }
+ }
+
+ /**
+ *
+ */
+ public String[] getDescriptionParameters() {
+ List parameters = new ArrayList();
+
+ for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) {
+ if (fragment instanceof ParameterFragment) {
+ parameters.add(((ParameterFragment) fragment).getParameterName());
+ }
+ }
+
+ return parameters.toArray(new String[parameters.size()]);
+ }
+
+ /**
+ *
+ */
+ public String toString(Map parameters) throws IllegalArgumentException {
+ StringBuffer result = new StringBuffer();
+
+ for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) {
+ if (result.length() > 0) {
+ result.append(" ");
+ }
+
+ if (fragment instanceof ParameterFragment) {
+ String value = null;
+ if (parameters != null) {
+ value = parameters.get(((ParameterFragment) fragment).getParameterName());
+ }
+
+ if (value != null) {
+ result.append(value);
+ }
+ else {
+ throw new IllegalArgumentException
+ ("required parameter \"" +
+ ((ParameterFragment) fragment).getParameterName() +
+ "\" for usability defect description " + this.name() + " not provided");
+ }
+ }
+ else {
+ result.append(getFragmentString(fragment));
+ }
+ }
+
+ return result.toString();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Enum#toString()
+ */
+ @Override
+ public String toString() {
+ StringBuffer result = new StringBuffer();
+
+ int paramCount = 1;
+ for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) {
+ if (result.length() > 0) {
+ result.append(" ");
+ }
+
+ if (fragment instanceof ParameterFragment) {
+ result.append("");
+ }
+ else {
+ result.append(getFragmentString(fragment));
+ }
+ }
+
+ return result.toString();
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param fragment
+ * @return
+ */
+ private String getFragmentString(Object fragment) {
+ String fragmentStr = fragment.toString().trim();
+
+ fragmentStr = fragmentStr.replaceAll("\n", " ");
+
+ while (fragmentStr.indexOf(" ") > -1) {
+ fragmentStr = fragmentStr.replaceAll(" ", " ");
+ }
+
+ return fragmentStr;
+ }
+
+}
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityDefectSeverity.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityDefectSeverity.java (revision 922)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityDefectSeverity.java (revision 922)
@@ -0,0 +1,13 @@
+package de.ugoe.cs.autoquest.usability;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 16.07.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+public enum UsabilityDefectSeverity {
+
+ INFO, LOW, MEDIUM, HIGH;
+
+}
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationManager.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationManager.java (revision 922)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationManager.java (revision 922)
@@ -0,0 +1,81 @@
+package de.ugoe.cs.autoquest.usability;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.util.console.Console;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 16.07.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+public class UsabilityEvaluationManager {
+
+ /** */
+ private List rules = new ArrayList();
+
+ /**
+ * TODO: comment
+ *
+ */
+ public UsabilityEvaluationManager() {
+ super();
+ init();
+ }
+
+ /**
+ * TODO: comment
+ *
+ */
+ private void init() {
+ rules.add(new TextInputStatisticsRule());
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param taskTree
+ */
+ public UsabilityEvaluationResult evaluateUsability(ITaskTree taskTree) {
+ Console.traceln(Level.INFO, "evaluating usability of task tree " + taskTree);
+
+ List results = new ArrayList();
+
+ for (UsabilityEvaluationRule rule : rules) {
+ Console.traceln(Level.INFO, "applying rule " + rule.getClass().getSimpleName());
+ UsabilityEvaluationResult result = rule.evaluate(taskTree);
+ results.add(result);
+ Console.traceln(Level.INFO, "the rule found " + result.getAllDefects().size() +
+ " usability defects, of which " + result.getSevereDefects().size() +
+ " are severe.");
+ }
+
+ UsabilityEvaluationResult result = mergeResults(results);
+ Console.println("the evaluation result contains " + result.getAllDefects().size() +
+ " defects, of which " + result.getSevereDefects().size() + " are severe.");
+ return result;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @param results
+ * @return
+ */
+ private UsabilityEvaluationResult mergeResults(List results) {
+ UsabilityEvaluationResult result = new UsabilityEvaluationResult();
+
+ for (UsabilityEvaluationResult ruleResult : results) {
+ for (UsabilityDefect defect : ruleResult.getAllDefects()) {
+ result.addDefect(defect);
+ }
+ }
+
+ return result;
+ }
+
+}
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationResult.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationResult.java (revision 922)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationResult.java (revision 922)
@@ -0,0 +1,52 @@
+package de.ugoe.cs.autoquest.usability;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 16.07.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+public class UsabilityEvaluationResult {
+
+ /** */
+ private List defects = new ArrayList();
+
+ /**
+ * TODO: comment
+ *
+ * @param defect
+ */
+ public void addDefect(UsabilityDefect defect) {
+ defects.add(defect);
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public List getAllDefects() {
+ return defects;
+ }
+
+ /**
+ * TODO: comment
+ *
+ * @return
+ */
+ public List getSevereDefects() {
+ List severeDefects = new ArrayList();
+
+ for (UsabilityDefect defect : defects) {
+ if (defect.getSeverity() == UsabilityDefectSeverity.HIGH) {
+ severeDefects.add(defect);
+ }
+ }
+
+ return severeDefects;
+ }
+
+}
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationRule.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationRule.java (revision 922)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationRule.java (revision 922)
@@ -0,0 +1,21 @@
+package de.ugoe.cs.autoquest.usability;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+
+/**
+ * TODO comment
+ *
+ * @version $Revision: $ $Date: 16.07.2012$
+ * @author 2012, last modified by $Author: pharms$
+ */
+public interface UsabilityEvaluationRule {
+
+ /**
+ * TODO: comment
+ *
+ * @param taskTree
+ * @return
+ */
+ UsabilityEvaluationResult evaluate(ITaskTree taskTree);
+
+}
Index: trunk/autoquest-core-usageprofiles-test/src/test/java/de/ugoe/cs/autoquest/usageprofiles/DeterministicFiniteAutomatonTest.java
===================================================================
--- trunk/autoquest-core-usageprofiles-test/src/test/java/de/ugoe/cs/autoquest/usageprofiles/DeterministicFiniteAutomatonTest.java (revision 922)
+++ trunk/autoquest-core-usageprofiles-test/src/test/java/de/ugoe/cs/autoquest/usageprofiles/DeterministicFiniteAutomatonTest.java (revision 922)
@@ -0,0 +1,158 @@
+package de.ugoe.cs.autoquest.usageprofiles;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.StringEventType;
+import de.ugoe.cs.autoquest.usageprofiles.DeterministicFiniteAutomaton;
+
+import java.util.Random;
+import org.junit.*;
+
+import static org.junit.Assert.*;
+
+/**
+ * The class DeterministicFiniteAutomatonTest contains tests for
+ * the class {@link DeterministicFiniteAutomaton}.
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class DeterministicFiniteAutomatonTest {
+
+ Collection> sequences;
+
+ @Test
+ public void testDeterministicFiniteAutomaton_1() throws Exception {
+ Random r = new Random();
+
+ DeterministicFiniteAutomaton result = new DeterministicFiniteAutomaton(
+ r);
+
+ assertNotNull(result);
+ assertEquals(2, result.trieOrder);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testDeterministicFiniteAutomaton_2() throws Exception {
+ new DeterministicFiniteAutomaton(null);
+ }
+
+ @Test
+ public void testGetProbability_1() throws Exception {
+ DeterministicFiniteAutomaton fixture = new DeterministicFiniteAutomaton(
+ new Random());
+ fixture.train(sequences);
+
+ List context = new ArrayList();
+ context.add(new Event(new StringEventType("a")));
+ context.add(new Event(new StringEventType("b")));
+
+ Event symbol = new Event(new StringEventType("r"));
+
+ double result = fixture.getProbability(context, symbol);
+
+ assertEquals(1.0d, result, 0.0001);
+ }
+
+ @Test
+ public void testGetProbability_2() throws Exception {
+ DeterministicFiniteAutomaton fixture = new DeterministicFiniteAutomaton(
+ new Random());
+ fixture.train(sequences);
+
+ List context = new ArrayList();
+ context.add(new Event(new StringEventType("a")));
+
+ Event symbol = new Event(new StringEventType("b"));
+
+ double result = fixture.getProbability(context, symbol);
+
+ assertEquals(1.0d / 4.0, result, 0.0001);
+ }
+
+ @Test
+ public void testGetProbability_3() throws Exception {
+ DeterministicFiniteAutomaton fixture = new DeterministicFiniteAutomaton(
+ new Random());
+ fixture.train(sequences);
+
+ List context = new ArrayList();
+ context.add(new Event(new StringEventType("a")));
+
+ Event symbol = new Event(new StringEventType("c"));
+
+ double result = fixture.getProbability(context, symbol);
+
+ assertEquals(1.0d / 4.0, result, 0.0001);
+ }
+
+ @Test
+ public void testGetProbability_4() throws Exception {
+ DeterministicFiniteAutomaton fixture = new DeterministicFiniteAutomaton(
+ new Random());
+ fixture.train(sequences);
+
+ List context = new ArrayList();
+ context.add(new Event(new StringEventType("a")));
+
+ Event symbol = new Event(new StringEventType("e"));
+
+ double result = fixture.getProbability(context, symbol);
+
+ assertEquals(0.0d, result, 0.0001);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testGetProbability_5() throws Exception {
+ DeterministicFiniteAutomaton fixture = new DeterministicFiniteAutomaton(
+ new Random());
+ fixture.train(sequences);
+
+ List context = new ArrayList();
+ context.add(new Event(new StringEventType("a")));
+
+ Event symbol = null;
+
+ fixture.getProbability(context, symbol);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testGetProbability_6() throws Exception {
+ DeterministicFiniteAutomaton fixture = new DeterministicFiniteAutomaton(
+ new Random());
+ fixture.train(sequences);
+
+ List context = null;
+
+ Event symbol = new Event(new StringEventType("a"));
+
+ fixture.getProbability(context, symbol);
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ List sequence = new ArrayList();
+ sequence.add(new Event(new StringEventType("a")));
+ sequence.add(new Event(new StringEventType("b")));
+ sequence.add(new Event(new StringEventType("r")));
+ sequence.add(new Event(new StringEventType("a")));
+ sequence.add(new Event(new StringEventType("c")));
+ sequence.add(new Event(new StringEventType("a")));
+ sequence.add(new Event(new StringEventType("d")));
+ sequence.add(new Event(new StringEventType("a")));
+ sequence.add(new Event(new StringEventType("b")));
+ sequence.add(new Event(new StringEventType("r")));
+ sequence.add(new Event(new StringEventType("a")));
+
+ sequences = new ArrayList>();
+ sequences.add(sequence);
+ }
+
+ public static void main(String[] args) {
+ new org.junit.runner.JUnitCore()
+ .run(DeterministicFiniteAutomatonTest.class);
+ }
+}
Index: trunk/autoquest-core-usageprofiles-test/src/test/java/de/ugoe/cs/autoquest/usageprofiles/FirstOrderMarkovModelTest.java
===================================================================
--- trunk/autoquest-core-usageprofiles-test/src/test/java/de/ugoe/cs/autoquest/usageprofiles/FirstOrderMarkovModelTest.java (revision 922)
+++ trunk/autoquest-core-usageprofiles-test/src/test/java/de/ugoe/cs/autoquest/usageprofiles/FirstOrderMarkovModelTest.java (revision 922)
@@ -0,0 +1,95 @@
+package de.ugoe.cs.autoquest.usageprofiles;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Random;
+import org.junit.*;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.StringEventType;
+import de.ugoe.cs.autoquest.usageprofiles.FirstOrderMarkovModel;
+import de.ugoe.cs.autoquest.usageprofiles.FirstOrderMarkovModel.MarkovEdge;
+import static org.junit.Assert.*;
+
+/**
+ * The class FirstOrderMarkovModelTest contains tests for the class
+ * {@link FirstOrderMarkovModel}.
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class FirstOrderMarkovModelTest {
+
+ Collection> sequences;
+
+ @Test
+ public void testFirstOrderMarkovModel_1() throws Exception {
+ Random r = new Random();
+
+ FirstOrderMarkovModel result = new FirstOrderMarkovModel(r);
+
+ assertNotNull(result);
+ assertEquals(r, result.r);
+ assertEquals(2, result.trieOrder);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testFirstOrderMarkovModel_2() throws Exception {
+ new FirstOrderMarkovModel(null);
+ }
+
+ @Test
+ public void testCalcEntropy() throws Exception {
+ Random r = new Random();
+ FirstOrderMarkovModel fixture = new FirstOrderMarkovModel(r);
+ fixture.train(sequences);
+
+ double result = fixture.calcEntropy();
+
+ assertEquals(0.7392d, result, 0.0001);
+ }
+
+ @Test
+ public void testMarkovEdgeMarkovEdge_1() throws Exception {
+ double weight = 0.2d;
+
+ MarkovEdge result = new MarkovEdge(weight);
+
+ assertNotNull(result);
+ assertEquals(weight, result.weight, 0.0001);
+ }
+
+ @Test
+ public void testMarkovEdgeToString_1() throws Exception {
+ double weight = 0.2d;
+ MarkovEdge fixture = new MarkovEdge(weight);
+
+ String result = fixture.toString();
+
+ assertEquals(Double.toString(0.2d), result);
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ List sequence = new ArrayList();
+ sequence.add(new Event(new StringEventType("a")));
+ sequence.add(new Event(new StringEventType("b")));
+ sequence.add(new Event(new StringEventType("r")));
+ sequence.add(new Event(new StringEventType("a")));
+ sequence.add(new Event(new StringEventType("c")));
+ sequence.add(new Event(new StringEventType("a")));
+ sequence.add(new Event(new StringEventType("d")));
+ sequence.add(new Event(new StringEventType("a")));
+ sequence.add(new Event(new StringEventType("b")));
+ sequence.add(new Event(new StringEventType("r")));
+ sequence.add(new Event(new StringEventType("a")));
+
+ sequences = new ArrayList>();
+ sequences.add(sequence);
+ }
+
+ public static void main(String[] args) {
+ new org.junit.runner.JUnitCore().run(FirstOrderMarkovModelTest.class);
+ }
+}
Index: trunk/autoquest-core-usageprofiles-test/src/test/java/de/ugoe/cs/autoquest/usageprofiles/HighOrderMarkovModelTest.java
===================================================================
--- trunk/autoquest-core-usageprofiles-test/src/test/java/de/ugoe/cs/autoquest/usageprofiles/HighOrderMarkovModelTest.java (revision 922)
+++ trunk/autoquest-core-usageprofiles-test/src/test/java/de/ugoe/cs/autoquest/usageprofiles/HighOrderMarkovModelTest.java (revision 922)
@@ -0,0 +1,242 @@
+package de.ugoe.cs.autoquest.usageprofiles;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.StringEventType;
+import de.ugoe.cs.autoquest.usageprofiles.HighOrderMarkovModel;
+
+import java.util.Random;
+import org.junit.*;
+
+import static org.junit.Assert.*;
+
+/**
+ * The class HighOrderMarkovModelTest contains tests for the class
+ * {@link HighOrderMarkovModel}.
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class HighOrderMarkovModelTest {
+
+ Collection> sequences;
+
+ @Test
+ public void testHighOrderMarkovModel_1() throws Exception {
+ int maxOrder = 1;
+ Random r = new Random();
+
+ HighOrderMarkovModel result = new HighOrderMarkovModel(maxOrder, r);
+
+ assertNotNull(result);
+ assertEquals(r, result.r);
+ assertEquals(maxOrder + 1, result.trieOrder);
+ }
+
+ @Test
+ public void testHighOrderMarkovModel_2() throws Exception {
+ int maxOrder = 0;
+ Random r = new Random();
+
+ HighOrderMarkovModel result = new HighOrderMarkovModel(maxOrder, r);
+
+ assertNotNull(result);
+ assertEquals(r, result.r);
+ assertEquals(maxOrder + 1, result.trieOrder);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testHighOrderMarkovModel_3() throws Exception {
+ int maxOrder = 1;
+ Random r = null;
+
+ new HighOrderMarkovModel(maxOrder, r);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testHighOrderMarkovModel_4() throws Exception {
+ int maxOrder = -1;
+ Random r = new Random();
+
+ new HighOrderMarkovModel(maxOrder, r);
+ }
+
+ @Test
+ public void testGetProbability_1() throws Exception {
+ int markovOrder = 1;
+ HighOrderMarkovModel fixture = new HighOrderMarkovModel(markovOrder,
+ new Random());
+ fixture.train(sequences);
+
+ List context = new ArrayList();
+ context.add(new Event(new StringEventType("a")));
+
+ Event symbol = new Event(new StringEventType("b"));
+
+ double result = fixture.getProbability(context, symbol);
+
+ assertEquals(2.0d / 5.0, result, 0.0001);
+ }
+
+ @Test
+ public void testGetProbability_2() throws Exception {
+ int markovOrder = 1;
+ HighOrderMarkovModel fixture = new HighOrderMarkovModel(markovOrder,
+ new Random());
+ fixture.train(sequences);
+
+ List context = new ArrayList();
+ context.add(new Event(new StringEventType("a")));
+
+ Event symbol = new Event(new StringEventType("r"));
+
+ double result = fixture.getProbability(context, symbol);
+
+ assertEquals(0.0d / 5.0, result, 0.0001);
+ }
+
+ @Test
+ public void testGetProbability_3() throws Exception {
+ int markovOrder = 1;
+ HighOrderMarkovModel fixture = new HighOrderMarkovModel(markovOrder,
+ new Random());
+ fixture.train(sequences);
+
+ List context = new ArrayList