Index: /trunk/quest-core-tasktrees/pom.xml =================================================================== --- /trunk/quest-core-tasktrees/pom.xml (revision 439) +++ /trunk/quest-core-tasktrees/pom.xml (revision 439) @@ -0,0 +1,35 @@ + + 4.0.0 + de.ugoe.cs.quest + quest-core-tasktrees + 0.0.1-SNAPSHOT + quest-core-tasktrees + + https://quest.informatik.uni-goettingen.de/svn/quest/trunk/quest-core-tasktrees + + + + de.ugoe.cs.tasktree + userinteraction + 0.0.1-SNAPSHOT + + + junit + junit + 4.8.1 + test + + + + + + maven-compiler-plugin + 2.3.2 + + 1.6 + 1.6 + + + + + Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/manager/ComponentManager.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/manager/ComponentManager.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/manager/ComponentManager.java (revision 439) @@ -0,0 +1,138 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: ComponentManager.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 12.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.manager; + +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; +import de.ugoe.cs.quest.tasktrees.temporalrelation.TemporalRelationshipRuleManager; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilderImpl; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactoryImpl; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 12.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +// ------------------------------------------------------------------------------------------------- +public class ComponentManager +{ + /** */ + private static ComponentManager sInstance; + + /** */ + private TemporalRelationshipRuleManager mTemporalRelationshipRuleManager; + + /** */ + private NodeEqualityRuleManager mNodeEqualityRuleManager; + + /** */ + private TaskTreeBuilder mTaskTreeBuilder; + + /** */ + private TaskTreeNodeFactory mTaskTreeNodeFactory; + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public static TemporalRelationshipRuleManager getTemporalRelationshipRuleManager() + { + return getInstance().mTemporalRelationshipRuleManager; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public static NodeEqualityRuleManager getNodeEqualityRuleManager() + { + return getInstance().mNodeEqualityRuleManager; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public static TaskTreeBuilder getDefaultTaskTreeBuilder() + { + return getInstance().mTaskTreeBuilder; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public static TaskTreeNodeFactory getDefaultTaskTreeNodeFactory() + { + return getInstance().mTaskTreeNodeFactory; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public static synchronized void clearInstance() + { + sInstance = null; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + private static synchronized ComponentManager getInstance() + { + if (sInstance == null) + { + sInstance = new ComponentManager(); + sInstance.init(); + } + return sInstance; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + private void init() + { + mNodeEqualityRuleManager = new NodeEqualityRuleManager(); + mNodeEqualityRuleManager.init(); + + mTemporalRelationshipRuleManager = + new TemporalRelationshipRuleManager(mNodeEqualityRuleManager); + mTemporalRelationshipRuleManager.init(); + + mTaskTreeBuilder = new TaskTreeBuilderImpl(); + mTaskTreeNodeFactory = new TaskTreeNodeFactoryImpl(); + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/manager/TaskTreeManager.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/manager/TaskTreeManager.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/manager/TaskTreeManager.java (revision 439) @@ -0,0 +1,269 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TaskTreeManager.java,v $ +// Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 06.11.2011 10:14:21 $ +// Project : TaskTreePerformanceTest +// Creation : 2011 by Patrick +// Copyright : Patrick Harms, 2011 +//------------------------------------------------------------------------------------------------- + +package de.ugoe.cs.quest.tasktrees.manager; + +import java.util.Observable; +import java.util.Observer; +import java.util.logging.Logger; + +import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.userinteraction.InteractionEvent; +import de.ugoe.cs.tasktree.userinteraction.KeyInteraction; +import de.ugoe.cs.tasktree.userinteraction.KeyboardFocusChange; +import de.ugoe.cs.tasktree.userinteraction.UserInteractionProvider; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +//------------------------------------------------------------------------------------------------- +public class TaskTreeManager implements Observer +{ + /** */ + private static final int MAX_INTERACTIONS_TILL_RULE_APPLICATION = 100; + + /** */ + private static Logger LOG = Logger.getLogger(TaskTreeManager.class.getName()); + + /** */ + private TaskTreeBuilder mTaskTreeBuilder = ComponentManager.getDefaultTaskTreeBuilder(); + + /** */ + private TaskTreeNodeFactory mTaskTreeNodeFactory = + ComponentManager.getDefaultTaskTreeNodeFactory(); + + /** */ + private int mInteractionsTillRuleApplication = MAX_INTERACTIONS_TILL_RULE_APPLICATION; + + /** */ + private Sequence mRootSequence; + + /** */ + private GUIElement mCurrentKeyboardFocusGUIElement; + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + public TaskTreeManager() + { + mRootSequence = mTaskTreeNodeFactory.createNewSequence(); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see java.util.Observer#update(java.util.Observable, java.lang.Object) + */ + //----------------------------------------------------------------------------------------------- + public void update(Observable observable, Object event) + { + if ((observable instanceof UserInteractionProvider) && + (event instanceof InteractionEvent)) + { + handleNewInteractionEvent((InteractionEvent) event); + } + else + { + LOG.warning("could not handle notification of " + observable + " regarding " + event); + } + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + public void handleNewInteractionEvent(InteractionEvent event) + { + if (event.getInteraction() instanceof KeyInteraction) + { + if (mCurrentKeyboardFocusGUIElement == null) + { + mCurrentKeyboardFocusGUIElement = event.getGUIElement(); + } + + addInteractionTask(mTaskTreeNodeFactory.createNewInteractionTask + (mCurrentKeyboardFocusGUIElement, event.getInteraction())); + } + else + { + addInteractionTask(mTaskTreeNodeFactory.createNewInteractionTask + (event.getGUIElement(), event.getInteraction())); + } + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + public synchronized TaskTree getTaskTree() + { + LOG.info("applying rules temporal relationship generation rules"); + + Sequence rootSequence = mRootSequence.clone(); + ComponentManager.getTemporalRelationshipRuleManager().applyRules + (rootSequence, mTaskTreeBuilder, mTaskTreeNodeFactory, true); + + return mTaskTreeNodeFactory.createTaskTree(rootSequence); + } + + //----------------------------------------------------------------------------------------------- + /** + * @param task + */ + //----------------------------------------------------------------------------------------------- + private synchronized void addInteractionTask(InteractionTask task) + { + handleInteractionTask(task); + } + + //----------------------------------------------------------------------------------------------- + /** + * 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 void handleInteractionTask(InteractionTask interactionTask) + { + if (interactionTask.getInteraction() instanceof KeyboardFocusChange) + { + mCurrentKeyboardFocusGUIElement = interactionTask.getGUIElement(); + } + else + { + LOG.info("handling interaction task \"" + interactionTask + "\""); + addTaskToSequence(interactionTask, mCurrentKeyboardFocusGUIElement); + } + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param interactionTask + */ + //----------------------------------------------------------------------------------------------- + /*private boolean handleAndCorrectFocusChanges(InteractionTask interactionTask) + { + GUIElement newGUIElement = interactionTask.getGUIElement(); + + // find the identical parent element + GUIElement identicalParentGUIElement = null; + + while ((identicalParentGUIElement == null) && (newGUIElement != null)) + { + GUIElement currentGUIElement = mCurrentGUIElement; + + while ((identicalParentGUIElement == null) && (currentGUIElement != null)) + { + if (newGUIElement.equals(currentGUIElement)) + { + identicalParentGUIElement = newGUIElement; + } + else + { + currentGUIElement = currentGUIElement.getParent(); + } + } + + newGUIElement = newGUIElement.getParent(); + } + + // now create focus lost interactions for each GUI element, that is not common with the + // hierarchy of the new GUI element + GUIElement currentGUIElement = mCurrentGUIElement; + + List tasksToBeAdded = new ArrayList(); + + while ((currentGUIElement != null) && + ((identicalParentGUIElement == null) || + (!currentGUIElement.equals(identicalParentGUIElement)))) + { + tasksToBeAdded.add + (mTaskTreeNodeFactory.createNewInteractionTask(currentGUIElement, new FocusLost())); + currentGUIElement = currentGUIElement.getParent(); + } + + // now create focus received interactions for each GUI element, that is not common with + // with the old one. Ensure, that if the current interaction is a focus reception, that + // it is used instead of a generated one + newGUIElement = interactionTask.getGUIElement(); + + int index = tasksToBeAdded.size(); + while ((newGUIElement != null) && + ((identicalParentGUIElement == null) || + (!newGUIElement.equals(identicalParentGUIElement)))) + { + tasksToBeAdded.add(index, mTaskTreeNodeFactory.createNewInteractionTask + (newGUIElement, new FocusReceived())); + newGUIElement = newGUIElement.getParent(); + } + + // this part ensures, that the original focus reception, if any, is preserved as is. + boolean taskAlreadyHandled = false; + if (interactionTask.getInteraction() instanceof FocusReceived) + { + if (tasksToBeAdded.size() > 0) + { + tasksToBeAdded.set(tasksToBeAdded.size() - 1, interactionTask); + } + //else + //{ + // in this case, we already have focus on the element to which the focus shall be changed. + // therefore, we discard the new focus change on the same element. + //} + + taskAlreadyHandled = true; + } + + // now that all tasks are determined, add them to the sequence + for (InteractionTask task : tasksToBeAdded) + { + addTaskToSequence(task); + } + + mCurrentGUIElement = interactionTask.getGUIElement(); + + return taskAlreadyHandled; + }*/ + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + private void addTaskToSequence(TaskTreeNode task, GUIElement currentKeyboardFocusGUIElement) + { + mTaskTreeBuilder.addChild(mRootSequence, task); + + if (--mInteractionsTillRuleApplication == 0) + { + mInteractionsTillRuleApplication = MAX_INTERACTIONS_TILL_RULE_APPLICATION; + + LOG.info("applying rules temporal relationship generation rules"); + ComponentManager.getTemporalRelationshipRuleManager().applyRules + (mRootSequence, mTaskTreeBuilder, mTaskTreeNodeFactory, false); + } + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/IterationComparisonRule.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/IterationComparisonRule.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/IterationComparisonRule.java (revision 439) @@ -0,0 +1,133 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: NodeIdentityRule.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; +import de.ugoe.cs.quest.tasktrees.treeifc.Selection; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class IterationComparisonRule implements NodeComparisonRule +{ + /** */ + private NodeEqualityRuleManager mRuleManager; + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + IterationComparisonRule(NodeEqualityRuleManager ruleManager) + { + super(); + mRuleManager = ruleManager; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode) + */ + //----------------------------------------------------------------------------------------------- + @Override + public NodeEquality compare(TaskTreeNode node1, TaskTreeNode node2) + { + if ((!(node1 instanceof Iteration)) || (!(node2 instanceof Iteration))) + { + return null; + } + + // 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 new NodesIdentical(); + } + + TaskTreeNode child1 = node1.getChildren().get(0); + TaskTreeNode 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.getStructuralEquality() || nodeEquality.getSemanticalEquality()) + { + return nodeEquality; + } + + // compare one iteration with a single node as a child and another one with a selection of + // semantically equal nodes + if (selectionChildrenSemanticallyEqualNode(child1, child2)) + { + return new NodesSemanticallyEqual(); + } + + // all other combinations (i.e. sequence with single child and sequence with selection) + // can not match + return null; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param taskTreeNode + * @param taskTreeNode2 + * @return + */ + //----------------------------------------------------------------------------------------------- + private boolean selectionChildrenSemanticallyEqualNode(TaskTreeNode taskTreeNode, + TaskTreeNode taskTreeNode2) + { + Selection selection = null; + TaskTreeNode node = null; + if (taskTreeNode instanceof Selection) + { + selection = (Selection) taskTreeNode; + node = taskTreeNode2; + } + else if (taskTreeNode2 instanceof Selection) + { + selection = (Selection) taskTreeNode2; + node = taskTreeNode; + } + else + { + return false; + } + + for (TaskTreeNode child : selection.getChildren()) + { + NodeEquality nodeEquality = mRuleManager.applyRules(node, child); + + if (!nodeEquality.getStructuralEquality() && !nodeEquality.getSemanticalEquality()) + { + return false; + } + } + + return true; + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeComparisonRule.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeComparisonRule.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeComparisonRule.java (revision 439) @@ -0,0 +1,32 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: EqualityRule.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @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 + */ + //----------------------------------------------------------------------------------------------- + public NodeEquality compare(TaskTreeNode node1, TaskTreeNode node2); + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEquality.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEquality.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEquality.java (revision 439) @@ -0,0 +1,39 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: NodeEquality.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.nodeequality; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public interface NodeEquality +{ + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public boolean getStructuralEquality(); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public boolean getSemanticalEquality(); + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityRuleManager.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityRuleManager.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeEqualityRuleManager.java (revision 439) @@ -0,0 +1,77 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: NodeEqualityRuleManager.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import java.util.ArrayList; +import java.util.List; +//import java.util.logging.Logger; + +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class NodeEqualityRuleManager +{ + + /** */ + //private static Logger LOG = Logger.getLogger(NodeEqualityRuleManager.class.getName()); + + /** */ + private List mRuleIndex = new ArrayList(); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + public void init() + { + mRuleIndex.add(new NodeIdentityRule()); + mRuleIndex.add(new IterationComparisonRule(this)); + mRuleIndex.add(new SequenceComparisonRule(this)); + mRuleIndex.add(new SelectionComparisonRule(this)); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param node1 + * @param node2 + * @return + */ + //----------------------------------------------------------------------------------------------- + public NodeEquality applyRules(TaskTreeNode node1, TaskTreeNode node2) + { + //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 new NodesUnequal(); + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeIdentityRule.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeIdentityRule.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodeIdentityRule.java (revision 439) @@ -0,0 +1,45 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: NodeIdentityRule.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @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(TaskTreeNode node1, TaskTreeNode node2) + { + if (node1 == node2) + { + return new NodesIdentical(); + } + else if ((node1 != null) && (node1.equals(node2))) + { + return new NodesEqual(); + } + else + { + return null; + } + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodesEqual.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodesEqual.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodesEqual.java (revision 439) @@ -0,0 +1,43 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: NodesEqual.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.nodeequality; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class NodesEqual implements NodeEquality +{ + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.nodeequality.NodeEquality#getStructuralEquality() + */ + //----------------------------------------------------------------------------------------------- + @Override + public boolean getStructuralEquality() + { + return true; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.nodeequality.NodeEquality#getSemanticalEquality() + */ + //----------------------------------------------------------------------------------------------- + @Override + public boolean getSemanticalEquality() + { + return true; + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodesIdentical.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodesIdentical.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodesIdentical.java (revision 439) @@ -0,0 +1,43 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: NodesIdentical.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.nodeequality; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class NodesIdentical implements NodeEquality +{ + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.nodeequality.NodeEquality#getStructuralEquality() + */ + //----------------------------------------------------------------------------------------------- + @Override + public boolean getStructuralEquality() + { + return true; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.nodeequality.NodeEquality#getSemanticalEquality() + */ + //----------------------------------------------------------------------------------------------- + @Override + public boolean getSemanticalEquality() + { + return true; + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodesSemanticallyEqual.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodesSemanticallyEqual.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodesSemanticallyEqual.java (revision 439) @@ -0,0 +1,43 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: NodesEqual.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.nodeequality; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class NodesSemanticallyEqual implements NodeEquality +{ + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.nodeequality.NodeEquality#getStructuralEquality() + */ + //----------------------------------------------------------------------------------------------- + @Override + public boolean getStructuralEquality() + { + return false; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.nodeequality.NodeEquality#getSemanticalEquality() + */ + //----------------------------------------------------------------------------------------------- + @Override + public boolean getSemanticalEquality() + { + return true; + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodesUnequal.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodesUnequal.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/NodesUnequal.java (revision 439) @@ -0,0 +1,43 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: NodeUnequality.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.nodeequality; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class NodesUnequal implements NodeEquality +{ + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.nodeequality.NodeEquality#getStructuralEquality() + */ + //----------------------------------------------------------------------------------------------- + @Override + public boolean getStructuralEquality() + { + return false; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.nodeequality.NodeEquality#getSemanticalEquality() + */ + //----------------------------------------------------------------------------------------------- + @Override + public boolean getSemanticalEquality() + { + return false; + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/SelectionComparisonRule.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/SelectionComparisonRule.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/SelectionComparisonRule.java (revision 439) @@ -0,0 +1,96 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: NodeIdentityRule.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class SelectionComparisonRule implements NodeComparisonRule +{ + + /** */ + private NodeEqualityRuleManager mRuleManager; + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + SelectionComparisonRule(NodeEqualityRuleManager ruleManager) + { + super(); + mRuleManager = ruleManager; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode) + */ + //----------------------------------------------------------------------------------------------- + @Override + public NodeEquality compare(TaskTreeNode node1, TaskTreeNode node2) + { + if ((!(node1 instanceof Sequence)) || (!(node2 instanceof Sequence))) + { + return null; + } + + // 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 new NodesEqual(); + } + + // Selections are semantically equal, if they have children, which are all semantically equal. + // they are structurally equals, if they have the same number and order of structurally equal + // children + boolean structurallyEqual = + node1.getChildren().size() == node2.getChildren().size(); + + for (int i = 0; i < node1.getChildren().size(); i++) + { + TaskTreeNode child1 = node1.getChildren().get(i); + + for (int j = 0; j < node2.getChildren().size(); j++) + { + TaskTreeNode child2 = node2.getChildren().get(j); + + NodeEquality nodeEquality = mRuleManager.applyRules(child1, child2); + + if (!nodeEquality.getSemanticalEquality()) + { + return null; + } + else if (structurallyEqual && (i == j)) + { + // if we compare two children at the same position and if they are structurally equal + // then it can be further expected, that the selections are structurally equal + structurallyEqual &= nodeEquality.getStructuralEquality(); + } + } + } + + if (structurallyEqual) + { + return new NodesEqual(); + } + else + { + return new NodesSemanticallyEqual(); + } + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/SequenceComparisonRule.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/SequenceComparisonRule.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/nodeequality/SequenceComparisonRule.java (revision 439) @@ -0,0 +1,94 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: NodeIdentityRule.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.nodeequality; + +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class SequenceComparisonRule implements NodeComparisonRule +{ + + + /** */ + private NodeEqualityRuleManager mRuleManager; + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + SequenceComparisonRule(NodeEqualityRuleManager ruleManager) + { + super(); + mRuleManager = ruleManager; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.nodeequality.NodeEqualityRule#apply(TaskTreeNode, TaskTreeNode) + */ + //----------------------------------------------------------------------------------------------- + @Override + public NodeEquality compare(TaskTreeNode node1, TaskTreeNode node2) + { + if ((!(node1 instanceof Sequence)) || (!(node2 instanceof Sequence))) + { + return null; + } + + // 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 new NodesEqual(); + } + + // Sequences are equal, if they have the same number and order of children. If all the + // children match structurally, then the sequences are structurally equal. Otherwise, if + // at least one pair of children matches only semantically, then the sequences match only + // semantically. + if (node1.getChildren().size() != node2.getChildren().size()) + { + return null; + } + + boolean structurallyEqual = true; + for (int i = 0; i < node1.getChildren().size(); i++) + { + TaskTreeNode child1 = node1.getChildren().get(i); + TaskTreeNode child2 = node2.getChildren().get(i); + + NodeEquality nodeEquality = mRuleManager.applyRules(child1, child2); + + structurallyEqual &= nodeEquality.getStructuralEquality(); + + if (!structurallyEqual && !nodeEquality.getSemanticalEquality()) + { + return null; + } + } + + if (structurallyEqual) + { + return new NodesEqual(); + } + else + { + return new NodesSemanticallyEqual(); + } + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGUIElementSequenceDetectionRule.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGUIElementSequenceDetectionRule.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGUIElementSequenceDetectionRule.java (revision 439) @@ -0,0 +1,137 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: DefaultSequenceDetectionRule.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 18.03.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; +import de.ugoe.cs.tasktree.guimodel.GUIElement; + +//------------------------------------------------------------------------------------------------- +/** + * 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(TaskTreeNode parent, + TaskTreeBuilder builder, + TaskTreeNodeFactory nodeFactory, + boolean finalize) + { + if (!(parent instanceof Sequence)) + { + return null; + } + + RuleApplicationResult result = new RuleApplicationResult(); + + GUIElement currentGUIElement = null; + int startingIndex = -1; + + int index = 0; + while (index < parent.getChildren().size()) + { + TaskTreeNode child = parent.getChildren().get(index); + + GUIElement guiElement = determineGUIElement(child); + + if ((guiElement != null) && (!guiElement.equals(currentGUIElement))) + { + if (startingIndex < 0) + { + startingIndex = index; + currentGUIElement = guiElement; + } + else + { + handleGuiElementSequence(parent, startingIndex, index - 1, builder, nodeFactory, result); + + return result; + } + } + + index++; + } + + if (startingIndex > -1) + { + if (finalize && (startingIndex > 0)) + { + handleGuiElementSequence + (parent, startingIndex, parent.getChildren().size() - 1, builder, nodeFactory, result); + } + else + { + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); + } + } + + return result; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param child + * @return + */ + //----------------------------------------------------------------------------------------------- + private GUIElement determineGUIElement(TaskTreeNode node) + { + if (node instanceof InteractionTask) + { + return ((InteractionTask) node).getGUIElement(); + } + else + { + return null; + } + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + private void handleGuiElementSequence(TaskTreeNode parent, + int startIndex, + int endIndex, + TaskTreeBuilder builder, + TaskTreeNodeFactory nodeFactory, + RuleApplicationResult result) + { + Sequence sequence = nodeFactory.createNewSequence(); + + for (int i = startIndex; i <= endIndex; i++) + { + builder.addChild(sequence, parent.getChildren().get(startIndex)); + builder.removeChild((Sequence) parent, startIndex); + } + + builder.addChild((Sequence) parent, startIndex, sequence); + + result.addNewlyCreatedParentNode(sequence); + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED); + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRule.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRule.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRule.java (revision 439) @@ -0,0 +1,289 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: DefaultIterationDetectionRule.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import java.util.ArrayList; +import java.util.List; + +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEquality; +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; +import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; +import de.ugoe.cs.quest.tasktrees.treeifc.Selection; +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class DefaultIterationDetectionRule implements TemporalRelationshipRule +{ + /** */ + private NodeEqualityRuleManager mNodeEqualityRuleManager; + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + DefaultIterationDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager) + { + super(); + mNodeEqualityRuleManager = nodeEqualityRuleManager; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see TemporalRelationshipRule#apply(TaskTreeNode, TaskTreeBuilder, TaskTreeNodeFactory) + */ + //----------------------------------------------------------------------------------------------- + @Override + public RuleApplicationResult apply(TaskTreeNode parent, + TaskTreeBuilder treeBuilder, + TaskTreeNodeFactory nodeFactory, + boolean finalize) + { + if (!(parent instanceof Sequence)) + { + return null; + } + + // parent must already have at least 2 children + if ((parent.getChildren() == null) || (parent.getChildren().size() < 2)) + { + return null; + } + + // iterations represent as a list of nodes that splits up in several equal sublists. If + // the remaining nodes also start an equal sublist, then the iteration may not be completed + // yet. So wait for further interactions to only identify completed iterations. + + // to find longer iterations first, start with long sequences + for (int end = parent.getChildren().size() - 1; end > 0; end--) + { + for (int start = 0; start < end; start++) + { + List equalVariants = + getEqualSublistVariantsInBoundaries(parent, start, end); + + if (equalVariants != null) + { + if (!finalize) + { + // check, if the iteration may go on. This may be the case, if the detected iteration + // finishes with the last child of the parent, or if the remaining children, which were + // not identified as part of the iteration, start a further occurrence of the iteration + if (end == (parent.getChildren().size() - 1)) + { + RuleApplicationResult result = new RuleApplicationResult(); + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); + return result; + } + + boolean allNodesEqual = true; + for (int i = 0; ((allNodesEqual) && (i < equalVariants.get(0).length)); i++) + { + if ((end + i + 1) >= parent.getChildren().size()) + { + break; + } + + NodeEquality nodeEquality = mNodeEqualityRuleManager.applyRules + (equalVariants.get(0)[i], parent.getChildren().get(end + i + 1)); + + allNodesEqual &= + nodeEquality.getStructuralEquality() || nodeEquality.getSemanticalEquality(); + } + + if (allNodesEqual) + { + RuleApplicationResult result = new RuleApplicationResult(); + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); + return result; + } + } + + RuleApplicationResult result = new RuleApplicationResult(); + Iteration newIteration = nodeFactory.createNewIteration(); + result.addNewlyCreatedParentNode(newIteration); + + if (equalVariants.size() == 1) + { + // all children are the same. Create an iteration of this child + if (equalVariants.get(0).length == 1) + { + // all children are the same. Create an iteration of this child + treeBuilder.setChild(newIteration, equalVariants.get(0)[0]); + } + else + { + // there was an iteration of structurally equal sequences + Sequence sequence = nodeFactory.createNewSequence(); + result.addNewlyCreatedParentNode(sequence); + + for (TaskTreeNode node : equalVariants.get(0)) + { + treeBuilder.addChild(sequence, node); + } + + treeBuilder.setChild(newIteration, sequence); + } + } + else + { + // there are distinct variants of semantically equal subsequences or children --> + // create an iterated selection + Selection selection = nodeFactory.createNewSelection(); + result.addNewlyCreatedParentNode(selection); + + for (TaskTreeNode[] variant : equalVariants) + { + if (variant.length == 1) + { + treeBuilder.addChild(selection, variant[0]); + } + else + { + Sequence sequence = nodeFactory.createNewSequence(); + result.addNewlyCreatedParentNode(sequence); + + for (TaskTreeNode node : variant) + { + treeBuilder.addChild(sequence, node); + } + + treeBuilder.addChild(selection, sequence); + } + } + + treeBuilder.setChild(newIteration, selection); + } + + // remove iterated children + for (int j = end; j >= start; j--) + { + treeBuilder.removeChild((Sequence) parent, j); + } + + // add the new iteration instead + treeBuilder.addChild((Sequence) parent, start, newIteration); + + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED); + return result; + } + } + } + + return null; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + private List getEqualSublistVariantsInBoundaries(TaskTreeNode parent, + int start, + int end) + { + List equalVariants = null; + + int noOfChildrenInBoundaries = end - start + 1; + + for (int subListLength = 1; subListLength <= (noOfChildrenInBoundaries / 2); subListLength++) + { + if ((noOfChildrenInBoundaries % subListLength) == 0) + { + equalVariants = getEqualSublistVariantsForSubListLength(parent, start, end, subListLength); + + if (equalVariants != null) + { + return equalVariants; + } + } + } + + return null; + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + private List getEqualSublistVariantsForSubListLength(TaskTreeNode parent, + int start, + int end, + int subListLength) + { + List equalVariants = new ArrayList(); + TaskTreeNode[] firstVariant = new TaskTreeNode[subListLength]; + + for (int i = 0; i < subListLength; i++) + { + firstVariant[i] = parent.getChildren().get(start + i); + } + + equalVariants.add(firstVariant); + + for (int parentIdx = (start + subListLength); parentIdx <= end; parentIdx += subListLength) + { + TaskTreeNode[] otherVariant = new TaskTreeNode[subListLength]; + + for (int i = 0; i < subListLength; i++) + { + NodeEquality nodeEquality = mNodeEqualityRuleManager.applyRules + (firstVariant[i], parent.getChildren().get(parentIdx + i)); + + if (!nodeEquality.getStructuralEquality()) + { + if (nodeEquality.getSemanticalEquality()) + { + otherVariant[i] = parent.getChildren().get(parentIdx + i); + } + else + { + return null; + } + } + } + + // check, if there is a semantically equal other variant. If so, add it to the list of + // variants + boolean semanticallyUnequal = false; + for (int i = 0; i < subListLength; i++) + { + if (otherVariant[i] == null) + { + otherVariant[i] = firstVariant[i]; + } + else + { + semanticallyUnequal = true; + } + } + + if (semanticallyUnequal) + { + equalVariants.add(otherVariant); + } + } + + return equalVariants; + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultMouseClickReductionRule.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultMouseClickReductionRule.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultMouseClickReductionRule.java (revision 439) @@ -0,0 +1,152 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: DefaultSequenceDetectionRule.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 18.03.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.userinteraction.MouseButtonDown; +import de.ugoe.cs.tasktree.userinteraction.MouseButtonInteraction; +import de.ugoe.cs.tasktree.userinteraction.MouseButtonUp; +import de.ugoe.cs.tasktree.userinteraction.MouseClick; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 18.03.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class DefaultMouseClickReductionRule implements TemporalRelationshipRule +{ + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, TaskTreeBuilder, TaskTreeNodeFactory) + */ + //----------------------------------------------------------------------------------------------- + @Override + public RuleApplicationResult apply(TaskTreeNode parent, + TaskTreeBuilder builder, + TaskTreeNodeFactory nodeFactory, + boolean finalize) + { + if (!(parent instanceof Sequence)) + { + return null; + } + + RuleApplicationResult result = new RuleApplicationResult(); + + int index = 0; + while (index < parent.getChildren().size() - 2) // -2 because we don't need to go to the end + { + if (mouseClickSequenceFound(parent.getChildren().get(index), + parent.getChildren().get(index + 1), + parent.getChildren().get(index + 2))) + { + builder.removeChild((Sequence) parent, index); + builder.removeChild((Sequence) parent, index); + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED); + return result; + } + else if ((parent.getChildren().get(index) instanceof Sequence) && + (parent.getChildren().get(index).getChildren().size() == 2) && + (mouseClickSequenceFound(parent.getChildren().get(index).getChildren().get(0), + parent.getChildren().get(index).getChildren().get(1), + parent.getChildren().get(index + 1)))) + { + builder.removeChild((Sequence) parent, index); + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED); + return result; + } + + index++; + } + + return result; + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + private boolean mouseClickSequenceFound(TaskTreeNode mouseButtonDown, + TaskTreeNode mouseButtonUp, + TaskTreeNode mouseClick) + { + // check the first in a row of three for validity + if (!(mouseButtonDown instanceof InteractionTask)) + { + return false; + } + + GUIElement guiElement = ((InteractionTask) mouseButtonDown).getGUIElement(); + + if (!(((InteractionTask) mouseButtonDown).getInteraction() instanceof MouseButtonDown)) + { + return false; + } + + MouseButtonInteraction.Button button = + ((MouseButtonDown) ((InteractionTask) mouseButtonDown).getInteraction()).getButton(); + + + // check the second node for validity + if (!(mouseButtonUp instanceof InteractionTask)) + { + return false; + } + + if (!guiElement.equals(((InteractionTask) mouseButtonUp).getGUIElement())) + { + return false; + } + + if (!(((InteractionTask) mouseButtonUp).getInteraction() instanceof MouseButtonUp)) + { + return false; + } + + if (!button.equals + (((MouseButtonUp) ((InteractionTask) mouseButtonUp).getInteraction()).getButton())) + { + return false; + } + + + // check the third node for validity + if (!(mouseClick instanceof InteractionTask)) + { + return false; + } + + if (!guiElement.equals(((InteractionTask) mouseClick).getGUIElement())) + { + return false; + } + + if (!(((InteractionTask) mouseClick).getInteraction() instanceof MouseClick)) + { + return false; + } + + if (!button.equals(((MouseClick) ((InteractionTask) mouseClick).getInteraction()).getButton())) + { + return false; + } + + return true; + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultSequenceDetectionRule.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultSequenceDetectionRule.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultSequenceDetectionRule.java (revision 439) @@ -0,0 +1,124 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: DefaultSequenceDetectionRule.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 18.03.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 18.03.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class DefaultSequenceDetectionRule implements TemporalRelationshipRule +{ + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.temporalrelation.TemporalRelationshipRule#apply(TaskTreeNode, TaskTreeBuilder, TaskTreeNodeFactory) + */ + //----------------------------------------------------------------------------------------------- + @Override + public RuleApplicationResult apply(TaskTreeNode parent, + TaskTreeBuilder builder, + TaskTreeNodeFactory nodeFactory, + boolean finalize) + { + if (!(parent instanceof Sequence)) + { + return null; + } + + RuleApplicationResult result = new RuleApplicationResult(); + int sequenceStartingIndex = -1; + + int index = 0; + while (index < parent.getChildren().size()) + { + TaskTreeNode child = parent.getChildren().get(index); + + if (child instanceof InteractionTask) + { + if (((InteractionTask) child).getInteraction().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) && + (!((InteractionTask) child).getInteraction().startsLogicalSequence())))) + { + boolean allNewChildrenAreSequences = true; + + for (int j = sequenceStartingIndex; ((allNewChildrenAreSequences) && (j < index)); j++) + { + allNewChildrenAreSequences &= (parent.getChildren().get(j) instanceof Sequence); + } + + if (!allNewChildrenAreSequences) + { + Sequence sequence = nodeFactory.createNewSequence(); + + for (int j = sequenceStartingIndex; j < index; j++) + { + builder.addChild(sequence, parent.getChildren().get(sequenceStartingIndex)); + builder.removeChild((Sequence) parent, sequenceStartingIndex); + } + + if (!((InteractionTask) child).getInteraction().startsLogicalSequence()) + { + builder.addChild(sequence, parent.getChildren().get(sequenceStartingIndex)); + builder.removeChild((Sequence) parent, sequenceStartingIndex); + } + + builder.addChild((Sequence) parent, sequenceStartingIndex, sequence); + + result.addNewlyCreatedParentNode(sequence); + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED); + return result; + } + } + } + + if (((InteractionTask) child).getInteraction().startsLogicalSequence()) + { + sequenceStartingIndex = index; + } + } + + index++; + } + + if (sequenceStartingIndex >= 0) + { + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); + } + + return result; + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultTextInputReductionRule.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultTextInputReductionRule.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultTextInputReductionRule.java (revision 439) @@ -0,0 +1,273 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: DefaultSequenceDetectionRule.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 18.03.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; + +import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeifc.TextInputInteractionTask; +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.guimodel.TextArea; +import de.ugoe.cs.tasktree.guimodel.TextField; +import de.ugoe.cs.tasktree.keyboardmaps.KeyboardMap; +import de.ugoe.cs.tasktree.keyboardmaps.KeyboardMapFactory; +import de.ugoe.cs.tasktree.keyboardmaps.VirtualKey; +import de.ugoe.cs.tasktree.userinteraction.KeyInteraction; +import de.ugoe.cs.tasktree.userinteraction.KeyPressed; +import de.ugoe.cs.tasktree.userinteraction.KeyReleased; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 18.03.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class DefaultTextInputReductionRule implements TemporalRelationshipRule +{ + /** */ + private KeyboardMap mKeyboardMap = KeyboardMapFactory.createKeyboardMap(Locale.GERMAN); + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see TemporalRelationshipRule#apply(TaskTreeNode, TaskTreeBuilder, TaskTreeNodeFactory) + */ + //----------------------------------------------------------------------------------------------- + @Override + public RuleApplicationResult apply(TaskTreeNode parent, + TaskTreeBuilder builder, + TaskTreeNodeFactory nodeFactory, + boolean finalize) + { + if ((!(parent instanceof Sequence)) || + (parent instanceof TextInputInteractionTask)) + { + return null; + } + + RuleApplicationResult result = new RuleApplicationResult(); + int textEntryStartIndex = -1; + GUIElement currentGUIElement = null; + + int index = 0; + TaskTreeNode task = null; + while (index < parent.getChildren().size()) + { + task = parent.getChildren().get(index); + if (isKeyInteraction(task) && isDataInputGUIElement(((InteractionTask) task).getGUIElement())) + { + if (textEntryStartIndex < 0) + { + textEntryStartIndex = index; + currentGUIElement = ((InteractionTask) task).getGUIElement(); + } + else if (!currentGUIElement.equals(((InteractionTask) task).getGUIElement())) + { + handleTextEntrySequence(parent, textEntryStartIndex, index - 1, currentGUIElement, + builder, nodeFactory, result); + return result; + } + } + else if (textEntryStartIndex >= 0) + { + handleTextEntrySequence(parent, textEntryStartIndex, index - 1, currentGUIElement, + builder, nodeFactory, result); + return result; + } + + index++; + } + + if (textEntryStartIndex >= 0) + { + if (finalize) + { + handleTextEntrySequence(parent, textEntryStartIndex, parent.getChildren().size() - 1, + currentGUIElement, builder, nodeFactory, result); + } + else + { + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FEASIBLE); + } + } + + return result; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param taskTreeNode + * @return + */ + //----------------------------------------------------------------------------------------------- + private boolean isKeyInteraction(TaskTreeNode taskTreeNode) + { + if ((taskTreeNode instanceof InteractionTask)) + { + return (((InteractionTask) taskTreeNode).getInteraction() instanceof KeyInteraction); + } + else + { + return false; + } + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param textEntryStartIndex + * @param i + * @param result + * @return + */ + //----------------------------------------------------------------------------------------------- + private void handleTextEntrySequence(TaskTreeNode parent, + int startIndex, + int endIndex, + GUIElement guiElement, + TaskTreeBuilder builder, + TaskTreeNodeFactory nodeFactory, + RuleApplicationResult result) + { + TextInputInteractionTask textInput = nodeFactory.createNewTextInputInteractionTask(guiElement); + + for (int i = startIndex; i <= endIndex; i++) + { + builder.addChild(textInput, parent.getChildren().get(startIndex)); + builder.removeChild((Sequence) parent, startIndex); + } + + builder.addChild((Sequence) parent, startIndex, textInput); + + StringBuffer enteredText = new StringBuffer(); + determineEnteredText(textInput, new ArrayList(), enteredText); + textInput.setEnteredText(enteredText.toString()); + + result.addNewlyCreatedParentNode(textInput); + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param guiElement + * @return + */ + //----------------------------------------------------------------------------------------------- + private boolean isDataInputGUIElement(GUIElement guiElement) + { + return ((guiElement instanceof TextField) || (guiElement instanceof TextArea)); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param sequence + * @param enteredText + */ + //----------------------------------------------------------------------------------------------- + private void determineEnteredText(TaskTreeNode node, + List pressedKeys, + StringBuffer enteredText) + { + if ((node instanceof Sequence) || (node instanceof TextInputInteractionTask)) + { + for (TaskTreeNode child : node.getChildren()) + { + if (child instanceof InteractionTask) + { + if (((InteractionTask) child).getInteraction() instanceof KeyPressed) + { + VirtualKey key = ((KeyPressed) ((InteractionTask) child).getInteraction()).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 (!(((InteractionTask) child).getGUIElement() instanceof TextField)) + { + enteredText.append(getCharacter(key, pressedKeys)); + } + } + else + { + char theChar = getCharacter(key, pressedKeys); + if (theChar != Character.UNASSIGNED) + { + enteredText.append(theChar); + } + } + } + else if (((InteractionTask) child).getInteraction() instanceof KeyReleased) + { + pressedKeys.remove(((KeyReleased) ((InteractionTask) child).getInteraction()).getKey()); + } + } + else + { + determineEnteredText(child, pressedKeys, enteredText); + } + } + } + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param key + * @param pressedKeys + * @return + */ + //----------------------------------------------------------------------------------------------- + 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 mKeyboardMap.getCharacterFor(key, numlock, shift, altgr, false); + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/RuleApplicationResult.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/RuleApplicationResult.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/RuleApplicationResult.java (revision 439) @@ -0,0 +1,92 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: RuleApplicationResult.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 18.03.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import java.util.ArrayList; +import java.util.List; + +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 18.03.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class RuleApplicationResult +{ + + /** */ + private RuleApplicationStatus mStatus = RuleApplicationStatus.RULE_NOT_APPLIED; + + /** */ + private List mNewParents = new ArrayList(); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param b + */ + //----------------------------------------------------------------------------------------------- + public RuleApplicationResult() + { + // this is the default indicating nothing so far + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param b + */ + //----------------------------------------------------------------------------------------------- + public void setRuleApplicationStatus(RuleApplicationStatus status) + { + mStatus = status; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public RuleApplicationStatus getRuleApplicationStatus() + { + return mStatus; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param sequence + */ + //----------------------------------------------------------------------------------------------- + public void addNewlyCreatedParentNode(TaskTreeNode newParent) + { + mNewParents.add(newParent); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public List getNewlyCreatedParentNodes() + { + return mNewParents; + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/RuleApplicationStatus.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/RuleApplicationStatus.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/RuleApplicationStatus.java (revision 439) @@ -0,0 +1,23 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: RuleApplicationStatus.java,v $ +// Version : $Revision: 0.0 $ $Author: pharms $ $Date: 09.07.2012 $ +// Project : TaskTreeTemporalRelationship +// Creation : 2012 by pharms +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 09.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +//------------------------------------------------------------------------------------------------- +public enum RuleApplicationStatus +{ + RULE_APPLICATION_FINISHED, + RULE_APPLICATION_FEASIBLE, + RULE_NOT_APPLIED; +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TemporalRelationshipRule.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TemporalRelationshipRule.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TemporalRelationshipRule.java (revision 439) @@ -0,0 +1,36 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TemporalRelationshipRule.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 12.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 12.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public interface TemporalRelationshipRule +{ + + //----------------------------------------------------------------------------------------------- + /** + * applies the rule to the given situation and returns a rule application result, if this was + * successful + */ + //----------------------------------------------------------------------------------------------- + public RuleApplicationResult apply(TaskTreeNode parent, + TaskTreeBuilder builder, + TaskTreeNodeFactory nodeFactory, + boolean finalize); + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TemporalRelationshipRuleManager.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TemporalRelationshipRuleManager.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TemporalRelationshipRuleManager.java (revision 439) @@ -0,0 +1,166 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TemporalRelationshipRuleManager.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 12.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Logger; + +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 12.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class TemporalRelationshipRuleManager +{ + /** */ + private static Logger LOG = Logger.getLogger(TemporalRelationshipRuleManager.class.getName()); + + /** */ + private NodeEqualityRuleManager mNodeEqualityRuleManager; + + /** */ + private List mRuleIndex = new ArrayList(); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + public TemporalRelationshipRuleManager(NodeEqualityRuleManager nodeEqualityRuleManager) + { + super(); + mNodeEqualityRuleManager = nodeEqualityRuleManager; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + public void init() + { + LOG.info("initializing"); + + mRuleIndex.add(new DefaultMouseClickReductionRule()); + mRuleIndex.add(new DefaultTextInputReductionRule()); + mRuleIndex.add(new DefaultGUIElementSequenceDetectionRule()); + mRuleIndex.add(new TrackBarSelectionDetectionRule(mNodeEqualityRuleManager)); + mRuleIndex.add(new DefaultSequenceDetectionRule()); + mRuleIndex.add(new DefaultIterationDetectionRule(mNodeEqualityRuleManager)); + } + + //----------------------------------------------------------------------------------------------- + /** + * returns true, if there is a rule that matches the current situation and if, therefore, a + * new temporal relationship has been added to the tree. + * + * @param parent + * @param newChild + * @return + */ + //----------------------------------------------------------------------------------------------- + public void applyRules(TaskTreeNode parent, + TaskTreeBuilder builder, + TaskTreeNodeFactory nodeFactory, + boolean finalize) + { + applyRules(parent, builder, nodeFactory, finalize, ""); + } + + //----------------------------------------------------------------------------------------------- + /** + * returns true, if there is a rule that matches the current situation and if, therefore, a + * new temporal relationship has been added to the tree. + * + * @param parent + * @param newChild + * @return + */ + //----------------------------------------------------------------------------------------------- + private int applyRules(TaskTreeNode parent, + TaskTreeBuilder builder, + TaskTreeNodeFactory nodeFactory, + boolean finalize, + String logIndent) + { + LOG.info(logIndent + "applying rules for " + parent); + + int noOfRuleApplications = 0; + + for (TemporalRelationshipRule rule : mRuleIndex) + { + 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)) + { + LOG.info(logIndent + "applied rule " + rule + " on " + parent); + noOfRuleApplications++; + + for (TaskTreeNode 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) + { + LOG.warning(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/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRule.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRule.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRule.java (revision 439) @@ -0,0 +1,220 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TrackBarSelectionDetectionRule.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 28.04.2012 $ +// Project : TaskTreeTemporalRelationship +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEquality; +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; +import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; +import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; +import de.ugoe.cs.quest.tasktrees.treeifc.Selection; +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; +import de.ugoe.cs.tasktree.guimodel.TrackBar; +import de.ugoe.cs.tasktree.userinteraction.ValueSelection; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 28.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class TrackBarSelectionDetectionRule implements TemporalRelationshipRule +{ + + /** */ + private NodeEqualityRuleManager mNodeEqualityRuleManager; + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + TrackBarSelectionDetectionRule(NodeEqualityRuleManager nodeEqualityRuleManager) + { + super(); + mNodeEqualityRuleManager = nodeEqualityRuleManager; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see TemporalRelationshipRule#apply(TaskTreeNode, TaskTreeBuilder, TaskTreeNodeFactory) + */ + //----------------------------------------------------------------------------------------------- + @Override + public RuleApplicationResult apply(TaskTreeNode parent, + TaskTreeBuilder builder, + TaskTreeNodeFactory nodeFactory, + boolean finalize) + { + if (!(parent instanceof Sequence)) + { + return null; + } + + RuleApplicationResult result = new RuleApplicationResult(); + + int valueSelectionStartIndex = -1; + + int index = 0; + while (index < parent.getChildren().size()) + { + TaskTreeNode child = parent.getChildren().get(index); + + if ((child instanceof InteractionTask) && + (((InteractionTask) child).getGUIElement() instanceof TrackBar) && + (((InteractionTask) child).getInteraction() 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, + TaskTreeNode parent, + TaskTreeBuilder builder, + TaskTreeNodeFactory nodeFactory, + RuleApplicationResult result) + { + Iteration iteration = nodeFactory.createNewIteration(); + result.addNewlyCreatedParentNode(iteration); + + Selection 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((Sequence) parent, startIndex); + } + + builder.addChild((Sequence) parent, startIndex, iteration); + + result.setRuleApplicationStatus(RuleApplicationStatus.RULE_APPLICATION_FINISHED); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + private void addChildIfNecessary(Selection parentSelection, + TaskTreeNode node, + TaskTreeBuilder builder, + TaskTreeNodeFactory nodeFactory, + RuleApplicationResult result) + { + for (int i = 0; i < parentSelection.getChildren().size(); i++) + { + TaskTreeNode child = parentSelection.getChildren().get(i); + + if (child instanceof InteractionTask) + { + // check, if the new node is a variant for the current interaction task + NodeEquality nodeEquality = mNodeEqualityRuleManager.applyRules(child, node); + if (nodeEquality.getSemanticalEquality()) + { + // the node is a variant. If it not structurally equal, a new sub-selection for the + // existing and the new node must be created. Otherwise, the new node does not need + // to be added + if (!nodeEquality.getStructuralEquality()) + { + Selection selection = nodeFactory.createNewSelection(); + result.addNewlyCreatedParentNode(selection); + builder.addChild(parentSelection, selection); + + builder.addChild(selection, child); + builder.addChild(selection, node); + builder.removeChild(parentSelection, child); + } + + return; + } + } + else if (child instanceof Selection) + { + // check, if the new node is a variant for the semantically equal children of the current + // selection + boolean addNode = true; + for (int j = 0; j < child.getChildren().size(); j++) + { + NodeEquality nodeEquality = mNodeEqualityRuleManager.applyRules(child, node); + if (!nodeEquality.getSemanticalEquality()) + { + // the new node is no semantical equivalent of the nodes in the current selection - + // break up + addNode = false; + break; + } + else if (nodeEquality.getStructuralEquality()) + { + addNode = false; + break; + } + } + + if (addNode) + { + // the node is a semantical equivalent to all the nodes in the existing sub-selection + // but it is not structurally identical to either of them. Therefore add it. + builder.addChild((Selection) child, node); + return; + } + } + } + + // if we did not return in the previous checks, then the node must be added + builder.addChild(parentSelection, node); + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/AbstractTask.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/AbstractTask.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/AbstractTask.java (revision 439) @@ -0,0 +1,22 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: AbstractTask.java,v $ +// Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 06.11.2011 12:53:24 $ +// Project : TaskTreePerformanceTest +// Creation : 2011 by Patrick +// Copyright : Patrick Harms, 2011 +//------------------------------------------------------------------------------------------------- + +package de.ugoe.cs.quest.tasktrees.treeifc; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +//------------------------------------------------------------------------------------------------- +public interface AbstractTask extends TaskTreeNode +{ + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/InteractionTask.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/InteractionTask.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/InteractionTask.java (revision 439) @@ -0,0 +1,39 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: InteractionTask.java,v $ +// Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 08.11.2011 19:44:52 $ +// Project : TaskTreePerformanceTest +// Creation : 2011 by Patrick +// Copyright : Patrick Harms, 2011 +//------------------------------------------------------------------------------------------------- + +package de.ugoe.cs.quest.tasktrees.treeifc; + +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.userinteraction.Interaction; + + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +//------------------------------------------------------------------------------------------------- +public interface InteractionTask extends TaskTreeNode +{ + //----------------------------------------------------------------------------------------------- + /** + * @return Returns the interaction. + */ + //----------------------------------------------------------------------------------------------- + public Interaction getInteraction(); + + //----------------------------------------------------------------------------------------------- + /** + * @return Returns the GUIElement. + */ + //----------------------------------------------------------------------------------------------- + public GUIElement getGUIElement(); + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/Iteration.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/Iteration.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/Iteration.java (revision 439) @@ -0,0 +1,21 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: Iteration.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 21.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeifc; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public interface Iteration extends TemporalRelationship +{ + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/NodeInfo.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/NodeInfo.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/NodeInfo.java (revision 439) @@ -0,0 +1,43 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: NodeInfo.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 21.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- + +package de.ugoe.cs.quest.tasktrees.treeifc; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public interface NodeInfo +{ + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + public TaskTreeNode getTask(); + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + public int getNoOfOccurencesInTree(); + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + public long getLastUpdate(); + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/Selection.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/Selection.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/Selection.java (revision 439) @@ -0,0 +1,21 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: Selection.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 21.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeifc; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public interface Selection extends TemporalRelationship +{ + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/Sequence.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/Sequence.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/Sequence.java (revision 439) @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: Sequence.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 21.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeifc; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public interface Sequence extends TemporalRelationship +{ + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public Sequence clone(); + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TaskTree.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TaskTree.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TaskTree.java (revision 439) @@ -0,0 +1,41 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TaskTree.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 21.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeifc; + +import java.util.Map; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public interface TaskTree +{ + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public TaskTreeNode getRoot(); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public Map getTaskMap(); + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TaskTreeBuilder.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TaskTreeBuilder.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TaskTreeBuilder.java (revision 439) @@ -0,0 +1,102 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TaskTreeBuilder.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 21.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeifc; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public interface TaskTreeBuilder +{ + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param sequence + * @param task + */ + //----------------------------------------------------------------------------------------------- + void addChild(Sequence parent, TaskTreeNode child); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param parent + * @param index + * @param sequence + */ + //----------------------------------------------------------------------------------------------- + void addChild(Sequence parent, int index, TaskTreeNode child); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param sequence + * @param task + */ + //----------------------------------------------------------------------------------------------- + void addChild(Selection parent, TaskTreeNode child); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param sequence + * @param task + */ + //----------------------------------------------------------------------------------------------- + void addChild(TextInputInteractionTask parent, TaskTreeNode child); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param iteration + * @param newChild + */ + //----------------------------------------------------------------------------------------------- + void setChild(Iteration iteration, TaskTreeNode newChild); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param parent + * @param i + */ + //----------------------------------------------------------------------------------------------- + void removeChild(Sequence parent, int index); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param parent + * @param i + */ + //----------------------------------------------------------------------------------------------- + void removeChild(Selection parent, TaskTreeNode child); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param parent + * @param i + */ + //----------------------------------------------------------------------------------------------- + void setDescription(TaskTreeNode parent, String description); + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TaskTreeNode.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TaskTreeNode.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TaskTreeNode.java (revision 439) @@ -0,0 +1,75 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: Task.java,v $ +// Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 08.11.2011 19:42:29 $ +// Project : TaskTreePerformanceTest +// Creation : 2011 by Patrick +// Copyright : Patrick Harms, 2011 +//------------------------------------------------------------------------------------------------- + +package de.ugoe.cs.quest.tasktrees.treeifc; + +import java.util.List; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +//------------------------------------------------------------------------------------------------- +public interface TaskTreeNode +{ + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + public String getName(); + + //----------------------------------------------------------------------------------------------- + /** + */ + //----------------------------------------------------------------------------------------------- + //public void addChild(TaskTreeNode child); + + //----------------------------------------------------------------------------------------------- + /** + */ + //----------------------------------------------------------------------------------------------- + //public void removeChild(int index); + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + public String getDescription(); + + //----------------------------------------------------------------------------------------------- + /** + */ + //----------------------------------------------------------------------------------------------- + public List getChildren(); + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + public boolean equals(TaskTreeNode taskTreeNode); + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + public int hashCode(); + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + public TaskTreeNode clone(); +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TaskTreeNodeFactory.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TaskTreeNodeFactory.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TaskTreeNodeFactory.java (revision 439) @@ -0,0 +1,82 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TaskTreeNodeFactory.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 21.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeifc; + +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.userinteraction.Interaction; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public interface TaskTreeNodeFactory +{ + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param GUIElement + * @param interaction + * @return + */ + //----------------------------------------------------------------------------------------------- + InteractionTask createNewInteractionTask(GUIElement guiElement, + Interaction interaction); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + Sequence createNewSequence(); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + TextInputInteractionTask createNewTextInputInteractionTask(GUIElement guiElement); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + Iteration createNewIteration(); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + Selection createNewSelection(); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param rootSequence + * @return + */ + //----------------------------------------------------------------------------------------------- + TaskTree createTaskTree(TaskTreeNode root); + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TemporalRelationship.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TemporalRelationship.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TemporalRelationship.java (revision 439) @@ -0,0 +1,21 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TemporalRelationship.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 12.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeifc; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 12.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +// ------------------------------------------------------------------------------------------------- +public interface TemporalRelationship extends TaskTreeNode +{ + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TextInputInteractionTask.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TextInputInteractionTask.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeifc/TextInputInteractionTask.java (revision 439) @@ -0,0 +1,44 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TextInputSequence.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 10.06.2012 $ +// Project : TaskTreeIfc +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeifc; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 10.06.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public interface TextInputInteractionTask extends InteractionTask +{ + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public TextInputInteractionTask clone(); + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + public String getEnteredText(); + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param string + */ + //----------------------------------------------------------------------------------------------- + public void setEnteredText(String text); +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/InteractionTaskImpl.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/InteractionTaskImpl.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/InteractionTaskImpl.java (revision 439) @@ -0,0 +1,105 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: InteractionTask.java,v $ +// Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 06.11.2011 10:57:52 $ +// Project : TaskTreePerformanceTest +// Creation : 2011 by Patrick +// Copyright : Patrick Harms, 2011 +//------------------------------------------------------------------------------------------------- + +package de.ugoe.cs.quest.tasktrees.treeimpl; + +import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.userinteraction.Interaction; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +//------------------------------------------------------------------------------------------------- +public class InteractionTaskImpl extends TaskTreeNodeImpl implements InteractionTask +{ + /** */ + private GUIElement mGUIElement; + + /** */ + private Interaction mInteraction; + + //----------------------------------------------------------------------------------------------- + /** + * @param guiElement + * @param interaction + */ + //----------------------------------------------------------------------------------------------- + InteractionTaskImpl(GUIElement guiElement, Interaction interaction) + { + super(interaction.getName() + "(" + guiElement + ")"); + super.setDescription(interaction + " on " + guiElement); + mGUIElement = guiElement; + mInteraction = interaction; + } + + //----------------------------------------------------------------------------------------------- + /** + * @return Returns the interaction. + */ + //----------------------------------------------------------------------------------------------- + public Interaction getInteraction() + { + return mInteraction; + } + + + //----------------------------------------------------------------------------------------------- + /** + * @return Returns the GUIElement. + */ + //----------------------------------------------------------------------------------------------- + public GUIElement getGUIElement() + { + return mGUIElement; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.harms.ctte.Task#equals(de.harms.ctte.Task) + */ + //----------------------------------------------------------------------------------------------- + @Override + public boolean equals(TaskTreeNode task) + { + if (!(task instanceof InteractionTask)) + { + return false; + } + + GUIElement otherInteractionElem = ((InteractionTask) task).getGUIElement(); + Interaction otherInteraction = ((InteractionTask) task).getInteraction(); + + if ((((mGUIElement == null) && (otherInteractionElem == null)) || + ((mGUIElement != null) && (mGUIElement.equals(otherInteractionElem)))) && + (((mInteraction == null) && (otherInteraction == null)) || + ((mInteraction != null) && (mInteraction.equals(otherInteraction))))) + { + return true; + } + + return false; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.harms.tasktrees.TreeNode#clone() + */ + //----------------------------------------------------------------------------------------------- + @Override + public TaskTreeNode clone() + { + return new InteractionTaskImpl(mGUIElement, mInteraction); + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/IterationImpl.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/IterationImpl.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/IterationImpl.java (revision 439) @@ -0,0 +1,81 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: Iteration.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeimpl; + +import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class IterationImpl extends TaskTreeNodeImpl implements Iteration +{ + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + IterationImpl() + { + super("Iteration"); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNode#addChild(TaskTreeNode) + */ + //----------------------------------------------------------------------------------------------- + @Override + public void addChild(TaskTreeNode child) + { + // adding more children is not allowed + throw new UnsupportedOperationException(); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param selection + * @return + */ + //----------------------------------------------------------------------------------------------- + public void setChild(TaskTreeNode child) + { + if (super.getChildren().size() > 0) + { + super.removeChild(0); + } + super.addChild(child); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see java.lang.Object#clone() + */ + //----------------------------------------------------------------------------------------------- + @Override + public TaskTreeNode clone() + { + IterationImpl clone = new IterationImpl(); + clone.setDescription(super.getDescription()); + + if (super.getChildren().size() > 0) + { + clone.setChild(super.getChildren().get(0)); + } + return clone; + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/NodeInfoImpl.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/NodeInfoImpl.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/NodeInfoImpl.java (revision 439) @@ -0,0 +1,114 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: NodeInfo.java,v $ +// Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 05.11.2011 19:24:14 $ +// Project : TestTreePerformanceTest +// Creation : 2011 by Patrick +// Copyright : Patrick Harms, 2011 +//------------------------------------------------------------------------------------------------- + +package de.ugoe.cs.quest.tasktrees.treeimpl; + +import java.util.ArrayList; +import java.util.List; + +import de.ugoe.cs.quest.tasktrees.treeifc.NodeInfo; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; + + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +//------------------------------------------------------------------------------------------------- +public class NodeInfoImpl implements NodeInfo +{ + /** */ + private TaskTreeNode mTask; + + /** */ + private long mLastUpdate; + + /** */ + private List mParentNodes = new ArrayList(); + + //----------------------------------------------------------------------------------------------- + /** + * @param node + */ + //----------------------------------------------------------------------------------------------- + NodeInfoImpl(TaskTreeNode task) + { + mTask = task; + mLastUpdate = System.currentTimeMillis(); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.NodeInfo#getTask() + */ + //----------------------------------------------------------------------------------------------- + @Override + public TaskTreeNode getTask() + { + return mTask; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeimpl.NodeInfo#getNoOfOccurencesInTree() + */ + //----------------------------------------------------------------------------------------------- + @Override + public int getNoOfOccurencesInTree() + { + return mParentNodes.size(); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeimpl.NodeInfo#getLastUpdate() + */ + //----------------------------------------------------------------------------------------------- + @Override + public long getLastUpdate() + { + return mLastUpdate; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + void addParent(TaskTreeNode parent) + { + mParentNodes.add(parent); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + void removeParent(TaskTreeNode parent) + { + mParentNodes.remove(parent); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + //----------------------------------------------------------------------------------------------- + @Override + public synchronized String toString() + { + return "NodeInfo(" + mTask + ", " + mParentNodes.size() + " parents)"; + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/SelectionImpl.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/SelectionImpl.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/SelectionImpl.java (revision 439) @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: Selection.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeimpl; + +import de.ugoe.cs.quest.tasktrees.treeifc.Selection; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class SelectionImpl extends TaskTreeNodeImpl implements Selection +{ + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param name + */ + //----------------------------------------------------------------------------------------------- + SelectionImpl() + { + super("Selection"); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see java.lang.Object#clone() + */ + //----------------------------------------------------------------------------------------------- + @Override + public TaskTreeNode clone() + { + SelectionImpl clone = new SelectionImpl(); + clone.setDescription(super.getDescription()); + + for (TaskTreeNode child : getChildren()) + { + clone.addChild(child); + } + + return clone; + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/SequenceImpl.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/SequenceImpl.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/SequenceImpl.java (revision 439) @@ -0,0 +1,66 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: Sequence.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 19.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeimpl; + +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 19.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class SequenceImpl extends TaskTreeNodeImpl implements Sequence +{ + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param name + */ + //----------------------------------------------------------------------------------------------- + SequenceImpl() + { + super("Sequence"); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param name + */ + //----------------------------------------------------------------------------------------------- + SequenceImpl(String name) + { + super(name); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeimpl.TaskTreeNodeImpl#clone() + */ + //----------------------------------------------------------------------------------------------- + @Override + public SequenceImpl clone() + { + SequenceImpl clone = new SequenceImpl(); + clone.setDescription(super.getDescription()); + + for (TaskTreeNode child : getChildren()) + { + clone.addChild(child); + } + + return clone; + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeBuilderImpl.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeBuilderImpl.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeBuilderImpl.java (revision 439) @@ -0,0 +1,221 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TaskTreeBuilderImpl.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 21.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeimpl; + +import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; +import de.ugoe.cs.quest.tasktrees.treeifc.Selection; +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TextInputInteractionTask; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class TaskTreeBuilderImpl implements TaskTreeBuilder +{ + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#addChild(Sequence, TaskTreeNode) + */ + //----------------------------------------------------------------------------------------------- + @Override + public void addChild(Sequence parent, TaskTreeNode child) + { + if (!(parent instanceof SequenceImpl)) + { + 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(Sequence parent, int index, TaskTreeNode child) + { + if (!(parent instanceof SequenceImpl)) + { + 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(Selection parent, TaskTreeNode child) + { + if (!(parent instanceof SelectionImpl)) + { + 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(de.ugoe.cs.tasktree.treeifc.TextInputInteractionTask, de.ugoe.cs.tasktree.treeifc.TaskTreeNode) + */ + //----------------------------------------------------------------------------------------------- + @Override + public void addChild(TextInputInteractionTask parent, TaskTreeNode child) + { + if (!(parent instanceof TextInputInteractionTaskImpl)) + { + 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(Iteration iteration, TaskTreeNode newChild) + { + if (!(iteration instanceof IterationImpl)) + { + throw new IllegalArgumentException + ("illegal type of iteration provided: " + iteration.getClass()); + } + + if (!(newChild instanceof TaskTreeNodeImpl)) + { + throw new IllegalArgumentException + ("illegal type of task tree node provided: " + newChild.getClass()); + } + + ((IterationImpl) iteration).setChild(determineNode(newChild)); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#removeChild(Sequence, int) + */ + //----------------------------------------------------------------------------------------------- + @Override + public void removeChild(Sequence parent, int index) + { + if (!(parent instanceof TaskTreeNodeImpl)) + { + throw new IllegalArgumentException + ("illegal type of task tree node provided: " + parent.getClass()); + } + + ((TaskTreeNodeImpl) parent).removeChild(index); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#removeChild(Selection, TaskTreeNode) + */ + //----------------------------------------------------------------------------------------------- + @Override + public void removeChild(Selection parent, TaskTreeNode child) + { + if (!(parent instanceof TaskTreeNodeImpl)) + { + 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)))) + { + ((TaskTreeNodeImpl) parent).removeChild(i); + break; + } + } + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#setDescription(TaskTreeNode, String) + */ + //----------------------------------------------------------------------------------------------- + @Override + public void setDescription(TaskTreeNode parent, String description) + { + if (!(parent instanceof TaskTreeNodeImpl)) + { + throw new IllegalArgumentException + ("illegal type of task tree node provided: " + parent.getClass()); + } + + ((TaskTreeNodeImpl) parent).setDescription(description); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + private void addChildInternal(TaskTreeNode parent, int index, TaskTreeNode child) + { + if (!(child instanceof TaskTreeNodeImpl)) + { + throw new IllegalArgumentException + ("illegal type of task tree node provided: " + child.getClass()); + } + + if (index > -1) + { + ((TaskTreeNodeImpl) parent).addChild(index, determineNode(child)); + } + else + { + ((TaskTreeNodeImpl) parent).addChild(determineNode(child)); + } + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param newChild + * @return + */ + //----------------------------------------------------------------------------------------------- + private TaskTreeNode determineNode(TaskTreeNode newNode) + { + return newNode; + /*TaskTreeNode node = mTaskMap.get(newNode); + if (node == null) + { + node = newNode; + mTaskMap.put(node, node); + } + + return node;*/ + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeImpl.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeImpl.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeImpl.java (revision 439) @@ -0,0 +1,103 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TaskTree.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 21.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeimpl; + +import java.util.HashMap; +import java.util.Map; + +import de.ugoe.cs.quest.tasktrees.treeifc.NodeInfo; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class TaskTreeImpl implements TaskTree +{ + /** the map of nodes */ + private Map mTaskMap; + + /** the root node of the task tree */ + private TaskTreeNode mRootNode; + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + TaskTreeImpl(TaskTreeNode rootNode) + { + mRootNode = rootNode; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTree#getRoot() + */ + //----------------------------------------------------------------------------------------------- + @Override + public TaskTreeNode getRoot() + { + return mRootNode; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTree#getTaskMap() + */ + //----------------------------------------------------------------------------------------------- + @Override + public synchronized Map getTaskMap() + { + if (mTaskMap == null) + { + mTaskMap = new HashMap(); + addNodeToMap(mRootNode, null); + } + return mTaskMap; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param rootNode + */ + //----------------------------------------------------------------------------------------------- + private void addNodeToMap(TaskTreeNode node, TaskTreeNode parent) + { + NodeInfoImpl nodeInfo = (NodeInfoImpl) mTaskMap.get(node); + + if (nodeInfo == null) + { + nodeInfo = new NodeInfoImpl(node); + mTaskMap.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 (TaskTreeNode child : node.getChildren()) + { + addNodeToMap(child, node); + } + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeNodeFactoryImpl.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeNodeFactoryImpl.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeNodeFactoryImpl.java (revision 439) @@ -0,0 +1,99 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TaskTreeNodeFactoryImpl.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 21.02.2012 $ +// Project : TaskTreeCreator +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeimpl; + +import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; +import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; +import de.ugoe.cs.quest.tasktrees.treeifc.Selection; +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeifc.TextInputInteractionTask; +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.userinteraction.Interaction; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 21.02.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class TaskTreeNodeFactoryImpl implements TaskTreeNodeFactory +{ + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see TaskTreeNodeFactory#createNewInteractionTask(GUIElement, Interaction) + */ + //----------------------------------------------------------------------------------------------- + @Override + public InteractionTask createNewInteractionTask(GUIElement guiElement, + Interaction interaction) + { + return new InteractionTaskImpl(guiElement, interaction); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewSequence() + */ + //----------------------------------------------------------------------------------------------- + @Override + public Sequence createNewSequence() + { + return new SequenceImpl(); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewTextInputInteractionTask() + */ + //----------------------------------------------------------------------------------------------- + @Override + public TextInputInteractionTask createNewTextInputInteractionTask(GUIElement guiElement) + { + return new TextInputInteractionTaskImpl(guiElement); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewIteration() + */ + //----------------------------------------------------------------------------------------------- + @Override + public Iteration createNewIteration() + { + return new IterationImpl(); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewSelection() + */ + //----------------------------------------------------------------------------------------------- + @Override + public Selection createNewSelection() + { + return new SelectionImpl(); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createTaskTree(de.ugoe.cs.tasktree.treeifc.TaskTreeNode) + */ + //----------------------------------------------------------------------------------------------- + @Override + public TaskTree createTaskTree(TaskTreeNode root) + { + return new TaskTreeImpl(root); + } + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeNodeImpl.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeNodeImpl.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeNodeImpl.java (revision 439) @@ -0,0 +1,288 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TreeNode.java,v $ +// Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 06.11.2011 11:00:46 $ +// Project : TaskTreePerformanceTest +// Creation : 2011 by Patrick +// Copyright : Patrick Harms, 2011 +//------------------------------------------------------------------------------------------------- + +package de.ugoe.cs.quest.tasktrees.treeimpl; + +import java.util.ArrayList; +import java.util.List; + +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; + + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +//------------------------------------------------------------------------------------------------- +public abstract class TaskTreeNodeImpl implements TaskTreeNode +{ + /** */ + private static int sTemporalId = 0; + + /** */ + private String mName; + + /** */ + private String mDescription; + + /** */ + private int mId; + + /** children */ + private List mChildren; + + //----------------------------------------------------------------------------------------------- + /** + */ + //----------------------------------------------------------------------------------------------- + TaskTreeNodeImpl(String name) + { + mName = name; + mId = getNewId(); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + private static synchronized int getNewId() + { + if (sTemporalId == Integer.MAX_VALUE) + { + sTemporalId = 0; + } + + return sTemporalId++; + } + + //----------------------------------------------------------------------------------------------- + /** + * @return Returns the name. + */ + //----------------------------------------------------------------------------------------------- + public String getName() + { + return mName; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNode#getDescription() + */ + //----------------------------------------------------------------------------------------------- + @Override + public String getDescription() + { + return mDescription; + } + + //----------------------------------------------------------------------------------------------- + /** + */ + //----------------------------------------------------------------------------------------------- + public synchronized List getChildren() + { + if ((mChildren == null) || (mChildren.size() == 0)) + { + return new ArrayList(); + } + + return mChildren.subList(0, mChildren.size()); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see java.lang.Object#equals(java.lang.Object) + */ + //----------------------------------------------------------------------------------------------- + @Override + public synchronized boolean equals(Object other) + { + if (!this.getClass().isInstance(other)) + { + return false; + } + else + { + return equals((TaskTreeNodeImpl) other); + } + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNode#equals(de.ugoe.cs.tasktree.treeifc.TaskTreeNode) + */ + //----------------------------------------------------------------------------------------------- + @Override + public boolean equals(TaskTreeNode other) + { + if (!this.getClass().isInstance(other)) + { + return false; + } + else + { + return equals((TaskTreeNodeImpl) other); + } + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see java.lang.Object#equals(java.lang.Object) + */ + //----------------------------------------------------------------------------------------------- + public synchronized boolean equals(TaskTreeNodeImpl other) + { + if (!this.getClass().isInstance(other)) + { + return false; + } + + if (other.hashCode() != hashCode()) + { + return false; + } + + if (mId != other.mId) + { + return false; + } + + if (!mName.equals(other.mName)) + { + return false; + } + + synchronized (other) + { + if ((other.mChildren == null) && (mChildren == null)) + { + return true; + } + + if (((other.mChildren == null) && (mChildren != null)) || + ((other.mChildren != null) && (mChildren == null))) + { + return false; + } + + if (other.mChildren.size() != mChildren.size()) + { + return false; + } + + for (int i = 0; i < mChildren.size(); i++) + { + if (!mChildren.get(i).equals(other.mChildren.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 (mChildren == null) + { + return mName + "(" + mId + ")"; + } + else + { + return mName + "(" + mId + ", " + mChildren.size() + " children)"; + } + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param i + * @return + */ + //----------------------------------------------------------------------------------------------- + void setDescription(String description) + { + mDescription = description; + } + + //----------------------------------------------------------------------------------------------- + /** + */ + //----------------------------------------------------------------------------------------------- + synchronized void addChild(TaskTreeNode child) + { + if (mChildren == null) + { + mChildren = new ArrayList(); + } + + mChildren.add(child); + } + + //----------------------------------------------------------------------------------------------- + /** + */ + //----------------------------------------------------------------------------------------------- + synchronized void addChild(int index, TaskTreeNode child) + { + if (mChildren == null) + { + mChildren = new ArrayList(); + } + + mChildren.add(index, child); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param i + * @return + */ + //----------------------------------------------------------------------------------------------- + synchronized TaskTreeNode removeChild(int index) + { + return mChildren.remove(index); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see java.lang.Object#clone() + */ + //----------------------------------------------------------------------------------------------- + @Override + public abstract TaskTreeNode clone(); + +} Index: /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TextInputInteractionTaskImpl.java =================================================================== --- /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TextInputInteractionTaskImpl.java (revision 439) +++ /trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TextInputInteractionTaskImpl.java (revision 439) @@ -0,0 +1,103 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TextInputSequenceImpl.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 10.06.2012 $ +// Project : TaskTreeImpl +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeimpl; + +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TextInputInteractionTask; +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.userinteraction.TextInput; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 10.06.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class TextInputInteractionTaskImpl extends InteractionTaskImpl + implements TextInputInteractionTask +{ + + /** the text, that was finally entered in this sequence without all backspaces, etc. */ + private String mEnteredText; + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param name + */ + //----------------------------------------------------------------------------------------------- + TextInputInteractionTaskImpl(GUIElement guiElement) + { + super(guiElement, new TextInput()); + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeimpl.TaskTreeNodeImpl#clone() + */ + //----------------------------------------------------------------------------------------------- + @Override + public TextInputInteractionTaskImpl clone() + { + TextInputInteractionTaskImpl clone = new TextInputInteractionTaskImpl(super.getGUIElement()); + clone.setDescription(super.getDescription()); + clone.setEnteredText(this.getEnteredText()); + + for (TaskTreeNode child : getChildren()) + { + clone.addChild(child); + } + + return clone; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TextInputSequence#getEnteredText() + */ + //----------------------------------------------------------------------------------------------- + @Override + public String getEnteredText() + { + return mEnteredText; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.ugoe.cs.tasktree.treeifc.TextInputSequence#setEnteredText(java.lang.String) + */ + //----------------------------------------------------------------------------------------------- + @Override + public void setEnteredText(String text) + { + mEnteredText = text; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + //----------------------------------------------------------------------------------------------- + @Override + public synchronized String toString() + { + if (super.getChildren() == null) + { + return super.getName(); + } + else + { + return "TextInputInteraction(\"" + mEnteredText + "\", " + super.getChildren().size() + + " children)"; + } + } + +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/manager/TaskTreeManagerTest.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/manager/TaskTreeManagerTest.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/manager/TaskTreeManagerTest.java (revision 439) @@ -0,0 +1,578 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TaskTreeManagerTest.java,v $ +// Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 08.11.2011 21:32:36 $ +// Project : TaskTreePerformanceTest +// Creation : 2011 by Patrick +// Copyright : Patrick Harms, 2011 +//------------------------------------------------------------------------------------------------- + +package de.ugoe.cs.quest.tasktrees.manager; + +import java.util.logging.Logger; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import de.ugoe.cs.quest.tasktrees.manager.ComponentManager; +import de.ugoe.cs.quest.tasktrees.manager.TaskTreeManager; +import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; +import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; +import de.ugoe.cs.quest.tasktrees.testutils.SimpleLogFormatter; +import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.userinteraction.Interaction; +import de.ugoe.cs.tasktree.userinteraction.InteractionEvent; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +//------------------------------------------------------------------------------------------------- + +public class TaskTreeManagerTest +{ + /** */ + TaskTreeManager mManager; + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Before + public void setUp() + { + Logger.getLogger("").getHandlers()[0].setFormatter(new SimpleLogFormatter()); + + mManager = new TaskTreeManager(); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @After + public void tearDown() + { + mManager = null; + ComponentManager.clearInstance(); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testOneInteractionOnOneElement() + { + simulateInteraction(new DummyGUIElement("elem1"), new DummyInteraction("bla", 1)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence {" + + " Interaction bla {}" + + "}", mManager.getTaskTree().getTaskMap()); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testManyInteractionsOnOneElement() + { + GUIElement element = new DummyGUIElement("elem1"); + simulateInteraction(element, new DummyInteraction("bla", 1)); + simulateInteraction(element, new DummyInteraction("bli", 1)); + simulateInteraction(element, new DummyInteraction("blo", 1)); + simulateInteraction(element, new DummyInteraction("blu", 1)); + simulateInteraction(element, new DummyInteraction("bla", 1)); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blo {}" + + " Interaction blu {}" + + " Interaction bla {}" + + "}", mManager.getTaskTree().getTaskMap()); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testOneInteractionOnManyElements() + { + GUIElement element1 = new DummyGUIElement("elem1"); + GUIElement element2 = new DummyGUIElement("elem2"); + GUIElement element3 = new DummyGUIElement("elem3"); + GUIElement element4 = new DummyGUIElement("elem4"); + GUIElement element5 = new DummyGUIElement("elem5"); + GUIElement element6 = new DummyGUIElement("elem6"); + simulateInteraction(element1, new DummyInteraction("bla", 1)); + simulateInteraction(element2, new DummyInteraction("bli", 1)); + simulateInteraction(element3, new DummyInteraction("bla", 1)); + simulateInteraction(element4, new DummyInteraction("bli", 1)); + simulateInteraction(element5, new DummyInteraction("blo", 1)); + simulateInteraction(element6, new DummyInteraction("bla", 1)); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Interaction bla {}" + + " }" + + " Sequence sequence2 {" + + " Interaction bli {}" + + " }" + + " Sequence sequence3 {" + + " Interaction bla {}" + + " }" + + " Sequence sequence4 {" + + " Interaction bli {}" + + " }" + + " Sequence sequence5 {" + + " Interaction blo {}" + + " }" + + " Sequence sequence6 {" + + " Interaction bla {}" + + " }" + + "}", mManager.getTaskTree().getTaskMap()); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testManyInteractionsOnManyElements() + { + GUIElement element1 = new DummyGUIElement("elem1"); + GUIElement element2 = new DummyGUIElement("elem2"); + GUIElement element3 = new DummyGUIElement("elem3"); + GUIElement element4 = new DummyGUIElement("elem4"); + GUIElement element5 = new DummyGUIElement("elem5"); + GUIElement element6 = new DummyGUIElement("elem6"); + simulateInteraction(element1, new DummyInteraction("bla", 1)); + simulateInteraction(element1, new DummyInteraction("bli", 1)); + simulateInteraction(element1, new DummyInteraction("bla", 1)); + simulateInteraction(element2, new DummyInteraction("bli", 1)); + simulateInteraction(element2, new DummyInteraction("blo", 1)); + simulateInteraction(element3, new DummyInteraction("bla", 1)); + simulateInteraction(element4, new DummyInteraction("bli", 1)); + simulateInteraction(element4, new DummyInteraction("bla", 1)); + simulateInteraction(element4, new DummyInteraction("bli", 1)); + simulateInteraction(element4, new DummyInteraction("blo", 1)); + simulateInteraction(element5, new DummyInteraction("bla", 1)); + simulateInteraction(element6, new DummyInteraction("bli", 1)); + simulateInteraction(element6, new DummyInteraction("bla", 1)); + simulateInteraction(element6, new DummyInteraction("bli", 1)); + simulateInteraction(element6, new DummyInteraction("blo", 1)); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction bla {}" + + " }" + + " Sequence sequence2 {" + + " Interaction bli {}" + + " Interaction blo {}" + + " }" + + " Sequence sequence3 {" + + " Interaction bla {}" + + " }" + + " Sequence sequence4 {" + + " Interaction bli {}" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blo {}" + + " }" + + " Sequence sequence5 {" + + " Interaction bla {}" + + " }" + + " Sequence sequence6 {" + + " Interaction bli {}" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blo {}" + + " }" + + "}", mManager.getTaskTree().getTaskMap()); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testInteractionIterationDetection() throws Exception + { + GUIElement element1 = new DummyGUIElement("elem1"); + Interaction interaction1 = new DummyInteraction("bla", 1); + simulateInteraction(element1, interaction1); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Interaction bla {}" + + "}", mManager.getTaskTree().getTaskMap()); + + simulateInteraction(element1, interaction1); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Interaction bla {}" + + " }" + + "}", mManager.getTaskTree().getTaskMap()); + + simulateInteraction(element1, interaction1); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Interaction bla {}" + + " }" + + "}", mManager.getTaskTree().getTaskMap()); + + for (int i = 0; i < 10; i++) + { + simulateInteraction(element1, interaction1); + } + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Interaction bla {}" + + " }" + + "}", mManager.getTaskTree().getTaskMap()); + + // now test with preceding and trailing other interactions + Interaction interaction2 = new DummyInteraction("bli", 1); + Interaction interaction3 = new DummyInteraction("blup", 1); + + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + for (int i = 0; i < 10; i++) + { + simulateInteraction(element1, interaction1); + } + simulateInteraction(element1, interaction3); + simulateInteraction(element1, interaction2); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Interaction bla {}" + + " }" + + " Interaction bli {}" + + " Interaction blup {}" + + " Iteration iteration2 {" + + " Interaction bla {}" + + " }" + + " Interaction blup {}" + + " Interaction bli {}" + + "}", mManager.getTaskTree().getTaskMap()); + + // now test with iterations of iterations + + for (int i = 0; i < 10; i++) + { + for (int j = 0; j < 5; j++) + { + simulateInteraction(element1, interaction1); + } + for (int j = 0; j < 5; j++) + { + simulateInteraction(element1, interaction2); + } + for (int j = 0; j < 5; j++) + { + simulateInteraction(element1, interaction3); + } + } + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Iteration iteration0 {" + + " Interaction bla {}" + + " }" + + " Interaction bli {}" + + " Interaction blup {}" + + " Iteration iteration1 {" + + " Interaction bla {}" + + " }" + + " Interaction blup {}" + + " Interaction bli {}" + + " Iteration iteration2 {" + + " Sequence sequence1 {" + + " Iteration iteration3 {" + + " Interaction bla {}" + + " }" + + " Iteration iteration4 {" + + " Interaction bli {}" + + " }" + + " Iteration iteration5 {" + + " Interaction blup {}" + + " }" + + " }" + + " }" + + "}", mManager.getTaskTree().getTaskMap()); + + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testSequenceIterationDetection() throws Exception + { + GUIElement element1 = new DummyGUIElement("elem1"); + Interaction interaction1 = new DummyInteraction("bla", 1); + Interaction interaction2 = new DummyInteraction("bli", 1); + Interaction interaction3 = new DummyInteraction("blup", 1); + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + "}", mManager.getTaskTree().getTaskMap()); + + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + "}", mManager.getTaskTree().getTaskMap()); + + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + "}", mManager.getTaskTree().getTaskMap()); + + for (int i = 0; i < 10; i++) + { + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + } + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + "}", mManager.getTaskTree().getTaskMap()); + + // now test with preceding and trailing other interactions + Interaction interaction4 = new DummyInteraction("ble", 1); + Interaction interaction5 = new DummyInteraction("blo", 1); + Interaction interaction6 = new DummyInteraction("blu", 1); + simulateInteraction(element1, interaction4); + simulateInteraction(element1, interaction5); + simulateInteraction(element1, interaction6); + for (int i = 0; i < 10; i++) + { + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + } + simulateInteraction(element1, interaction6); + simulateInteraction(element1, interaction5); + simulateInteraction(element1, interaction4); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + " Interaction ble {}" + + " Interaction blo {}" + + " Interaction blu {}" + + " Iteration iteration2 {" + + " Sequence sequence3 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + " Interaction blu {}" + + " Interaction blo {}" + + " Interaction ble {}" + + "}", mManager.getTaskTree().getTaskMap()); + + // now test with iterations of iterations + for (int i = 0; i < 10; i++) + { + for (int j = 0; j < 5; j++) + { + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + } + for (int j = 0; j < 5; j++) + { + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction3); + } + for (int j = 0; j < 5; j++) + { + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + } + } + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + " Interaction ble {}" + + " Interaction blo {}" + + " Interaction blu {}" + + " Iteration iteration2 {" + + " Sequence sequence3 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + " Interaction blu {}" + + " Interaction blo {}" + + " Interaction ble {}" + + " Iteration iteration3 {" + + " Sequence sequence4 {" + + " Iteration iteration4 {" + + " Sequence sequence4 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + " Iteration iteration5 {" + + " Sequence sequence5 {" + + " Interaction bli {}" + + " Interaction bla {}" + + " Interaction blup {}" + + " }" + + " }" + + " Iteration iteration6 {" + + " Sequence sequence6 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + " }" + + " }" + + "}", mManager.getTaskTree().getTaskMap()); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testGUIElementHierarchyChanges() throws Exception + { + GUIElement element1 = new DummyGUIElement("elem1"); + GUIElement element2 = new DummyGUIElement("elem2"); + GUIElement element3 = new DummyGUIElement("elem3"); + GUIElement parent1 = new DummyGUIElement("parent1"); + GUIElement parent2 = new DummyGUIElement("parent2"); + GUIElement parent3 = new DummyGUIElement("parent3"); + + element1.setParent(parent1); + element2.setParent(parent2); + element3.setParent(parent3); + + parent1.setParent(parent2); + parent2.setParent(parent3); + + Interaction interaction1 = new DummyInteraction("bla", 1); + simulateInteraction(element1, interaction1); + simulateInteraction(element2, interaction1); + simulateInteraction(element3, interaction1); + simulateInteraction(element2, interaction1); + simulateInteraction(element3, interaction1); + simulateInteraction(element2, interaction1); + simulateInteraction(element1, interaction1); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Interaction bla {}" + + " }" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " }" + + " Iteration iteration0 {" + + " Sequence sequence3 {" + + " Sequence sequence4 {" + + " Interaction bla {}" + + " }" + + " Sequence sequence5 {" + + " Interaction bla {}" + + " }" + + " }" + + " }" + + " Sequence sequence6 {" + + " Interaction bla {}" + + " }" + + "}", mManager.getTaskTree().getTaskMap()); + + } + + //----------------------------------------------------------------------------------------------- + /** + * @param interactionsDoNotOverwriteElement + */ + //----------------------------------------------------------------------------------------------- + private void simulateInteraction(GUIElement GUIElement, Interaction interaction) + { + mManager.handleNewInteractionEvent(new InteractionEvent(GUIElement, interaction)); + } + +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/AbstractTemporalRelationshipTC.java (revision 439) @@ -0,0 +1,101 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: AbstractTemporalRelationshipTC.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 28.04.2012 $ +// Project : TaskTreeTemporalRelationship +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Logger; + +import org.junit.Before; + +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; +import de.ugoe.cs.quest.tasktrees.temporalrelation.TemporalRelationshipRuleManager; +import de.ugoe.cs.quest.tasktrees.testutils.SimpleLogFormatter; +import de.ugoe.cs.quest.tasktrees.testutils.Utilities; +import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilderImpl; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactoryImpl; +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.userinteraction.Interaction; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 28.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class AbstractTemporalRelationshipTC +{ + + /** */ + private List mInteractions; + + /** */ + private TaskTreeBuilder mTaskTreeBuilder = new TaskTreeBuilderImpl(); + + /** */ + private TaskTreeNodeFactory mTaskTreeNodeFactory = new TaskTreeNodeFactoryImpl(); + + /** */ + private NodeEqualityRuleManager mNodeEqualityRuleManager = + Utilities.getNodeEqualityRuleManagerForTests(); + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Before + public void setUp() + { + Logger.getLogger("").getHandlers()[0].setFormatter(new SimpleLogFormatter()); + mInteractions = new ArrayList(); + } + + //----------------------------------------------------------------------------------------------- + /** + * @param interactionsDoNotOverwriteElement + */ + //----------------------------------------------------------------------------------------------- + protected void simulateInteraction(GUIElement GUIElement, Interaction interaction) + { + mInteractions.add + (mTaskTreeNodeFactory.createNewInteractionTask(GUIElement, interaction)); + } + + //----------------------------------------------------------------------------------------------- + /** + * @param interactionsDoNotOverwriteElement + * @return + */ + //----------------------------------------------------------------------------------------------- + protected TaskTree getTaskTree() + { + Sequence sequence = mTaskTreeNodeFactory.createNewSequence(); + + for (InteractionTask task : mInteractions) + { + mTaskTreeBuilder.addChild(sequence, task); + } + + TemporalRelationshipRuleManager ruleManager = + new TemporalRelationshipRuleManager(mNodeEqualityRuleManager); + + ruleManager.init(); + ruleManager.applyRules(sequence, mTaskTreeBuilder, mTaskTreeNodeFactory, true); + + return mTaskTreeNodeFactory.createTaskTree(sequence); + } + +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGUIElementSequenceDetectionRuleTest.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGUIElementSequenceDetectionRuleTest.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultGUIElementSequenceDetectionRuleTest.java (revision 439) @@ -0,0 +1,232 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TaskTreeManagerTest.java,v $ +// Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 08.11.2011 21:32:36 $ +// Project : TaskTreePerformanceTest +// Creation : 2011 by Patrick +// Copyright : Patrick Harms, 2011 +//------------------------------------------------------------------------------------------------- + +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import org.junit.Test; + +import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; +import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; +import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.userinteraction.Interaction; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +//------------------------------------------------------------------------------------------------- +public class DefaultGUIElementSequenceDetectionRuleTest extends AbstractTemporalRelationshipTC +{ + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testOneInteractionOnOneElement() + { + simulateInteraction(new DummyGUIElement("elem1"), new DummyInteraction("bla", 1)); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence {" + + " Interaction bla {}" + + "}", getTaskTree().getTaskMap()); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testManyInteractionsOnOneElement() + { + GUIElement element = new DummyGUIElement("elem1"); + simulateInteraction(element, new DummyInteraction("bla", 1)); + simulateInteraction(element, new DummyInteraction("bli", 1)); + simulateInteraction(element, new DummyInteraction("blo", 1)); + simulateInteraction(element, new DummyInteraction("blu", 1)); + simulateInteraction(element, new DummyInteraction("bla", 1)); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blo {}" + + " Interaction blu {}" + + " Interaction bla {}" + + "}", getTaskTree().getTaskMap()); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testOneInteractionOnManyElements() + { + GUIElement element1 = new DummyGUIElement("elem1"); + GUIElement element2 = new DummyGUIElement("elem2"); + GUIElement element3 = new DummyGUIElement("elem3"); + GUIElement element4 = new DummyGUIElement("elem4"); + GUIElement element5 = new DummyGUIElement("elem5"); + GUIElement element6 = new DummyGUIElement("elem6"); + simulateInteraction(element1, new DummyInteraction("bla", 1)); + simulateInteraction(element2, new DummyInteraction("bli", 1)); + simulateInteraction(element3, new DummyInteraction("bla", 1)); + simulateInteraction(element4, new DummyInteraction("bli", 1)); + simulateInteraction(element5, new DummyInteraction("blo", 1)); + simulateInteraction(element6, new DummyInteraction("bla", 1)); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Interaction bla {}" + + " }" + + " Sequence sequence2 {" + + " Interaction bli {}" + + " }" + + " Sequence sequence3 {" + + " Interaction bla {}" + + " }" + + " Sequence sequence4 {" + + " Interaction bli {}" + + " }" + + " Sequence sequence5 {" + + " Interaction blo {}" + + " }" + + " Sequence sequence6 {" + + " Interaction bla {}" + + " }" + + "}", getTaskTree().getTaskMap()); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testManyInteractionsOnManyElements() + { + GUIElement element1 = new DummyGUIElement("elem1"); + GUIElement element2 = new DummyGUIElement("elem2"); + GUIElement element3 = new DummyGUIElement("elem3"); + GUIElement element4 = new DummyGUIElement("elem4"); + GUIElement element5 = new DummyGUIElement("elem5"); + GUIElement element6 = new DummyGUIElement("elem6"); + simulateInteraction(element1, new DummyInteraction("bla", 1)); + simulateInteraction(element1, new DummyInteraction("bli", 1)); + simulateInteraction(element1, new DummyInteraction("bla", 1)); + simulateInteraction(element2, new DummyInteraction("bli", 1)); + simulateInteraction(element2, new DummyInteraction("blo", 1)); + simulateInteraction(element3, new DummyInteraction("bla", 1)); + simulateInteraction(element4, new DummyInteraction("bli", 1)); + simulateInteraction(element4, new DummyInteraction("bla", 1)); + simulateInteraction(element4, new DummyInteraction("bli", 1)); + simulateInteraction(element4, new DummyInteraction("blo", 1)); + simulateInteraction(element5, new DummyInteraction("bla", 1)); + simulateInteraction(element6, new DummyInteraction("bli", 1)); + simulateInteraction(element6, new DummyInteraction("bla", 1)); + simulateInteraction(element6, new DummyInteraction("bli", 1)); + simulateInteraction(element6, new DummyInteraction("blo", 1)); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction bla {}" + + " }" + + " Sequence sequence2 {" + + " Interaction bli {}" + + " Interaction blo {}" + + " }" + + " Sequence sequence3 {" + + " Interaction bla {}" + + " }" + + " Sequence sequence4 {" + + " Interaction bli {}" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blo {}" + + " }" + + " Sequence sequence5 {" + + " Interaction bla {}" + + " }" + + " Sequence sequence6 {" + + " Interaction bli {}" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blo {}" + + " }" + + "}", getTaskTree().getTaskMap()); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testGUIElementHierarchyChanges() throws Exception + { + GUIElement element1 = new DummyGUIElement("elem1"); + GUIElement element2 = new DummyGUIElement("elem2"); + GUIElement element3 = new DummyGUIElement("elem3"); + GUIElement parent1 = new DummyGUIElement("parent1"); + GUIElement parent2 = new DummyGUIElement("parent2"); + GUIElement parent3 = new DummyGUIElement("parent3"); + + element1.setParent(parent1); + element2.setParent(parent2); + element3.setParent(parent3); + + parent1.setParent(parent2); + parent2.setParent(parent3); + + Interaction interaction1 = new DummyInteraction("bla", 1); + simulateInteraction(element1, interaction1); + simulateInteraction(element2, interaction1); + simulateInteraction(element3, interaction1); + simulateInteraction(element2, interaction1); + simulateInteraction(element3, interaction1); + simulateInteraction(element2, interaction1); + simulateInteraction(element1, interaction1); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Interaction bla {}" + + " }" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " }" + + " Iteration iteration0 {" + + " Sequence sequence3 {" + + " Sequence sequence4 {" + + " Interaction bla {}" + + " }" + + " Sequence sequence5 {" + + " Interaction bla {}" + + " }" + + " }" + + " }" + + " Sequence sequence6 {" + + " Interaction bla {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + } + +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultIterationDetectionRuleTest.java (revision 439) @@ -0,0 +1,329 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: DefaultIterationDetectionRuleTest.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 28.04.2012 $ +// Project : TaskTreeTemporalRelationship +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import org.junit.Test; + +import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; +import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; +import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.userinteraction.Interaction; + +//------------------------------------------------------------------------------------------------- +/** + * 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 + { + GUIElement element1 = new DummyGUIElement("elem1"); + Interaction interaction1 = new DummyInteraction("bla", 1); + simulateInteraction(element1, interaction1); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Interaction bla {}" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, interaction1); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Interaction bla {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, interaction1); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Interaction bla {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + for (int i = 0; i < 10; i++) + { + simulateInteraction(element1, interaction1); + } + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Interaction bla {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + // now test with preceding and trailing other interactions + Interaction interaction2 = new DummyInteraction("bli", 1); + Interaction interaction3 = new DummyInteraction("blup", 1); + + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + for (int i = 0; i < 10; i++) + { + simulateInteraction(element1, interaction1); + } + simulateInteraction(element1, interaction3); + simulateInteraction(element1, interaction2); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Interaction bla {}" + + " }" + + " Interaction bli {}" + + " Interaction blup {}" + + " Iteration iteration2 {" + + " Interaction bla {}" + + " }" + + " Interaction blup {}" + + " Interaction bli {}" + + "}", getTaskTree().getTaskMap()); + + // now test with iterations of iterations + + for (int i = 0; i < 10; i++) + { + for (int j = 0; j < 5; j++) + { + simulateInteraction(element1, interaction1); + } + for (int j = 0; j < 5; j++) + { + simulateInteraction(element1, interaction2); + } + for (int j = 0; j < 5; j++) + { + simulateInteraction(element1, interaction3); + } + } + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Interaction bla {}" + + " }" + + " Interaction bli {}" + + " Interaction blup {}" + + " Iteration iteration2 {" + + " Interaction bla {}" + + " }" + + " Interaction blup {}" + + " Interaction bli {}" + + " Iteration iteration3 {" + + " Sequence sequence2 {" + + " Iteration iteration4 {" + + " Interaction bla {}" + + " }" + + " Iteration iteration5 {" + + " Interaction bli {}" + + " }" + + " Iteration iteration6 {" + + " Interaction blup {}" + + " }" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testSequenceIterationDetection() throws Exception + { + GUIElement element1 = new DummyGUIElement("elem1"); + Interaction interaction1 = new DummyInteraction("bla", 1); + Interaction interaction2 = new DummyInteraction("bli", 1); + Interaction interaction3 = new DummyInteraction("blup", 1); + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + + for (int i = 0; i < 10; i++) + { + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + } + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + + // now test with preceding and trailing other interactions + Interaction interaction4 = new DummyInteraction("ble", 1); + Interaction interaction5 = new DummyInteraction("blo", 1); + Interaction interaction6 = new DummyInteraction("blu", 1); + simulateInteraction(element1, interaction4); + simulateInteraction(element1, interaction5); + simulateInteraction(element1, interaction6); + for (int i = 0; i < 10; i++) + { + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + } + simulateInteraction(element1, interaction6); + simulateInteraction(element1, interaction5); + simulateInteraction(element1, interaction4); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + " Interaction ble {}" + + " Interaction blo {}" + + " Interaction blu {}" + + " Iteration iteration2 {" + + " Sequence sequence3 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + " Interaction blu {}" + + " Interaction blo {}" + + " Interaction ble {}" + + "}", getTaskTree().getTaskMap()); + + // now test with iterations of iterations + for (int i = 0; i < 10; i++) + { + for (int j = 0; j < 5; j++) + { + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + } + for (int j = 0; j < 5; j++) + { + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction3); + } + for (int j = 0; j < 5; j++) + { + simulateInteraction(element1, interaction1); + simulateInteraction(element1, interaction2); + simulateInteraction(element1, interaction3); + } + } + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration iteration1 {" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + " Interaction ble {}" + + " Interaction blo {}" + + " Interaction blu {}" + + " Iteration iteration2 {" + + " Sequence sequence3 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + " Interaction blu {}" + + " Interaction blo {}" + + " Interaction ble {}" + + " Iteration iteration3 {" + + " Sequence sequence4 {" + + " Iteration iteration4 {" + + " Sequence sequence4 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + " Iteration iteration5 {" + + " Sequence sequence5 {" + + " Interaction bli {}" + + " Interaction bla {}" + + " Interaction blup {}" + + " }" + + " }" + + " Iteration iteration6 {" + + " Sequence sequence6 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction blup {}" + + " }" + + " }" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + } + +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultMouseClickReductionRuleTest.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultMouseClickReductionRuleTest.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultMouseClickReductionRuleTest.java (revision 439) @@ -0,0 +1,174 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TaskTreeManagerTest.java,v $ +// Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 08.11.2011 21:32:36 $ +// Project : TaskTreePerformanceTest +// Creation : 2011 by Patrick +// Copyright : Patrick Harms, 2011 +//------------------------------------------------------------------------------------------------- + +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import org.junit.Test; + +import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; +import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; +import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.userinteraction.MouseButtonDown; +import de.ugoe.cs.tasktree.userinteraction.MouseButtonInteraction; +import de.ugoe.cs.tasktree.userinteraction.MouseButtonUp; +import de.ugoe.cs.tasktree.userinteraction.MouseClick; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +//------------------------------------------------------------------------------------------------- +public class DefaultMouseClickReductionRuleTest extends AbstractTemporalRelationshipTC +{ + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testMouseClickInOneSequenceElement() + { + MouseButtonInteraction.Button leftBtn = MouseButtonInteraction.Button.LEFT; + MouseButtonInteraction.Button middleBtn = MouseButtonInteraction.Button.MIDDLE; + MouseButtonInteraction.Button rightBtn = MouseButtonInteraction.Button.RIGHT; + + GUIElement element1 = new DummyGUIElement("elem1"); + GUIElement element2 = new DummyGUIElement("elem1"); + + simulateInteraction(element1, new MouseButtonDown(leftBtn)); + simulateInteraction(element1, new MouseButtonUp(leftBtn)); + simulateInteraction(element1, new MouseClick(leftBtn)); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence {" + + " Interaction LeftMouseClick {}" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, new DummyInteraction("bla", 1)); + simulateInteraction(element1, new DummyInteraction("bli", 1)); + simulateInteraction(element1, new MouseButtonDown(middleBtn)); + simulateInteraction(element1, new MouseButtonUp(middleBtn)); + simulateInteraction(element1, new MouseClick(middleBtn)); + simulateInteraction(element1, new DummyInteraction("blo", 1)); + simulateInteraction(element1, new DummyInteraction("blu", 1)); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence {" + + " Interaction LeftMouseClick {}" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction MiddleMouseClick {}" + + " Interaction blo {}" + + " Interaction blu {}" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element2, new DummyInteraction("bla", 1)); + simulateInteraction(element2, new DummyInteraction("bli", 1)); + simulateInteraction(element2, new MouseButtonDown(rightBtn)); + simulateInteraction(element2, new MouseButtonUp(rightBtn)); + simulateInteraction(element2, new MouseClick(rightBtn)); + simulateInteraction(element2, new DummyInteraction("blo", 1)); + simulateInteraction(element2, new DummyInteraction("blu", 1)); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Interaction LeftMouseClick {}" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction MiddleMouseClick {}" + + " Interaction blo {}" + + " Interaction blu {}" + + " }" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction RightMouseClick {}" + + " Interaction blo {}" + + " Interaction blu {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, new MouseButtonDown(leftBtn)); + simulateInteraction(element1, new MouseButtonUp(leftBtn)); + simulateInteraction(element2, new MouseClick(leftBtn)); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Interaction LeftMouseClick {}" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction MiddleMouseClick {}" + + " Interaction blo {}" + + " Interaction blu {}" + + " }" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction RightMouseClick {}" + + " Interaction blo {}" + + " Interaction blu {}" + + " }" + + " Sequence sequence3 {" + + " Interaction LeftMouseButtonDown {}" + + " Interaction LeftMouseButtonUp {}" + + " }" + + " Sequence sequence4 {" + + " Interaction LeftMouseClick {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, new MouseButtonDown(middleBtn)); + simulateInteraction(element1, new MouseButtonUp(middleBtn)); + simulateInteraction(element1, new MouseClick(rightBtn)); + simulateInteraction(element2, new DummyInteraction("bla", 1)); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " Interaction LeftMouseClick {}" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction MiddleMouseClick {}" + + " Interaction blo {}" + + " Interaction blu {}" + + " }" + + " Sequence sequence2 {" + + " Interaction bla {}" + + " Interaction bli {}" + + " Interaction RightMouseClick {}" + + " Interaction blo {}" + + " Interaction blu {}" + + " }" + + " Sequence sequence3 {" + + " Interaction LeftMouseButtonDown {}" + + " Interaction LeftMouseButtonUp {}" + + " }" + + " Sequence sequence4 {" + + " Interaction LeftMouseClick {}" + + " }" + + " Sequence sequence5 {" + + " Sequence sequence6 {" + + " Interaction MiddleMouseButtonDown {}" + + " Interaction MiddleMouseButtonUp {}" + + " }" + + " Interaction RightMouseClick {}" + + " }" + + " Sequence sequence7 {" + + " Interaction bla {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + } + +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultTextInputReductionRuleTest.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultTextInputReductionRuleTest.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/DefaultTextInputReductionRuleTest.java (revision 439) @@ -0,0 +1,411 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: DefaultIterationDetectionRuleTest.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 28.04.2012 $ +// Project : TaskTreeTemporalRelationship +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import org.junit.Test; + +import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; +import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.guimodel.TextField; +import de.ugoe.cs.tasktree.keyboardmaps.VirtualKey; +import de.ugoe.cs.tasktree.userinteraction.KeyPressed; +import de.ugoe.cs.tasktree.userinteraction.KeyReleased; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 28.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class DefaultTextInputReductionRuleTest extends AbstractTemporalRelationshipTC +{ + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testSimpleTextEntry() + { + GUIElement element1 = new DummyTextField("elem1"); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_A)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_A)); + new TaskTreeChecker(true).assertTaskMap + ("Sequence sequence0 {" + + " TextInputInteraction TextInput a {" + + " Interaction KeyPressed LETTER_A {}" + + " Interaction KeyReleased LETTER_A {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_B)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_B)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " TextInputInteraction TextInput ab {" + + " Interaction KeyPressed LETTER_A {}" + + " Interaction KeyReleased LETTER_A {}" + + " Interaction KeyPressed LETTER_B {}" + + " Interaction KeyReleased LETTER_B {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_C)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_C)); + simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " TextInputInteraction TextInput abC {" + + " Interaction KeyPressed LETTER_A {}" + + " Interaction KeyReleased LETTER_A {}" + + " Interaction KeyPressed LETTER_B {}" + + " Interaction KeyReleased LETTER_B {}" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed LETTER_C {}" + + " Interaction KeyReleased LETTER_C {}" + + " Interaction KeyReleased SHIFT {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_D)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_D)); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_E)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_E)); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_F)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_F)); + simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " TextInputInteraction TextInput abCDEF {" + + " Interaction KeyPressed LETTER_A {}" + + " Interaction KeyReleased LETTER_A {}" + + " Interaction KeyPressed LETTER_B {}" + + " Interaction KeyReleased LETTER_B {}" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed LETTER_C {}" + + " Interaction KeyReleased LETTER_C {}" + + " Interaction KeyReleased SHIFT {}" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed LETTER_D {}" + + " Interaction KeyReleased LETTER_D {}" + + " Interaction KeyPressed LETTER_E {}" + + " Interaction KeyReleased LETTER_E {}" + + " Interaction KeyPressed LETTER_F {}" + + " Interaction KeyReleased LETTER_F {}" + + " Interaction KeyReleased SHIFT {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + + simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); + simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_G)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_G)); + simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); + simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " TextInputInteraction TextInput abCDEFg {" + + " Interaction KeyPressed LETTER_A {}" + + " Interaction KeyReleased LETTER_A {}" + + " Interaction KeyPressed LETTER_B {}" + + " Interaction KeyReleased LETTER_B {}" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed LETTER_C {}" + + " Interaction KeyReleased LETTER_C {}" + + " Interaction KeyReleased SHIFT {}" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed LETTER_D {}" + + " Interaction KeyReleased LETTER_D {}" + + " Interaction KeyPressed LETTER_E {}" + + " Interaction KeyReleased LETTER_E {}" + + " Interaction KeyPressed LETTER_F {}" + + " Interaction KeyReleased LETTER_F {}" + + " Interaction KeyReleased SHIFT {}" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed LETTER_G {}" + + " Interaction KeyReleased LETTER_G {}" + + " Interaction KeyReleased SHIFT {}" + + " Interaction KeyReleased SHIFT {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testTextEntryOnDifferentGuiElements() + { + GUIElement element1 = new DummyTextField("elem1"); + GUIElement element2 = new DummyTextField("elem2"); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_A)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_A)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " TextInputInteraction TextInput a {" + + " Interaction KeyPressed LETTER_A {}" + + " Interaction KeyReleased LETTER_A {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element2, new KeyPressed(VirtualKey.LETTER_B)); + simulateInteraction(element2, new KeyReleased(VirtualKey.LETTER_B)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " TextInputInteraction TextInput a {" + + " Interaction KeyPressed LETTER_A {}" + + " Interaction KeyReleased LETTER_A {}" + + " }" + + " }" + + " Sequence sequence2 {" + + " TextInputInteraction TextInput b {" + + " Interaction KeyPressed LETTER_B {}" + + " Interaction KeyReleased LETTER_B {}" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_C)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_C)); + simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " TextInputInteraction TextInput a {" + + " Interaction KeyPressed LETTER_A {}" + + " Interaction KeyReleased LETTER_A {}" + + " }" + + " }" + + " Sequence sequence2 {" + + " TextInputInteraction TextInput b {" + + " Interaction KeyPressed LETTER_B {}" + + " Interaction KeyReleased LETTER_B {}" + + " }" + + " }" + + " Sequence sequence3 {" + + " TextInputInteraction TextInput C {" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed LETTER_C {}" + + " Interaction KeyReleased LETTER_C {}" + + " Interaction KeyReleased SHIFT {}" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element2, new KeyPressed(VirtualKey.SHIFT)); + simulateInteraction(element2, new KeyPressed(VirtualKey.LETTER_D)); + simulateInteraction(element2, new KeyReleased(VirtualKey.LETTER_D)); + simulateInteraction(element2, new KeyPressed(VirtualKey.LETTER_E)); + simulateInteraction(element2, new KeyReleased(VirtualKey.LETTER_E)); + simulateInteraction(element2, new KeyPressed(VirtualKey.LETTER_F)); + simulateInteraction(element2, new KeyReleased(VirtualKey.LETTER_F)); + simulateInteraction(element2, new KeyReleased(VirtualKey.SHIFT)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " TextInputInteraction TextInput a {" + + " Interaction KeyPressed LETTER_A {}" + + " Interaction KeyReleased LETTER_A {}" + + " }" + + " }" + + " Sequence sequence2 {" + + " TextInputInteraction TextInput b {" + + " Interaction KeyPressed LETTER_B {}" + + " Interaction KeyReleased LETTER_B {}" + + " }" + + " }" + + " Sequence sequence3 {" + + " TextInputInteraction TextInput C {" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed LETTER_C {}" + + " Interaction KeyReleased LETTER_C {}" + + " Interaction KeyReleased SHIFT {}" + + " }" + + " }" + + " Sequence sequence4 {" + + " TextInputInteraction TextInput DEF {" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed LETTER_D {}" + + " Interaction KeyReleased LETTER_D {}" + + " Interaction KeyPressed LETTER_E {}" + + " Interaction KeyReleased LETTER_E {}" + + " Interaction KeyPressed LETTER_F {}" + + " Interaction KeyReleased LETTER_F {}" + + " Interaction KeyReleased SHIFT {}" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + + + simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); + simulateInteraction(element1, new KeyPressed(VirtualKey.SHIFT)); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_G)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_G)); + simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); + simulateInteraction(element1, new KeyReleased(VirtualKey.SHIFT)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " Sequence sequence1 {" + + " TextInputInteraction TextInput a {" + + " Interaction KeyPressed LETTER_A {}" + + " Interaction KeyReleased LETTER_A {}" + + " }" + + " }" + + " Sequence sequence2 {" + + " TextInputInteraction TextInput b {" + + " Interaction KeyPressed LETTER_B {}" + + " Interaction KeyReleased LETTER_B {}" + + " }" + + " }" + + " Sequence sequence3 {" + + " TextInputInteraction TextInput C {" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed LETTER_C {}" + + " Interaction KeyReleased LETTER_C {}" + + " Interaction KeyReleased SHIFT {}" + + " }" + + " }" + + " Sequence sequence4 {" + + " TextInputInteraction TextInput DEF {" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed LETTER_D {}" + + " Interaction KeyReleased LETTER_D {}" + + " Interaction KeyPressed LETTER_E {}" + + " Interaction KeyReleased LETTER_E {}" + + " Interaction KeyPressed LETTER_F {}" + + " Interaction KeyReleased LETTER_F {}" + + " Interaction KeyReleased SHIFT {}" + + " }" + + " }" + + " Sequence sequence5 {" + + " TextInputInteraction TextInput g {" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed SHIFT {}" + + " Interaction KeyPressed LETTER_G {}" + + " Interaction KeyReleased LETTER_G {}" + + " Interaction KeyReleased SHIFT {}" + + " Interaction KeyReleased SHIFT {}" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testUsageOfBackspace() + { + GUIElement element1 = new DummyTextField("elem1"); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_A)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_A)); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_B)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_B)); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_C)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_C)); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_D)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_D)); + simulateInteraction(element1, new KeyPressed(VirtualKey.BACK_SPACE)); + simulateInteraction(element1, new KeyReleased(VirtualKey.BACK_SPACE)); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_E)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_E)); + simulateInteraction(element1, new KeyPressed(VirtualKey.LETTER_F)); + simulateInteraction(element1, new KeyReleased(VirtualKey.LETTER_F)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " TextInputInteraction TextInput abcef {" + + " Interaction KeyPressed LETTER_A {}" + + " Interaction KeyReleased LETTER_A {}" + + " Interaction KeyPressed LETTER_B {}" + + " Interaction KeyReleased LETTER_B {}" + + " Interaction KeyPressed LETTER_C {}" + + " Interaction KeyReleased LETTER_C {}" + + " Interaction KeyPressed LETTER_D {}" + + " Interaction KeyReleased LETTER_D {}" + + " Interaction KeyPressed BACK_SPACE {}" + + " Interaction KeyReleased BACK_SPACE {}" + + " Interaction KeyPressed LETTER_E {}" + + " Interaction KeyReleased LETTER_E {}" + + " Interaction KeyPressed LETTER_F {}" + + " Interaction KeyReleased LETTER_F {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, new KeyPressed(VirtualKey.BACK_SPACE)); + simulateInteraction(element1, new KeyReleased(VirtualKey.BACK_SPACE)); + simulateInteraction(element1, new KeyPressed(VirtualKey.BACK_SPACE)); + simulateInteraction(element1, new KeyReleased(VirtualKey.BACK_SPACE)); + simulateInteraction(element1, new KeyPressed(VirtualKey.BACK_SPACE)); + simulateInteraction(element1, new KeyReleased(VirtualKey.BACK_SPACE)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence0 {" + + " TextInputInteraction TextInput ab {" + + " Interaction KeyPressed LETTER_A {}" + + " Interaction KeyReleased LETTER_A {}" + + " Interaction KeyPressed LETTER_B {}" + + " Interaction KeyReleased LETTER_B {}" + + " Interaction KeyPressed LETTER_C {}" + + " Interaction KeyReleased LETTER_C {}" + + " Interaction KeyPressed LETTER_D {}" + + " Interaction KeyReleased LETTER_D {}" + + " Interaction KeyPressed BACK_SPACE {}" + + " Interaction KeyReleased BACK_SPACE {}" + + " Interaction KeyPressed LETTER_E {}" + + " Interaction KeyReleased LETTER_E {}" + + " Interaction KeyPressed LETTER_F {}" + + " Interaction KeyReleased LETTER_F {}" + + " Interaction KeyPressed BACK_SPACE {}" + + " Interaction KeyReleased BACK_SPACE {}" + + " Interaction KeyPressed BACK_SPACE {}" + + " Interaction KeyReleased BACK_SPACE {}" + + " Interaction KeyPressed BACK_SPACE {}" + + " Interaction KeyReleased BACK_SPACE {}" + + " }" + + "}", getTaskTree().getTaskMap()); + + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + private static class DummyTextField extends DummyGUIElement implements TextField + { + + //--------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param name + */ + //--------------------------------------------------------------------------------------------- + public DummyTextField(String name) + { + super(name); + } + + } + +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/temporalrelation/TrackBarSelectionDetectionRuleTest.java (revision 439) @@ -0,0 +1,180 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: DefaultIterationDetectionRuleTest.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 28.04.2012 $ +// Project : TaskTreeTemporalRelationship +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.temporalrelation; + +import org.junit.Test; + +import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; +import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; +import de.ugoe.cs.quest.tasktrees.testutils.TaskTreeChecker; +import de.ugoe.cs.tasktree.guimodel.GUIElement; +import de.ugoe.cs.tasktree.guimodel.TrackBar; +import de.ugoe.cs.tasktree.userinteraction.ValueSelection; + +//------------------------------------------------------------------------------------------------- +/** + * 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 + { + GUIElement element1 = new DummyTrackBar(); + simulateInteraction(element1, new ValueSelection(1)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Interaction ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, new ValueSelection(2)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Interaction ValueSelection {}" + + " Interaction ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, new ValueSelection(3)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Interaction ValueSelection {}" + + " Interaction ValueSelection {}" + + " Interaction ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, new ValueSelection(2)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Interaction ValueSelection {}" + + " Interaction ValueSelection {}" + + " Interaction ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + + simulateInteraction(element1, new ValueSelection(3)); + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Interaction ValueSelection {}" + + " Interaction ValueSelection {}" + + " Interaction ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testComplexDetection() throws Exception + { + GUIElement element1 = new DummyTrackBar(); + simulateInteraction(element1, new ValueSelection(1)); + simulateInteraction(element1, new ValueSelection(2)); + simulateInteraction(element1, new ValueSelection(3)); + simulateInteraction(element1, new ValueSelection(1)); + simulateInteraction(element1, new DummyInteraction("bla", 1)); + simulateInteraction(element1, new DummyInteraction("bla", 2)); + simulateInteraction(element1, new ValueSelection(2)); + simulateInteraction(element1, new ValueSelection(1)); + simulateInteraction(element1, new DummyInteraction("bla", 3)); + simulateInteraction(element1, new ValueSelection(3)); + simulateInteraction(element1, new ValueSelection(2)); + simulateInteraction(element1, new ValueSelection(3)); + simulateInteraction(element1, new DummyInteraction("bla", 1)); + simulateInteraction(element1, new DummyInteraction("bla", 2)); + simulateInteraction(element1, new ValueSelection(1)); + simulateInteraction(element1, new ValueSelection(1)); + + new TaskTreeChecker().assertTaskMap + ("Sequence sequence1 {" + + " Iteration interation1 {" + + " Selection selection1 {" + + " Interaction ValueSelection {}" + + " Interaction ValueSelection {}" + + " Interaction ValueSelection {}" + + " }" + + " }" + + " Interaction bla {}" + + " Interaction bla {}" + + " Iteration interation2 {" + + " Selection selection2 {" + + " Interaction ValueSelection {}" + + " Interaction ValueSelection {}" + + " }" + + " }" + + " Interaction bla {}" + + " Iteration interation3 {" + + " Selection selection3 {" + + " Interaction ValueSelection {}" + + " Interaction ValueSelection {}" + + " }" + + " }" + + " Interaction bla {}" + + " Interaction bla {}" + + " Iteration interation4 {" + + " Selection selection4 {" + + " Interaction ValueSelection {}" + + " }" + + " }" + + "}", getTaskTree().getTaskMap()); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO comment + * + * @version $Revision: $ $Date: 28.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ + //----------------------------------------------------------------------------------------------- + public class DummyTrackBar extends DummyGUIElement implements TrackBar + { + + //--------------------------------------------------------------------------------------------- + /** + * + */ + //--------------------------------------------------------------------------------------------- + public DummyTrackBar() + { + super("DummyTrackBar"); + } + } + +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyGUIElement.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyGUIElement.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyGUIElement.java (revision 439) @@ -0,0 +1,59 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: DummyGUIElement.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 02.04.2012 $ +// Project : TaskTreeTestUtils +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.testutils; + +import de.ugoe.cs.tasktree.guimodel.AbstractDefaultGUIElement; +import de.ugoe.cs.tasktree.guimodel.GUIElement; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 02.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class DummyGUIElement extends AbstractDefaultGUIElement + implements GUIElement +{ + /** */ + private String mName; + + //--------------------------------------------------------------------------------------------- + /** + * + */ + //--------------------------------------------------------------------------------------------- + public DummyGUIElement(String name) + { + super(); + mName = name; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + //----------------------------------------------------------------------------------------------- + @Override + public String toString() + { + return mName; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.harms.attef.userinteraction.GUIElement#equals(GUIElement) + */ + //----------------------------------------------------------------------------------------------- + public boolean equals(GUIElement other) + { + return this == other; + } + +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyInteraction.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyInteraction.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyInteraction.java (revision 439) @@ -0,0 +1,102 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: DummyInteraction.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 02.04.2012 $ +// Project : TaskTreeTestUtils +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.testutils; + +import de.ugoe.cs.tasktree.userinteraction.Interaction; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 02.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class DummyInteraction implements Interaction +{ + /** */ + private int mInteractionNumber; + + /** */ + private String mInteractionType; + + //----------------------------------------------------------------------------------------------- + /** + * @param interactionNumber + * @param interactionType + */ + //----------------------------------------------------------------------------------------------- + public DummyInteraction(String interactionType, int interactionNumber) + { + super(); + mInteractionNumber = interactionNumber; + mInteractionType = interactionType; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see de.harms.attef.userinteraction.Interaction#getName() + */ + //----------------------------------------------------------------------------------------------- + public String getName() + { + return mInteractionType; + } + + //----------------------------------------------------------------------------------------------- + /* (non-Javadoc) + * @see java.lang.Object#toString() + */ + //----------------------------------------------------------------------------------------------- + @Override + public String toString() + { + return mInteractionType; + } + + //----------------------------------------------------------------------------------------------- + /* (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; + } + + //----------------------------------------------------------------------------------------------- + /** + * @return the interactionType + */ + //----------------------------------------------------------------------------------------------- + public String getInteractionType() + { + return mInteractionType; + } + + //----------------------------------------------------------------------------------------------- + /** + * @return the interactionNumber + */ + //----------------------------------------------------------------------------------------------- + public int getInteractionNumber() + { + return mInteractionNumber; + } + +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyTextField.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyTextField.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/DummyTextField.java (revision 439) @@ -0,0 +1,34 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: DummyGUIElement.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 02.04.2012 $ +// Project : TaskTreeTestUtils +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.testutils; + +import de.ugoe.cs.tasktree.guimodel.TextField; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 02.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class DummyTextField extends DummyGUIElement + implements TextField +{ + + //--------------------------------------------------------------------------------------------- + /** + * + */ + //--------------------------------------------------------------------------------------------- + public DummyTextField(String name) + { + super("text field \"" + name + "\""); + } + +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/SimpleLogFormatter.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/SimpleLogFormatter.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/SimpleLogFormatter.java (revision 439) @@ -0,0 +1,89 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TestLogger.java,v $ +// Version : $Revision: 0.0 $ $Author: Patrick $ $Date: 26.11.2011 15:26:38 $ +// Project : TaskTreePerformanceTest +// Creation : 2011 by Patrick +// Copyright : Patrick Harms, 2011 +//------------------------------------------------------------------------------------------------- + +package de.ugoe.cs.quest.tasktrees.testutils; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.PrintStream; +import java.text.SimpleDateFormat; +import java.util.logging.Formatter; +import java.util.logging.LogRecord; + + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ +//------------------------------------------------------------------------------------------------- + +public class SimpleLogFormatter extends Formatter +{ + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Override + public String format(LogRecord record) + { + StringBuffer result = new StringBuffer(); + result.append(record.getLevel().getName().charAt(0)); + result.append(" | "); + result.append(new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss,SSS").format(record.getMillis())); + result.append(" | "); + tailValue("" + record.getThreadID(), 6, result); + result.append(" | "); + tailValue(record.getLoggerName(), 30, result); + result.append(" | "); + result.append(record.getMessage()); + + if (record.getThrown() != null) + { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + record.getThrown().printStackTrace(new PrintStream(out)); + result.append("\n"); + result.append(out.toString()); + try + { + out.close(); + } + catch (IOException e) + { + // ignore + } + } + + result.append("\n"); + + return result.toString(); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + private void tailValue(String value, int length, StringBuffer output) + { + for (int i = value.length() - length - 1; i < value.length(); i++) + { + if (i < 0) + { + output.append(" "); + } + else + { + output.append(value.charAt(i)); + } + } + } +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/TaskTreeChecker.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/TaskTreeChecker.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/TaskTreeChecker.java (revision 439) @@ -0,0 +1,573 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TaskTreeChecker.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 01.04.2012 $ +// Project : TestUtils +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.testutils; + +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; +import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; +import de.ugoe.cs.quest.tasktrees.treeifc.NodeInfo; +import de.ugoe.cs.quest.tasktrees.treeifc.Selection; +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TextInputInteractionTask; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 01.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class TaskTreeChecker +{ + /** */ + private boolean mDoTrace; + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + public TaskTreeChecker() + { + this(false); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + public TaskTreeChecker(boolean doTrace) + { + mDoTrace = doTrace; + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + public void assertTaskMap(String taskTreeSpec, Map taskMap) + { + Map taskMapCopy = new HashMap(); + + for (Map.Entry entry : taskMap.entrySet()) + { + if (entry.getValue().getNoOfOccurencesInTree() > 0) + { + taskMapCopy.put(entry.getKey(), entry.getValue().getNoOfOccurencesInTree()); + } + else + { + taskMapCopy.put(entry.getKey(), 1); + } + } + + if (mDoTrace) + { + dumpTaskMap(taskMapCopy); + } + + TaskSpec task = null; + + Matcher matcher = + Pattern.compile("(\\s*(\\w+)\\s+(\\w+)\\s+((\\w*\\s)*)(\\{))|((\\}))").matcher(taskTreeSpec); + + do + { + if (!matcher.find()) + { + if (!matcher.hitEnd()) + { + throw new IllegalArgumentException("could not parse task specification"); + } + else + { + break; + } + } + + task = parseTask(matcher); + if (task != null) + { + assertTaskAndChildrenInMapAndRemove(task, taskMapCopy); + } + } + while (task != null); + + assertTrue("more tasks in map, than expected", taskMapCopy.isEmpty()); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param taskTree + */ + //----------------------------------------------------------------------------------------------- + public void dumpAsCheckString(TaskTree taskTree) + { + dumpNodeAsCheckString(taskTree.getRoot(), new int[4], ""); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param root + * @param string + */ + //----------------------------------------------------------------------------------------------- + private void dumpNodeAsCheckString(TaskTreeNode node, + int[] typeCounters, + String indent) + { + System.err.print(" \""); + System.err.print(indent); + + if (node instanceof Sequence) + { + System.err.print("Sequence sequence"); + System.err.print(typeCounters[0]++); + System.err.println(" {\" +"); + } + else if (node instanceof Iteration) + { + System.err.print("Iteration iteration"); + System.err.print(typeCounters[1]++); + System.err.println(" {\" +"); + } + else if (node instanceof Selection) + { + System.err.print("Selection selection"); + System.err.print(typeCounters[2]++); + System.err.println(" {\" +"); + } + else if (node instanceof TextInputInteractionTask) + { + System.err.print("TextInputInteraction textInput"); + System.err.print(typeCounters[3]++); + System.err.print(" "); + System.err.print(((TextInputInteractionTask) node).getEnteredText()); + System.err.println(" {\" +"); + } + else if (node instanceof InteractionTask) + { + System.err.print("Interaction "); + System.err.print(((InteractionTask) node).getInteraction().getName()); + System.err.print(" {}\" +"); + } + else + { + fail("unknown type of node in task tree " + node); + } + + for (TaskTreeNode child : node.getChildren()) + { + dumpNodeAsCheckString(child, typeCounters, indent + " "); + } + + if (!(node instanceof InteractionTask) || + (node instanceof TextInputInteractionTask)) + { + System.err.print(" \""); + System.err.print(indent); + System.err.print("}\" +"); + } + + System.err.println(); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param taskTree + */ + //----------------------------------------------------------------------------------------------- + public void dumpFullTaskTree(TaskTree taskTree) throws FileNotFoundException + { + PrintWriter out = null; + try + { + out = new PrintWriter(new FileOutputStream("taskTree.txt")); + dumpFullNode(taskTree.getRoot(), out, ""); + } + finally + { + if (out != null) + { + out.close(); + } + } + + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + private void dumpFullNode(TaskTreeNode node, PrintWriter out, String indent) + { + out.print(indent); + if (node instanceof Sequence) + { + out.println("Sequence"); + out.print(indent); + out.println("{"); + } + else if (node instanceof Iteration) + { + out.println("Iteration"); + out.print(indent); + out.println("{"); + } + else if (node instanceof Selection) + { + out.println("Selection"); + out.print(indent); + out.println("{"); + } + else if (node instanceof TextInputInteractionTask) + { + out.print("TextInputInteraction"); + out.print(" "); + out.println(((TextInputInteractionTask) node).getEnteredText()); + out.print(indent); + out.println("{"); + } + else if (node instanceof InteractionTask) + { + out.print(((InteractionTask) node).getInteraction().getName()); + out.print(" "); + out.print(((InteractionTask) node).getGUIElement()); + out.print(" "); + out.print(((InteractionTask) node).getGUIElement().getOriginalTypeInfo()); + } + else + { + fail("unknown type of node in task tree " + node); + } + + for (TaskTreeNode child : node.getChildren()) + { + dumpFullNode(child, out, indent + " "); + } + + if (!(node instanceof InteractionTask) || + (node instanceof TextInputInteractionTask)) + { + out.print(indent); + out.print("}"); + } + + out.println(); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + private TaskSpec parseTask(Matcher tokenMatcher) + { + String firstToken = tokenMatcher.group(); + + if ("}".equals(firstToken)) + { + throw new IllegalArgumentException("found a closing bracket at an unexpected place"); + } + + TaskSpec task = new TaskSpec(); + task.type = tokenMatcher.group(2); + task.interactionName = tokenMatcher.group(3); + task.additionalInfo = tokenMatcher.group(4).trim(); + + if ("".equals(task.interactionName)) + { + task.interactionName = null; + } + + if (!tokenMatcher.find()) + { + throw new IllegalArgumentException("could not parse task specification"); + } + + firstToken = tokenMatcher.group(); + + if (!"}".equals(firstToken)) + { + ArrayList children = new ArrayList(); + + TaskSpec child = null; + + do + { + child = parseTask(tokenMatcher); + + if (child != null) + { + children.add(child); + + if (!tokenMatcher.find()) + { + throw new IllegalArgumentException("could not parse task specification"); + } + + firstToken = tokenMatcher.group(); + + if ("}".equals(firstToken)) + { + break; + } + } + + } + while (child != null); + + task.children = children.toArray(new TaskSpec[children.size()]); + } + + return task; + } + + //----------------------------------------------------------------------------------------------- + /** + * @param task + * @param taskMapCopy + */ + //----------------------------------------------------------------------------------------------- + private void assertTaskAndChildrenInMapAndRemove(TaskSpec task, + Map taskMap) + { + for (Map.Entry entry : taskMap.entrySet()) + { + if (taskSpecEqualsTask(task, entry.getKey())) + { + if (task.children != null) + { + for (TaskSpec child : task.children) + { + assertTaskAndChildrenInMapAndRemove(child, taskMap); + } + } + + int count = taskMap.get(entry.getKey()); + if (count == 1) + { + taskMap.remove(entry.getKey()); + } + else + { + taskMap.put(entry.getKey(), count - 1); + } + return; + } + } + + fail("expected task " + task.type + " " + task.interactionName + " not included in task map"); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + private boolean taskSpecEqualsTask(TaskSpec taskSpec, TaskTreeNode task) + { + if (mDoTrace) + { + System.err.println("comparing " + taskSpec.interactionName + " with"); + dumpTask(task, 0, ""); + } + + if (("Interaction".equals(taskSpec.type) && (!(task instanceof InteractionTask))) || + ("TextInputInteraction".equals(taskSpec.type) && + (!(task instanceof TextInputInteractionTask))) || + ("Sequence".equals(taskSpec.type) && (!(task instanceof Sequence))) || + ("Selection".equals(taskSpec.type) && (!(task instanceof Selection))) || + ("Iteration".equals(taskSpec.type) && (!(task instanceof Iteration)))) + { + if (mDoTrace) + { + System.err.println("task types do not match: " + taskSpec.type + " != " + + task.getClass().getSimpleName() + "\n"); + } + return false; + } + else if (!"Interaction".equals(taskSpec.type) && + !"TextInputInteraction".equals(taskSpec.type) && + !"Sequence".equals(taskSpec.type) && + !"Selection".equals(taskSpec.type) && + !"Iteration".equals(taskSpec.type)) + { + fail("unknown task type " + taskSpec.type + " --> please extend test case"); + } + + if ("TextInputInteraction".equals(taskSpec.type)) + { + if (!"".equals(taskSpec.additionalInfo) && + !(taskSpec.additionalInfo.equals(((TextInputInteractionTask) task).getEnteredText()))) + { + if (mDoTrace) + { + System.err.println + ("expected text \"" + taskSpec.additionalInfo + "\" is not equal to the text " + + "provided by the task \"" + ((TextInputInteractionTask) task).getEnteredText() + + "\"\n"); + } + return false; + } + } + else if ((task instanceof InteractionTask) && + (((InteractionTask) task).getInteraction() != null) && + (!taskSpec.interactionName.equals(((InteractionTask) task).getInteraction().getName()))) + { + // simple interaction names do not match. But what about the interaction name in combination + // with the additional info + String complexInteractionName = taskSpec.interactionName + + (!"".equals(taskSpec.additionalInfo) ? " " + taskSpec.additionalInfo : ""); + + if (!complexInteractionName.equals(((InteractionTask) task).getInteraction().getName())) + { + if (mDoTrace) + { + System.err.println("interaction names do not match: " + taskSpec.interactionName + + " != " + ((InteractionTask) task).getInteraction().getName() + "\n"); + } + return false; + } + } + + if (((taskSpec.children == null) && (task.getChildren().size() > 0)) || + ((taskSpec.children != null) && (taskSpec.children.length != task.getChildren().size()))) + { + if (mDoTrace) + { + System.err.println("numbers of children do not match: " + + (taskSpec.children == null ? "0" : taskSpec.children.length) + " != " + + (task.getChildren() == null ? "0" : task.getChildren().size()) + "\n"); + } + return false; + } + + Iterator children = task.getChildren().iterator(); + if (taskSpec.children != null) + { + for (TaskSpec child : taskSpec.children) + { + if (!taskSpecEqualsTask(child, children.next())) + { + if (mDoTrace) + { + System.err.println("one of the children does not match\n"); + } + return false; + } + } + } + + if (!children.hasNext()) + { + if (mDoTrace) + { + System.err.println("nodes match\n"); + } + return true; + } + else + { + if (mDoTrace) + { + System.err.println("number of children does not match\n"); + } + return false; + } + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + private void dumpTaskMap(Map taskMap) + { + System.err.println(); + for (Map.Entry entry : taskMap.entrySet()) + { + dumpTask(entry.getKey(), entry.getValue(), ""); + System.err.println(); + } + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + private void dumpTask(TaskTreeNode task, int count, String indent) + { + System.err.print(indent); + System.err.print(task); + System.err.print(" "); + System.err.print(task.getDescription()); + System.err.print(" "); + + if (count > 0) + { + System.err.print("("); + System.err.print(count); + System.err.print(" occurrences)"); + } + + System.err.println(); + + if ((task.getChildren() != null) && (task.getChildren().size() > 0)) + { + for (TaskTreeNode child : task.getChildren()) + { + dumpTask(child, 0, indent + " "); + } + } + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO comment + * + * @version $Revision: $ $Date: $ + * @author 2011, last modified by $Author: $ + */ + //----------------------------------------------------------------------------------------------- + private class TaskSpec + { + public String type; + public String interactionName; + public String additionalInfo; + public TaskSpec[] children; + } + +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/Utilities.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/Utilities.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/testutils/Utilities.java (revision 439) @@ -0,0 +1,43 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TestUtils.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 02.04.2012 $ +// Project : TaskTreeTestUtils +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.testutils; + +import de.ugoe.cs.quest.tasktrees.nodeequality.NodeEqualityRuleManager; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 02.04.2012$ + * @author 2012, last modified by $Author: patrick$ + */ +//------------------------------------------------------------------------------------------------- +public class Utilities +{ + /** */ + private static final NodeEqualityRuleManager NODE_EQUALITY_RULE_MANAGER = + new NodeEqualityRuleManager(); + + static + { + NODE_EQUALITY_RULE_MANAGER.init(); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @return + */ + //----------------------------------------------------------------------------------------------- + public static NodeEqualityRuleManager getNodeEqualityRuleManagerForTests() + { + return NODE_EQUALITY_RULE_MANAGER; + } + +} Index: /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeImplTest.java =================================================================== --- /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeImplTest.java (revision 439) +++ /trunk/quest-core-tasktrees/src/test/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeImplTest.java (revision 439) @@ -0,0 +1,549 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TaskTreeImplTest.java,v $ +// Version : $Revision: 0.0 $ $Author: patrick $ $Date: 02.04.2012 $ +// Project : TaskTreeImpl +// Creation : 2012 by patrick +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.tasktrees.treeimpl; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import java.util.HashMap; +import java.util.Map; + +import org.junit.Test; + +import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; +import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; +import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; +import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; +import de.ugoe.cs.quest.tasktrees.treeifc.NodeInfo; +import de.ugoe.cs.quest.tasktrees.treeifc.Selection; +import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeimpl.NodeInfoImpl; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilderImpl; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactoryImpl; + +//------------------------------------------------------------------------------------------------- +/** + * 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 TaskTreeBuilder mTaskTreeBuilder = new TaskTreeBuilderImpl(); + + /** */ + private TaskTreeNodeFactory mTaskTreeNodeFactory = new TaskTreeNodeFactoryImpl(); + + //----------------------------------------------------------------------------------------------- + /** + * @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(); + TaskTreeNode rootNode = createTree(noOfMaxChildren, maxDepth, treeInfos); + System.err.println(" creating task tree"); + TaskTree taskTree = mTaskTreeNodeFactory.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()) + { + NodeInfo 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 TaskTreeNode createTree(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + /*for (int i = 0; i < (MAX_TREE_DEPTH + 1 - maxDepth); i++) + { + System.err.print(" "); + }*/ + + TaskTreeNode 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 interaction 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 interaction task "); + tree = createNewInteractionTask(treeInfos); + break; + } + case 1: + { + //System.err.print("reusing interaction task "); + tree = reuseInteractionTask(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 interaction task per default "); + tree = createNewInteractionTask(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 InteractionTask createNewInteractionTask(Map treeInfos) + throws Exception + { + Thread.sleep(2); + long id = System.currentTimeMillis(); + InteractionTask task = mTaskTreeNodeFactory.createNewInteractionTask + (new DummyGUIElement("elem" + id), new DummyInteraction("interaction" + id, 1)); + + treeInfos.put(task, new NodeInfoImpl(task)); + + return task; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + //----------------------------------------------------------------------------------------------- + private InteractionTask reuseInteractionTask(Map treeInfos) + throws Exception + { + int noOfInteractionTasks = 0; + + for (Map.Entry entry : treeInfos.entrySet()) + { + if (entry.getKey() instanceof InteractionTask) + { + noOfInteractionTasks++; + } + } + + if (noOfInteractionTasks > 0) + { + noOfInteractionTasks = (int) (Math.random() * noOfInteractionTasks); + + for (Map.Entry entry : treeInfos.entrySet()) + { + if (entry.getKey() instanceof InteractionTask) + { + if (--noOfInteractionTasks <= 0) + { + return (InteractionTask) entry.getKey(); + } + } + } + } + else + { + return createNewInteractionTask(treeInfos); + } + + throw new RuntimeException("this is an implementation error"); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + //----------------------------------------------------------------------------------------------- + private Sequence createNewSequence(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + Sequence sequence = mTaskTreeNodeFactory.createNewSequence(); + + int noOfChildren = (int) (Math.random() * maxNoOfChildren); + + for (int i = 0; i < noOfChildren; i++) + { + TaskTreeNode 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 + ((NodeInfoImpl) treeInfos.get(child)).removeParent(sequence); + ((NodeInfoImpl) treeInfos.get(child)).addParent(sequence); + mTaskTreeBuilder.addChild(sequence, child); + } + + treeInfos.put(sequence, new NodeInfoImpl(sequence)); + return sequence; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + //----------------------------------------------------------------------------------------------- + private Sequence reuseSequence(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + int noOfSequences = 0; + + for (Map.Entry entry : treeInfos.entrySet()) + { + if (entry.getKey() instanceof Sequence) + { + noOfSequences++; + } + } + + if (noOfSequences > 0) + { + noOfSequences = (int) (Math.random() * noOfSequences); + + for (Map.Entry entry : treeInfos.entrySet()) + { + if (entry.getKey() instanceof Sequence) + { + if (--noOfSequences <= 0) + { + return (Sequence) entry.getKey(); + } + } + } + } + else + { + return createNewSequence(maxNoOfChildren, maxDepth, treeInfos); + } + + throw new RuntimeException("this is an implementation error"); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + //----------------------------------------------------------------------------------------------- + private Selection createNewSelection(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + Selection selection = mTaskTreeNodeFactory.createNewSelection(); + + int noOfChildren = (int) (Math.random() * maxNoOfChildren); + + for (int i = 0; i < noOfChildren; i++) + { + TaskTreeNode 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 + ((NodeInfoImpl) treeInfos.get(child)).removeParent(selection); + ((NodeInfoImpl) treeInfos.get(child)).addParent(selection); + mTaskTreeBuilder.addChild(selection, child); + } + + treeInfos.put(selection, new NodeInfoImpl(selection)); + return selection; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + //----------------------------------------------------------------------------------------------- + private Selection reuseSelection(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + int noOfSelections = 0; + + for (Map.Entry entry : treeInfos.entrySet()) + { + if (entry.getKey() instanceof Selection) + { + noOfSelections++; + } + } + + if (noOfSelections > 0) + { + noOfSelections = (int) (Math.random() * noOfSelections); + + for (Map.Entry entry : treeInfos.entrySet()) + { + if (entry.getKey() instanceof Selection) + { + if (--noOfSelections <= 0) + { + return (Selection) entry.getKey(); + } + } + } + } + else + { + return createNewSelection(maxNoOfChildren, maxDepth, treeInfos); + } + + throw new RuntimeException("this is an implementation error"); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + //----------------------------------------------------------------------------------------------- + private Iteration createNewIteration(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + Iteration iteration = mTaskTreeNodeFactory.createNewIteration(); + + TaskTreeNode 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 + ((NodeInfoImpl) treeInfos.get(child)).removeParent(iteration); + ((NodeInfoImpl) treeInfos.get(child)).addParent(iteration); + mTaskTreeBuilder.setChild(iteration, child); + + treeInfos.put(iteration, new NodeInfoImpl(iteration)); + return iteration; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param treeInfos + * @return + */ + //----------------------------------------------------------------------------------------------- + private Iteration reuseIteration(int maxNoOfChildren, + int maxDepth, + Map treeInfos) + throws Exception + { + int noOfIterations = 0; + + for (Map.Entry entry : treeInfos.entrySet()) + { + if (entry.getKey() instanceof Iteration) + { + noOfIterations++; + } + } + + if (noOfIterations > 0) + { + noOfIterations = (int) (Math.random() * noOfIterations); + + for (Map.Entry entry : treeInfos.entrySet()) + { + if (entry.getKey() instanceof Iteration) + { + if (--noOfIterations <= 0) + { + return (Iteration) entry.getKey(); + } + } + } + } + else + { + return createNewIteration(maxNoOfChildren, maxDepth, treeInfos); + } + + throw new RuntimeException("this is an implementation error"); + } + +}