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 497) +++ trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/AbstractUsabilityEvaluationTC.java (revision 561) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: AbstractUsabilityEvaluationTC.java,v $ // Version : $Revision: 0.0 $ $Author: pharms $ $Date: 18.07.2012 $ @@ -5,5 +4,6 @@ // Creation : 2012 by pharms // Copyright : Patrick Harms, 2012 -//------------------------------------------------------------------------------------------------- + + package de.ugoe.cs.quest.usability; @@ -21,16 +21,15 @@ 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; - -//------------------------------------------------------------------------------------------------- +import de.ugoe.cs.quest.tasktrees.treeifc.IIteration; +import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; +import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; +import de.ugoe.cs.quest.tasktrees.treeifc.ITextInputEventTask; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; + /** * TODO comment @@ -39,225 +38,179 @@ * @author 2012, last modified by $Author: pharms$ */ -//------------------------------------------------------------------------------------------------- -public class AbstractUsabilityEvaluationTC -{ - - /** */ - private TaskTreeBuilder mTaskTreeBuilder = new TaskTreeBuilderImpl(); - - /** */ - private TaskTreeNodeFactory mTaskTreeNodeFactory = new TaskTreeNodeFactoryImpl(); - - //----------------------------------------------------------------------------------------------- - /** +public class AbstractUsabilityEvaluationTC { + + /** */ + private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder(); + + /** */ + private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory(); + + /** * */ - //----------------------------------------------------------------------------------------------- - @Before - public void setUp() - { - Logger.getLogger("").getHandlers()[0].setFormatter(new SimpleLogFormatter()); - } - - //----------------------------------------------------------------------------------------------- - /** + @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()) + protected ITaskTree createTaskTree(String spec) { + Matcher matcher = + Pattern.compile("(\\s*(\\w+)\\s*(\\(((\\w*\\s*)*)\\))?\\s*(\\{))|(\\})").matcher(spec); + + if (!matcher.find()) { + if (!matcher.hitEnd()) { + throw new IllegalArgumentException("could not parse task specification"); + } + } + + return taskTreeNodeFactory.createTaskTree(parseTask(matcher, new int[1])); + } + + /** + * TODO: comment + * + * @param expectedDefects + * @param evaluateUsability + */ + protected void assertUsabilityEvaluationResult(UsabilityDefect[] expectedDefects, + UsabilityEvaluationResult evaluationResult) { - 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"); - } - } - - - //----------------------------------------------------------------------------------------------- - /** + 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()) - { + private ITaskTreeNode parseTask(Matcher tokenMatcher, int[] typeNumbers) { + String firstToken = tokenMatcher.group(); + + if ("}".equals(firstToken)) { + throw new IllegalArgumentException("found a closing bracket at an unexpected place"); + } + + ITaskTreeNode treeNode = instantiateTreeNode(tokenMatcher, typeNumbers); + + if (!tokenMatcher.find()) { throw new IllegalArgumentException("could not parse task specification"); - } - - firstToken = tokenMatcher.group(); - - if ("}".equals(firstToken)) - { - 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()); - } - } + } + + firstToken = tokenMatcher.group(); + + if (!"}".equals(firstToken)) { + ITaskTreeNode child = null; + + do { + child = parseTask(tokenMatcher, typeNumbers); + + if (child != null) { + addChild(treeNode, child); + + if (!tokenMatcher.find()) { + throw new IllegalArgumentException("could not parse task specification"); + } + + firstToken = tokenMatcher.group(); + + if ("}".equals(firstToken)) { + break; + } + } + + } + while (child != null); + + } + + return treeNode; + } + + /** + * TODO: comment + * + * @param group + * @return + */ + private ITaskTreeNode instantiateTreeNode(Matcher tokenMatcher, int[] typeNumbers) { + String type = tokenMatcher.group(2); + String additionalInfo = tokenMatcher.group(4); + + if ("Interaction".equals(type)) { + return taskTreeNodeFactory.createNewEventTask + (new DummyInteraction("dummy", typeNumbers[0]++), new DummyGUIElement("dummy")); + } + else if ("Sequence".equals(type)) { + return taskTreeNodeFactory.createNewSequence(); + } + else if ("Iteration".equals(type)) { + return taskTreeNodeFactory.createNewIteration(); + } + else if ("Selection".equals(type)) { + return taskTreeNodeFactory.createNewSelection(); + } + else if ("TextInput".equals(type)) { + if (additionalInfo == null) { + fail("no simulated text provided for text input interactin task"); + } + + ITextInputEventTask task = + taskTreeNodeFactory.createNewTextInputEventTask(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(ITaskTreeNode parent, ITaskTreeNode child) { + if (parent instanceof ISequence) { + taskTreeBuilder.addChild((ISequence) parent, child); + } + else if (parent instanceof IIteration) { + if (parent.getChildren().size() <= 0) { + taskTreeBuilder.setChild((IIteration) parent, child); + } + else { + fail("can not add more than one child to an iteration"); + } + } + else if (parent instanceof ISelection) { + taskTreeBuilder.addChild((ISelection) parent, child); + } + else if (parent instanceof ITextInputEventTask) { + taskTreeBuilder.addChild((ITextInputEventTask) 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 497) +++ trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/TextInputStatisticsRuleTest.java (revision 561) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: TextInputStatisticsRuleTest.java,v $ // Version : $Revision: 0.0 $ $Author: pharms $ $Date: 18.07.2012 $ @@ -5,5 +4,6 @@ // Creation : 2012 by pharms // Copyright : Patrick Harms, 2012 -//------------------------------------------------------------------------------------------------- + + package de.ugoe.cs.quest.usability; @@ -18,5 +18,4 @@ import org.junit.Test; -//------------------------------------------------------------------------------------------------- /** * TODO comment @@ -25,717 +24,660 @@ * @author 2012, last modified by $Author: pharms$ */ -//------------------------------------------------------------------------------------------------- -public class TextInputStatisticsRuleTest extends AbstractUsabilityEvaluationTC -{ - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testWithDifferentTextInputInteractionsOnly() - { - UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); - - // ===== check ===== - String spec = "TextInput (bla) {}"; - UsabilityDefect[] expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (bla) {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (a) {}" + - " TextInput (b) {}" + - " TextInput (c) {}" + - " TextInput (d) {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Selection {" + - " TextInput (a) {}" + - " TextInput (b) {}" + - " TextInput (c) {}" + - " TextInput (d) {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Iteration {" + - " TextInput (bla) {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (a) {}" + - " Sequence {" + - " TextInput (b) {}" + - " TextInput (c) {}" + - " TextInput (d) {}" + - " TextInput (e) {}" + - " }" + - " Iteration {" + - " TextInput (f) {}" + - " }" + - " TextInput (g) {}" + - " Selection {" + - " TextInput (h) {}" + - " TextInput (i) {}" + - " TextInput (j) {}" + - " TextInput (k) {}" + - " }" + - " Sequence {" + - " TextInput (l) {}" + - " Sequence {" + - " TextInput (m) {}" + - " TextInput (n) {}" + - " TextInput (o) {}" + - " TextInput (p) {}" + - " }" + - " Iteration {" + - " TextInput (q) {}" + - " }" + - " TextInput (r) {}" + - " Selection {" + - " TextInput (s) {}" + - " TextInput (t) {}" + - " TextInput (u) {}" + - " TextInput (v) {}" + - " }" + - " }" + - " Selection {" + - " TextInput (w) {}" + - " Sequence {" + - " TextInput (x) {}" + - " TextInput (y) {}" + - " TextInput (z) {}" + - " TextInput (aa) {}" + - " }" + - " Iteration {" + - " TextInput (ab) {}" + - " }" + - " TextInput (ac) {}" + - " Selection {" + - " TextInput (ad) {}" + - " TextInput (ae) {}" + - " TextInput (af) {}" + - " TextInput (ag) {}" + - " }" + - " }" + - " TextInput (ah) {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testCombinationsOfTextInputInteractionsAndOtherInteractions() - { - UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); - - // ===== check ===== - String spec = - "Sequence {" + - " Interaction {}" + - " TextInput (a) {}" + - " TextInput (b) {}" + - " Interaction {}" + - " TextInput (c) {}" + - "}"; - - UsabilityDefect[] expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " Interaction {}" + - " TextInput (a) {}" + - " Interaction {}" + - " Interaction {}" + - " TextInput (c) {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(INFO, TEXT_FIELD_INPUT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " Interaction {}" + - " TextInput (a) {}" + - " Interaction {}" + - " Interaction {}" + - " Interaction {}" + - "}"; - - expectedDefects = new UsabilityDefect[0]; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Selection {" + - " Interaction {}" + - " TextInput (a) {}" + - " TextInput (b) {}" + - " Interaction {}" + - " TextInput (c) {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (a) {}" + - " Sequence {" + - " Interaction {}" + - " TextInput (b) {}" + - " TextInput (c) {}" + - " Interaction {}" + - " TextInput (d) {}" + - " }" + - " Iteration {" + - " TextInput (e) {}" + - " }" + - " Interaction {}" + - " Selection {" + - " Interaction {}" + - " TextInput (f) {}" + - " TextInput (g) {}" + - " Interaction {}" + - " TextInput (h) {}" + - " TextInput (i) {}" + - " }" + - " Sequence {" + - " TextInput (j) {}" + - " Sequence {" + - " TextInput (k) {}" + - " Interaction {}" + - " TextInput (l) {}" + - " TextInput (m) {}" + - " Interaction {}" + - " TextInput (n) {}" + - " TextInput (o) {}" + - " }" + - " Iteration {" + - " Interaction {}" + - " }" + - " Interaction {}" + - " Selection {" + - " TextInput (p) {}" + - " TextInput (q) {}" + - " TextInput (r) {}" + - " Interaction {}" + - " TextInput (s) {}" + - " TextInput (t) {}" + - " Interaction {}" + - " TextInput (u) {}" + - " TextInput (v) {}" + - " }" + - " }" + - " Selection {" + - " Interaction {}" + - " Sequence {" + - " TextInput (w) {}" + - " Interaction {}" + - " TextInput (x) {}" + - " TextInput (y) {}" + - " Interaction {}" + - " }" + - " Iteration {" + - " TextInput (z) {}" + - " }" + - " TextInput (aa) {}" + - " Selection {" + - " TextInput (ab) {}" + - " Interaction {}" + - " TextInput (ac) {}" + - " TextInput (ad) {}" + - " Interaction {}" + - " TextInput (ae) {}" + - " }" + - " }" + - " Interaction {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (a) {}" + - " Sequence {" + - " Interaction {}" + - " TextInput (b) {}" + - " Interaction {}" + - " Interaction {}" + - " TextInput (c) {}" + - " }" + - " Iteration {" + - " TextInput (d) {}" + - " }" + - " Interaction {}" + - " Selection {" + - " Interaction {}" + - " TextInput (e) {}" + - " Interaction {}" + - " Interaction {}" + - " TextInput (g) {}" + - " Interaction {}" + - " }" + - " Sequence {" + - " TextInput (i) {}" + - " Sequence {" + - " TextInput (j) {}" + - " Interaction {}" + - " TextInput (k) {}" + - " Interaction {}" + - " Interaction {}" + - " TextInput (m) {}" + - " Interaction {}" + - " }" + - " Iteration {" + - " Interaction {}" + - " }" + - " Interaction {}" + - " Selection {" + - " TextInput (o) {}" + - " Interaction {}" + - " Interaction {}" + - " Interaction {}" + - " Interaction {}" + - " TextInput (s) {}" + - " Interaction {}" + - " TextInput (t) {}" + - " TextInput (u) {}" + - " }" + - " }" + - " Selection {" + - " Interaction {}" + - " Sequence {" + - " TextInput (v) {}" + - " Interaction {}" + - " Interaction {}" + - " TextInput (x) {}" + - " Interaction {}" + - " }" + - " Iteration {" + - " TextInput (y) {}" + - " }" + - " TextInput (z) {}" + - " Selection {" + - " TextInput (aa) {}" + - " Interaction {}" + - " TextInput (ab) {}" + - " Interaction {}" + - " Interaction {}" + - " TextInput (ad) {}" + - " }" + - " }" + - " Interaction {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(INFO, TEXT_FIELD_INPUT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testTextEntryRepetitions() - { - UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); - - // ===== check ===== - String spec = - "Sequence {" + - " TextInput (a b c) {}" + - " Sequence {" + - " TextInput (a) {}" + - " TextInput (b) {}" + - " TextInput (c) {}" + - " TextInput (a) {}" + - " }" + - " Iteration {" + - " TextInput (a) {}" + - " }" + - " TextInput (a) {}" + - " Selection {" + - " TextInput (b c) {}" + - " TextInput (a) {}" + - " TextInput (a c) {}" + - " TextInput (b a) {}" + - " }" + - " Sequence {" + - " TextInput (b c) {}" + - " Sequence {" + - " TextInput (d a c) {}" + - " TextInput (b b b a) {}" + - " TextInput (a a c c) {}" + - " TextInput (b b a) {}" + - " }" + - " }" + - " TextInput (d) {}" + - "}"; - - UsabilityDefect[] expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_REPETITIONS) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (a b c d e f g h i j k l m) {}" + - " Sequence {" + - " TextInput (a) {}" + - " TextInput (b) {}" + - " TextInput (c) {}" + - " TextInput (d) {}" + - " }" + - " Iteration {" + - " TextInput (e) {}" + - " }" + - " TextInput (f) {}" + - " Selection {" + - " TextInput (g) {}" + - " TextInput (h) {}" + - " TextInput (i) {}" + - " TextInput (j) {}" + - " }" + - " Sequence {" + - " TextInput (k) {}" + - " Sequence {" + - " TextInput (l) {}" + - " TextInput (m) {}" + - " TextInput (n) {}" + - " TextInput (o) {}" + - " }" + - " }" + - " TextInput (p) {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_REPETITIONS) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (a b c d e f g h i j k l m) {}" + - " Sequence {" + - " TextInput (a) {}" + - " TextInput (b) {}" + - " TextInput (c) {}" + - " TextInput (d) {}" + - " }" + - " Iteration {" + - " TextInput (e) {}" + - " }" + - " TextInput (a) {}" + - " Selection {" + - " TextInput (b) {}" + - " TextInput (c) {}" + - " TextInput (d) {}" + - " TextInput (e) {}" + - " }" + - " Sequence {" + - " TextInput (a) {}" + - " Sequence {" + - " TextInput (b) {}" + - " TextInput (c) {}" + - " TextInput (d) {}" + - " TextInput (e) {}" + - " }" + - " }" + - " TextInput (f) {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), - new UsabilityDefect(MEDIUM, TEXT_FIELD_INPUT_REPETITIONS) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (a b c d e f g h i j k l m) {}" + - " Sequence {" + - " TextInput (a) {}" + - " TextInput (b) {}" + - " TextInput (c) {}" + - " TextInput (a) {}" + - " }" + - " Iteration {" + - " TextInput (b) {}" + - " }" + - " TextInput (c) {}" + - " Selection {" + - " TextInput (a) {}" + - " TextInput (b) {}" + - " TextInput (c) {}" + - " TextInput (a) {}" + - " }" + - " Sequence {" + - " TextInput (b) {}" + - " Sequence {" + - " TextInput (c) {}" + - " TextInput (a) {}" + - " TextInput (b) {}" + - " TextInput (c) {}" + - " }" + - " }" + - " TextInput (a) {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), - new UsabilityDefect(MEDIUM, TEXT_FIELD_INPUT_REPETITIONS) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (a b c) {}" + - " Sequence {" + - " TextInput (a) {}" + - " TextInput (b) {}" + - " TextInput (c) {}" + - " }" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), - new UsabilityDefect(LOW, TEXT_FIELD_INPUT_REPETITIONS) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (a b c) {}" + - " Sequence {" + - " TextInput (a) {}" + - " TextInput (a) {}" + - " TextInput (b) {}" + - " }" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), - new UsabilityDefect(LOW, TEXT_FIELD_INPUT_REPETITIONS) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (a b c) {}" + - " Sequence {" + - " TextInput (a) {}" + - " TextInput (d) {}" + - " TextInput (e) {}" + - " }" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), - new UsabilityDefect(INFO, TEXT_FIELD_INPUT_REPETITIONS) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - } - - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testNoLetterOrDigitInput() - { - UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); - - // ===== check ===== - String spec = - "Sequence {" + - " TextInput (_a_b_c_) {}" + - "}"; - - UsabilityDefect[] expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), - new UsabilityDefect(HIGH, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (12345_6789012345) {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), - new UsabilityDefect(MEDIUM, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (123456789012345678901234567890_123456789012345) {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), - new UsabilityDefect(LOW, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - // ===== check ===== - spec = - "Sequence {" + - " TextInput (1234567890123456789012345678901234567890123456789_01234567890" + - "12345678901234567890123456789012345) {}" + - "}"; - - expectedDefects = new UsabilityDefect[] - { - new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), - new UsabilityDefect(INFO, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) - }; - - assertUsabilityEvaluationResult - (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); - - } +public class TextInputStatisticsRuleTest extends AbstractUsabilityEvaluationTC { + + /** + * TODO: comment + * + */ + @Test + public void testWithDifferentTextInputInteractionsOnly() { + UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); + + // ===== check ===== + String spec = + "TextInput (bla) {}"; + UsabilityDefect[] expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (bla) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Selection {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Iteration {" + + " TextInput (bla) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a) {}" + + " Sequence {" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " TextInput (e) {}" + + " }" + + " Iteration {" + + " TextInput (f) {}" + + " }" + + " TextInput (g) {}" + + " Selection {" + + " TextInput (h) {}" + + " TextInput (i) {}" + + " TextInput (j) {}" + + " TextInput (k) {}" + + " }" + + " Sequence {" + + " TextInput (l) {}" + + " Sequence {" + + " TextInput (m) {}" + + " TextInput (n) {}" + + " TextInput (o) {}" + + " TextInput (p) {}" + + " }" + + " Iteration {" + + " TextInput (q) {}" + + " }" + + " TextInput (r) {}" + + " Selection {" + + " TextInput (s) {}" + + " TextInput (t) {}" + + " TextInput (u) {}" + + " TextInput (v) {}" + + " }" + + " }" + + " Selection {" + + " TextInput (w) {}" + + " Sequence {" + + " TextInput (x) {}" + + " TextInput (y) {}" + + " TextInput (z) {}" + + " TextInput (aa) {}" + + " }" + + " Iteration {" + + " TextInput (ab) {}" + + " }" + + " TextInput (ac) {}" + + " Selection {" + + " TextInput (ad) {}" + + " TextInput (ae) {}" + + " TextInput (af) {}" + + " TextInput (ag) {}" + + " }" + + " }" + + " TextInput (ah) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + } + + /** + * TODO: comment + * + */ + @Test + public void testCombinationsOfTextInputInteractionsAndOtherInteractions() { + UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); + + // ===== check ===== + String spec = + "Sequence {" + + " Interaction {}" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " Interaction {}" + + " TextInput (c) {}" + + "}"; + + UsabilityDefect[] expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " Interaction {}" + + " TextInput (a) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (c) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(INFO, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " Interaction {}" + + " TextInput (a) {}" + + " Interaction {}" + + " Interaction {}" + + " Interaction {}" + + "}"; + + expectedDefects = new UsabilityDefect[0]; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Selection {" + + " Interaction {}" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " Interaction {}" + + " TextInput (c) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a) {}" + + " Sequence {" + + " Interaction {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " Interaction {}" + + " TextInput (d) {}" + + " }" + + " Iteration {" + + " TextInput (e) {}" + + " }" + + " Interaction {}" + + " Selection {" + + " Interaction {}" + + " TextInput (f) {}" + + " TextInput (g) {}" + + " Interaction {}" + + " TextInput (h) {}" + + " TextInput (i) {}" + + " }" + + " Sequence {" + + " TextInput (j) {}" + + " Sequence {" + + " TextInput (k) {}" + + " Interaction {}" + + " TextInput (l) {}" + + " TextInput (m) {}" + + " Interaction {}" + + " TextInput (n) {}" + + " TextInput (o) {}" + + " }" + + " Iteration {" + + " Interaction {}" + + " }" + + " Interaction {}" + + " Selection {" + + " TextInput (p) {}" + + " TextInput (q) {}" + + " TextInput (r) {}" + + " Interaction {}" + + " TextInput (s) {}" + + " TextInput (t) {}" + + " Interaction {}" + + " TextInput (u) {}" + + " TextInput (v) {}" + + " }" + + " }" + + " Selection {" + + " Interaction {}" + + " Sequence {" + + " TextInput (w) {}" + + " Interaction {}" + + " TextInput (x) {}" + + " TextInput (y) {}" + + " Interaction {}" + + " }" + + " Iteration {" + + " TextInput (z) {}" + + " }" + + " TextInput (aa) {}" + + " Selection {" + + " TextInput (ab) {}" + + " Interaction {}" + + " TextInput (ac) {}" + + " TextInput (ad) {}" + + " Interaction {}" + + " TextInput (ae) {}" + + " }" + + " }" + + " Interaction {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a) {}" + + " Sequence {" + + " Interaction {}" + + " TextInput (b) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (c) {}" + + " }" + + " Iteration {" + + " TextInput (d) {}" + + " }" + + " Interaction {}" + + " Selection {" + + " Interaction {}" + + " TextInput (e) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (g) {}" + + " Interaction {}" + + " }" + + " Sequence {" + + " TextInput (i) {}" + + " Sequence {" + + " TextInput (j) {}" + + " Interaction {}" + + " TextInput (k) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (m) {}" + + " Interaction {}" + + " }" + + " Iteration {" + + " Interaction {}" + + " }" + + " Interaction {}" + + " Selection {" + + " TextInput (o) {}" + + " Interaction {}" + + " Interaction {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (s) {}" + + " Interaction {}" + + " TextInput (t) {}" + + " TextInput (u) {}" + + " }" + + " }" + + " Selection {" + + " Interaction {}" + + " Sequence {" + + " TextInput (v) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (x) {}" + + " Interaction {}" + + " }" + + " Iteration {" + + " TextInput (y) {}" + + " }" + + " TextInput (z) {}" + + " Selection {" + + " TextInput (aa) {}" + + " Interaction {}" + + " TextInput (ab) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (ad) {}" + + " }" + + " }" + + " Interaction {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(INFO, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + } + + /** + * TODO: comment + * + */ + @Test + public void testTextEntryRepetitions() { + UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); + + // ===== check ===== + String spec = + "Sequence {" + + " TextInput (a b c) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (a) {}" + + " }" + + " Iteration {" + + " TextInput (a) {}" + + " }" + + " TextInput (a) {}" + + " Selection {" + + " TextInput (b c) {}" + + " TextInput (a) {}" + + " TextInput (a c) {}" + + " TextInput (b a) {}" + + " }" + + " Sequence {" + + " TextInput (b c) {}" + + " Sequence {" + + " TextInput (d a c) {}" + + " TextInput (b b b a) {}" + + " TextInput (a a c c) {}" + + " TextInput (b b a) {}" + + " }" + + " }" + + " TextInput (d) {}" + + "}"; + + UsabilityDefect[] expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a b c d e f g h i j k l m) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " }" + + " Iteration {" + + " TextInput (e) {}" + + " }" + + " TextInput (f) {}" + + " Selection {" + + " TextInput (g) {}" + + " TextInput (h) {}" + + " TextInput (i) {}" + + " TextInput (j) {}" + + " }" + + " Sequence {" + + " TextInput (k) {}" + + " Sequence {" + + " TextInput (l) {}" + + " TextInput (m) {}" + + " TextInput (n) {}" + + " TextInput (o) {}" + + " }" + + " }" + + " TextInput (p) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a b c d e f g h i j k l m) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " }" + + " Iteration {" + + " TextInput (e) {}" + + " }" + + " TextInput (a) {}" + + " Selection {" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " TextInput (e) {}" + + " }" + + " Sequence {" + + " TextInput (a) {}" + + " Sequence {" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " TextInput (e) {}" + + " }" + + " }" + + " TextInput (f) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(MEDIUM, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a b c d e f g h i j k l m) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (a) {}" + + " }" + + " Iteration {" + + " TextInput (b) {}" + + " }" + + " TextInput (c) {}" + + " Selection {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (a) {}" + + " }" + + " Sequence {" + + " TextInput (b) {}" + + " Sequence {" + + " TextInput (c) {}" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " }" + + " }" + + " TextInput (a) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(MEDIUM, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a b c) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " }" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(LOW, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a b c) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " }" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(LOW, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a b c) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (d) {}" + + " TextInput (e) {}" + + " }" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(INFO, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + } + + /** + * TODO: comment + * + */ + @Test + public void testNoLetterOrDigitInput() { + UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); + + // ===== check ===== + String spec = + "Sequence {" + + " TextInput (_a_b_c_) {}" + + "}"; + + UsabilityDefect[] expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(HIGH, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (12345_6789012345) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(MEDIUM, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (123456789012345678901234567890_123456789012345) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(LOW, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (1234567890123456789012345678901234567890123456789_01234567890" + + "12345678901234567890123456789012345) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(INFO, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + } } Index: trunk/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 497) +++ trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/UsabilityDefectDescriptionTest.java (revision 561) @@ -1,3 +1,2 @@ -//------------------------------------------------------------------------------------------------- // Module : $RCSfile: UsabilityDefectDescriptionTest.java,v $ // Version : $Revision: 0.0 $ $Author: pharms $ $Date: 20.07.2012 $ @@ -5,5 +4,6 @@ // Creation : 2012 by pharms // Copyright : Patrick Harms, 2012 -//------------------------------------------------------------------------------------------------- + + package de.ugoe.cs.quest.usability; @@ -16,5 +16,4 @@ import org.junit.Test; -//------------------------------------------------------------------------------------------------- /** * TODO comment @@ -23,48 +22,37 @@ * @author 2012, last modified by $Author: pharms$ */ -//------------------------------------------------------------------------------------------------- -public class UsabilityDefectDescriptionTest -{ +public class UsabilityDefectDescriptionTest { - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testInitialization() - { - for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) - { - assertNotNull(description.toString()); - assertNotSame("", description.toString()); - System.err.println(description); + /** + * TODO: comment + * + */ + @Test + public void testInitialization() { + for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) { + assertNotNull(description.toString()); + assertNotSame("", description.toString()); + System.err.println(description); + } } - } - //----------------------------------------------------------------------------------------------- - /** - * TODO: comment - * - */ - //----------------------------------------------------------------------------------------------- - @Test - public void testParameterization() - { - for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) - { - Map parameters = new HashMap(); - - for (String parameter : description.getDescriptionParameters()) - { - parameters.put(parameter, ""); - } - - assertNotNull(description.toString(parameters)); - assertNotSame("", description.toString(parameters)); - System.err.println(description.toString(parameters)); + /** + * TODO: comment + * + */ + @Test + public void testParameterization() { + for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) { + Map parameters = new HashMap(); + + for (String parameter : description.getDescriptionParameters()) { + parameters.put(parameter, ""); + } + + assertNotNull(description.toString(parameters)); + assertNotSame("", description.toString(parameters)); + System.err.println(description.toString(parameters)); + } } - } }