Index: /trunk/autoquest-core-usability-test/.classpath =================================================================== --- /trunk/autoquest-core-usability-test/.classpath (revision 897) +++ /trunk/autoquest-core-usability-test/.classpath (revision 897) @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + Index: /trunk/autoquest-core-usability-test/.project =================================================================== --- /trunk/autoquest-core-usability-test/.project (revision 897) +++ /trunk/autoquest-core-usability-test/.project (revision 897) @@ -0,0 +1,23 @@ + + + quest-core-usability-test + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.m2e.core.maven2Nature + org.eclipse.jdt.core.javanature + + Index: /trunk/autoquest-core-usability-test/.settings/org.eclipse.jdt.core.prefs =================================================================== --- /trunk/autoquest-core-usability-test/.settings/org.eclipse.jdt.core.prefs (revision 897) +++ /trunk/autoquest-core-usability-test/.settings/org.eclipse.jdt.core.prefs (revision 897) @@ -0,0 +1,5 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 +org.eclipse.jdt.core.compiler.compliance=1.6 +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.source=1.6 Index: /trunk/autoquest-core-usability-test/.settings/org.eclipse.m2e.core.prefs =================================================================== --- /trunk/autoquest-core-usability-test/.settings/org.eclipse.m2e.core.prefs (revision 897) +++ /trunk/autoquest-core-usability-test/.settings/org.eclipse.m2e.core.prefs (revision 897) @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 Index: /trunk/autoquest-core-usability-test/pom.xml =================================================================== --- /trunk/autoquest-core-usability-test/pom.xml (revision 897) +++ /trunk/autoquest-core-usability-test/pom.xml (revision 897) @@ -0,0 +1,16 @@ + + + de.ugoe.cs.quest + quest-test + 0.0.1-SNAPSHOT + + 4.0.0 + quest-core-usability-test + + quest-core-usability + + Index: /trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/AbstractUsabilityEvaluationTC.java =================================================================== --- /trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/AbstractUsabilityEvaluationTC.java (revision 897) +++ /trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/AbstractUsabilityEvaluationTC.java (revision 897) @@ -0,0 +1,210 @@ +package de.ugoe.cs.quest.usability; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; + +import java.util.ArrayList; +import java.util.logging.Level; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import org.junit.Before; + +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.eventcore.gui.TextInput; +import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; +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.treeimpl.TaskTreeBuilder; +import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; +import de.ugoe.cs.quest.test.DummyGUIElement; +import de.ugoe.cs.quest.test.DummyInteraction; +import de.ugoe.cs.quest.test.DummyTextField; +import de.ugoe.cs.util.console.TextConsole; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 18.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +public class AbstractUsabilityEvaluationTC { + + /** */ + private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder(); + + /** */ + private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory(); + + /** + * + */ + @Before + public void setUp() { + new TextConsole(Level.FINEST); + } + + /** + * + */ + protected ITaskTree createTaskTree(String spec) { + Matcher matcher = + Pattern.compile("(\\s*(\\w+)\\s*(\\(((\\w*\\s*)*)\\))?\\s*(\\{))|(\\})").matcher(spec); + + if (!matcher.find()) { + if (!matcher.hitEnd()) { + throw new IllegalArgumentException("could not parse task specification"); + } + } + + return taskTreeNodeFactory.createTaskTree(parseTask(matcher, new int[1])); + } + + /** + * TODO: comment + * + * @param expectedDefects + * @param evaluateUsability + */ + protected void assertUsabilityEvaluationResult(UsabilityDefect[] expectedDefects, + UsabilityEvaluationResult evaluationResult) + { + assertEquals(expectedDefects.length, evaluationResult.getAllDefects().size()); + + EXPECTED_DEFECT_ITERATION: + for (UsabilityDefect expectedDefect : expectedDefects) { + for (UsabilityDefect defect : evaluationResult.getAllDefects()) { + if (expectedDefect.equals(defect)) { + System.err.println(defect.getParameterizedDescription()); + continue EXPECTED_DEFECT_ITERATION; + } + } + + for (UsabilityDefect defect : evaluationResult.getAllDefects()) { + System.err.println(defect); + } + + fail("expected defect " + expectedDefect + " not found in evaluation result"); + } + } + + /** + * + */ + private ITaskTreeNode parseTask(Matcher tokenMatcher, int[] typeNumbers) { + String firstToken = tokenMatcher.group(); + + if ("}".equals(firstToken)) { + throw new IllegalArgumentException("found a closing bracket at an unexpected place"); + } + + ITaskTreeNode treeNode = instantiateTreeNode(tokenMatcher, typeNumbers); + + if (!tokenMatcher.find()) { + throw new IllegalArgumentException("could not parse task specification"); + } + + firstToken = tokenMatcher.group(); + + if (!"}".equals(firstToken)) { + ITaskTreeNode child = null; + + do { + child = parseTask(tokenMatcher, typeNumbers); + + if (child != null) { + addChild(treeNode, child); + + if (!tokenMatcher.find()) { + throw new IllegalArgumentException("could not parse task specification"); + } + + firstToken = tokenMatcher.group(); + + if ("}".equals(firstToken)) { + break; + } + } + + } + while (child != null); + + } + + return treeNode; + } + + /** + * TODO: comment + * + * @param group + * @return + */ + private ITaskTreeNode instantiateTreeNode(Matcher tokenMatcher, int[] typeNumbers) { + String type = tokenMatcher.group(2); + String additionalInfo = tokenMatcher.group(4); + + if ("Interaction".equals(type)) { + return taskTreeNodeFactory.createNewEventTask + (new DummyInteraction("dummy", typeNumbers[0]++), new DummyGUIElement("dummy")); + } + else if ("Sequence".equals(type)) { + return taskTreeNodeFactory.createNewSequence(); + } + else if ("Iteration".equals(type)) { + return taskTreeNodeFactory.createNewIteration(); + } + else if ("Selection".equals(type)) { + return taskTreeNodeFactory.createNewSelection(); + } + else if ("TextInput".equals(type)) { + if (additionalInfo == null) { + fail("no simulated text provided for text input interactin task"); + } + + TextInput textInput = new TextInput(additionalInfo, new ArrayList()); + + IEventTask task = taskTreeNodeFactory.createNewEventTask + (textInput, new DummyTextField(additionalInfo)); + + return task; + } + else { + fail("invalid type of task tree node: " + type); + return null; + } + } + + /** + * TODO: comment + * + * @param treeNode + * @param child + */ + private void addChild(ITaskTreeNode parent, ITaskTreeNode child) { + if (parent instanceof ISequence) { + taskTreeBuilder.addChild((ISequence) parent, child); + } + else if (parent instanceof IIteration) { + if (parent.getChildren().size() <= 0) { + taskTreeBuilder.setChild((IIteration) parent, child); + } + else { + fail("can not add more than one child to an iteration"); + } + } + else if (parent instanceof ISelection) { + taskTreeBuilder.addChild((ISelection) parent, child); + } + else { + fail("can not add children to parent task tree node of type " + + parent.getClass().getName()); + } + } + +} Index: /trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/TextInputStatisticsRuleTest.java =================================================================== --- /trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/TextInputStatisticsRuleTest.java (revision 897) +++ /trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/TextInputStatisticsRuleTest.java (revision 897) @@ -0,0 +1,676 @@ +package de.ugoe.cs.quest.usability; + +import static de.ugoe.cs.quest.usability.UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO; +import static de.ugoe.cs.quest.usability.UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS; +import static de.ugoe.cs.quest.usability.UsabilityDefectDescription.TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO; +import static de.ugoe.cs.quest.usability.UsabilityDefectSeverity.HIGH; +import static de.ugoe.cs.quest.usability.UsabilityDefectSeverity.INFO; +import static de.ugoe.cs.quest.usability.UsabilityDefectSeverity.LOW; +import static de.ugoe.cs.quest.usability.UsabilityDefectSeverity.MEDIUM; + +import org.junit.Test; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 18.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +public class TextInputStatisticsRuleTest extends AbstractUsabilityEvaluationTC { + + /** + * TODO: comment + * + */ + @Test + public void testWithDifferentTextInputInteractionsOnly() { + UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); + + // ===== check ===== + String spec = + "TextInput (bla) {}"; + UsabilityDefect[] expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (bla) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Selection {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Iteration {" + + " TextInput (bla) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a) {}" + + " Sequence {" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " TextInput (e) {}" + + " }" + + " Iteration {" + + " TextInput (f) {}" + + " }" + + " TextInput (g) {}" + + " Selection {" + + " TextInput (h) {}" + + " TextInput (i) {}" + + " TextInput (j) {}" + + " TextInput (k) {}" + + " }" + + " Sequence {" + + " TextInput (l) {}" + + " Sequence {" + + " TextInput (m) {}" + + " TextInput (n) {}" + + " TextInput (o) {}" + + " TextInput (p) {}" + + " }" + + " Iteration {" + + " TextInput (q) {}" + + " }" + + " TextInput (r) {}" + + " Selection {" + + " TextInput (s) {}" + + " TextInput (t) {}" + + " TextInput (u) {}" + + " TextInput (v) {}" + + " }" + + " }" + + " Selection {" + + " TextInput (w) {}" + + " Sequence {" + + " TextInput (x) {}" + + " TextInput (y) {}" + + " TextInput (z) {}" + + " TextInput (aa) {}" + + " }" + + " Iteration {" + + " TextInput (ab) {}" + + " }" + + " TextInput (ac) {}" + + " Selection {" + + " TextInput (ad) {}" + + " TextInput (ae) {}" + + " TextInput (af) {}" + + " TextInput (ag) {}" + + " }" + + " }" + + " TextInput (ah) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + } + + /** + * TODO: comment + * + */ + @Test + public void testCombinationsOfTextInputInteractionsAndOtherInteractions() { + UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); + + // ===== check ===== + String spec = + "Sequence {" + + " Interaction {}" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " Interaction {}" + + " TextInput (c) {}" + + "}"; + + UsabilityDefect[] expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " Interaction {}" + + " TextInput (a) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (c) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(INFO, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " Interaction {}" + + " TextInput (a) {}" + + " Interaction {}" + + " Interaction {}" + + " Interaction {}" + + "}"; + + expectedDefects = new UsabilityDefect[0]; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Selection {" + + " Interaction {}" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " Interaction {}" + + " TextInput (c) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a) {}" + + " Sequence {" + + " Interaction {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " Interaction {}" + + " TextInput (d) {}" + + " }" + + " Iteration {" + + " TextInput (e) {}" + + " }" + + " Interaction {}" + + " Selection {" + + " Interaction {}" + + " TextInput (f) {}" + + " TextInput (g) {}" + + " Interaction {}" + + " TextInput (h) {}" + + " TextInput (i) {}" + + " }" + + " Sequence {" + + " TextInput (j) {}" + + " Sequence {" + + " TextInput (k) {}" + + " Interaction {}" + + " TextInput (l) {}" + + " TextInput (m) {}" + + " Interaction {}" + + " TextInput (n) {}" + + " TextInput (o) {}" + + " }" + + " Iteration {" + + " Interaction {}" + + " }" + + " Interaction {}" + + " Selection {" + + " TextInput (p) {}" + + " TextInput (q) {}" + + " TextInput (r) {}" + + " Interaction {}" + + " TextInput (s) {}" + + " TextInput (t) {}" + + " Interaction {}" + + " TextInput (u) {}" + + " TextInput (v) {}" + + " }" + + " }" + + " Selection {" + + " Interaction {}" + + " Sequence {" + + " TextInput (w) {}" + + " Interaction {}" + + " TextInput (x) {}" + + " TextInput (y) {}" + + " Interaction {}" + + " }" + + " Iteration {" + + " TextInput (z) {}" + + " }" + + " TextInput (aa) {}" + + " Selection {" + + " TextInput (ab) {}" + + " Interaction {}" + + " TextInput (ac) {}" + + " TextInput (ad) {}" + + " Interaction {}" + + " TextInput (ae) {}" + + " }" + + " }" + + " Interaction {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a) {}" + + " Sequence {" + + " Interaction {}" + + " TextInput (b) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (c) {}" + + " }" + + " Iteration {" + + " TextInput (d) {}" + + " }" + + " Interaction {}" + + " Selection {" + + " Interaction {}" + + " TextInput (e) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (g) {}" + + " Interaction {}" + + " }" + + " Sequence {" + + " TextInput (i) {}" + + " Sequence {" + + " TextInput (j) {}" + + " Interaction {}" + + " TextInput (k) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (m) {}" + + " Interaction {}" + + " }" + + " Iteration {" + + " Interaction {}" + + " }" + + " Interaction {}" + + " Selection {" + + " TextInput (o) {}" + + " Interaction {}" + + " Interaction {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (s) {}" + + " Interaction {}" + + " TextInput (t) {}" + + " TextInput (u) {}" + + " }" + + " }" + + " Selection {" + + " Interaction {}" + + " Sequence {" + + " TextInput (v) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (x) {}" + + " Interaction {}" + + " }" + + " Iteration {" + + " TextInput (y) {}" + + " }" + + " TextInput (z) {}" + + " Selection {" + + " TextInput (aa) {}" + + " Interaction {}" + + " TextInput (ab) {}" + + " Interaction {}" + + " Interaction {}" + + " TextInput (ad) {}" + + " }" + + " }" + + " Interaction {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(INFO, TEXT_FIELD_INPUT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + } + + /** + * TODO: comment + * + */ + @Test + public void testTextEntryRepetitions() { + UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); + + // ===== check ===== + String spec = + "Sequence {" + + " TextInput (a b c) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (a) {}" + + " }" + + " Iteration {" + + " TextInput (a) {}" + + " }" + + " TextInput (a) {}" + + " Selection {" + + " TextInput (b c) {}" + + " TextInput (a) {}" + + " TextInput (a c) {}" + + " TextInput (b a) {}" + + " }" + + " Sequence {" + + " TextInput (b c) {}" + + " Sequence {" + + " TextInput (d a c) {}" + + " TextInput (b b b a) {}" + + " TextInput (a a c c) {}" + + " TextInput (b b a) {}" + + " }" + + " }" + + " TextInput (d) {}" + + "}"; + + UsabilityDefect[] expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a b c d e f g h i j k l m) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " }" + + " Iteration {" + + " TextInput (e) {}" + + " }" + + " TextInput (f) {}" + + " Selection {" + + " TextInput (g) {}" + + " TextInput (h) {}" + + " TextInput (i) {}" + + " TextInput (j) {}" + + " }" + + " Sequence {" + + " TextInput (k) {}" + + " Sequence {" + + " TextInput (l) {}" + + " TextInput (m) {}" + + " TextInput (n) {}" + + " TextInput (o) {}" + + " }" + + " }" + + " TextInput (p) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a b c d e f g h i j k l m) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " }" + + " Iteration {" + + " TextInput (e) {}" + + " }" + + " TextInput (a) {}" + + " Selection {" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " TextInput (e) {}" + + " }" + + " Sequence {" + + " TextInput (a) {}" + + " Sequence {" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (d) {}" + + " TextInput (e) {}" + + " }" + + " }" + + " TextInput (f) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(MEDIUM, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a b c d e f g h i j k l m) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (a) {}" + + " }" + + " Iteration {" + + " TextInput (b) {}" + + " }" + + " TextInput (c) {}" + + " Selection {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " TextInput (a) {}" + + " }" + + " Sequence {" + + " TextInput (b) {}" + + " Sequence {" + + " TextInput (c) {}" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " }" + + " }" + + " TextInput (a) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(MEDIUM, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a b c) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " TextInput (c) {}" + + " }" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(LOW, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a b c) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (a) {}" + + " TextInput (b) {}" + + " }" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(LOW, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (a b c) {}" + + " Sequence {" + + " TextInput (a) {}" + + " TextInput (d) {}" + + " TextInput (e) {}" + + " }" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(INFO, TEXT_FIELD_INPUT_REPETITIONS) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + } + + /** + * TODO: comment + * + */ + @Test + public void testNoLetterOrDigitInput() { + UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); + + // ===== check ===== + String spec = + "Sequence {" + + " TextInput (_a_b_c_) {}" + + "}"; + + UsabilityDefect[] expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(HIGH, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (12345_6789012345) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(MEDIUM, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (123456789012345678901234567890_123456789012345) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(LOW, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + // ===== check ===== + spec = + "Sequence {" + + " TextInput (1234567890123456789012345678901234567890123456789_01234567890" + + "12345678901234567890123456789012345) {}" + + "}"; + + expectedDefects = new UsabilityDefect[] + { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), + new UsabilityDefect(INFO, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) }; + + assertUsabilityEvaluationResult + (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); + + } +} Index: /trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/UsabilityDefectDescriptionTest.java =================================================================== --- /trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/UsabilityDefectDescriptionTest.java (revision 897) +++ /trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/UsabilityDefectDescriptionTest.java (revision 897) @@ -0,0 +1,51 @@ +package de.ugoe.cs.quest.usability; + +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNotSame; + +import java.util.HashMap; +import java.util.Map; + +import org.junit.Test; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 20.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +public class UsabilityDefectDescriptionTest { + + /** + * TODO: comment + * + */ + @Test + public void testInitialization() { + for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) { + assertNotNull(description.toString()); + assertNotSame("", description.toString()); + System.err.println(description); + } + } + + /** + * TODO: comment + * + */ + @Test + public void testParameterization() { + for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) { + Map parameters = new HashMap(); + + for (String parameter : description.getDescriptionParameters()) { + parameters.put(parameter, ""); + } + + assertNotNull(description.toString(parameters)); + assertNotSame("", description.toString(parameters)); + System.err.println(description.toString(parameters)); + } + } + +}