Index: trunk/quest-core-usability-test/pom.xml =================================================================== --- trunk/quest-core-usability-test/pom.xml (revision 474) +++ trunk/quest-core-usability-test/pom.xml (revision 474) @@ -0,0 +1,135 @@ + + 4.0.0 + de.ugoe.cs.quest + quest-core-usability-test + 0.0.1-SNAPSHOT + quest-core-usability-test + + https://quest.informatik.uni-goettingen.de/svn/quest/trunk/quest-core-usability-test + + + + de.ugoe.cs.quest + quest-core-usability + 0.0.1-SNAPSHOT + test + + + de.ugoe.cs.quest + quest-core-tasktrees-test + 0.0.1-SNAPSHOT + test-jar + test + + + junit + junit + 4.8.1 + test + + + + + + + org.eclipse.m2e + lifecycle-mapping + 1.0.0 + + + + + + org.apache.maven.plugins + maven-dependency-plugin + [1.0.0,) + + unpack + + + + + + + + + org.codehaus.mojo + emma-maven-plugin + [1.0-alpha-3,) + + emma + + + + + + + + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 2.3.2 + + 1.6 + 1.6 + + + + org.apache.maven.plugins + maven-dependency-plugin + 2.4 + + + unpack + process-classes + + unpack + + + + + de.ugoe.cs.quest + quest-core-tasktrees + 0.0.1-SNAPSHOT + ${project.build.directory}/classes + + + + + + + + org.codehaus.mojo + emma-maven-plugin + 1.0-alpha-3 + true + + + process-classes + + emma + + + + + + org.apache.maven.plugins + maven-jar-plugin + 2.3.2 + + + + test-jar + + + + + + + Index: trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/AbstractUsabilityEvaluationTC.java =================================================================== --- trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/AbstractUsabilityEvaluationTC.java (revision 474) +++ trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/AbstractUsabilityEvaluationTC.java (revision 474) @@ -0,0 +1,263 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: AbstractUsabilityEvaluationTC.java,v $ +// Version : $Revision: 0.0 $ $Author: pharms $ $Date: 18.07.2012 $ +// Project : UsabilityEvaluationManager +// Creation : 2012 by pharms +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.usability; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; + +import java.util.logging.Logger; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import org.junit.Before; + +import de.ugoe.cs.quest.tasktrees.testutils.DummyGUIElement; +import de.ugoe.cs.quest.tasktrees.testutils.DummyInteraction; +import de.ugoe.cs.quest.tasktrees.testutils.DummyTextField; +import de.ugoe.cs.quest.tasktrees.testutils.SimpleLogFormatter; +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.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.quest.tasktrees.treeimpl.TaskTreeBuilderImpl; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactoryImpl; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 18.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +//------------------------------------------------------------------------------------------------- +public class AbstractUsabilityEvaluationTC +{ + + /** */ + private TaskTreeBuilder mTaskTreeBuilder = new TaskTreeBuilderImpl(); + + /** */ + private TaskTreeNodeFactory mTaskTreeNodeFactory = new TaskTreeNodeFactoryImpl(); + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + @Before + public void setUp() + { + Logger.getLogger("").getHandlers()[0].setFormatter(new SimpleLogFormatter()); + } + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + protected TaskTree createTaskTree(String spec) + { + Matcher matcher = + Pattern.compile("(\\s*(\\w+)\\s*(\\(((\\w*\\s*)*)\\))?\\s*(\\{))|(\\})").matcher(spec); + + if (!matcher.find()) + { + if (!matcher.hitEnd()) + { + throw new IllegalArgumentException("could not parse task specification"); + } + } + + return mTaskTreeNodeFactory.createTaskTree(parseTask(matcher, new int[1])); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param expectedDefects + * @param evaluateUsability + */ + //----------------------------------------------------------------------------------------------- + protected void assertUsabilityEvaluationResult(UsabilityDefect[] expectedDefects, + UsabilityEvaluationResult evaluationResult) + { + assertEquals(expectedDefects.length, evaluationResult.getAllDefects().size()); + + EXPECTED_DEFECT_ITERATION: + for (UsabilityDefect expectedDefect : expectedDefects) + { + for (UsabilityDefect defect : evaluationResult.getAllDefects()) + { + if (expectedDefect.equals(defect)) + { + System.err.println(defect.getParameterizedDescription()); + continue EXPECTED_DEFECT_ITERATION; + } + } + + for (UsabilityDefect defect : evaluationResult.getAllDefects()) + { + System.err.println(defect); + } + + fail("expected defect " + expectedDefect + " not found in evaluation result"); + } + } + + + //----------------------------------------------------------------------------------------------- + /** + * + */ + //----------------------------------------------------------------------------------------------- + private TaskTreeNode parseTask(Matcher tokenMatcher, int[] typeNumbers) + { + String firstToken = tokenMatcher.group(); + + if ("}".equals(firstToken)) + { + throw new IllegalArgumentException("found a closing bracket at an unexpected place"); + } + + TaskTreeNode treeNode = instantiateTreeNode(tokenMatcher, typeNumbers); + + if (!tokenMatcher.find()) + { + throw new IllegalArgumentException("could not parse task specification"); + } + + firstToken = tokenMatcher.group(); + + if (!"}".equals(firstToken)) + { + TaskTreeNode child = null; + + do + { + child = parseTask(tokenMatcher, typeNumbers); + + if (child != null) + { + addChild(treeNode, child); + + if (!tokenMatcher.find()) + { + throw new IllegalArgumentException("could not parse task specification"); + } + + firstToken = tokenMatcher.group(); + + if ("}".equals(firstToken)) + { + break; + } + } + + } + while (child != null); + + } + + return treeNode; + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param group + * @return + */ + //----------------------------------------------------------------------------------------------- + private TaskTreeNode instantiateTreeNode(Matcher tokenMatcher, int[] typeNumbers) + { + String type = tokenMatcher.group(2); + String additionalInfo = tokenMatcher.group(4); + + if ("Interaction".equals(type)) + { + return mTaskTreeNodeFactory.createNewInteractionTask + (new DummyGUIElement("dummy"), new DummyInteraction("dummy", typeNumbers[0]++)); + } + else if ("Sequence".equals(type)) + { + return mTaskTreeNodeFactory.createNewSequence(); + } + else if ("Iteration".equals(type)) + { + return mTaskTreeNodeFactory.createNewIteration(); + } + else if ("Selection".equals(type)) + { + return mTaskTreeNodeFactory.createNewSelection(); + } + else if ("TextInput".equals(type)) + { + if (additionalInfo == null) + { + fail("no simulated text provided for text input interactin task"); + } + + TextInputInteractionTask task = + mTaskTreeNodeFactory.createNewTextInputInteractionTask(new DummyTextField(additionalInfo)); + + task.setEnteredText(additionalInfo); + return task; + } + else + { + fail("invalid type of task tree node: " + type); + return null; + } + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + * @param treeNode + * @param child + */ + //----------------------------------------------------------------------------------------------- + private void addChild(TaskTreeNode parent, TaskTreeNode child) + { + if (parent instanceof Sequence) + { + mTaskTreeBuilder.addChild((Sequence) parent, child); + } + else if (parent instanceof Iteration) + { + if (parent.getChildren().size() <= 0) + { + mTaskTreeBuilder.setChild((Iteration) parent, child); + } + else + { + fail("can not add more than one child to an iteration"); + } + } + else if (parent instanceof Selection) + { + mTaskTreeBuilder.addChild((Selection) parent, child); + } + else if (parent instanceof TextInputInteractionTask) + { + mTaskTreeBuilder.addChild((TextInputInteractionTask) parent, child); + } + else + { + fail("can not add children to parent task tree node of type " + parent.getClass().getName()); + } + } + +} Index: trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/TextInputStatisticsRuleTest.java =================================================================== --- trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/TextInputStatisticsRuleTest.java (revision 474) +++ trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/TextInputStatisticsRuleTest.java (revision 474) @@ -0,0 +1,649 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: TextInputStatisticsRuleTest.java,v $ +// Version : $Revision: 0.0 $ $Author: pharms $ $Date: 18.07.2012 $ +// Project : UsabilityEvaluationManager +// Creation : 2012 by pharms +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.usability; + +import org.junit.Test; + +import de.ugoe.cs.quest.usability.UsabilityDefect; +import de.ugoe.cs.quest.usability.UsabilityDefectDescription; +import de.ugoe.cs.quest.usability.UsabilityDefectSeverity; +import de.ugoe.cs.quest.usability.UsabilityEvaluationManager; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 18.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +//------------------------------------------------------------------------------------------------- +public class TextInputStatisticsRuleTest extends AbstractUsabilityEvaluationTC +{ + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testWithDifferentTextInputInteractionsOnly() + { + UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); + + String spec = "TextInput (bla) {}"; + UsabilityDefect[] expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Sequence {" + + " TextInput (bla) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Selection {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Iteration {" + + " TextInput (bla) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Sequence {" + + " TextInput (a) {}" + + " Sequence {" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " TextInput (e) {}" + + " }" + + " Iteration {" + + " TextInput (f) {}" + + " }" + + " TextInput (g) {}" + + " Selection {" + + " TextInput (h) {}" + + " TextInput (i) {}" + + " TextInput (j) {}" + + " TextInput (k) {}" + + " }" + + " Sequence {" + + " TextInput (l) {}" + + " Sequence {" + + " TextInput (m) {}" + + " TextInput (n) {}" + + " TextInput (o) {}" + + " TextInput (p) {}" + + " }" + + " Iteration {" + + " TextInput (q) {}" + + " }" + + " TextInput (r) {}" + + " Selection {" + + " TextInput (s) {}" + + " TextInput (t) {}" + + " TextInput (u) {}" + + " TextInput (v) {}" + + " }" + + " }" + + " Selection {" + + " TextInput (w) {}" + + " Sequence {" + + " TextInput (x) {}" + + " TextInput (y) {}" + + " TextInput (z) {}" + + " TextInput (aa) {}" + + " }" + + " Iteration {" + + " TextInput (ab) {}" + + " }" + + " TextInput (ac) {}" + + " Selection {" + + " TextInput (ad) {}" + + " TextInput (ae) {}" + + " TextInput (af) {}" + + " TextInput (ag) {}" + + " }" + + " }" + + " TextInput (ah) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testCombinationsOfTextInputInteractionsAndOtherInteractions() + { + UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); + + String spec = + "Sequence {" + + " Interaction {}" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " Interaction {}" + + " TextInput (c) {}" + + "}"; + + UsabilityDefect[] expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.INFO, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Sequence {" + + " Interaction {}" + + " TextInput (a) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (c) {}" + + "}"; + + expectedDefects = new UsabilityDefect[0]; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Selection {" + + " Interaction {}" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " Interaction {}" + + " TextInput (c) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.INFO, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Sequence {" + + " TextInput (a) {}" + + " Sequence {" + + " Interaction {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " Interaction {}" + + " TextInput (d) {}" + + " }" + + " Iteration {" + + " TextInput (e) {}" + + " }" + + " Interaction {}" + + " Selection {" + + " Interaction {}" + + " TextInput (f) {}" + + " TextInput (g) {}" + + " Interaction {}" + + " TextInput (h) {}" + + " TextInput (i) {}" + + " }" + + " Sequence {" + + " TextInput (j) {}" + + " Sequence {" + + " TextInput (k) {}" + + " Interaction {}" + + " TextInput (l) {}" + + " TextInput (m) {}" + + " Interaction {}" + + " TextInput (n) {}" + + " TextInput (o) {}" + + " }" + + " Iteration {" + + " Interaction {}" + + " }" + + " Interaction {}" + + " Selection {" + + " TextInput (p) {}" + + " TextInput (q) {}" + + " TextInput (r) {}" + + " Interaction {}" + + " TextInput (s) {}" + + " TextInput (t) {}" + + " Interaction {}" + + " TextInput (u) {}" + + " TextInput (v) {}" + + " }" + + " }" + + " Selection {" + + " Interaction {}" + + " Sequence {" + + " TextInput (w) {}" + + " Interaction {}" + + " TextInput (x) {}" + + " TextInput (y) {}" + + " Interaction {}" + + " }" + + " Iteration {" + + " TextInput (z) {}" + + " }" + + " TextInput (aa) {}" + + " Selection {" + + " TextInput (ab) {}" + + " Interaction {}" + + " TextInput (ac) {}" + + " TextInput (ad) {}" + + " Interaction {}" + + " TextInput (ae) {}" + + " }" + + " }" + + " Interaction {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.INFO, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Sequence {" + + " TextInput (a) {}" + + " Sequence {" + + " Interaction {}" + + " TextInput (b) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (c) {}" + + " }" + + " Iteration {" + + " TextInput (d) {}" + + " }" + + " Interaction {}" + + " Selection {" + + " Interaction {}" + + " TextInput (e) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (g) {}" + + " Interaction {}" + + " }" + + " Sequence {" + + " TextInput (i) {}" + + " Sequence {" + + " TextInput (j) {}" + + " Interaction {}" + + " TextInput (k) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (m) {}" + + " Interaction {}" + + " }" + + " Iteration {" + + " Interaction {}" + + " }" + + " Interaction {}" + + " Selection {" + + " TextInput (o) {}" + + " Interaction {}" + + " Interaction {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (s) {}" + + " Interaction {}" + + " TextInput (t) {}" + + " TextInput (u) {}" + + " }" + + " }" + + " Selection {" + + " Interaction {}" + + " Sequence {" + + " TextInput (v) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (x) {}" + + " Interaction {}" + + " }" + + " Iteration {" + + " TextInput (y) {}" + + " }" + + " TextInput (z) {}" + + " Selection {" + + " TextInput (aa) {}" + + " Interaction {}" + + " TextInput (ab) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (ad) {}" + + " }" + + " }" + + " Interaction {}" + + "}"; + + expectedDefects = new UsabilityDefect[0]; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + } + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testTextEntryRepetitions() + { + UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); + + String spec = + "Sequence {" + + " TextInput (a b c) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (a) {}" + + " }" + + " Iteration {" + + " TextInput (a) {}" + + " }" + + " TextInput (a) {}" + + " Selection {" + + " TextInput (b c) {}" + + " TextInput (a) {}" + + " TextInput (a c) {}" + + " TextInput (b a) {}" + + " }" + + " Sequence {" + + " TextInput (b c) {}" + + " Sequence {" + + " TextInput (d a c) {}" + + " TextInput (b b b a) {}" + + " TextInput (a a c c) {}" + + " TextInput (b b a) {}" + + " }" + + " }" + + " TextInput (d) {}" + + "}"; + + UsabilityDefect[] expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Sequence {" + + " TextInput (a b c d e f g h i j k l m) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " }" + + " Iteration {" + + " TextInput (e) {}" + + " }" + + " TextInput (f) {}" + + " Selection {" + + " TextInput (g) {}" + + " TextInput (h) {}" + + " TextInput (i) {}" + + " TextInput (j) {}" + + " }" + + " Sequence {" + + " TextInput (k) {}" + + " Sequence {" + + " TextInput (l) {}" + + " TextInput (m) {}" + + " TextInput (n) {}" + + " TextInput (o) {}" + + " }" + + " }" + + " TextInput (p) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Sequence {" + + " TextInput (a b c d e f g h i j k l m) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " }" + + " Iteration {" + + " TextInput (e) {}" + + " }" + + " TextInput (a) {}" + + " Selection {" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " TextInput (e) {}" + + " }" + + " Sequence {" + + " TextInput (a) {}" + + " Sequence {" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " TextInput (e) {}" + + " }" + + " }" + + " TextInput (f) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect + (UsabilityDefectSeverity.MEDIUM, UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Sequence {" + + " TextInput (a b c d e f g h i j k l m) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (a) {}" + + " }" + + " Iteration {" + + " TextInput (b) {}" + + " }" + + " TextInput (c) {}" + + " Selection {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (a) {}" + + " }" + + " Sequence {" + + " TextInput (b) {}" + + " Sequence {" + + " TextInput (c) {}" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " }" + + " }" + + " TextInput (a) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect + (UsabilityDefectSeverity.MEDIUM, UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Sequence {" + + " TextInput (a b c) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " }" + + "}"; + + expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect + (UsabilityDefectSeverity.LOW, UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Sequence {" + + " TextInput (a b c) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " }" + + "}"; + + expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect + (UsabilityDefectSeverity.LOW, UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + spec = + "Sequence {" + + " TextInput (a b c) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (d) {}" + + " TextInput (e) {}" + + " }" + + "}"; + + expectedDefects = new UsabilityDefect[] + { + new UsabilityDefect + (UsabilityDefectSeverity.HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect + (UsabilityDefectSeverity.INFO, UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS) + }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + } + +} Index: trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/UsabilityDefectDescriptionTest.java =================================================================== --- trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/UsabilityDefectDescriptionTest.java (revision 474) +++ trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/UsabilityDefectDescriptionTest.java (revision 474) @@ -0,0 +1,45 @@ +//------------------------------------------------------------------------------------------------- +// Module : $RCSfile: UsabilityDefectDescriptionTest.java,v $ +// Version : $Revision: 0.0 $ $Author: pharms $ $Date: 20.07.2012 $ +// Project : UsabilityEvaluationManager +// Creation : 2012 by pharms +// Copyright : Patrick Harms, 2012 +//------------------------------------------------------------------------------------------------- +package de.ugoe.cs.quest.usability; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import de.ugoe.cs.quest.usability.UsabilityDefectDescription; + +//------------------------------------------------------------------------------------------------- +/** + * TODO comment + * + * @version $Revision: $ $Date: 20.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +//------------------------------------------------------------------------------------------------- +public class UsabilityDefectDescriptionTest +{ + + //----------------------------------------------------------------------------------------------- + /** + * TODO: comment + * + */ + //----------------------------------------------------------------------------------------------- + @Test + public void testInitialization() + { + assertNotNull(UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO.toString()); + assertNotSame("", UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO.toString()); + System.err.println(UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO); + + assertNotNull(UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS.toString()); + assertNotSame("", UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS.toString()); + System.err.println(UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS); + } + +}