- Timestamp:
- 08/17/12 09:26:21 (12 years ago)
- Location:
- trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability
- Files:
-
- 7 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability/TextInputStatisticsRule.java
r496 r561 1 //-------------------------------------------------------------------------------------------------2 1 // Module : $RCSfile: TextInputStatisticsRule.java,v $ 3 2 // Version : $Revision: 0.0 $ $Author: pharms $ $Date: 16.07.2012 $ … … 5 4 // Creation : 2012 by pharms 6 5 // Copyright : Patrick Harms, 2012 7 //------------------------------------------------------------------------------------------------- 6 7 8 8 package de.ugoe.cs.quest.usability; 9 9 … … 14 14 import java.util.Map; 15 15 16 import de.ugoe.cs.quest.eventcore.guimodel.TextArea; 17 import de.ugoe.cs.quest.eventcore.guimodel.TextField; 18 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; 19 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; 20 import de.ugoe.cs.quest.tasktrees.treeifc.TextInputInteractionTask; 21 22 //------------------------------------------------------------------------------------------------- 16 import de.ugoe.cs.quest.eventcore.guimodel.ITextArea; 17 import de.ugoe.cs.quest.eventcore.guimodel.ITextField; 18 import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; 19 import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; 20 import de.ugoe.cs.quest.tasktrees.treeifc.ITextInputEventTask; 21 23 22 /** 24 23 * TODO comment … … 27 26 * @author 2012, last modified by $Author: pharms$ 28 27 */ 29 //------------------------------------------------------------------------------------------------- 30 public class TextInputStatisticsRule implements de.ugoe.cs.quest.usability.UsabilityEvaluationRule 31 { 32 33 //----------------------------------------------------------------------------------------------- 34 /* (non-Javadoc) 35 * @see de.ugoe.cs.usability.UsabilityEvaluationRule#evaluate(TaskTree) 36 */ 37 //----------------------------------------------------------------------------------------------- 38 @Override 39 public UsabilityEvaluationResult evaluate(TaskTree taskTree) 40 { 41 TextInputStatistics statistics = new TextInputStatistics(); 42 calculateStatistics(taskTree.getRoot(), statistics); 43 44 UsabilityEvaluationResult results = new UsabilityEvaluationResult(); 45 analyzeStatistics(statistics, results); 46 47 return results; 48 } 49 50 //----------------------------------------------------------------------------------------------- 51 /** 52 * TODO: comment 53 * 54 * @param statistics 55 * @param results 56 */ 57 //----------------------------------------------------------------------------------------------- 58 private void analyzeStatistics(TextInputStatistics statistics, UsabilityEvaluationResult results) 59 { 60 checkTextInputRatio(statistics, results); 61 checkTextFieldEntryRepetitions(statistics, results); 62 checkTextFieldNoLetterOrDigitInputs(statistics, results); 63 } 64 65 //----------------------------------------------------------------------------------------------- 66 /** 67 * TODO: comment 68 * 69 * @param statistics 70 * @param results 71 */ 72 //----------------------------------------------------------------------------------------------- 73 private void checkTextInputRatio(TextInputStatistics statistics, 28 public class TextInputStatisticsRule implements de.ugoe.cs.quest.usability.UsabilityEvaluationRule { 29 30 /* 31 * (non-Javadoc) 32 * 33 * @see de.ugoe.cs.usability.UsabilityEvaluationRule#evaluate(TaskTree) 34 */ 35 @Override 36 public UsabilityEvaluationResult evaluate(ITaskTree taskTree) { 37 TextInputStatistics statistics = new TextInputStatistics(); 38 calculateStatistics(taskTree.getRoot(), statistics); 39 40 UsabilityEvaluationResult results = new UsabilityEvaluationResult(); 41 analyzeStatistics(statistics, results); 42 43 return results; 44 } 45 46 /** 47 * TODO: comment 48 * 49 * @param statistics 50 * @param results 51 */ 52 private void analyzeStatistics(TextInputStatistics statistics, 74 53 UsabilityEvaluationResult results) 75 {76 float allTextFieldInputs =77 statistics.getNoOfTextFieldInputs() + statistics.getNoOfTextAreaInputs();78 79 float ratio = allTextFieldInputs / (float) statistics.getNoOfAllInteractions();80 81 UsabilityDefectSeverity severity = null;82 if (ratio > 0.9)83 54 { 84 severity = UsabilityDefectSeverity.HIGH; 85 } 86 else if (ratio > 0.7) 55 checkTextInputRatio(statistics, results); 56 checkTextFieldEntryRepetitions(statistics, results); 57 checkTextFieldNoLetterOrDigitInputs(statistics, results); 58 } 59 60 /** 61 * TODO: comment 62 * 63 * @param statistics 64 * @param results 65 */ 66 private void checkTextInputRatio(TextInputStatistics statistics, 67 UsabilityEvaluationResult results) 87 68 { 88 severity = UsabilityDefectSeverity.MEDIUM; 89 } 90 else if (ratio > 0.5) 69 float allTextFieldInputs = 70 statistics.getNoOfTextFieldInputs() + statistics.getNoOfTextAreaInputs(); 71 72 float ratio = allTextFieldInputs / (float) statistics.getNoOfAllEvents(); 73 74 UsabilityDefectSeverity severity = null; 75 if (ratio > 0.9) { 76 severity = UsabilityDefectSeverity.HIGH; 77 } 78 else if (ratio > 0.7) { 79 severity = UsabilityDefectSeverity.MEDIUM; 80 } 81 else if (ratio > 0.5) { 82 severity = UsabilityDefectSeverity.LOW; 83 } 84 else if (ratio > 0.3) { 85 severity = UsabilityDefectSeverity.INFO; 86 } 87 88 if (severity != null) { 89 Map<String, String> parameters = new HashMap<String, String>(); 90 parameters.put("textInputRatio", DecimalFormat.getInstance().format(ratio * 100) + "%"); 91 92 results.addDefect 93 (new UsabilityDefect(severity, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO, 94 parameters)); 95 } 96 } 97 98 /** 99 * TODO: comment 100 * 101 * @param statistics 102 * @param results 103 */ 104 private void checkTextFieldEntryRepetitions(TextInputStatistics statistics, 105 UsabilityEvaluationResult results) 91 106 { 92 severity = UsabilityDefectSeverity.LOW; 93 } 94 else if (ratio > 0.3) 107 Map<String, Integer> words = new HashMap<String, Integer>(); 108 int numberOfRepeatedWords = 0; 109 int maxRepetitions = 0; 110 111 for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) { 112 String[] fragments = statistics.getTextFieldInputFragments(i); 113 for (String fragment : fragments) { 114 if (!"".equals(fragment.trim())) { 115 Integer count = words.get(fragment); 116 if (count == null) { 117 words.put(fragment, 1); 118 } 119 else { 120 count++; 121 words.put(fragment, count); 122 maxRepetitions = Math.max(count, maxRepetitions); 123 124 if (count == 2) { 125 // do not calculate repeated words several times 126 numberOfRepeatedWords++; 127 } 128 } 129 } 130 } 131 } 132 133 UsabilityDefectSeverity severity = null; 134 if ((numberOfRepeatedWords > 10) || (maxRepetitions > 10)) { 135 severity = UsabilityDefectSeverity.HIGH; 136 } 137 else if ((numberOfRepeatedWords > 4) || (maxRepetitions > 4)) { 138 severity = UsabilityDefectSeverity.MEDIUM; 139 } 140 else if ((numberOfRepeatedWords > 2) || (maxRepetitions > 2)) { 141 severity = UsabilityDefectSeverity.LOW; 142 } 143 else if ((numberOfRepeatedWords > 1) || (maxRepetitions > 1)) { 144 severity = UsabilityDefectSeverity.INFO; 145 } 146 147 if (severity != null) { 148 Map<String, String> parameters = new HashMap<String, String>(); 149 parameters.put("textRepetitionRatio", numberOfRepeatedWords + 150 " repeated tokens, up to " + maxRepetitions + " repetitions per token"); 151 152 results.addDefect 153 (new UsabilityDefect(severity, 154 UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS, 155 parameters)); 156 } 157 } 158 159 /** 160 * TODO: comment 161 * 162 * @param statistics 163 * @param results 164 */ 165 private void checkTextFieldNoLetterOrDigitInputs(TextInputStatistics statistics, 166 UsabilityEvaluationResult results) 95 167 { 96 severity = UsabilityDefectSeverity.INFO; 97 } 98 99 if (severity != null) 100 { 101 Map<String, String> parameters = new HashMap<String, String>(); 102 parameters.put("textInputRatio", DecimalFormat.getInstance().format(ratio * 100) + "%"); 103 104 results.addDefect 105 (new UsabilityDefect 106 (severity, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO, parameters)); 107 } 108 } 109 110 //----------------------------------------------------------------------------------------------- 111 /** 112 * TODO: comment 113 * 114 * @param statistics 115 * @param results 116 */ 117 //----------------------------------------------------------------------------------------------- 118 private void checkTextFieldEntryRepetitions(TextInputStatistics statistics, 119 UsabilityEvaluationResult results) 120 { 121 Map<String, Integer> words = new HashMap<String, Integer>(); 122 int numberOfRepeatedWords = 0; 123 int maxRepetitions = 0; 124 125 for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) 126 { 127 String[] fragments = statistics.getTextFieldInputFragments(i); 128 for (String fragment : fragments) 129 { 130 if (!"".equals(fragment.trim())) 168 int allCharactersCount = 0; 169 int noLetterOrDigitCount = 0; 170 171 for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) { 172 String[] fragments = statistics.getTextFieldInputFragments(i); 173 for (String fragment : fragments) { 174 String effectiveFragment = fragment.trim(); 175 for (int j = 0; j < effectiveFragment.length(); j++) { 176 if (!Character.isWhitespace(effectiveFragment.charAt(j))) { 177 if (!Character.isLetterOrDigit(effectiveFragment.charAt(j))) { 178 noLetterOrDigitCount++; 179 } 180 allCharactersCount++; 181 } 182 } 183 } 184 } 185 186 float ratio = (float) noLetterOrDigitCount / (float) allCharactersCount; 187 188 UsabilityDefectSeverity severity = null; 189 if (ratio > 0.1) // every 10th sign 131 190 { 132 Integer count = words.get(fragment); 133 if (count == null) 134 { 135 words.put(fragment, 1); 136 } 137 else 138 { 139 count++; 140 words.put(fragment, count); 141 maxRepetitions = Math.max(count, maxRepetitions); 142 143 if (count == 2) 144 { 145 // do not calculate repeated words several times 146 numberOfRepeatedWords++; 191 severity = UsabilityDefectSeverity.HIGH; 192 } 193 else if (ratio > 0.05) // every 20th sign 194 { 195 severity = UsabilityDefectSeverity.MEDIUM; 196 } 197 else if (ratio > 0.02) // every 50th sign 198 { 199 severity = UsabilityDefectSeverity.LOW; 200 } 201 else if (ratio > 0.01) // every 100th sign 202 { 203 severity = UsabilityDefectSeverity.INFO; 204 } 205 206 if (severity != null) { 207 Map<String, String> parameters = new HashMap<String, String>(); 208 parameters.put("noLetterOrDigitRatio", allCharactersCount + " entered characters of " + 209 "which " + noLetterOrDigitCount + " were no letter or digit"); 210 211 results.addDefect 212 (new UsabilityDefect(severity, 213 UsabilityDefectDescription.TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO, 214 parameters)); 215 } 216 } 217 218 /** 219 * TODO: comment 220 * 221 * @param taskTree 222 * @param statistics 223 */ 224 private void calculateStatistics(ITaskTreeNode node, TextInputStatistics statistics) { 225 if (node instanceof ITextInputEventTask) { 226 calculateStatistics((ITextInputEventTask) node, statistics); 227 } 228 else { 229 if ((node.getChildren() == null) || (node.getChildren().size() == 0)) { 230 statistics.incrementNoOfOtherEventTasks(); 147 231 } 148 } 149 } 150 } 151 } 152 153 UsabilityDefectSeverity severity = null; 154 if ((numberOfRepeatedWords > 10) || (maxRepetitions > 10)) 155 { 156 severity = UsabilityDefectSeverity.HIGH; 157 } 158 else if ((numberOfRepeatedWords > 4) || (maxRepetitions > 4)) 159 { 160 severity = UsabilityDefectSeverity.MEDIUM; 161 } 162 else if ((numberOfRepeatedWords > 2) || (maxRepetitions > 2)) 163 { 164 severity = UsabilityDefectSeverity.LOW; 165 } 166 else if ((numberOfRepeatedWords > 1) || (maxRepetitions > 1)) 167 { 168 severity = UsabilityDefectSeverity.INFO; 169 } 170 171 if (severity != null) 172 { 173 Map<String, String> parameters = new HashMap<String, String>(); 174 parameters.put("textRepetitionRatio", numberOfRepeatedWords + " repeated tokens, up to " + 175 maxRepetitions + " repetitions per token"); 176 177 results.addDefect 178 (new UsabilityDefect 179 (severity, UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS, parameters)); 180 } 181 } 182 183 //----------------------------------------------------------------------------------------------- 184 /** 185 * TODO: comment 186 * 187 * @param statistics 188 * @param results 189 */ 190 //----------------------------------------------------------------------------------------------- 191 private void checkTextFieldNoLetterOrDigitInputs(TextInputStatistics statistics, 192 UsabilityEvaluationResult results) 193 { 194 int allCharactersCount = 0; 195 int noLetterOrDigitCount = 0; 196 197 for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) 198 { 199 String[] fragments = statistics.getTextFieldInputFragments(i); 200 for (String fragment : fragments) 201 { 202 String effectiveFragment = fragment.trim(); 203 for (int j = 0; j < effectiveFragment.length(); j++) 204 { 205 if (!Character.isWhitespace(effectiveFragment.charAt(j))) 206 { 207 if (!Character.isLetterOrDigit(effectiveFragment.charAt(j))) 208 { 209 noLetterOrDigitCount++; 232 else { 233 for (ITaskTreeNode child : node.getChildren()) { 234 calculateStatistics(child, statistics); 235 } 210 236 } 211 allCharactersCount++; 212 } 213 } 214 } 215 } 216 217 float ratio = (float) noLetterOrDigitCount / (float) allCharactersCount; 218 219 UsabilityDefectSeverity severity = null; 220 if (ratio > 0.1) // every 10th sign 221 { 222 severity = UsabilityDefectSeverity.HIGH; 223 } 224 else if (ratio > 0.05) // every 20th sign 225 { 226 severity = UsabilityDefectSeverity.MEDIUM; 227 } 228 else if (ratio > 0.02) // every 50th sign 229 { 230 severity = UsabilityDefectSeverity.LOW; 231 } 232 else if (ratio > 0.01) // every 100th sign 233 { 234 severity = UsabilityDefectSeverity.INFO; 235 } 236 237 if (severity != null) 238 { 239 Map<String, String> parameters = new HashMap<String, String>(); 240 parameters.put("noLetterOrDigitRatio", allCharactersCount + " entered characters of " + 241 "which " + noLetterOrDigitCount + " were no letter or digit"); 242 243 results.addDefect 244 (new UsabilityDefect 245 (severity, UsabilityDefectDescription.TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO, parameters)); 246 } 247 } 248 249 //----------------------------------------------------------------------------------------------- 250 /** 251 * TODO: comment 252 * 253 * @param taskTree 254 * @param statistics 255 */ 256 //----------------------------------------------------------------------------------------------- 257 private void calculateStatistics(TaskTreeNode node, TextInputStatistics statistics) 258 { 259 if (node instanceof TextInputInteractionTask) 260 { 261 calculateStatistics((TextInputInteractionTask) node, statistics); 262 } 263 else 264 { 265 if ((node.getChildren() == null) || 266 (node.getChildren().size() == 0)) 267 { 268 statistics.incrementNoOfOtherInteractionTasks(); 269 } 270 else 271 { 272 for (TaskTreeNode child : node.getChildren()) 273 { 274 calculateStatistics(child, statistics); 275 } 276 } 277 } 278 } 279 280 //----------------------------------------------------------------------------------------------- 281 /** 282 * TODO: comment 283 * 284 * @param taskTree 285 * @param statistics 286 */ 287 //----------------------------------------------------------------------------------------------- 288 private void calculateStatistics(TextInputInteractionTask node, TextInputStatistics statistics) 289 { 290 String[] fragments = determineTextFragments(node.getEnteredText()); 291 292 if (node.getGUIElement() instanceof TextField) 293 { 294 statistics.addTextFieldInput(node, fragments); 295 } 296 else if (node.getGUIElement() instanceof TextArea) 297 { 298 statistics.addTextAreaInput(node, fragments); 299 } 300 } 301 302 //----------------------------------------------------------------------------------------------- 303 /** 304 * TODO: comment 305 * 306 * @param enteredText 307 * @return 308 */ 309 //----------------------------------------------------------------------------------------------- 310 private String[] determineTextFragments(String enteredText) 311 { 312 List<String> fragments = new ArrayList<String>(); 313 314 StringBuffer fragment = new StringBuffer(); 315 char lastChar = 0; 316 317 for (int i = 0; i < enteredText.length(); i++) 318 { 319 char currentChar = enteredText.charAt(i); 320 321 if (!isEqualCharacterType(lastChar, currentChar)) 322 { 323 // the previous fragment ended. so finalize it and start a new one 324 if ((fragment != null) && (fragment.length() > 0)) 325 { 326 fragments.add(fragment.toString()); 327 fragment = new StringBuffer(); 328 } 329 } 330 331 fragment.append(currentChar); 332 lastChar = currentChar; 333 } 334 335 if ((fragment != null) && (fragment.length() > 0)) 336 { 337 fragments.add(fragment.toString()); 338 } 339 340 return fragments.toArray(new String[fragments.size()]); 341 } 342 343 //----------------------------------------------------------------------------------------------- 344 /** 345 * TODO: comment 346 * 347 * @param lastChar 348 * @param currentChar 349 * @return 350 */ 351 //----------------------------------------------------------------------------------------------- 352 private boolean isEqualCharacterType(char char1, char char2) 353 { 354 return 355 ((char1 == char2) || 356 (Character.isWhitespace(char1) && Character.isWhitespace(char2)) || 357 (Character.isDigit(char1) && Character.isDigit(char2)) || 358 (Character.isLetter(char1) && Character.isLetter(char2)) || 359 (Character.isJavaIdentifierPart(char1) && Character.isJavaIdentifierPart(char2))); 360 } 361 362 //------------------------------------------------------------------------------------------------- 363 /** 364 * TODO comment 365 * 366 * @version $Revision: $ $Date: 16.07.2012$ 367 * @author 2012, last modified by $Author: pharms$ 368 */ 369 //------------------------------------------------------------------------------------------------- 370 public static class TextInputStatistics 371 { 372 /** */ 373 private List<Object[]> mTextFieldInputs = new ArrayList<Object[]>(); 374 375 /** */ 376 private List<Object[]> mTextAreaInputs = new ArrayList<Object[]>(); 377 378 /** */ 379 private int mOtherInteractionsCount; 380 381 //----------------------------------------------------------------------------------------------- 382 /** 383 * TODO: comment 384 * @param node 385 * @param fragments 386 * 387 */ 388 //----------------------------------------------------------------------------------------------- 389 public void addTextFieldInput(TextInputInteractionTask node, String[] fragments) 390 { 391 mTextFieldInputs.add(new Object[] { node, fragments }); 392 } 393 394 //----------------------------------------------------------------------------------------------- 395 /** 396 * TODO: comment 397 * @param node 398 * @param fragments 399 * 400 */ 401 //----------------------------------------------------------------------------------------------- 402 public void addTextAreaInput(TextInputInteractionTask node, String[] fragments) 403 { 404 mTextAreaInputs.add(new Object[] { node, fragments }); 405 } 406 407 //----------------------------------------------------------------------------------------------- 408 /** 409 * TODO: comment 410 * 237 } 238 } 239 240 /** 241 * TODO: comment 242 * 243 * @param taskTree 244 * @param statistics 245 */ 246 private void calculateStatistics(ITextInputEventTask node, TextInputStatistics statistics) { 247 String[] fragments = determineTextFragments(node.getEnteredText()); 248 249 if (node.getEventTarget() instanceof ITextField) { 250 statistics.addTextFieldInput(node, fragments); 251 } 252 else if (node.getEventTarget() instanceof ITextArea) { 253 statistics.addTextAreaInput(node, fragments); 254 } 255 } 256 257 /** 258 * TODO: comment 259 * 260 * @param enteredText 411 261 * @return 412 262 */ 413 //----------------------------------------------------------------------------------------------- 414 public int getNoOfAllInteractions() 415 { 416 return mTextFieldInputs.size() + mTextAreaInputs.size() + mOtherInteractionsCount; 417 } 418 419 //----------------------------------------------------------------------------------------------- 420 /** 421 * TODO: comment 422 * 263 private String[] determineTextFragments(String enteredText) { 264 List<String> fragments = new ArrayList<String>(); 265 266 StringBuffer fragment = new StringBuffer(); 267 char lastChar = 0; 268 269 for (int i = 0; i < enteredText.length(); i++) { 270 char currentChar = enteredText.charAt(i); 271 272 if (!isEqualCharacterType(lastChar, currentChar)) { 273 // the previous fragment ended. so finalize it and start a new one 274 if ((fragment != null) && (fragment.length() > 0)) { 275 fragments.add(fragment.toString()); 276 fragment = new StringBuffer(); 277 } 278 } 279 280 fragment.append(currentChar); 281 lastChar = currentChar; 282 } 283 284 if ((fragment != null) && (fragment.length() > 0)) { 285 fragments.add(fragment.toString()); 286 } 287 288 return fragments.toArray(new String[fragments.size()]); 289 } 290 291 /** 292 * TODO: comment 293 * 294 * @param lastChar 295 * @param currentChar 423 296 * @return 424 297 */ 425 //----------------------------------------------------------------------------------------------- 426 public int getNoOfTextFieldInputs() 427 { 428 return mTextFieldInputs.size(); 429 } 430 431 //----------------------------------------------------------------------------------------------- 432 /** 433 * TODO: comment 434 * 435 * @param i 436 * @return 437 */ 438 //----------------------------------------------------------------------------------------------- 439 public String[] getTextFieldInputFragments(int index) 440 { 441 return (String[]) mTextFieldInputs.get(index)[1]; 442 } 443 444 //----------------------------------------------------------------------------------------------- 445 /** 446 * TODO: comment 447 * 448 * @return 449 */ 450 //----------------------------------------------------------------------------------------------- 451 public int getNoOfTextAreaInputs() 452 { 453 return mTextAreaInputs.size(); 454 } 455 456 //----------------------------------------------------------------------------------------------- 457 /** 458 * TODO: comment 459 * 460 * @param i 461 * @return 462 */ 463 //----------------------------------------------------------------------------------------------- 464 public String[] getTextAreaInputFragments(int index) 465 { 466 return (String[]) mTextAreaInputs.get(index)[1]; 467 } 468 469 //----------------------------------------------------------------------------------------------- 470 /** 471 * TODO: comment 472 * 473 */ 474 //----------------------------------------------------------------------------------------------- 475 public void incrementNoOfOtherInteractionTasks() 476 { 477 mOtherInteractionsCount++; 478 } 479 480 481 } 298 private boolean isEqualCharacterType(char char1, char char2) { 299 return 300 ((char1 == char2) || 301 (Character.isWhitespace(char1) && Character.isWhitespace(char2)) || 302 (Character.isDigit(char1) && Character.isDigit(char2)) || 303 (Character.isLetter(char1) && Character.isLetter(char2)) || 304 (Character.isJavaIdentifierPart(char1) && Character.isJavaIdentifierPart(char2))); 305 } 306 307 /** 308 * TODO comment 309 * 310 * @version $Revision: $ $Date: 16.07.2012$ 311 * @author 2012, last modified by $Author: pharms$ 312 */ 313 public static class TextInputStatistics { 314 315 /** */ 316 private List<Object[]> textFieldInputs = new ArrayList<Object[]>(); 317 318 /** */ 319 private List<Object[]> textAreaInputs = new ArrayList<Object[]>(); 320 321 /** */ 322 private int otherEventsCount; 323 324 /** 325 * TODO: comment 326 * 327 * @param node 328 * @param fragments 329 * 330 */ 331 public void addTextFieldInput(ITextInputEventTask node, String[] fragments) { 332 textFieldInputs.add(new Object[] { node, fragments }); 333 } 334 335 /** 336 * TODO: comment 337 * 338 * @param node 339 * @param fragments 340 * 341 */ 342 public void addTextAreaInput(ITextInputEventTask node, String[] fragments) { 343 textAreaInputs.add(new Object[] { node, fragments }); 344 } 345 346 /** 347 * TODO: comment 348 * 349 * @return 350 */ 351 public int getNoOfAllEvents() { 352 return textFieldInputs.size() + textAreaInputs.size() + otherEventsCount; 353 } 354 355 /** 356 * TODO: comment 357 * 358 * @return 359 */ 360 public int getNoOfTextFieldInputs() { 361 return textFieldInputs.size(); 362 } 363 364 /** 365 * TODO: comment 366 * 367 * @param i 368 * @return 369 */ 370 public String[] getTextFieldInputFragments(int index) { 371 return (String[]) textFieldInputs.get(index)[1]; 372 } 373 374 /** 375 * TODO: comment 376 * 377 * @return 378 */ 379 public int getNoOfTextAreaInputs() { 380 return textAreaInputs.size(); 381 } 382 383 /** 384 * TODO: comment 385 * 386 * @param i 387 * @return 388 */ 389 public String[] getTextAreaInputFragments(int index) { 390 return (String[]) textAreaInputs.get(index)[1]; 391 } 392 393 /** 394 * TODO: comment 395 * 396 */ 397 public void incrementNoOfOtherEventTasks() { 398 otherEventsCount++; 399 } 400 401 } 482 402 483 403 } -
trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefect.java
r477 r561 1 //-------------------------------------------------------------------------------------------------2 1 // Module : $RCSfile: UsabilityDefect.java,v $ 3 2 // Version : $Revision: 0.0 $ $Author: pharms $ $Date: 16.07.2012 $ … … 5 4 // Creation : 2012 by pharms 6 5 // Copyright : Patrick Harms, 2012 7 //------------------------------------------------------------------------------------------------- 6 7 8 8 package de.ugoe.cs.quest.usability; 9 9 10 10 import java.util.Map; 11 11 12 //-------------------------------------------------------------------------------------------------13 12 /** 14 13 * TODO comment … … 17 16 * @author 2012, last modified by $Author: pharms$ 18 17 */ 19 //------------------------------------------------------------------------------------------------- 20 public class UsabilityDefect 21 { 18 public class UsabilityDefect { 22 19 23 /** */ 24 private UsabilityDefectSeverity mSeverity; 25 26 /** */ 27 private UsabilityDefectDescription mDescription; 20 /** */ 21 private UsabilityDefectSeverity severity; 28 22 29 /** */30 private Map<String, String> mDescriptionParameters;23 /** */ 24 private UsabilityDefectDescription description; 31 25 32 //----------------------------------------------------------------------------------------------- 33 /** 34 * TODO: comment 35 * 36 * @param medium 37 * @param highTextInputRatio 38 */ 39 //----------------------------------------------------------------------------------------------- 40 public UsabilityDefect(UsabilityDefectSeverity severity, 41 UsabilityDefectDescription description) 42 { 43 this(severity, description, null); 44 } 26 /** */ 27 private Map<String, String> descriptionParameters; 45 28 46 //----------------------------------------------------------------------------------------------- 47 /** 48 * TODO: comment 49 * 50 * @param medium 51 * @param highTextInputRatio 52 */ 53 //----------------------------------------------------------------------------------------------- 54 public UsabilityDefect(UsabilityDefectSeverity severity, 55 UsabilityDefectDescription description, 56 Map<String, String> parameters) 57 { 58 mSeverity = severity; 59 mDescription = description; 60 mDescriptionParameters = parameters; 61 } 29 /** 30 * TODO: comment 31 * 32 * @param medium 33 * @param highTextInputRatio 34 */ 35 public UsabilityDefect(UsabilityDefectSeverity severity, UsabilityDefectDescription description) 36 { 37 this(severity, description, null); 38 } 62 39 63 //----------------------------------------------------------------------------------------------- 64 /** 65 * TODO: comment 66 * 67 * @return 68 */ 69 //----------------------------------------------------------------------------------------------- 70 public UsabilityDefectSeverity getSeverity() 71 { 72 return mSeverity; 73 } 40 /** 41 * TODO: comment 42 * 43 * @param medium 44 * @param highTextInputRatio 45 */ 46 public UsabilityDefect(UsabilityDefectSeverity severity, 47 UsabilityDefectDescription description, 48 Map<String, String> parameters) 49 { 50 this.severity = severity; 51 this.description = description; 52 this.descriptionParameters = parameters; 53 } 74 54 75 //----------------------------------------------------------------------------------------------- 76 /** 77 * @param severity the severity to set 78 */ 79 //----------------------------------------------------------------------------------------------- 80 public void setSeverity(UsabilityDefectSeverity severity) 81 { 82 mSeverity = severity; 83 } 55 /** 56 * TODO: comment 57 * 58 * @return 59 */ 60 public UsabilityDefectSeverity getSeverity() { 61 return severity; 62 } 84 63 85 //----------------------------------------------------------------------------------------------- 86 /** 87 * @param description the description to set 88 */ 89 //----------------------------------------------------------------------------------------------- 90 public void setDescription(UsabilityDefectDescription description) 91 { 92 mDescription = description; 93 } 64 /** 65 * @param severity 66 * the severity to set 67 */ 68 public void setSeverity(UsabilityDefectSeverity severity) { 69 this.severity = severity; 70 } 94 71 95 //----------------------------------------------------------------------------------------------- 96 /** 72 /** 73 * @param description 74 * the description to set 75 */ 76 public void setDescription(UsabilityDefectDescription description) { 77 this.description = description; 78 } 79 80 /** 97 81 * 98 82 */ 99 //----------------------------------------------------------------------------------------------- 100 public String getParameterizedDescription() 101 { 102 return mDescription.toString(mDescriptionParameters); 103 } 83 public String getParameterizedDescription() { 84 return description.toString(descriptionParameters); 85 } 104 86 105 //----------------------------------------------------------------------------------------------- 106 /* (non-Javadoc) 107 * @see java.lang.Object#equals(java.lang.Object) 108 */ 109 //----------------------------------------------------------------------------------------------- 110 @Override 111 public boolean equals(Object obj) 112 { 113 if (obj instanceof UsabilityDefect) 114 { 115 return 116 (mSeverity == ((UsabilityDefect) obj).mSeverity) && 117 (mDescription == ((UsabilityDefect) obj).mDescription); 87 /* 88 * (non-Javadoc) 89 * 90 * @see java.lang.Object#equals(java.lang.Object) 91 */ 92 @Override 93 public boolean equals(Object obj) { 94 if (obj instanceof UsabilityDefect) { 95 return 96 (severity == ((UsabilityDefect) obj).severity) && 97 (description == ((UsabilityDefect) obj).description); 98 } 99 else { 100 return false; 101 } 118 102 } 119 else 120 { 121 return false; 103 104 /* 105 * (non-Javadoc) 106 * 107 * @see java.lang.Object#hashCode() 108 */ 109 @Override 110 public int hashCode() { 111 return severity.hashCode() + description.hashCode(); 122 112 } 123 }124 113 125 //----------------------------------------------------------------------------------------------- 126 /* (non-Javadoc) 127 * @see java.lang.Object#hashCode() 128 */ 129 //----------------------------------------------------------------------------------------------- 130 @Override 131 public int hashCode() 132 { 133 return mSeverity.hashCode() + mDescription.hashCode(); 134 } 135 136 //----------------------------------------------------------------------------------------------- 137 /* (non-Javadoc) 138 * @see java.lang.Object#toString() 139 */ 140 //----------------------------------------------------------------------------------------------- 141 @Override 142 public String toString() 143 { 144 return "UsabilityDefect(" + mSeverity.name() + ", " + mDescription.name() + ")"; 145 } 114 /* 115 * (non-Javadoc) 116 * 117 * @see java.lang.Object#toString() 118 */ 119 @Override 120 public String toString() { 121 return "UsabilityDefect(" + severity.name() + ", " + description.name() + ")"; 122 } 146 123 147 124 } -
trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefectDescription.java
r496 r561 1 //-------------------------------------------------------------------------------------------------2 1 // Module : $RCSfile: UsabilityDefectDescriptions.java,v $ 3 2 // Version : $Revision: 0.0 $ $Author: pharms $ $Date: 18.07.2012 $ … … 5 4 // Creation : 2012 by pharms 6 5 // Copyright : Patrick Harms, 2012 7 //------------------------------------------------------------------------------------------------- 6 8 7 package de.ugoe.cs.quest.usability; 9 8 … … 18 17 import javax.xml.bind.Unmarshaller; 19 18 20 //-------------------------------------------------------------------------------------------------21 19 /** 22 20 * TODO comment … … 25 23 * @author 2012, last modified by $Author: pharms$ 26 24 */ 27 //------------------------------------------------------------------------------------------------- 28 public enum UsabilityDefectDescription 29 { 30 TEXT_FIELD_INPUT_RATIO, 31 TEXT_FIELD_INPUT_REPETITIONS, 32 TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO; 25 public enum UsabilityDefectDescription { 26 27 TEXT_FIELD_INPUT_RATIO, 28 TEXT_FIELD_INPUT_REPETITIONS, 29 TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO; 33 30 34 /** */ 35 private static final String DEFAULT_MESSAGES_FILE = "defectDescriptions_en.xml"; 36 37 /** */ 38 private static DefectDescriptions sDefectDescriptions; 31 /** */ 32 private static final String DEFAULT_MESSAGES_FILE = "defectDescriptions_en.xml"; 39 33 40 /** */ 41 private DefectDescription mDefectDescription; 42 43 //----------------------------------------------------------------------------------------------- 44 /** 45 * TODO: comment 46 * 47 * @param name 48 * @param ordinal 49 */ 50 //----------------------------------------------------------------------------------------------- 51 private UsabilityDefectDescription() 52 { 53 init(); 54 } 34 /** */ 35 private static DefectDescriptions sDefectDescriptions; 55 36 56 //----------------------------------------------------------------------------------------------- 57 /** 58 * TODO: comment 59 * 60 */ 61 //----------------------------------------------------------------------------------------------- 62 @SuppressWarnings("unchecked") 63 private void init() 64 { 65 synchronized (this.getClass()) 66 { 67 if (sDefectDescriptions == null) 68 { 69 InputStream inputStream = ClassLoader.getSystemResourceAsStream(DEFAULT_MESSAGES_FILE); 37 /** */ 38 private DefectDescription defectDescription; 70 39 71 try 72 { 73 String packageName = DefectDescriptions.class.getPackage().getName(); 74 JAXBContext jaxbContext = JAXBContext.newInstance(packageName); 75 Unmarshaller unmarshaller = jaxbContext.createUnmarshaller(); 76 77 sDefectDescriptions = 78 ((JAXBElement<DefectDescriptions>) unmarshaller.unmarshal(inputStream)).getValue(); 40 /** 41 * TODO: comment 42 * 43 * @param name 44 * @param ordinal 45 */ 46 private UsabilityDefectDescription() { 47 init(); 48 } 49 50 /** 51 * TODO: comment 52 * 53 */ 54 @SuppressWarnings("unchecked") 55 private void init() { 56 synchronized (this.getClass()) { 57 if (sDefectDescriptions == null) { 58 InputStream inputStream = 59 ClassLoader.getSystemResourceAsStream(DEFAULT_MESSAGES_FILE); 60 61 try { 62 String packageName = DefectDescriptions.class.getPackage().getName(); 63 JAXBContext jaxbContext = JAXBContext.newInstance(packageName); 64 Unmarshaller unmarshaller = jaxbContext.createUnmarshaller(); 65 66 sDefectDescriptions = 67 ((JAXBElement<DefectDescriptions>) unmarshaller.unmarshal(inputStream)) 68 .getValue(); 69 } 70 catch (Exception e) { 71 throw new RuntimeException 72 ("error while initializing usability defect descriptions", e); 73 } 74 finally { 75 if (inputStream != null) { 76 try { 77 inputStream.close(); 78 } 79 catch (IOException e) { 80 // ignore 81 } 82 } 83 } 84 } 79 85 } 80 catch (Exception e) 81 { 82 throw new RuntimeException("error while initializing usability defect descriptions", e); 86 87 for (DefectDescription description : sDefectDescriptions.getDefectDescription()) { 88 if (this.name().equals(description.getDefectId())) { 89 defectDescription = description; 90 break; 91 } 83 92 } 84 finally 85 { 86 if (inputStream != null) 87 { 88 try 89 { 90 inputStream.close(); 91 } 92 catch (IOException e) 93 { 94 // ignore 95 } 96 } 93 94 if (defectDescription == null) { 95 throw new RuntimeException 96 ("error while initializing usability defect descriptions. No " + 97 "description text available for description " + this.name()); 97 98 } 98 }99 99 } 100 101 for (DefectDescription description : sDefectDescriptions.getDefectDescription())102 {103 if (this.name().equals(description.getDefectId()))104 {105 mDefectDescription = description;106 break;107 }108 }109 110 if (mDefectDescription == null)111 {112 throw new RuntimeException("error while initializing usability defect descriptions. No " +113 "description text available for description " + this.name());114 }115 }116 100 117 //----------------------------------------------------------------------------------------------- 118 /** 101 /** 119 102 * 120 103 */ 121 //----------------------------------------------------------------------------------------------- 122 public String[] getDescriptionParameters() 123 { 124 List<String> parameters = new ArrayList<String>(); 125 126 for (Object fragment : mDefectDescription.getTextFragmentOrParameterFragment()) 127 { 128 if (fragment instanceof ParameterFragment) 129 { 130 parameters.add(((ParameterFragment) fragment).getParameterName()); 131 } 104 public String[] getDescriptionParameters() { 105 List<String> parameters = new ArrayList<String>(); 106 107 for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) { 108 if (fragment instanceof ParameterFragment) { 109 parameters.add(((ParameterFragment) fragment).getParameterName()); 110 } 111 } 112 113 return parameters.toArray(new String[parameters.size()]); 132 114 } 133 134 return parameters.toArray(new String[parameters.size()]); 135 } 136 137 //----------------------------------------------------------------------------------------------- 138 /** 115 116 /** 139 117 * 140 118 */ 141 //----------------------------------------------------------------------------------------------- 142 public String toString(Map<String, String> parameters) throws IllegalArgumentException 143 { 144 StringBuffer result = new StringBuffer(); 145 146 for (Object fragment : mDefectDescription.getTextFragmentOrParameterFragment()) 147 { 148 if (result.length() > 0) 149 { 150 result.append(" "); 151 } 152 153 if (fragment instanceof ParameterFragment) 154 { 155 String value = null; 156 if (parameters != null) 157 { 158 value = parameters.get(((ParameterFragment) fragment).getParameterName()); 119 public String toString(Map<String, String> parameters) throws IllegalArgumentException { 120 StringBuffer result = new StringBuffer(); 121 122 for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) { 123 if (result.length() > 0) { 124 result.append(" "); 125 } 126 127 if (fragment instanceof ParameterFragment) { 128 String value = null; 129 if (parameters != null) { 130 value = parameters.get(((ParameterFragment) fragment).getParameterName()); 131 } 132 133 if (value != null) { 134 result.append(value); 135 } 136 else { 137 throw new IllegalArgumentException 138 ("required parameter \"" + 139 ((ParameterFragment) fragment).getParameterName() + 140 "\" for usability defect description " + this.name() + " not provided"); 141 } 142 } 143 else { 144 result.append(getFragmentString(fragment)); 145 } 159 146 } 160 161 if (value != null) 162 { 163 result.append(value); 147 148 return result.toString(); 149 } 150 151 /* 152 * (non-Javadoc) 153 * 154 * @see java.lang.Enum#toString() 155 */ 156 @Override 157 public String toString() { 158 StringBuffer result = new StringBuffer(); 159 160 int paramCount = 1; 161 for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) { 162 if (result.length() > 0) { 163 result.append(" "); 164 } 165 166 if (fragment instanceof ParameterFragment) { 167 result.append("<parameter"); 168 result.append(paramCount++); 169 result.append(">"); 170 } 171 else { 172 result.append(getFragmentString(fragment)); 173 } 164 174 } 165 else 166 { 167 throw new IllegalArgumentException 168 ("required parameter \"" + ((ParameterFragment) fragment).getParameterName() + 169 "\" for usability defect description " + this.name() + " not provided"); 175 176 return result.toString(); 177 } 178 179 /** 180 * TODO: comment 181 * 182 * @param fragment 183 * @return 184 */ 185 private String getFragmentString(Object fragment) { 186 String fragmentStr = fragment.toString().trim(); 187 188 fragmentStr = fragmentStr.replaceAll("\n", " "); 189 190 while (fragmentStr.indexOf(" ") > -1) { 191 fragmentStr = fragmentStr.replaceAll(" ", " "); 170 192 } 171 } 172 else 173 { 174 result.append(getFragmentString(fragment)); 175 } 193 194 return fragmentStr; 176 195 } 177 178 return result.toString();179 }180 181 //-----------------------------------------------------------------------------------------------182 /* (non-Javadoc)183 * @see java.lang.Enum#toString()184 */185 //-----------------------------------------------------------------------------------------------186 @Override187 public String toString()188 {189 StringBuffer result = new StringBuffer();190 191 int paramCount = 1;192 for (Object fragment : mDefectDescription.getTextFragmentOrParameterFragment())193 {194 if (result.length() > 0)195 {196 result.append(" ");197 }198 199 if (fragment instanceof ParameterFragment)200 {201 result.append("<parameter");202 result.append(paramCount++);203 result.append(">");204 }205 else206 {207 result.append(getFragmentString(fragment));208 }209 }210 211 return result.toString();212 }213 214 //-----------------------------------------------------------------------------------------------215 /**216 * TODO: comment217 *218 * @param fragment219 * @return220 */221 //-----------------------------------------------------------------------------------------------222 private String getFragmentString(Object fragment)223 {224 String fragmentStr = fragment.toString().trim();225 226 fragmentStr = fragmentStr.replaceAll("\n", " ");227 228 while (fragmentStr.indexOf(" ") > -1)229 {230 fragmentStr = fragmentStr.replaceAll(" ", " ");231 }232 233 return fragmentStr;234 }235 196 236 197 } -
trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefectSeverity.java
r442 r561 1 //-------------------------------------------------------------------------------------------------2 1 // Module : $RCSfile: UsabilityDefectSeverity.java,v $ 3 2 // Version : $Revision: 0.0 $ $Author: pharms $ $Date: 16.07.2012 $ … … 5 4 // Creation : 2012 by pharms 6 5 // Copyright : Patrick Harms, 2012 7 //------------------------------------------------------------------------------------------------- 6 7 8 8 package de.ugoe.cs.quest.usability; 9 9 10 //-------------------------------------------------------------------------------------------------11 10 /** 12 11 * TODO comment … … 15 14 * @author 2012, last modified by $Author: pharms$ 16 15 */ 17 //------------------------------------------------------------------------------------------------- 18 public enum UsabilityDefectSeverity 19 { 20 INFO, 21 LOW, 22 MEDIUM, 23 HIGH; 16 public enum UsabilityDefectSeverity { 17 18 INFO, LOW, MEDIUM, HIGH; 19 24 20 } -
trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityEvaluationManager.java
r442 r561 1 //-------------------------------------------------------------------------------------------------2 1 // Module : $RCSfile: UsabilityEvaluationManager.java,v $ 3 2 // Version : $Revision: 0.0 $ $Author: pharms $ $Date: 16.07.2012 $ … … 5 4 // Creation : 2012 by pharms 6 5 // Copyright : Patrick Harms, 2012 7 //------------------------------------------------------------------------------------------------- 6 8 7 package de.ugoe.cs.quest.usability; 9 8 … … 12 11 import java.util.logging.Logger; 13 12 14 import de.ugoe.cs.quest.tasktrees.treeifc. TaskTree;13 import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; 15 14 16 //-------------------------------------------------------------------------------------------------17 15 /** 18 16 * TODO comment … … 21 19 * @author 2012, last modified by $Author: pharms$ 22 20 */ 23 //------------------------------------------------------------------------------------------------- 24 public class UsabilityEvaluationManager 25 { 26 /** */ 27 private static Logger LOG = Logger.getLogger(UsabilityEvaluationManager.class.getName()); 21 public class UsabilityEvaluationManager { 22 23 /** */ 24 private static Logger LOG = Logger.getLogger(UsabilityEvaluationManager.class.getName()); 28 25 29 /** */ 30 private List<UsabilityEvaluationRule> mRules = new ArrayList<UsabilityEvaluationRule>(); 31 32 //----------------------------------------------------------------------------------------------- 33 /** 34 * TODO: comment 35 * 36 */ 37 //----------------------------------------------------------------------------------------------- 38 public UsabilityEvaluationManager() 39 { 40 super(); 41 init(); 42 } 26 /** */ 27 private List<UsabilityEvaluationRule> rules = new ArrayList<UsabilityEvaluationRule>(); 43 28 44 //----------------------------------------------------------------------------------------------- 45 /** 46 * TODO: comment 47 * 48 */ 49 //----------------------------------------------------------------------------------------------- 50 private void init() 51 { 52 mRules.add(new TextInputStatisticsRule()); 53 } 29 /** 30 * TODO: comment 31 * 32 */ 33 public UsabilityEvaluationManager() { 34 super(); 35 init(); 36 } 54 37 55 //----------------------------------------------------------------------------------------------- 56 /** 57 * TODO: comment 58 * 59 * @param taskTree 60 */ 61 //----------------------------------------------------------------------------------------------- 62 public UsabilityEvaluationResult evaluateUsability(TaskTree taskTree) 63 { 64 LOG.info("evaluating usability of task tree " + taskTree); 65 66 List<UsabilityEvaluationResult> results = new ArrayList<UsabilityEvaluationResult>(); 67 68 for (UsabilityEvaluationRule rule : mRules) 69 { 70 LOG.info("applying rule " + rule.getClass().getSimpleName()); 71 UsabilityEvaluationResult result = rule.evaluate(taskTree); 72 results.add(result); 73 LOG.info("the rule found " + result.getAllDefects().size() + " usability defects, of " + 74 "which " + result.getSevereDefects().size() + " are severe."); 38 /** 39 * TODO: comment 40 * 41 */ 42 private void init() { 43 rules.add(new TextInputStatisticsRule()); 75 44 } 76 77 UsabilityEvaluationResult result = mergeResults(results);78 LOG.info("the evaluation result contains " + result.getAllDefects().size() + " defects, of " +79 "which " + result.getSevereDefects().size() + " are severe.");80 return result;81 }82 45 83 //----------------------------------------------------------------------------------------------- 84 /** 85 * TODO: comment 86 * 87 * @param results 88 * @return 89 */ 90 //----------------------------------------------------------------------------------------------- 91 private UsabilityEvaluationResult mergeResults(List<UsabilityEvaluationResult> results) 92 { 93 UsabilityEvaluationResult result = new UsabilityEvaluationResult(); 94 95 for (UsabilityEvaluationResult ruleResult : results) 96 { 97 for (UsabilityDefect defect : ruleResult.getAllDefects()) 98 { 99 result.addDefect(defect); 100 } 46 /** 47 * TODO: comment 48 * 49 * @param taskTree 50 */ 51 public UsabilityEvaluationResult evaluateUsability(ITaskTree taskTree) { 52 LOG.info("evaluating usability of task tree " + taskTree); 53 54 List<UsabilityEvaluationResult> results = new ArrayList<UsabilityEvaluationResult>(); 55 56 for (UsabilityEvaluationRule rule : rules) { 57 LOG.info("applying rule " + rule.getClass().getSimpleName()); 58 UsabilityEvaluationResult result = rule.evaluate(taskTree); 59 results.add(result); 60 LOG.info("the rule found " + result.getAllDefects().size() + " usability defects, of " + 61 "which " + result.getSevereDefects().size() + " are severe."); 62 } 63 64 UsabilityEvaluationResult result = mergeResults(results); 65 LOG.info("the evaluation result contains " + result.getAllDefects().size() + 66 " defects, of which " + result.getSevereDefects().size() + " are severe."); 67 return result; 101 68 } 102 103 return result; 104 } 105 69 70 /** 71 * TODO: comment 72 * 73 * @param results 74 * @return 75 */ 76 private UsabilityEvaluationResult mergeResults(List<UsabilityEvaluationResult> results) { 77 UsabilityEvaluationResult result = new UsabilityEvaluationResult(); 78 79 for (UsabilityEvaluationResult ruleResult : results) { 80 for (UsabilityDefect defect : ruleResult.getAllDefects()) { 81 result.addDefect(defect); 82 } 83 } 84 85 return result; 86 } 87 106 88 } -
trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityEvaluationResult.java
r442 r561 1 //-------------------------------------------------------------------------------------------------2 1 // Module : $RCSfile: UsabilityEvaluationResult.java,v $ 3 2 // Version : $Revision: 0.0 $ $Author: pharms $ $Date: 16.07.2012 $ … … 5 4 // Creation : 2012 by pharms 6 5 // Copyright : Patrick Harms, 2012 7 //------------------------------------------------------------------------------------------------- 6 7 8 8 package de.ugoe.cs.quest.usability; 9 9 … … 11 11 import java.util.List; 12 12 13 //-------------------------------------------------------------------------------------------------14 13 /** 15 14 * TODO comment … … 18 17 * @author 2012, last modified by $Author: pharms$ 19 18 */ 20 //------------------------------------------------------------------------------------------------- 21 public class UsabilityEvaluationResult 22 { 23 /** */ 24 private List<UsabilityDefect> mDefects = new ArrayList<UsabilityDefect>(); 19 public class UsabilityEvaluationResult { 20 21 /** */ 22 private List<UsabilityDefect> defects = new ArrayList<UsabilityDefect>(); 25 23 26 //----------------------------------------------------------------------------------------------- 27 /** 28 * TODO: comment 29 * 30 * @param defect 31 */ 32 //----------------------------------------------------------------------------------------------- 33 public void addDefect(UsabilityDefect defect) 34 { 35 mDefects.add(defect); 36 } 24 /** 25 * TODO: comment 26 * 27 * @param defect 28 */ 29 public void addDefect(UsabilityDefect defect) { 30 defects.add(defect); 31 } 37 32 38 //----------------------------------------------------------------------------------------------- 39 /** 40 * TODO: comment 41 * 42 * @return 43 */ 44 //----------------------------------------------------------------------------------------------- 45 public List<UsabilityDefect> getAllDefects() 46 { 47 return mDefects; 48 } 33 /** 34 * TODO: comment 35 * 36 * @return 37 */ 38 public List<UsabilityDefect> getAllDefects() { 39 return defects; 40 } 49 41 50 //----------------------------------------------------------------------------------------------- 51 /** 52 * TODO: comment 53 * 54 * @return 55 */ 56 //----------------------------------------------------------------------------------------------- 57 public List<UsabilityDefect> getSevereDefects() 58 { 59 List<UsabilityDefect> severeDefects = new ArrayList<UsabilityDefect>(); 60 61 for (UsabilityDefect defect : mDefects) 62 { 63 if (defect.getSeverity() == UsabilityDefectSeverity.HIGH) 64 { 65 severeDefects.add(defect); 66 } 42 /** 43 * TODO: comment 44 * 45 * @return 46 */ 47 public List<UsabilityDefect> getSevereDefects() { 48 List<UsabilityDefect> severeDefects = new ArrayList<UsabilityDefect>(); 49 50 for (UsabilityDefect defect : defects) { 51 if (defect.getSeverity() == UsabilityDefectSeverity.HIGH) { 52 severeDefects.add(defect); 53 } 54 } 55 56 return severeDefects; 67 57 } 68 69 return severeDefects;70 }71 58 72 59 } -
trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityEvaluationRule.java
r442 r561 1 //-------------------------------------------------------------------------------------------------2 1 // Module : $RCSfile: UsabilityEvaluationRule.java,v $ 3 2 // Version : $Revision: 0.0 $ $Author: pharms $ $Date: 16.07.2012 $ … … 5 4 // Creation : 2012 by pharms 6 5 // Copyright : Patrick Harms, 2012 7 //------------------------------------------------------------------------------------------------- 6 7 8 8 package de.ugoe.cs.quest.usability; 9 9 10 import de.ugoe.cs.quest.tasktrees.treeifc. TaskTree;10 import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; 11 11 12 //-------------------------------------------------------------------------------------------------13 12 /** 14 13 * TODO comment … … 17 16 * @author 2012, last modified by $Author: pharms$ 18 17 */ 19 //------------------------------------------------------------------------------------------------- 20 public interface UsabilityEvaluationRule 21 { 18 public interface UsabilityEvaluationRule { 22 19 23 //----------------------------------------------------------------------------------------------- 24 /** 25 * TODO: comment 26 * 27 * @param taskTree 28 * @return 29 */ 30 //----------------------------------------------------------------------------------------------- 31 UsabilityEvaluationResult evaluate(TaskTree taskTree); 20 /** 21 * TODO: comment 22 * 23 * @param taskTree 24 * @return 25 */ 26 UsabilityEvaluationResult evaluate(ITaskTree taskTree); 32 27 33 28 }
Note: See TracChangeset
for help on using the changeset viewer.