Index: /trunk/autoquest-core-usability/.classpath =================================================================== --- /trunk/autoquest-core-usability/.classpath (revision 896) +++ /trunk/autoquest-core-usability/.classpath (revision 896) @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index: /trunk/autoquest-core-usability/.project =================================================================== --- /trunk/autoquest-core-usability/.project (revision 896) +++ /trunk/autoquest-core-usability/.project (revision 896) @@ -0,0 +1,23 @@ + + + quest-core-usability + + + + + + 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/.settings/org.eclipse.jdt.core.prefs =================================================================== --- /trunk/autoquest-core-usability/.settings/org.eclipse.jdt.core.prefs (revision 896) +++ /trunk/autoquest-core-usability/.settings/org.eclipse.jdt.core.prefs (revision 896) @@ -0,0 +1,12 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.6 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.source=1.6 Index: /trunk/autoquest-core-usability/.settings/org.eclipse.m2e.core.prefs =================================================================== --- /trunk/autoquest-core-usability/.settings/org.eclipse.m2e.core.prefs (revision 896) +++ /trunk/autoquest-core-usability/.settings/org.eclipse.m2e.core.prefs (revision 896) @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 Index: /trunk/autoquest-core-usability/pom.xml =================================================================== --- /trunk/autoquest-core-usability/pom.xml (revision 896) +++ /trunk/autoquest-core-usability/pom.xml (revision 896) @@ -0,0 +1,39 @@ + + + de.ugoe.cs.quest + quest + 0.0.1-SNAPSHOT + + 4.0.0 + quest-core-usability + quest-core-usability + + ${quest-scm-trunk-dir}/quest-core-usability + + + + de.ugoe.cs.quest + quest-core-tasktrees + ${project.parent.version} + + + + + + org.jvnet.jaxb2.maven2 + maven-jaxb2-plugin + 0.8.2 + + de.ugoe.cs.quest.usability + + + + + generate + + + + + + + Index: /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/TextInputStatisticsRule.java =================================================================== --- /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/TextInputStatisticsRule.java (revision 896) +++ /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/TextInputStatisticsRule.java (revision 896) @@ -0,0 +1,400 @@ +package de.ugoe.cs.quest.usability; + +import java.text.DecimalFormat; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import de.ugoe.cs.quest.eventcore.gui.TextInput; +import de.ugoe.cs.quest.eventcore.guimodel.ITextArea; +import de.ugoe.cs.quest.eventcore.guimodel.ITextField; +import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 16.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +public class TextInputStatisticsRule implements de.ugoe.cs.quest.usability.UsabilityEvaluationRule { + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.usability.UsabilityEvaluationRule#evaluate(TaskTree) + */ + @Override + public UsabilityEvaluationResult evaluate(ITaskTree taskTree) { + TextInputStatistics statistics = new TextInputStatistics(); + calculateStatistics(taskTree.getRoot(), statistics); + + UsabilityEvaluationResult results = new UsabilityEvaluationResult(); + analyzeStatistics(statistics, results); + + return results; + } + + /** + * TODO: comment + * + * @param statistics + * @param results + */ + private void analyzeStatistics(TextInputStatistics statistics, + UsabilityEvaluationResult results) + { + checkTextInputRatio(statistics, results); + checkTextFieldEntryRepetitions(statistics, results); + checkTextFieldNoLetterOrDigitInputs(statistics, results); + } + + /** + * TODO: comment + * + * @param statistics + * @param results + */ + private void checkTextInputRatio(TextInputStatistics statistics, + UsabilityEvaluationResult results) + { + float allTextFieldInputs = + statistics.getNoOfTextFieldInputs() + statistics.getNoOfTextAreaInputs(); + + float ratio = allTextFieldInputs / (float) statistics.getNoOfAllEvents(); + + UsabilityDefectSeverity severity = null; + if (ratio > 0.9) { + severity = UsabilityDefectSeverity.HIGH; + } + else if (ratio > 0.7) { + severity = UsabilityDefectSeverity.MEDIUM; + } + else if (ratio > 0.5) { + severity = UsabilityDefectSeverity.LOW; + } + else if (ratio > 0.3) { + severity = UsabilityDefectSeverity.INFO; + } + + if (severity != null) { + Map parameters = new HashMap(); + parameters.put("textInputRatio", DecimalFormat.getInstance().format(ratio * 100) + "%"); + + results.addDefect + (new UsabilityDefect(severity, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO, + parameters)); + } + } + + /** + * TODO: comment + * + * @param statistics + * @param results + */ + private void checkTextFieldEntryRepetitions(TextInputStatistics statistics, + UsabilityEvaluationResult results) + { + Map words = new HashMap(); + int numberOfRepeatedWords = 0; + int maxRepetitions = 0; + + for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) { + String[] fragments = statistics.getTextFieldInputFragments(i); + for (String fragment : fragments) { + if (!"".equals(fragment.trim())) { + Integer count = words.get(fragment); + if (count == null) { + words.put(fragment, 1); + } + else { + count++; + words.put(fragment, count); + maxRepetitions = Math.max(count, maxRepetitions); + + if (count == 2) { + // do not calculate repeated words several times + numberOfRepeatedWords++; + } + } + } + } + } + + UsabilityDefectSeverity severity = null; + if ((numberOfRepeatedWords > 10) || (maxRepetitions > 10)) { + severity = UsabilityDefectSeverity.HIGH; + } + else if ((numberOfRepeatedWords > 4) || (maxRepetitions > 4)) { + severity = UsabilityDefectSeverity.MEDIUM; + } + else if ((numberOfRepeatedWords > 2) || (maxRepetitions > 2)) { + severity = UsabilityDefectSeverity.LOW; + } + else if ((numberOfRepeatedWords > 1) || (maxRepetitions > 1)) { + severity = UsabilityDefectSeverity.INFO; + } + + if (severity != null) { + Map parameters = new HashMap(); + parameters.put("textRepetitionRatio", numberOfRepeatedWords + + " repeated tokens, up to " + maxRepetitions + " repetitions per token"); + + results.addDefect + (new UsabilityDefect(severity, + UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS, + parameters)); + } + } + + /** + * TODO: comment + * + * @param statistics + * @param results + */ + private void checkTextFieldNoLetterOrDigitInputs(TextInputStatistics statistics, + UsabilityEvaluationResult results) + { + int allCharactersCount = 0; + int noLetterOrDigitCount = 0; + + for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) { + String[] fragments = statistics.getTextFieldInputFragments(i); + for (String fragment : fragments) { + String effectiveFragment = fragment.trim(); + for (int j = 0; j < effectiveFragment.length(); j++) { + if (!Character.isWhitespace(effectiveFragment.charAt(j))) { + if (!Character.isLetterOrDigit(effectiveFragment.charAt(j))) { + noLetterOrDigitCount++; + } + allCharactersCount++; + } + } + } + } + + float ratio = (float) noLetterOrDigitCount / (float) allCharactersCount; + + UsabilityDefectSeverity severity = null; + if (ratio > 0.1) // every 10th sign + { + severity = UsabilityDefectSeverity.HIGH; + } + else if (ratio > 0.05) // every 20th sign + { + severity = UsabilityDefectSeverity.MEDIUM; + } + else if (ratio > 0.02) // every 50th sign + { + severity = UsabilityDefectSeverity.LOW; + } + else if (ratio > 0.01) // every 100th sign + { + severity = UsabilityDefectSeverity.INFO; + } + + if (severity != null) { + Map parameters = new HashMap(); + parameters.put("noLetterOrDigitRatio", allCharactersCount + " entered characters of " + + "which " + noLetterOrDigitCount + " were no letter or digit"); + + results.addDefect + (new UsabilityDefect(severity, + UsabilityDefectDescription.TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO, + parameters)); + } + } + + /** + * TODO: comment + * + * @param taskTree + * @param statistics + */ + private void calculateStatistics(ITaskTreeNode node, TextInputStatistics statistics) { + if ((node instanceof IEventTask) && + (((IEventTask) node).getEventType() instanceof TextInput)) + { + calculateStatistics((IEventTask) node, statistics); + } + else { + if ((node.getChildren() == null) || (node.getChildren().size() == 0)) { + statistics.incrementNoOfOtherEventTasks(); + } + else { + for (ITaskTreeNode child : node.getChildren()) { + calculateStatistics(child, statistics); + } + } + } + } + + /** + * TODO: comment + * + * @param taskTree + * @param statistics + */ + private void calculateStatistics(IEventTask node, TextInputStatistics statistics) { + String[] fragments = + determineTextFragments(((TextInput) node.getEventType()).getEnteredText()); + + if (node.getEventTarget() instanceof ITextField) { + statistics.addTextFieldInput(node, fragments); + } + else if (node.getEventTarget() instanceof ITextArea) { + statistics.addTextAreaInput(node, fragments); + } + } + + /** + * TODO: comment + * + * @param enteredText + * @return + */ + private String[] determineTextFragments(String enteredText) { + List fragments = new ArrayList(); + + StringBuffer fragment = new StringBuffer(); + char lastChar = 0; + + for (int i = 0; i < enteredText.length(); i++) { + char currentChar = enteredText.charAt(i); + + if (!isEqualCharacterType(lastChar, currentChar)) { + // the previous fragment ended. so finalize it and start a new one + if ((fragment != null) && (fragment.length() > 0)) { + fragments.add(fragment.toString()); + fragment = new StringBuffer(); + } + } + + fragment.append(currentChar); + lastChar = currentChar; + } + + if ((fragment != null) && (fragment.length() > 0)) { + fragments.add(fragment.toString()); + } + + return fragments.toArray(new String[fragments.size()]); + } + + /** + * TODO: comment + * + * @param lastChar + * @param currentChar + * @return + */ + private boolean isEqualCharacterType(char char1, char char2) { + return + ((char1 == char2) || + (Character.isWhitespace(char1) && Character.isWhitespace(char2)) || + (Character.isDigit(char1) && Character.isDigit(char2)) || + (Character.isLetter(char1) && Character.isLetter(char2)) || + (Character.isJavaIdentifierPart(char1) && Character.isJavaIdentifierPart(char2))); + } + + /** + * TODO comment + * + * @version $Revision: $ $Date: 16.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ + public static class TextInputStatistics { + + /** */ + private List textFieldInputs = new ArrayList(); + + /** */ + private List textAreaInputs = new ArrayList(); + + /** */ + private int otherEventsCount; + + /** + * TODO: comment + * + * @param node + * @param fragments + * + */ + public void addTextFieldInput(IEventTask node, String[] fragments) { + textFieldInputs.add(new Object[] { node, fragments }); + } + + /** + * TODO: comment + * + * @param node + * @param fragments + * + */ + public void addTextAreaInput(IEventTask node, String[] fragments) { + textAreaInputs.add(new Object[] { node, fragments }); + } + + /** + * TODO: comment + * + * @return + */ + public int getNoOfAllEvents() { + return textFieldInputs.size() + textAreaInputs.size() + otherEventsCount; + } + + /** + * TODO: comment + * + * @return + */ + public int getNoOfTextFieldInputs() { + return textFieldInputs.size(); + } + + /** + * TODO: comment + * + * @param i + * @return + */ + public String[] getTextFieldInputFragments(int index) { + return (String[]) textFieldInputs.get(index)[1]; + } + + /** + * TODO: comment + * + * @return + */ + public int getNoOfTextAreaInputs() { + return textAreaInputs.size(); + } + + /** + * TODO: comment + * + * @param i + * @return + */ + public String[] getTextAreaInputFragments(int index) { + return (String[]) textAreaInputs.get(index)[1]; + } + + /** + * TODO: comment + * + */ + public void incrementNoOfOtherEventTasks() { + otherEventsCount++; + } + + } + +} Index: /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefect.java =================================================================== --- /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefect.java (revision 896) +++ /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefect.java (revision 896) @@ -0,0 +1,117 @@ +package de.ugoe.cs.quest.usability; + +import java.util.Map; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 16.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +public class UsabilityDefect { + + /** */ + private UsabilityDefectSeverity severity; + + /** */ + private UsabilityDefectDescription description; + + /** */ + private Map descriptionParameters; + + /** + * TODO: comment + * + * @param medium + * @param highTextInputRatio + */ + public UsabilityDefect(UsabilityDefectSeverity severity, UsabilityDefectDescription description) + { + this(severity, description, null); + } + + /** + * TODO: comment + * + * @param medium + * @param highTextInputRatio + */ + public UsabilityDefect(UsabilityDefectSeverity severity, + UsabilityDefectDescription description, + Map parameters) + { + this.severity = severity; + this.description = description; + this.descriptionParameters = parameters; + } + + /** + * TODO: comment + * + * @return + */ + public UsabilityDefectSeverity getSeverity() { + return severity; + } + + /** + * @param severity + * the severity to set + */ + public void setSeverity(UsabilityDefectSeverity severity) { + this.severity = severity; + } + + /** + * @param description + * the description to set + */ + public void setDescription(UsabilityDefectDescription description) { + this.description = description; + } + + /** + * + */ + public String getParameterizedDescription() { + return description.toString(descriptionParameters); + } + + /* + * (non-Javadoc) + * + * @see java.lang.Object#equals(java.lang.Object) + */ + @Override + public boolean equals(Object obj) { + if (obj instanceof UsabilityDefect) { + return + (severity == ((UsabilityDefect) obj).severity) && + (description == ((UsabilityDefect) obj).description); + } + else { + return false; + } + } + + /* + * (non-Javadoc) + * + * @see java.lang.Object#hashCode() + */ + @Override + public int hashCode() { + return severity.hashCode() + description.hashCode(); + } + + /* + * (non-Javadoc) + * + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + return "UsabilityDefect(" + severity.name() + ", " + description.name() + ")"; + } + +} Index: /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefectDescription.java =================================================================== --- /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefectDescription.java (revision 896) +++ /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefectDescription.java (revision 896) @@ -0,0 +1,191 @@ +package de.ugoe.cs.quest.usability; + +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import javax.xml.bind.JAXBContext; +import javax.xml.bind.JAXBElement; +import javax.xml.bind.Unmarshaller; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 18.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +public enum UsabilityDefectDescription { + + TEXT_FIELD_INPUT_RATIO, + TEXT_FIELD_INPUT_REPETITIONS, + TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO; + + /** */ + private static final String DEFAULT_MESSAGES_FILE = "defectDescriptions_en.xml"; + + /** */ + private static DefectDescriptions sDefectDescriptions; + + /** */ + private DefectDescription defectDescription; + + /** + * TODO: comment + * + * @param name + * @param ordinal + */ + private UsabilityDefectDescription() { + init(); + } + + /** + * TODO: comment + * + */ + @SuppressWarnings("unchecked") + private void init() { + synchronized (this.getClass()) { + if (sDefectDescriptions == null) { + InputStream inputStream = + ClassLoader.getSystemResourceAsStream(DEFAULT_MESSAGES_FILE); + + try { + String packageName = DefectDescriptions.class.getPackage().getName(); + JAXBContext jaxbContext = JAXBContext.newInstance(packageName); + Unmarshaller unmarshaller = jaxbContext.createUnmarshaller(); + + sDefectDescriptions = + ((JAXBElement) unmarshaller.unmarshal(inputStream)) + .getValue(); + } + catch (Exception e) { + throw new RuntimeException + ("error while initializing usability defect descriptions", e); + } + finally { + if (inputStream != null) { + try { + inputStream.close(); + } + catch (IOException e) { + // ignore + } + } + } + } + } + + for (DefectDescription description : sDefectDescriptions.getDefectDescription()) { + if (this.name().equals(description.getDefectId())) { + defectDescription = description; + break; + } + } + + if (defectDescription == null) { + throw new RuntimeException + ("error while initializing usability defect descriptions. No " + + "description text available for description " + this.name()); + } + } + + /** + * + */ + public String[] getDescriptionParameters() { + List parameters = new ArrayList(); + + for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) { + if (fragment instanceof ParameterFragment) { + parameters.add(((ParameterFragment) fragment).getParameterName()); + } + } + + return parameters.toArray(new String[parameters.size()]); + } + + /** + * + */ + public String toString(Map parameters) throws IllegalArgumentException { + StringBuffer result = new StringBuffer(); + + for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) { + if (result.length() > 0) { + result.append(" "); + } + + if (fragment instanceof ParameterFragment) { + String value = null; + if (parameters != null) { + value = parameters.get(((ParameterFragment) fragment).getParameterName()); + } + + if (value != null) { + result.append(value); + } + else { + throw new IllegalArgumentException + ("required parameter \"" + + ((ParameterFragment) fragment).getParameterName() + + "\" for usability defect description " + this.name() + " not provided"); + } + } + else { + result.append(getFragmentString(fragment)); + } + } + + return result.toString(); + } + + /* + * (non-Javadoc) + * + * @see java.lang.Enum#toString() + */ + @Override + public String toString() { + StringBuffer result = new StringBuffer(); + + int paramCount = 1; + for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) { + if (result.length() > 0) { + result.append(" "); + } + + if (fragment instanceof ParameterFragment) { + result.append(""); + } + else { + result.append(getFragmentString(fragment)); + } + } + + return result.toString(); + } + + /** + * TODO: comment + * + * @param fragment + * @return + */ + private String getFragmentString(Object fragment) { + String fragmentStr = fragment.toString().trim(); + + fragmentStr = fragmentStr.replaceAll("\n", " "); + + while (fragmentStr.indexOf(" ") > -1) { + fragmentStr = fragmentStr.replaceAll(" ", " "); + } + + return fragmentStr; + } + +} Index: /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefectSeverity.java =================================================================== --- /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefectSeverity.java (revision 896) +++ /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefectSeverity.java (revision 896) @@ -0,0 +1,13 @@ +package de.ugoe.cs.quest.usability; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 16.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +public enum UsabilityDefectSeverity { + + INFO, LOW, MEDIUM, HIGH; + +} Index: /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityEvaluationManager.java =================================================================== --- /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityEvaluationManager.java (revision 896) +++ /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityEvaluationManager.java (revision 896) @@ -0,0 +1,81 @@ +package de.ugoe.cs.quest.usability; + +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Level; + +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; +import de.ugoe.cs.util.console.Console; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 16.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +public class UsabilityEvaluationManager { + + /** */ + private List rules = new ArrayList(); + + /** + * TODO: comment + * + */ + public UsabilityEvaluationManager() { + super(); + init(); + } + + /** + * TODO: comment + * + */ + private void init() { + rules.add(new TextInputStatisticsRule()); + } + + /** + * TODO: comment + * + * @param taskTree + */ + public UsabilityEvaluationResult evaluateUsability(ITaskTree taskTree) { + Console.traceln(Level.INFO, "evaluating usability of task tree " + taskTree); + + List results = new ArrayList(); + + for (UsabilityEvaluationRule rule : rules) { + Console.traceln(Level.INFO, "applying rule " + rule.getClass().getSimpleName()); + UsabilityEvaluationResult result = rule.evaluate(taskTree); + results.add(result); + Console.traceln(Level.INFO, "the rule found " + result.getAllDefects().size() + + " usability defects, of which " + result.getSevereDefects().size() + + " are severe."); + } + + UsabilityEvaluationResult result = mergeResults(results); + Console.println("the evaluation result contains " + result.getAllDefects().size() + + " defects, of which " + result.getSevereDefects().size() + " are severe."); + return result; + } + + /** + * TODO: comment + * + * @param results + * @return + */ + private UsabilityEvaluationResult mergeResults(List results) { + UsabilityEvaluationResult result = new UsabilityEvaluationResult(); + + for (UsabilityEvaluationResult ruleResult : results) { + for (UsabilityDefect defect : ruleResult.getAllDefects()) { + result.addDefect(defect); + } + } + + return result; + } + +} Index: /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityEvaluationResult.java =================================================================== --- /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityEvaluationResult.java (revision 896) +++ /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityEvaluationResult.java (revision 896) @@ -0,0 +1,52 @@ +package de.ugoe.cs.quest.usability; + +import java.util.ArrayList; +import java.util.List; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 16.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +public class UsabilityEvaluationResult { + + /** */ + private List defects = new ArrayList(); + + /** + * TODO: comment + * + * @param defect + */ + public void addDefect(UsabilityDefect defect) { + defects.add(defect); + } + + /** + * TODO: comment + * + * @return + */ + public List getAllDefects() { + return defects; + } + + /** + * TODO: comment + * + * @return + */ + public List getSevereDefects() { + List severeDefects = new ArrayList(); + + for (UsabilityDefect defect : defects) { + if (defect.getSeverity() == UsabilityDefectSeverity.HIGH) { + severeDefects.add(defect); + } + } + + return severeDefects; + } + +} Index: /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityEvaluationRule.java =================================================================== --- /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityEvaluationRule.java (revision 896) +++ /trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityEvaluationRule.java (revision 896) @@ -0,0 +1,21 @@ +package de.ugoe.cs.quest.usability; + +import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; + +/** + * TODO comment + * + * @version $Revision: $ $Date: 16.07.2012$ + * @author 2012, last modified by $Author: pharms$ + */ +public interface UsabilityEvaluationRule { + + /** + * TODO: comment + * + * @param taskTree + * @return + */ + UsabilityEvaluationResult evaluate(ITaskTree taskTree); + +} Index: /trunk/autoquest-core-usability/src/main/resources/defectDescriptions.xsd =================================================================== --- /trunk/autoquest-core-usability/src/main/resources/defectDescriptions.xsd (revision 896) +++ /trunk/autoquest-core-usability/src/main/resources/defectDescriptions.xsd (revision 896) @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + Index: /trunk/autoquest-core-usability/src/main/resources/defectDescriptions_en.xml =================================================================== --- /trunk/autoquest-core-usability/src/main/resources/defectDescriptions_en.xml (revision 896) +++ /trunk/autoquest-core-usability/src/main/resources/defectDescriptions_en.xml (revision 896) @@ -0,0 +1,44 @@ + + + + + + The ratio of interactions that enter text into text fields is relatively high in comparison + with the other user interactions ( + + + + ). This should be reduced. As an example, entering data can also be done using check boxes + or combo boxes in the case predefined values must be entered. + + + + + + Several interactions that enter text into text fields repeat tokens such as words or + specific signs ( + + + + ). This is an indicator that the same data must be entered several times. This could be + better supported by using e.g. automatic filling of input fields, provision of combo + boxes or lists prefilled with data that was already entered previously. + + + + + + Much of the text entered into text fields contains signs other than letters or digits ( + + + + ). This is an indicator that the entered data has to follow a specific syntax. This should + be supported by syntax checking, auto completion or even providing the text fields in a way + that does not require the entering of special signs as they are already included at the right + positions. + + +