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/java/de/ugoe/cs/autoquest/usability
Files:
7 added
11 edited
3 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} 
Note: See TracChangeset for help on using the changeset viewer.