Ignore:
Timestamp:
03/12/15 15:50:28 (10 years ago)
Author:
pharms
Message:
  • extension with further smell detections
  • may not fully work. But Hudson is more happy because compile errors should be gone
Location:
trunk/autoquest-core-usability/src/main
Files:
7 added
11 edited
5 moved

Legend:

Unmodified
Added
Removed

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/EventCoverageQuantileRule.java

    r1493 r1918  
    5757 
    5858                //TODO document magic numbers 
    59                 UsabilityDefectSeverity severity = UsabilityDefectSeverity.getSeverity 
    60                     (ratio, 990, 975, 950, 900, sequence, taskModel); 
     59                UsabilitySmellIntensity severity = 
     60                    UsabilitySmellIntensity.getIntensity(ratio, sequence, taskModel); 
    6161 
    6262                if (severity != null) { 
    … …  
    8181                    parameters.put("ratio", effRatio); 
    8282 
    83                     results.addDefect(severity, UsabilityDefectDescription.HIGH_EVENT_COVERAGE, 
    84                                       parameters); 
     83                    results.addSmell(sequence, severity, 
     84                                     UsabilitySmellDescription.HIGH_EVENT_COVERAGE, parameters); 
    8585                } 
    8686            } 

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/EventCoverageRatioRule.java

    r1493 r1918  
    5656                    (TaskMetric.EVENT_COVERAGE_RATIO); 
    5757 
    58                 //TODO document magic numbers 
    59                 UsabilityDefectSeverity severity = UsabilityDefectSeverity.getSeverity 
    60                     (ratio, 300, 150, 50, 10, sequence, taskModel); 
     58                UsabilitySmellIntensity severity = 
     59                    UsabilitySmellIntensity.getIntensity(ratio, sequence, taskModel); 
    6160 
    6261                if (severity != null) { 
    … …  
    6564                    parameters.put("ratio", (ratio / 10)); 
    6665 
    67                     results.addDefect(severity, UsabilityDefectDescription.HIGH_EVENT_COVERAGE, 
    68                                       parameters); 
     66                    results.addSmell(sequence, severity, 
     67                                     UsabilitySmellDescription.HIGH_EVENT_COVERAGE, parameters); 
    6968                } 
    7069            } 

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/MissingFeedbackRule.java

    r1493 r1918  
    7878            // be considered as usability smell. 
    7979             
    80             UsabilityDefectSeverity severity = UsabilityDefectSeverity.getSeverity 
    81                 (entry.getValue(), 2000, 1000, 500, 50, entry.getKey(), taskModel); 
    82  
    83             if (severity != null) { 
     80            UsabilitySmellIntensity intensity = 
     81                UsabilitySmellIntensity.getIntensity(entry.getValue(), entry.getKey(), taskModel); 
     82 
     83            if (intensity != null) { 
    8484                Map<String, Object> parameters = new HashMap<String, Object>(); 
    8585 
    … …  
    8888                long cummulatedWaitingTime = 0; 
    8989                int numberOfAdditionalClicks = 0; 
    90                  
    91                 System.out.println("\n\n#################################"); 
    9290                 
    9391                Event exampleEvent = null; 
    … …  
    10199                        for (List<Event> subsequence : clicksOnIdenticalButton) { 
    102100                            exampleEvent = subsequence.get(0); 
    103                             System.out.println(exampleEvent.getTimestamp()); 
    104101                             
    105102                            Event endEvent = subsequence.get(subsequence.size() - 1); 
    … …  
    123120                parameters.put("task", entry.getKey()); 
    124121                 
    125                 results.addDefect 
    126                     (severity, UsabilityDefectDescription.MISSING_FEEDBACK, parameters); 
     122                results.addSmell(entry.getKey(), intensity, 
     123                                 UsabilitySmellDescription.MISSING_FEEDBACK, parameters); 
    127124            } 
    128125        } 

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/RequiredInefficientActionsRule.java

    r1493 r1918  
    6767            int ratio = (int) (1000 * stats.getMean()); 
    6868 
    69             UsabilityDefectSeverity severity = UsabilityDefectSeverity.getSeverity 
    70                 (ratio, 500, 300, 200, 100, entry.getKey(), taskModel); 
     69            UsabilitySmellIntensity severity = 
     70                UsabilitySmellIntensity.getIntensity(ratio, entry.getKey(), taskModel); 
    7171 
    7272            if (severity != null) { 
    … …  
    7575                parameters.put("ratio", (ratio / 10)); 
    7676 
    77                 results.addDefect 
    78                     (severity, UsabilityDefectDescription.INEFFICIENT_ACTIONS, parameters); 
     77                results.addSmell(entry.getKey(), severity, 
     78                                 UsabilitySmellDescription.INEFFICIENT_ACTIONS, parameters); 
    7979            } 
    8080        } 

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/TargetDistanceRule.java

    r1493 r1918  
    136136            // for HTML: 600 means not on the same page 
    137137            // for HTML: 501 means in average not on the same page 
    138             UsabilityDefectSeverity severity = UsabilityDefectSeverity.getSeverity 
    139                 (ratio, 800, 600, 501, 501, task, taskModel); 
     138            UsabilitySmellIntensity severity = 
     139                UsabilitySmellIntensity.getIntensity(ratio, task, taskModel); 
    140140 
    141141            if (severity != null) { 
    … …  
    148148                parameters.put("distance", ((double) ratio / 1000)); 
    149149 
    150                 results.addDefect 
    151                     (severity, UsabilityDefectDescription.HIGH_TARGET_DISTANCE, parameters); 
     150                results.addSmell 
     151                    (task, severity, UsabilitySmellDescription.HIGH_TARGET_DISTANCE, parameters); 
    152152            } 
    153153        } 

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/TaskCooccurrenceRule.java

    r1493 r1918  
    6262                int index2 = 1; 
    6363                List<ITask> children = sequence.getChildren(); 
     64                ITaskInfo infoSequence = taskModel.getTaskInfo(sequence); 
     65                int countSequence = infoSequence.getMeasureValue(TaskMetric.COUNT); 
    6466                 
    6567                while (index2 < children.size()) { 
    … …  
    6971                    ITaskInfo info2 = taskModel.getTaskInfo(task2); 
    7072                     
    71                     int ratioTask1 = 1000 * info1.getMeasureValue(TaskMetric.COUNT, sequence) / 
    72                         info1.getMeasureValue(TaskMetric.COUNT); 
    73                     int ratioTask2 = 1000 * info2.getMeasureValue(TaskMetric.COUNT, sequence) / 
    74                             info2.getMeasureValue(TaskMetric.COUNT); 
     73                    int ratioTask1 = 1000 * countSequence / info1.getMeasureValue(TaskMetric.COUNT); 
     74                    int ratioTask2 = 1000 * countSequence / info2.getMeasureValue(TaskMetric.COUNT); 
    7575                     
    76                     createSucceededDefectIfRequired(ratioTask1, task1, task2, results, taskModel); 
    77                     createPrecededDefectIfRequired(ratioTask2, task1, task2, results, taskModel); 
     76                    createSucceededSmellIfRequired(ratioTask1, task1, task2, results, taskModel); 
     77                    createPrecededSmellIfRequired(ratioTask2, task1, task2, results, taskModel); 
    7878                     
    7979                    index1 = index2; 
    … …  
    8787     * 
    8888     */ 
    89     private void createSucceededDefectIfRequired(int                       ratio, 
    90                                                  ITask                     task1, 
    91                                                  ITask                     task2, 
    92                                                  UsabilityEvaluationResult results, 
    93                                                  ITaskModel                taskModel) 
     89    private void createSucceededSmellIfRequired(int                       ratio, 
     90                                                ITask                     task1, 
     91                                                ITask                     task2, 
     92                                                UsabilityEvaluationResult results, 
     93                                                ITaskModel                taskModel) 
    9494    { 
    9595        //TODO document magic numbers 
    96         UsabilityDefectSeverity severity = UsabilityDefectSeverity.getSeverity 
    97             (ratio, 900, 700, 500, 300, task1, taskModel); 
     96        UsabilitySmellIntensity severity = 
     97            UsabilitySmellIntensity.getIntensity(ratio, task1, taskModel); 
    9898 
    9999        if (!isScroll(task1) && !isScroll(task2) && (severity != null)) { 
    … …  
    103103            parameters.put("ratio", (ratio / 10)); 
    104104 
    105             results.addDefect(severity, UsabilityDefectDescription.COOCCURENCE_SUCCEED, parameters); 
     105            results.addSmell 
     106                (task1, severity, UsabilitySmellDescription.COOCCURENCE_SUCCEED, parameters); 
    106107        } 
    107108    } 
    … …  
    110111     * 
    111112     */ 
    112     private void createPrecededDefectIfRequired(int                       ratio, 
    113                                                 ITask                     task1, 
    114                                                 ITask                     task2, 
    115                                                 UsabilityEvaluationResult results, 
    116                                                 ITaskModel                taskModel) 
     113    private void createPrecededSmellIfRequired(int                       ratio, 
     114                                               ITask                     task1, 
     115                                               ITask                     task2, 
     116                                               UsabilityEvaluationResult results, 
     117                                               ITaskModel                taskModel) 
    117118    { 
    118119        //TODO document magic numbers 
    119         UsabilityDefectSeverity severity = UsabilityDefectSeverity.getSeverity 
    120             (ratio, 900, 700, 500, 300, task2, taskModel); 
     120        UsabilitySmellIntensity severity = 
     121            UsabilitySmellIntensity.getIntensity(ratio, task2, taskModel); 
    121122 
    122123        if (!isScroll(task1) && !isScroll(task2) && (severity != null)) { 
    … …  
    126127            parameters.put("ratio", (ratio / 10)); 
    127128 
    128             results.addDefect(severity, UsabilityDefectDescription.COOCCURENCE_PRECED, parameters); 
     129            results.addSmell 
     130                (task1, severity, UsabilitySmellDescription.COOCCURENCE_PRECED, parameters); 
    129131        } 
    130132    } 
    … …  
    140142    private boolean isScroll(ITask task) { 
    141143        if (task instanceof IEventTask) { 
    142             return ((IEventTaskInstance) ((IEventTask) task).getInstances().iterator().next()).getEvent().getType() instanceof Scroll; 
     144            return ((IEventTaskInstance) ((IEventTask) task).getInstances().iterator().next()) 
     145                .getEvent().getType() instanceof Scroll; 
    143146        } 
    144147        else if (task instanceof IIteration) { 

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/TaskTreeTestRule.java

    r1493 r1918  
    1515package de.ugoe.cs.autoquest.usability; 
    1616 
     17import java.util.ArrayList; 
     18import java.util.HashSet; 
     19import java.util.List; 
     20import java.util.Set; 
     21 
    1722import de.ugoe.cs.autoquest.eventcore.Event; 
    1823import de.ugoe.cs.autoquest.tasktrees.treeifc.DefaultTaskInstanceTraversingVisitor; 
     24import de.ugoe.cs.autoquest.tasktrees.treeifc.DefaultTaskTraversingVisitor; 
     25import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; 
    1926import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTaskInstance; 
     27import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; 
     28import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; 
     29import de.ugoe.cs.autoquest.tasktrees.treeifc.IStructuringTemporalRelationship; 
     30import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
     31import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInfo; 
    2032import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance; 
    2133import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstanceVisitor; 
    … …  
    4153 
    4254        checkTimestamps(taskModel); 
     55        checkTaskInfos(taskModel); 
     56        checkEventTaskInstances(taskModel); 
     57        checkTraversal(taskModel); 
    4358 
    4459        return results; 
     60    } 
     61 
     62    /** 
     63     * <p> 
     64     * TODO: comment 
     65     * </p> 
     66     * 
     67     * @param taskModel 
     68     */ 
     69    private void checkEventTaskInstances(ITaskModel taskModel) { 
     70        Set<IEventTaskInstance> instancesInModel = new HashSet<>(); 
     71         
     72        for (ITask task : taskModel.getTasks()) { 
     73            if (task instanceof IEventTask) { 
     74                for (ITaskInstance instance : task.getInstances()) { 
     75                    instancesInModel.add((IEventTaskInstance) instance); 
     76                } 
     77            } 
     78        } 
     79         
     80        final Set<IEventTaskInstance> instancesInSessions = new HashSet<>(); 
     81         
     82        for (IUserSession session : taskModel.getUserSessions()) { 
     83            for (ITaskInstance rootInstance : session) { 
     84                rootInstance.accept(new DefaultTaskInstanceTraversingVisitor() { 
     85                    @Override 
     86                    public void visit(IEventTaskInstance eventTaskInstance) { 
     87                        instancesInSessions.add(eventTaskInstance); 
     88                    } 
     89                }); 
     90            } 
     91        } 
     92         
     93        if (instancesInModel.size() != instancesInSessions.size()) { 
     94            throw new RuntimeException("instances not equal"); 
     95        } 
     96        else { 
     97            for (IEventTaskInstance instance : instancesInModel) { 
     98                if (!instancesInSessions.contains(instance)) { 
     99                    throw new RuntimeException("instance of model not contained in sessions"); 
     100                } 
     101            } 
     102             
     103            for (IEventTaskInstance instance : instancesInSessions) { 
     104                if (!instancesInModel.contains(instance)) { 
     105                    throw new RuntimeException("instance of sessions not contained in model"); 
     106                } 
     107            } 
     108        } 
     109    } 
     110 
     111    /** 
     112     * <p> 
     113     * TODO: comment 
     114     * </p> 
     115     * 
     116     * @param taskModel 
     117     */ 
     118    private void checkTraversal(ITaskModel taskModel) { 
     119        for (ITask task : taskModel.getTasks()) { 
     120            final List<ITask> traversal1 = new ArrayList<>(); 
     121             
     122            task.accept(new DefaultTaskTraversingVisitor() { 
     123                @Override 
     124                public void visit(IEventTask eventTask) { 
     125                    traversal1.add(eventTask); 
     126                    super.visit(eventTask); 
     127                } 
     128 
     129                @Override 
     130                public void visit(IStructuringTemporalRelationship relationship) { 
     131                    traversal1.add(relationship); 
     132                    super.visit(relationship); 
     133                } 
     134                 
     135            }); 
     136             
     137            final List<ITask> traversal2 = new ArrayList<>(); 
     138             
     139            task.accept(new DefaultTaskTraversingVisitor() { 
     140                @Override 
     141                public void visit(IEventTask eventTask) { 
     142                    traversal2.add(eventTask); 
     143                    super.visit(eventTask); 
     144                } 
     145 
     146                @Override 
     147                public void visit(ISelection selection) { 
     148                    traversal2.add(selection); 
     149                    super.visit(selection); 
     150                } 
     151 
     152                @Override 
     153                public void visit(ISequence sequence) { 
     154                    traversal2.add(sequence); 
     155                    super.visit(sequence); 
     156                } 
     157            }); 
     158             
     159            if (traversal1.size() != traversal2.size()) { 
     160                throw new RuntimeException("traversals not equal"); 
     161            } 
     162            else { 
     163                for (int i = 0; i < traversal1.size(); i++) { 
     164                    if (!traversal1.get(i).equals(traversal2.get(i))) { 
     165                        throw new RuntimeException("traversals not equal at position " + i); 
     166                    } 
     167                } 
     168            } 
     169        } 
    45170    } 
    46171 
    … …  
    78203         
    79204    } 
     205 
     206    /** 
     207     * <p> 
     208     * TODO: comment 
     209     * </p> 
     210     * 
     211     * @param taskModel 
     212     */ 
     213    private void checkTaskInfos(ITaskModel taskModel) { 
     214        for (ITask task : taskModel.getTasks()) { 
     215            ITaskInfo taskInfo = taskModel.getTaskInfo(task); 
     216            if (taskInfo == null) { 
     217                System.out.println("task " + task + " has no associated task infos"); 
     218            } 
     219        } 
     220    } 
    80221} 

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/TextInputStatisticsRule.java

    r1493 r1918  
    8484        int ratio = 1000 * allTextFieldInputs / statistics.getNoOfAllEvents(); 
    8585 
    86         // TODO comment magic numbers 
    87         UsabilityDefectSeverity severity = UsabilityDefectSeverity.getSeverity 
    88             (ratio, 900, 700, 500, 300); 
     86        UsabilitySmellIntensity severity = UsabilitySmellIntensity.getIntensity(ratio); 
    8987         
    9088        if (severity != null) { 
    … …  
    9290            parameters.put("textInputRatio", (ratio / 10)); 
    9391 
    94             results.addDefect 
    95                 (severity, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO, parameters); 
     92            results.addSmell 
     93                (severity, UsabilitySmellDescription.TEXT_FIELD_INPUT_RATIO, parameters); 
    9694        } 
    9795    } 
    … …  
    117115                1000 * noOfUsagesOfTextField1WithSameTextInTextField2 / noOfUsagesOfTextField2; 
    118116 
    119             createTextFieldEntryRepetitionDefect(ratioTextField1, entry.textField1, 
     117            createTextFieldEntryRepetitionSmell(ratioTextField1, entry.textField1, 
    120118                                                 entry.textField2, results); 
    121119             
    122             createTextFieldEntryRepetitionDefect(ratioTextField2, entry.textField2, 
     120            createTextFieldEntryRepetitionSmell(ratioTextField2, entry.textField2, 
    123121                                                 entry.textField1, results); 
    124122             
    … …  
    129127     * 
    130128     */ 
    131     private void createTextFieldEntryRepetitionDefect(int                       ratioOfEqualEntries, 
     129    private void createTextFieldEntryRepetitionSmell(int                       ratioOfEqualEntries, 
    132130                                                      ITextField                textField1, 
    133131                                                      ITextField                textField2, 
    134132                                                      UsabilityEvaluationResult results) 
    135133    { 
    136         // TODO comment magic numbers 
    137         UsabilityDefectSeverity severity = UsabilityDefectSeverity.getSeverity 
    138             (ratioOfEqualEntries, 900, 500, 200, 100); 
     134        UsabilitySmellIntensity severity = 
     135            UsabilitySmellIntensity.getIntensity(ratioOfEqualEntries); 
    139136         
    140137        if (severity != null) { 
    … …  
    144141            parameters.put("textField2", textField2); 
    145142 
    146             results.addDefect 
    147                 (severity, UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS, parameters); 
     143            results.addSmell 
     144                (severity, UsabilitySmellDescription.TEXT_FIELD_INPUT_REPETITIONS, parameters); 
    148145        } 
    149146    } 
    … …  
    172169            int ratio = 1000 * noLetterOrDigitCount / allCharactersCount; 
    173170 
    174             UsabilityDefectSeverity severity = 
    175                 UsabilityDefectSeverity.getSeverity(ratio, 
    176                                                     100, // every 10th sign 
    177                                                     50, // every 20th sign 
    178                                                     20, // every 50th sign 
    179                                                     10 // every 100th sign 
    180                                                     ); 
     171            UsabilitySmellIntensity severity = UsabilitySmellIntensity.getIntensity(ratio); 
    181172 
    182173            if (severity != null) { 
    … …  
    185176                parameters.put("noLetterOrDigitRatio", (ratio / 10)); 
    186177 
    187                 results.addDefect 
    188                     (severity, UsabilityDefectDescription.TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO, 
     178                results.addSmell 
     179                    (severity, UsabilitySmellDescription.TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO, 
    189180                     parameters); 
    190181            } 

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UnusedGUIElementsRule.java

    r1493 r1918  
    7878        int ratio = 1000 * unusedGUIElements.size() / allGUIElements.size(); 
    7979         
    80         UsabilityDefectSeverity severity = 
    81             UsabilityDefectSeverity.getSeverity(ratio, 200, 100, 50, 25); 
     80        UsabilitySmellIntensity severity = UsabilitySmellIntensity.getIntensity(ratio); 
    8281 
    8382        if (severity != null) { 
    … …  
    8988            parameters.put("unusedGuiElements", unusedGUIElements); 
    9089             
    91             results.addDefect 
    92                 (severity, UsabilityDefectDescription.UNUSED_GUI_ELEMENTS, parameters); 
     90            results.addSmell 
     91                (severity, UsabilitySmellDescription.UNUSED_GUI_ELEMENTS, parameters); 
    9392        } 
    9493     } 

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationManager.java

    r1493 r1918  
    4848     */ 
    4949    private void init() { 
    50         //rules.add(new TextInputStatisticsRule()); 
    51         rules.add(new MissingFeedbackRule()); 
    52         rules.add(new EventCoverageRatioRule()); 
    53         rules.add(new RequiredInefficientActionsRule()); 
    54         //rules.add(new TaskCooccurrenceRule()); 
    55         rules.add(new TargetDistanceRule()); 
    56         //rules.add(new UnusedGUIElementsRule()); 
    57         //rules.add(new TaskTreeTestRule()); 
     50        rules.add(new TaskTreeTestRule()); 
     51//        rules.add(new TextInputStatisticsRule()); 
     52//        rules.add(new MissingFeedbackRule()); 
     53//        rules.add(new EventCoverageRatioRule()); 
     54//        rules.add(new TargetDistanceRule()); 
     55//        rules.add(new RequiredInefficientActionsRule()); 
     56//        rules.add(new DataEntryMethodChangeRule()); 
     57        rules.add(new DefaultValueRule()); 
     58//        rules.add(new CheckBoxMultipleSelectionRule()); 
     59//        rules.add(new CommonTaskRateRule()); 
     60//        rules.add(new MisleadingClickCueRule()); 
     61//        rules.add(new DefaultCursorPositioningRule()); 
     62//        rules.add(new UnusedGUIElementsRule()); 
     63//        rules.add(new TaskCooccurrenceRule()); 
    5864    } 
    5965 
    … …  
    7076            UsabilityEvaluationResult result = rule.evaluate(taskModel); 
    7177            interimResults.add(result); 
    72             Console.traceln(Level.INFO, "the rule found " + result.getAllDefects().size() + 
    73                             " usability defects, of which " + result.getSevereDefects().size() + 
    74                             " are severe."); 
     78            Console.traceln(Level.INFO, "the rule found " + result.getAllSmells().size() + 
     79                            " usability smells."); 
    7580             
    76             if ((rule instanceof EventCoverageRatioRule) || 
    77                 (rule instanceof RequiredInefficientActionsRule) || 
    78                 (rule instanceof TargetDistanceRule)) 
    79             { 
    80                 ITask[] referredTasks = new ITask[result.getAllDefects().size()]; 
     81            List<ITask> referredTasks = new ArrayList<ITask>(); 
    8182 
    82                 for (int i = 0; i < result.getAllDefects().size(); i++) { 
    83                     referredTasks[i] = 
    84                         (ITask) result.getAllDefects().get(i).getDescriptionFragments().get(1); 
     83            for (UsabilitySmell smell : result.getAllSmells()) { 
     84                if (smell.getSmellingTask() != null) { 
     85                    referredTasks.add(smell.getSmellingTask()); 
    8586                } 
     87            } 
    8688                 
    87                 int counter = 0; 
    88                 for (int i = 0; i < referredTasks.length; i++) { 
    89                     for (int j = 0; j < referredTasks.length; j++) { 
    90                         if (isChildOf(referredTasks[i], referredTasks[j])) { 
    91                             counter++; 
    92                             break; 
    93                         } 
     89            int counter = 0; 
     90            for (int i = 0; i < referredTasks.size(); i++) { 
     91                for (int j = 0; j < referredTasks.size(); j++) { 
     92                    if (isChildOf(referredTasks.get(i), referredTasks.get(j))) { 
     93                        counter++; 
     94                        break; 
    9495                    } 
    9596                } 
     97            } 
    9698                 
    97                 if (counter > 0) { 
    98                     Console.traceln(Level.INFO, counter + " of the findings are duplicates in " + 
    99                                     "that they refer to tasks whose parent tasks are also " + 
    100                                     "referred by the findings"); 
    101                 } 
     99            if (counter > 0) { 
     100                Console.traceln(Level.INFO, counter + " of the findings are duplicates in " + 
     101                                "that they refer to tasks whose parent tasks are also " + 
     102                                "referred by the findings"); 
    102103            } 
    103104        } 
    104105 
    105106        UsabilityEvaluationResult result = new UsabilityEvaluationResult(taskModel, interimResults); 
    106         Console.println("the evaluation result contains " + result.getAllDefects().size() + 
    107                         " defects, of which " + result.getSevereDefects().size() + " are severe."); 
     107        Console.println("the evaluation result contains " + result.getAllSmells().size() + 
     108                        " smells."); 
    108109 
    109110        return result; 

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationResult.java

    r1493 r1918  
    1919import java.util.Map; 
    2020 
     21import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    2122import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
    2223 
    … …  
    3334     
    3435    /** */ 
    35     private List<UsabilityDefect> defects = new ArrayList<UsabilityDefect>(); 
     36    private List<UsabilitySmell> smells = new ArrayList<UsabilitySmell>(); 
    3637 
    3738    /** 
    … …  
    5051        this.taskModel = taskModel; 
    5152        for (UsabilityEvaluationResult result : results) { 
    52             for (UsabilityDefect defect : result.getAllDefects()) { 
    53                 defects.add(defect); 
     53            for (UsabilitySmell smell : result.getAllSmells()) { 
     54                smells.add(smell); 
    5455            } 
    5556        } 
    … …  
    5960     * 
    6061     */ 
    61     public void addDefect(UsabilityDefectSeverity    severity, 
    62                           UsabilityDefectDescription description, 
    63                           Map<String, Object>        parameters) 
     62    public void addSmell(UsabilitySmellIntensity   intensity, 
     63                         UsabilitySmellDescription description, 
     64                         Map<String, Object>       parameters) 
    6465    { 
    65         defects.add(new UsabilityDefect(severity, description, parameters)); 
     66        addSmell(null, intensity, description, parameters); 
    6667    } 
    6768 
    … …  
    6970     * 
    7071     */ 
    71     public List<UsabilityDefect> getAllDefects() { 
    72         return defects; 
     72    public void addSmell(ITask                     smellingTask, 
     73                         UsabilitySmellIntensity   intensity, 
     74                         UsabilitySmellDescription description, 
     75                         Map<String, Object>       parameters) 
     76    { 
     77        smells.add(new UsabilitySmell(smellingTask, intensity, description, parameters)); 
    7378    } 
    7479 
    … …  
    7681     * 
    7782     */ 
    78     public List<UsabilityDefect> getSevereDefects() { 
    79         List<UsabilityDefect> severeDefects = new ArrayList<UsabilityDefect>(); 
    80  
    81         for (UsabilityDefect defect : defects) { 
    82             if (defect.getSeverity() == UsabilityDefectSeverity.HIGH) { 
    83                 severeDefects.add(defect); 
    84             } 
    85         } 
    86  
    87         return severeDefects; 
     83    public List<UsabilitySmell> getAllSmells() { 
     84        return smells; 
    8885    } 
    8986 

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilitySmell.java

    r1493 r1918  
    1818import java.util.Map; 
    1919 
     20import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
     21 
    2022/** 
    2123 * TODO comment 
    … …  
    2426 * @author 2012, last modified by $Author: pharms$ 
    2527 */ 
    26 public class UsabilityDefect { 
     28public class UsabilitySmell { 
    2729 
    2830    /** */ 
    29     private UsabilityDefectSeverity severity; 
     31    private ITask smellingTask; 
     32     
     33    /** */ 
     34    private UsabilitySmellIntensity intensity; 
    3035 
    3136    /** */ 
    32     private UsabilityDefectDescription description; 
     37    private UsabilitySmellDescription description; 
    3338 
    3439    /** */ 
    … …  
    3843     * 
    3944     */ 
    40     UsabilityDefect(UsabilityDefectSeverity severity, UsabilityDefectDescription description) { 
    41         this(severity, description, null); 
     45    UsabilitySmell(UsabilitySmellIntensity intensity, UsabilitySmellDescription description) { 
     46        this(intensity, description, null); 
     47    } 
     48     
     49    /** 
     50     * 
     51     */ 
     52    UsabilitySmell(ITask                     smellingTask, 
     53                   UsabilitySmellIntensity   intensity, 
     54                   UsabilitySmellDescription description) 
     55    { 
     56        this(intensity, description, null); 
    4257    } 
    4358 
    … …  
    4560     * 
    4661     */ 
    47     UsabilityDefect(UsabilityDefectSeverity    severity, 
    48                     UsabilityDefectDescription description, 
    49                     Map<String, Object>        parameters) 
     62    UsabilitySmell(UsabilitySmellIntensity   intensity, 
     63                   UsabilitySmellDescription description, 
     64                   Map<String, Object>       parameters) 
    5065    { 
    51         this.severity = severity; 
     66        this(null, intensity, description, parameters); 
     67    } 
     68 
     69    /** 
     70     * 
     71     */ 
     72    UsabilitySmell(ITask                     smellingTask, 
     73                   UsabilitySmellIntensity   intensity, 
     74                   UsabilitySmellDescription description, 
     75                   Map<String, Object>       parameters) 
     76    { 
     77        this.smellingTask = smellingTask; 
     78        this.intensity = intensity; 
    5279        this.description = description; 
    5380        this.descriptionParameters = parameters; 
    … …  
    5784     *  
    5885     */ 
    59     public UsabilityDefectSeverity getSeverity() { 
    60         return severity; 
     86    public ITask getSmellingTask() { 
     87        return smellingTask; 
     88    } 
     89 
     90    /** 
     91     *  
     92     */ 
     93    public UsabilitySmellIntensity getIntensity() { 
     94        return intensity; 
    6195    } 
    6296 
    … …  
    6498     * 
    6599     */ 
    66     public void setSeverity(UsabilityDefectSeverity severity) { 
    67         this.severity = severity; 
     100    public void setIntensity(UsabilitySmellIntensity intensity) { 
     101        this.intensity = intensity; 
    68102    } 
    69103 
    … …  
    71105     * 
    72106     */ 
    73     public void setDescription(UsabilityDefectDescription description) { 
     107    public void setDescription(UsabilitySmellDescription description) { 
    74108        this.description = description; 
    75109    } 
    … …  
    102136    @Override 
    103137    public boolean equals(Object obj) { 
    104         if (obj instanceof UsabilityDefect) { 
    105             return 
    106                 (severity == ((UsabilityDefect) obj).severity) && 
    107                 (description == ((UsabilityDefect) obj).description); 
     138        if (obj instanceof UsabilitySmell) { 
     139            return description.equals(((UsabilitySmell) obj).description); 
    108140        } 
    109141        else { 
    … …  
    119151    @Override 
    120152    public int hashCode() { 
    121         return severity.hashCode() + description.hashCode(); 
     153        return description.hashCode(); 
    122154    } 
    123155 
    … …  
    129161    @Override 
    130162    public String toString() { 
    131         return "UsabilityDefect(" + severity.name() + ", " + description.name() + ")"; 
     163        if (smellingTask == null) { 
     164            return "UsabilitySmell(" + intensity + ", " + description.name() + ")"; 
     165        } 
     166        else { 
     167            return "UsabilitySmell(" + smellingTask + ", " + intensity + ", " + 
     168                description.name() + ")"; 
     169        } 
    132170    } 
    133171 

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilitySmellDescription.java

    r1493 r1918  
    3232 * @author 2012, last modified by $Author: pharms$ 
    3333 */ 
    34 public enum UsabilityDefectDescription { 
     34public enum UsabilitySmellDescription { 
    3535     
    3636    INEFFICIENT_ACTIONS, 
    … …  
    4343    HIGH_TARGET_DISTANCE, 
    4444    MISSING_FEEDBACK, 
    45     UNUSED_GUI_ELEMENTS; 
     45    UNUSED_GUI_ELEMENTS, 
     46    DATA_ENTRY_METHOD_CHANGE, 
     47    GOOD_DEFAULTS, 
     48    CHECK_BOX_SINGLE_SELECTION, 
     49    COMMON_TASK_RATE, 
     50    MISLEADING_CLICK_CUE, 
     51    MOST_OFTEN_DONE_FIRST; 
    4652 
    4753    /** */ 
    48     private static final String DEFAULT_MESSAGES_FILE = "defectDescriptions_en.xml"; 
     54    private static final String DEFAULT_MESSAGES_FILE = "smellDescriptions_en.xml"; 
    4955 
    5056    /** */ 
    51     private static DefectDescriptions sDefectDescriptions; 
     57    private static SmellDescriptions sSmellDescriptions; 
    5258 
    5359    /** */ 
    54     private DefectDescription defectDescription; 
     60    private SmellDescription smellDescription; 
    5561 
    5662    /** 
    5763     * 
    5864     */ 
    59     private UsabilityDefectDescription() { 
     65    private UsabilitySmellDescription() { 
    6066        init(); 
    6167    } 
    … …  
    6773    private void init() { 
    6874        synchronized (this.getClass()) { 
    69             if (sDefectDescriptions == null) { 
     75            if (sSmellDescriptions == null) { 
    7076                InputStream inputStream = 
    7177                    ClassLoader.getSystemResourceAsStream(DEFAULT_MESSAGES_FILE); 
    7278 
    7379                try { 
    74                     String packageName = DefectDescriptions.class.getPackage().getName(); 
     80                    String packageName = SmellDescriptions.class.getPackage().getName(); 
    7581                    JAXBContext jaxbContext = JAXBContext.newInstance(packageName); 
    7682                    Unmarshaller unmarshaller = jaxbContext.createUnmarshaller(); 
    7783 
    78                     sDefectDescriptions = 
    79                         ((JAXBElement<DefectDescriptions>) unmarshaller.unmarshal(inputStream)) 
     84                    sSmellDescriptions = 
     85                        ((JAXBElement<SmellDescriptions>) unmarshaller.unmarshal(inputStream)) 
    8086                            .getValue(); 
    8187                } 
    8288                catch (Exception e) { 
    8389                    throw new RuntimeException 
    84                         ("error while initializing usability defect descriptions", e); 
     90                        ("error while initializing usability smell descriptions", e); 
    8591                } 
    8692                finally { 
    … …  
    97103        } 
    98104 
    99         for (DefectDescription description : sDefectDescriptions.getDefectDescription()) { 
    100             if (this.name().equals(description.getDefectId())) { 
    101                 defectDescription = description; 
     105        for (SmellDescription description : sSmellDescriptions.getSmellDescription()) { 
     106            if (this.name().equals(description.getSmellId())) { 
     107                smellDescription = description; 
    102108                break; 
    103109            } 
    104110        } 
    105111 
    106         if (defectDescription == null) { 
     112        if (smellDescription == null) { 
    107113            throw new RuntimeException 
    108                 ("error while initializing usability defect descriptions. No " + 
     114                ("error while initializing usability smell descriptions. No " + 
    109115                 "description text available for description " + this.name()); 
    110116        } 
    … …  
    117123        List<String> parameters = new ArrayList<String>(); 
    118124 
    119         for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) { 
     125        for (Object fragment : smellDescription.getTextFragmentOrParameterFragment()) { 
    120126            if (fragment instanceof ParameterFragment) { 
    121127                parameters.add(((ParameterFragment) fragment).getParameterName()); 
    … …  
    132138        StringBuffer result = new StringBuffer(); 
    133139 
    134         for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) { 
     140        for (Object fragment : smellDescription.getTextFragmentOrParameterFragment()) { 
    135141            if (result.length() > 0) { 
    136142                result.append(" "); 
    … …  
    161167                        ("required parameter \"" + 
    162168                         ((ParameterFragment) fragment).getParameterName() + 
    163                          "\" for usability defect description " + this.name() + " not provided"); 
     169                         "\" for usability smell description " + this.name() + " not provided"); 
    164170                } 
    165171            } 
    … …  
    180186        List<Object> result = new ArrayList<Object>(); 
    181187 
    182         for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) { 
     188        for (Object fragment : smellDescription.getTextFragmentOrParameterFragment()) { 
    183189            if (fragment instanceof ParameterFragment) { 
    184190                Object value = null; 
    … …  
    194200                        ("required parameter \"" + 
    195201                         ((ParameterFragment) fragment).getParameterName() + 
    196                          "\" for usability defect description " + this.name() + " not provided"); 
     202                         "\" for usability smell description " + this.name() + " not provided"); 
    197203                } 
    198204            } 
    … …  
    209215     */ 
    210216    public String getBriefDescription() { 
    211         return defectDescription.briefText; 
     217        return smellDescription.briefText; 
    212218    } 
    213219 
    … …  
    222228 
    223229        int paramCount = 1; 
    224         for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) { 
     230        for (Object fragment : smellDescription.getTextFragmentOrParameterFragment()) { 
    225231            if (result.length() > 0) { 
    226232                result.append(" "); 

  • trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilitySmellIntensity.java

    r1493 r1918  
    2626 * @author 2012, last modified by $Author: pharms$ 
    2727 */ 
    28 public enum UsabilityDefectSeverity { 
    29      
    30     INFO, LOW, MEDIUM, HIGH; 
     28public class UsabilitySmellIntensity { 
    3129     
    3230    /** */ 
    33     static int defaultCoverageQuantile = 950; 
     31    private int ratio; 
     32     
     33    /** */ 
     34    private int eventCoverage; 
     35     
     36    /** */ 
     37    private int eventCoverageQuantile; 
    3438 
    3539    /** 
    3640     *  
    3741     */ 
    38     static UsabilityDefectSeverity getSeverity(int ratio, 
    39                                                int highRatioLevel, 
    40                                                int mediumRatioLevel, 
    41                                                int lowRatioLevel, 
    42                                                int infoRatioLevel) 
     42    static UsabilitySmellIntensity getIntensity(int        ratio, 
     43                                                ITask      taskWithSmell, 
     44                                                ITaskModel wholeTaskModel) 
    4345    { 
    44         return getSeverity(ratio, highRatioLevel, mediumRatioLevel, lowRatioLevel, infoRatioLevel, 
    45                            defaultCoverageQuantile); 
     46        ITaskInfo taskInfo = wholeTaskModel.getTaskInfo(taskWithSmell); 
     47        int eventCoverage = taskInfo.getMeasureValue(TaskMetric.EVENT_COVERAGE); 
     48        int eventCoverageQuantile = taskInfo.getMeasureValue(TaskMetric.EVENT_COVERAGE_QUANTILE); 
     49        return getIntensity(ratio, eventCoverage, eventCoverageQuantile); 
    4650    } 
    4751 
    … …  
    4953     *  
    5054     */ 
    51     static UsabilityDefectSeverity getSeverity(int        ratio, 
    52                                                int        highRatioLevel, 
    53                                                int        mediumRatioLevel, 
    54                                                int        lowRatioLevel, 
    55                                                int        infoRatioLevel, 
    56                                                ITask      taskWithDefect, 
    57                                                ITaskModel wholeTaskModel) 
    58     { 
    59         ITaskInfo taskInfo = wholeTaskModel.getTaskInfo(taskWithDefect); 
    60         int eventCoverageQuantile = taskInfo.getMeasureValue(TaskMetric.EVENT_COVERAGE_QUANTILE); 
    61         return getSeverity(ratio, highRatioLevel, mediumRatioLevel, lowRatioLevel, infoRatioLevel, 
    62                            eventCoverageQuantile); 
     55    static UsabilitySmellIntensity getIntensity(int ratio) { 
     56        return getIntensity(ratio, -1, -1); 
    6357    } 
    6458 
    … …  
    6660     *  
    6761     */ 
    68     static UsabilityDefectSeverity getSeverity(int ratio, 
    69                                                int highRatioLevel, 
    70                                                int mediumRatioLevel, 
    71                                                int lowRatioLevel, 
    72                                                int infoRatioLevel, 
    73                                                int coverageQuantile) 
     62    static UsabilitySmellIntensity getIntensity(int ratio, 
     63                                                int eventCoverage, 
     64                                                int eventCoverageQuantile) 
    7465    { 
    75         int effectiveRatio = ratio; 
    76          
    77         // event coverage ratio is in per mille. The more executed events a task covers, the more 
    78         // important a related usability defect. 
    79         /*if (eventCoverageRatio < 1) { 
    80             // one per mille, so one of thousand events is covered 
    81             effectiveRatio *= 0.2; 
     66        if ((ratio > 0) && ((eventCoverageQuantile == -1) || (eventCoverageQuantile > 0))) { 
     67            return new UsabilitySmellIntensity(ratio, eventCoverage, eventCoverageQuantile); 
    8268        } 
    83         else if (eventCoverageRatio < 5) { 
    84             // 5 per mille, so one of 250 events is covered 
    85             effectiveRatio *= 0.4; 
     69        else { 
     70            return null; 
    8671        } 
    87         else if (eventCoverageRatio < 10) { 
    88             // 1 percent, so one of 100 events is covered 
    89             effectiveRatio *= 0.5; 
    90         } 
    91         else if (eventCoverageRatio < 20) { 
    92             // 2 percent, so one of 50 events is covered 
    93             effectiveRatio *= 0.6; 
    94         } 
    95         else if (eventCoverageRatio < 30) { 
    96             // 3 percent, so one of 33 events is covered 
    97             effectiveRatio *= 0.7; 
    98         } 
    99         else if (eventCoverageRatio < 40) { 
    100             // 4 percent, so one of 28 events is covered 
    101             effectiveRatio *= 0.8; 
    102         } 
    103         else if (eventCoverageRatio < 50) { 
    104             // 5 percent, so one of 25 events is covered 
    105             effectiveRatio *= 0.9; 
    106         }*/ 
    107         //else { 
    108             // more than 5 percent, so 1 of 20 events, do not change ratio 
    109         //} 
    110         if (coverageQuantile >= defaultCoverageQuantile) { 
    111             if (effectiveRatio >= highRatioLevel) { 
    112                 return UsabilityDefectSeverity.HIGH; 
    113             } 
    114             else if (effectiveRatio >= mediumRatioLevel) { 
    115                 return UsabilityDefectSeverity.MEDIUM; 
    116             } 
    117             else if (effectiveRatio >= lowRatioLevel) { 
    118                 return UsabilityDefectSeverity.LOW; 
    119             } 
    120             else if (effectiveRatio >= infoRatioLevel) { 
    121                 return UsabilityDefectSeverity.INFO; 
    122             } 
    123         } 
    124          
    125         return null; 
    12672    } 
     73 
     74    /** 
     75     * <p> 
     76     * TODO: comment 
     77     * </p> 
     78     * 
     79     * @param ratio 
     80     * @param eventCoverage 
     81     * @param eventCoverageQuantile 
     82     */ 
     83    private UsabilitySmellIntensity(int ratio, int eventCoverage, int eventCoverageQuantile) { 
     84        super(); 
     85        this.ratio = ratio; 
     86        this.eventCoverage = eventCoverage; 
     87        this.eventCoverageQuantile = eventCoverageQuantile; 
     88    } 
     89 
     90    /** 
     91     * @return the ratio 
     92     */ 
     93    public int getRatio() { 
     94        return ratio; 
     95    } 
     96 
     97    /** 
     98     * @return the eventCoverage 
     99     */ 
     100    public int getEventCoverage() { 
     101        return eventCoverage; 
     102    } 
     103 
     104    /** 
     105     * @return the eventCoverageQuantile 
     106     */ 
     107    public int getEventCoverageQuantile() { 
     108        return eventCoverageQuantile; 
     109    } 
     110 
     111    /* (non-Javadoc) 
     112     * @see java.lang.Object#toString() 
     113     */ 
     114    @Override 
     115    public String toString() { 
     116        return Integer.toString(ratio); 
     117    } 
     118     
    127119} 

  • trunk/autoquest-core-usability/src/main/resources/smellDescriptions.xsd

    r1493 r1918  
    88  elementFormDefault="qualified"> 
    99   
    10   <xsd:element name="defectDescriptions" type="tns:DefectDescriptions" /> 
     10  <xsd:element name="smellDescriptions" type="tns:SmellDescriptions" /> 
    1111 
    12   <xsd:complexType name="DefectDescriptions"> 
     12  <xsd:complexType name="SmellDescriptions"> 
    1313    <xsd:sequence> 
    14       <xsd:element name="defectDescription" type="tns:DefectDescription" maxOccurs="unbounded" /> 
     14      <xsd:element name="smellDescription" type="tns:SmellDescription" maxOccurs="unbounded" /> 
    1515    </xsd:sequence> 
    1616  </xsd:complexType> 
    1717 
    18   <xsd:complexType name="DefectDescription"> 
     18  <xsd:complexType name="SmellDescription"> 
    1919    <xsd:choice maxOccurs="unbounded"> 
    2020      <xsd:element name="textFragment" type="tns:SimpleFragment" /> 
    2121      <xsd:element name="parameterFragment" type="tns:ParameterFragment" /> 
    2222    </xsd:choice> 
    23     <xsd:attribute name="defectId" type="xsd:string" use="required" /> 
     23    <xsd:attribute name="smellId" type="xsd:string" use="required" /> 
    2424    <xsd:attribute name="briefText" type="xsd:string" use="required" /> 
    2525  </xsd:complexType> 

  • trunk/autoquest-core-usability/src/main/resources/smellDescriptions_en.xml

    r1493 r1918  
    11<?xml version="1.0" encoding="UTF-8"?> 
    2 <defectDescriptions 
     2<smellDescriptions 
    33  xmlns="http://autoquest.informatik.uni-goettingen.de" 
    44  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    5   xsi:schemaLocation="http://autoquest.informatik.uni-goettingen.de defectDescriptions.xsd"> 
    6    
    7   <defectDescription defectId="TEXT_FIELD_INPUT_RATIO" briefText="many text inputs"> 
     5  xsi:schemaLocation="http://autoquest.informatik.uni-goettingen.de smellDescriptions.xsd"> 
     6   
     7  <smellDescription smellId="TEXT_FIELD_INPUT_RATIO" briefText="many text inputs"> 
    88    <textFragment> 
    99      The ratio of interactions that enter text into text fields is relatively high in comparison 
    … …  
    1515      or combo boxes in the case predefined values must be entered. 
    1616    </textFragment> 
    17   </defectDescription> 
    18    
    19   <defectDescription defectId="TEXT_FIELD_INPUT_REPETITIONS" briefText="many text repetitions"> 
     17  </smellDescription> 
     18   
     19  <smellDescription smellId="TEXT_FIELD_INPUT_REPETITIONS" briefText="many text repetitions"> 
    2020    <textFragment> 
    2121      In 
    … …  
    3434      reenter the same text several times into different text fields. 
    3535    </textFragment> 
    36   </defectDescription> 
    37    
    38   <defectDescription defectId="TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO" briefText="many special signs"> 
     36  </smellDescription> 
     37   
     38  <smellDescription smellId="TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO" briefText="many special signs"> 
    3939    <parameterFragment parameterName="noLetterOrDigitRatio" /> 
    4040    <textFragment> 
    … …  
    4848      included at the right positions. 
    4949    </textFragment> 
    50   </defectDescription> 
    51    
    52   <defectDescription defectId="HIGH_EVENT_COVERAGE" briefText="often executed"> 
     50  </smellDescription> 
     51   
     52  <smellDescription smellId="HIGH_EVENT_COVERAGE" briefText="often executed"> 
    5353    <textFragment> 
    5454      The task 
    … …  
    6464      be executed by users for fulfilling this task. 
    6565    </textFragment> 
    66   </defectDescription> 
    67    
    68   <defectDescription defectId="INEFFICIENT_ACTIONS" briefText="inefficient actions"> 
     66  </smellDescription> 
     67   
     68  <smellDescription smellId="INEFFICIENT_ACTIONS" briefText="inefficient actions"> 
    6969    <textFragment> 
    7070      For executing task 
    … …  
    8181      them: scrolling. 
    8282    </textFragment> 
    83   </defectDescription> 
    84    
    85   <defectDescription defectId="COOCCURENCE_SUCCEED" briefText="usual cooccurrence"> 
     83  </smellDescription> 
     84   
     85  <smellDescription smellId="COOCCURENCE_SUCCEED" briefText="usual cooccurrence"> 
    8686    <textFragment> 
    8787      In 
    … …  
    101101      reduce the number of actions to be performed by the user. 
    102102    </textFragment> 
    103   </defectDescription> 
    104    
    105   <defectDescription defectId="COOCCURENCE_PRECED" briefText="usual cooccurrence"> 
     103  </smellDescription> 
     104   
     105  <smellDescription smellId="COOCCURENCE_PRECED" briefText="usual cooccurrence"> 
    106106    <textFragment> 
    107107      In 
    … …  
    121121      reduce the number of actions to be performed by the user. 
    122122    </textFragment> 
    123   </defectDescription> 
    124    
    125   <defectDescription defectId="HIGH_TARGET_DISTANCE" briefText="long way to go"> 
     123  </smellDescription> 
     124   
     125  <smellDescription smellId="HIGH_TARGET_DISTANCE" briefText="long way to go"> 
    126126    <textFragment> 
    127127      For executing the task 
    … …  
    139139      on average ), they should be more colocated to ease the execution of the task for the user. 
    140140    </textFragment> 
    141   </defectDescription> 
    142    
    143   <defectDescription defectId="MISSING_FEEDBACK" briefText="missing feedback"> 
     141  </smellDescription> 
     142   
     143  <smellDescription smellId="MISSING_FEEDBACK" briefText="missing feedback"> 
    144144    <textFragment> 
    145145      A click on the button 
    … …  
    163163      actions. Please consider showing the user some progress after he performed the 
    164164      first click. This is especially important if the operation triggered with the click usually 
    165       takes longer than one second. This defect was observed based on task 
     165      takes longer than one second. This smell was observed based on task 
    166166    </textFragment> 
    167167    <parameterFragment parameterName="task" /> 
    … …  
    169169      . 
    170170    </textFragment> 
    171   </defectDescription> 
    172    
    173   <defectDescription defectId="UNUSED_GUI_ELEMENTS" briefText="unused GUI elements"> 
     171  </smellDescription> 
     172   
     173  <smellDescription smellId="UNUSED_GUI_ELEMENTS" briefText="unused GUI elements"> 
    174174    <parameterFragment parameterName="ratio" /> 
    175175    <textFragment> 
    … …  
    189189    </textFragment> 
    190190    <parameterFragment parameterName="unusedGuiElements" /> 
    191   </defectDescription> 
    192 </defectDescriptions> 
     191  </smellDescription> 
     192   
     193  <smellDescription smellId="DATA_ENTRY_METHOD_CHANGE" briefText="data entry method change"> 
     194    <textFragment> 
     195      When executing task 
     196    </textFragment> 
     197    <parameterFragment parameterName="task" /> 
     198    <textFragment> 
     199      , the users have to switch between keyboard and mouse in 
     200    </textFragment> 
     201    <parameterFragment parameterName="ratio" /> 
     202    <textFragment> 
     203      % on average between two subsequently executed actions. Frequently changing between mouse and 
     204      keyboard causes users to become slow when utilizing a GUI. Hence, these should be minimized to 
     205      optimize the users performance. 
     206    </textFragment> 
     207  </smellDescription> 
     208   
     209  <smellDescription smellId="GOOD_DEFAULTS" briefText="good defaults"> 
     210    <textFragment> 
     211      When using GUI element 
     212    </textFragment> 
     213    <parameterFragment parameterName="guiElement" /> 
     214    <textFragment> 
     215      in view 
     216    </textFragment> 
     217    <parameterFragment parameterName="view" /> 
     218    <textFragment> 
     219      , the values selected by the users are not equally distributed. Hence, it may be useful to 
     220      have a good default value. The users entered the following values with their respective 
     221      frequency in brackets most often (only the five most important entries listed): 
     222    </textFragment> 
     223    <parameterFragment parameterName="selectedValues" /> 
     224  </smellDescription> 
     225   
     226  <smellDescription smellId="CHECK_BOX_SINGLE_SELECTION" briefText="check box single selection"> 
     227    <textFragment> 
     228      Found a group of check boxes of which only one is usually selected. In this case, radio 
     229      buttons should be used instead, if the alternatives are mutually exclusive. The check boxes 
     230      belonging to the group are: 
     231    </textFragment> 
     232    <parameterFragment parameterName="radioButtons" /> 
     233  </smellDescription> 
     234   
     235  <smellDescription smellId="COMMON_TASK_RATE" briefText="common task rate"> 
     236    <textFragment> 
     237      The user sessions show only a few commonalities. On average, ten subsequently executed 
     238      actions need to be described by 
     239    </textFragment> 
     240    <parameterFragment parameterName="ratio" /> 
     241    <textFragment> 
     242      different determined tasks. In the worst case, each action is its own task. In the best case, 
     243      all actions are described by the same tasks. This indicates, that the users act relatively 
     244      different as otherwise, all their actions would be described by only a few tasks. Hence, 
     245      users seem to be missing guidance, as otherwise, they would behave similar resulting in less 
     246      generated task which still cover many recorded actions. 
     247    </textFragment> 
     248  </smellDescription> 
     249   
     250  <smellDescription smellId="MISLEADING_CLICK_CUE" briefText="misleading cue to click"> 
     251    <textFragment> 
     252      In the 
     253    </textFragment> 
     254    <parameterFragment parameterName="noOfViewDisplays" /> 
     255    <textFragment> 
     256      times the view 
     257    </textFragment> 
     258    <parameterFragment parameterName="view" /> 
     259    <textFragment> 
     260      has been displayed, the element 
     261    </textFragment> 
     262    <parameterFragment parameterName="element" /> 
     263    <textFragment> 
     264      has been clicked 
     265    </textFragment> 
     266    <parameterFragment parameterName="uselessClicks" /> 
     267    <textFragment> 
     268      times although it may not be clickable (it is no, e.g., button). If the element is not 
     269      clickable, then the element seems to give a cue that it was clickable although it is not. 
     270      Hence, it should be considered to change the appearance of the element to prevent it from 
     271      looking clickable.  
     272    </textFragment> 
     273  </smellDescription> 
     274   
     275  <smellDescription smellId="MOST_OFTEN_DONE_FIRST" briefText="most often done first in view"> 
     276    <textFragment> 
     277      When opening the view 
     278    </textFragment> 
     279    <parameterFragment parameterName="view" /> 
     280    <textFragment> 
     281      , users most often position the cursor into the text field 
     282    </textFragment> 
     283    <parameterFragment parameterName="textfield" /> 
     284    <textFragment> 
     285      (in  
     286    </textFragment> 
     287    <parameterFragment parameterName="ratio" /> 
     288    <textFragment> 
     289      % of cases when the view is opened). This should be automated to remove one action required 
     290      for users. 
     291    </textFragment> 
     292  </smellDescription> 
     293</smellDescriptions> 
Note: See TracChangeset for help on using the changeset viewer.