Ignore:
Timestamp:
08/17/12 09:26:21 (12 years ago)
Author:
pharms
Message:
  • adapted to new coding style in quest
Location:
trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability
Files:
7 edited

Legend:

Unmodified
Added
Removed

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

    r496 r561  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: TextInputStatisticsRule.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: pharms $  $Date: 16.07.2012 $ 
    … …  
    54// Creation  : 2012 by pharms 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
     7 
    88package de.ugoe.cs.quest.usability; 
    99 
    … …  
    1414import java.util.Map; 
    1515 
    16 import de.ugoe.cs.quest.eventcore.guimodel.TextArea; 
    17 import de.ugoe.cs.quest.eventcore.guimodel.TextField; 
    18 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; 
    19 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; 
    20 import de.ugoe.cs.quest.tasktrees.treeifc.TextInputInteractionTask; 
    21  
    22 //------------------------------------------------------------------------------------------------- 
     16import de.ugoe.cs.quest.eventcore.guimodel.ITextArea; 
     17import de.ugoe.cs.quest.eventcore.guimodel.ITextField; 
     18import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; 
     19import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; 
     20import de.ugoe.cs.quest.tasktrees.treeifc.ITextInputEventTask; 
     21 
    2322/** 
    2423 * TODO comment 
    … …  
    2726 * @author 2012, last modified by $Author: pharms$ 
    2827 */ 
    29 //------------------------------------------------------------------------------------------------- 
    30 public class TextInputStatisticsRule implements de.ugoe.cs.quest.usability.UsabilityEvaluationRule 
    31 { 
    32  
    33   //----------------------------------------------------------------------------------------------- 
    34   /* (non-Javadoc) 
    35    * @see de.ugoe.cs.usability.UsabilityEvaluationRule#evaluate(TaskTree) 
    36    */ 
    37   //----------------------------------------------------------------------------------------------- 
    38   @Override 
    39   public UsabilityEvaluationResult evaluate(TaskTree taskTree) 
    40   { 
    41     TextInputStatistics statistics = new TextInputStatistics(); 
    42     calculateStatistics(taskTree.getRoot(), statistics); 
    43      
    44     UsabilityEvaluationResult results = new UsabilityEvaluationResult(); 
    45     analyzeStatistics(statistics, results); 
    46      
    47     return results; 
    48   } 
    49  
    50   //----------------------------------------------------------------------------------------------- 
    51   /** 
    52    * TODO: comment 
    53    * 
    54    * @param statistics 
    55    * @param results 
    56    */ 
    57   //----------------------------------------------------------------------------------------------- 
    58   private void analyzeStatistics(TextInputStatistics statistics, UsabilityEvaluationResult results) 
    59   { 
    60     checkTextInputRatio(statistics, results); 
    61     checkTextFieldEntryRepetitions(statistics, results); 
    62     checkTextFieldNoLetterOrDigitInputs(statistics, results); 
    63   } 
    64  
    65   //----------------------------------------------------------------------------------------------- 
    66   /** 
    67    * TODO: comment 
    68    * 
    69    * @param statistics 
    70    * @param results  
    71    */ 
    72   //----------------------------------------------------------------------------------------------- 
    73   private void checkTextInputRatio(TextInputStatistics       statistics, 
     28public class TextInputStatisticsRule implements de.ugoe.cs.quest.usability.UsabilityEvaluationRule { 
     29 
     30    /* 
     31     * (non-Javadoc) 
     32     *  
     33     * @see de.ugoe.cs.usability.UsabilityEvaluationRule#evaluate(TaskTree) 
     34     */ 
     35    @Override 
     36    public UsabilityEvaluationResult evaluate(ITaskTree taskTree) { 
     37        TextInputStatistics statistics = new TextInputStatistics(); 
     38        calculateStatistics(taskTree.getRoot(), statistics); 
     39 
     40        UsabilityEvaluationResult results = new UsabilityEvaluationResult(); 
     41        analyzeStatistics(statistics, results); 
     42 
     43        return results; 
     44    } 
     45 
     46    /** 
     47     * TODO: comment 
     48     *  
     49     * @param statistics 
     50     * @param results 
     51     */ 
     52    private void analyzeStatistics(TextInputStatistics       statistics, 
    7453                                   UsabilityEvaluationResult results) 
    75   { 
    76     float allTextFieldInputs = 
    77       statistics.getNoOfTextFieldInputs() + statistics.getNoOfTextAreaInputs(); 
    78      
    79     float ratio = allTextFieldInputs / (float) statistics.getNoOfAllInteractions(); 
    80      
    81     UsabilityDefectSeverity severity = null; 
    82     if (ratio > 0.9) 
    8354    { 
    84       severity = UsabilityDefectSeverity.HIGH; 
    85     } 
    86     else if (ratio > 0.7) 
     55        checkTextInputRatio(statistics, results); 
     56        checkTextFieldEntryRepetitions(statistics, results); 
     57        checkTextFieldNoLetterOrDigitInputs(statistics, results); 
     58    } 
     59 
     60    /** 
     61     * TODO: comment 
     62     *  
     63     * @param statistics 
     64     * @param results 
     65     */ 
     66    private void checkTextInputRatio(TextInputStatistics       statistics, 
     67                                     UsabilityEvaluationResult results) 
    8768    { 
    88       severity = UsabilityDefectSeverity.MEDIUM; 
    89     } 
    90     else if (ratio > 0.5) 
     69        float allTextFieldInputs = 
     70            statistics.getNoOfTextFieldInputs() + statistics.getNoOfTextAreaInputs(); 
     71 
     72        float ratio = allTextFieldInputs / (float) statistics.getNoOfAllEvents(); 
     73 
     74        UsabilityDefectSeverity severity = null; 
     75        if (ratio > 0.9) { 
     76            severity = UsabilityDefectSeverity.HIGH; 
     77        } 
     78        else if (ratio > 0.7) { 
     79            severity = UsabilityDefectSeverity.MEDIUM; 
     80        } 
     81        else if (ratio > 0.5) { 
     82            severity = UsabilityDefectSeverity.LOW; 
     83        } 
     84        else if (ratio > 0.3) { 
     85            severity = UsabilityDefectSeverity.INFO; 
     86        } 
     87 
     88        if (severity != null) { 
     89            Map<String, String> parameters = new HashMap<String, String>(); 
     90            parameters.put("textInputRatio", DecimalFormat.getInstance().format(ratio * 100) + "%"); 
     91 
     92            results.addDefect 
     93                (new UsabilityDefect(severity, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO, 
     94                                     parameters)); 
     95        } 
     96    } 
     97 
     98    /** 
     99     * TODO: comment 
     100     *  
     101     * @param statistics 
     102     * @param results 
     103     */ 
     104    private void checkTextFieldEntryRepetitions(TextInputStatistics       statistics, 
     105                                                UsabilityEvaluationResult results) 
    91106    { 
    92       severity = UsabilityDefectSeverity.LOW; 
    93     } 
    94     else if (ratio > 0.3) 
     107        Map<String, Integer> words = new HashMap<String, Integer>(); 
     108        int numberOfRepeatedWords = 0; 
     109        int maxRepetitions = 0; 
     110 
     111        for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) { 
     112            String[] fragments = statistics.getTextFieldInputFragments(i); 
     113            for (String fragment : fragments) { 
     114                if (!"".equals(fragment.trim())) { 
     115                    Integer count = words.get(fragment); 
     116                    if (count == null) { 
     117                        words.put(fragment, 1); 
     118                    } 
     119                    else { 
     120                        count++; 
     121                        words.put(fragment, count); 
     122                        maxRepetitions = Math.max(count, maxRepetitions); 
     123 
     124                        if (count == 2) { 
     125                            // do not calculate repeated words several times 
     126                            numberOfRepeatedWords++; 
     127                        } 
     128                    } 
     129                } 
     130            } 
     131        } 
     132 
     133        UsabilityDefectSeverity severity = null; 
     134        if ((numberOfRepeatedWords > 10) || (maxRepetitions > 10)) { 
     135            severity = UsabilityDefectSeverity.HIGH; 
     136        } 
     137        else if ((numberOfRepeatedWords > 4) || (maxRepetitions > 4)) { 
     138            severity = UsabilityDefectSeverity.MEDIUM; 
     139        } 
     140        else if ((numberOfRepeatedWords > 2) || (maxRepetitions > 2)) { 
     141            severity = UsabilityDefectSeverity.LOW; 
     142        } 
     143        else if ((numberOfRepeatedWords > 1) || (maxRepetitions > 1)) { 
     144            severity = UsabilityDefectSeverity.INFO; 
     145        } 
     146 
     147        if (severity != null) { 
     148            Map<String, String> parameters = new HashMap<String, String>(); 
     149            parameters.put("textRepetitionRatio", numberOfRepeatedWords + 
     150                           " repeated tokens, up to " + maxRepetitions + " repetitions per token"); 
     151 
     152            results.addDefect 
     153                (new UsabilityDefect(severity, 
     154                                     UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS, 
     155                                     parameters)); 
     156        } 
     157    } 
     158 
     159    /** 
     160     * TODO: comment 
     161     *  
     162     * @param statistics 
     163     * @param results 
     164     */ 
     165    private void checkTextFieldNoLetterOrDigitInputs(TextInputStatistics       statistics, 
     166                                                     UsabilityEvaluationResult results) 
    95167    { 
    96       severity = UsabilityDefectSeverity.INFO; 
    97     } 
    98      
    99     if (severity != null) 
    100     { 
    101       Map<String, String> parameters = new HashMap<String, String>(); 
    102       parameters.put("textInputRatio", DecimalFormat.getInstance().format(ratio * 100) + "%"); 
    103        
    104       results.addDefect 
    105         (new UsabilityDefect 
    106            (severity, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO, parameters)); 
    107     } 
    108   } 
    109  
    110   //----------------------------------------------------------------------------------------------- 
    111   /** 
    112    * TODO: comment 
    113    * 
    114    * @param statistics 
    115    * @param results 
    116    */ 
    117   //----------------------------------------------------------------------------------------------- 
    118   private void checkTextFieldEntryRepetitions(TextInputStatistics       statistics, 
    119                                               UsabilityEvaluationResult results) 
    120   { 
    121     Map<String, Integer> words = new HashMap<String, Integer>(); 
    122     int numberOfRepeatedWords = 0; 
    123     int maxRepetitions = 0; 
    124  
    125     for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) 
    126     { 
    127       String[] fragments = statistics.getTextFieldInputFragments(i); 
    128       for (String fragment : fragments) 
    129       { 
    130         if (!"".equals(fragment.trim())) 
     168        int allCharactersCount = 0; 
     169        int noLetterOrDigitCount = 0; 
     170 
     171        for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) { 
     172            String[] fragments = statistics.getTextFieldInputFragments(i); 
     173            for (String fragment : fragments) { 
     174                String effectiveFragment = fragment.trim(); 
     175                for (int j = 0; j < effectiveFragment.length(); j++) { 
     176                    if (!Character.isWhitespace(effectiveFragment.charAt(j))) { 
     177                        if (!Character.isLetterOrDigit(effectiveFragment.charAt(j))) { 
     178                            noLetterOrDigitCount++; 
     179                        } 
     180                        allCharactersCount++; 
     181                    } 
     182                } 
     183            } 
     184        } 
     185 
     186        float ratio = (float) noLetterOrDigitCount / (float) allCharactersCount; 
     187 
     188        UsabilityDefectSeverity severity = null; 
     189        if (ratio > 0.1) // every 10th sign 
    131190        { 
    132           Integer count = words.get(fragment); 
    133           if (count == null) 
    134           { 
    135             words.put(fragment, 1); 
    136           } 
    137           else 
    138           { 
    139             count++; 
    140             words.put(fragment, count); 
    141             maxRepetitions = Math.max(count, maxRepetitions); 
    142  
    143             if (count == 2) 
    144             { 
    145               // do not calculate repeated words several times 
    146               numberOfRepeatedWords++; 
     191            severity = UsabilityDefectSeverity.HIGH; 
     192        } 
     193        else if (ratio > 0.05) // every 20th sign 
     194        { 
     195            severity = UsabilityDefectSeverity.MEDIUM; 
     196        } 
     197        else if (ratio > 0.02) // every 50th sign 
     198        { 
     199            severity = UsabilityDefectSeverity.LOW; 
     200        } 
     201        else if (ratio > 0.01) // every 100th sign 
     202        { 
     203            severity = UsabilityDefectSeverity.INFO; 
     204        } 
     205 
     206        if (severity != null) { 
     207            Map<String, String> parameters = new HashMap<String, String>(); 
     208            parameters.put("noLetterOrDigitRatio", allCharactersCount + " entered characters of " + 
     209                           "which " + noLetterOrDigitCount + " were no letter or digit"); 
     210 
     211            results.addDefect 
     212                (new UsabilityDefect(severity, 
     213                                     UsabilityDefectDescription.TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO, 
     214                                     parameters)); 
     215        } 
     216    } 
     217 
     218    /** 
     219     * TODO: comment 
     220     *  
     221     * @param taskTree 
     222     * @param statistics 
     223     */ 
     224    private void calculateStatistics(ITaskTreeNode node, TextInputStatistics statistics) { 
     225        if (node instanceof ITextInputEventTask) { 
     226            calculateStatistics((ITextInputEventTask) node, statistics); 
     227        } 
     228        else { 
     229            if ((node.getChildren() == null) || (node.getChildren().size() == 0)) { 
     230                statistics.incrementNoOfOtherEventTasks(); 
    147231            } 
    148           } 
    149         } 
    150       } 
    151     } 
    152      
    153     UsabilityDefectSeverity severity = null; 
    154     if ((numberOfRepeatedWords > 10) || (maxRepetitions > 10)) 
    155     { 
    156       severity = UsabilityDefectSeverity.HIGH; 
    157     } 
    158     else if ((numberOfRepeatedWords > 4) || (maxRepetitions > 4)) 
    159     { 
    160       severity = UsabilityDefectSeverity.MEDIUM; 
    161     } 
    162     else if ((numberOfRepeatedWords > 2) || (maxRepetitions > 2)) 
    163     { 
    164       severity = UsabilityDefectSeverity.LOW; 
    165     } 
    166     else if ((numberOfRepeatedWords > 1) || (maxRepetitions > 1)) 
    167     { 
    168       severity = UsabilityDefectSeverity.INFO; 
    169     } 
    170      
    171     if (severity != null) 
    172     { 
    173       Map<String, String> parameters = new HashMap<String, String>(); 
    174       parameters.put("textRepetitionRatio", numberOfRepeatedWords + " repeated tokens, up to " + 
    175                      maxRepetitions + " repetitions per token"); 
    176  
    177       results.addDefect 
    178         (new UsabilityDefect 
    179            (severity, UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS, parameters)); 
    180     } 
    181   } 
    182  
    183   //----------------------------------------------------------------------------------------------- 
    184   /** 
    185    * TODO: comment 
    186    * 
    187    * @param statistics 
    188    * @param results 
    189    */ 
    190   //----------------------------------------------------------------------------------------------- 
    191   private void checkTextFieldNoLetterOrDigitInputs(TextInputStatistics       statistics, 
    192                                                    UsabilityEvaluationResult results) 
    193   { 
    194     int allCharactersCount = 0; 
    195     int noLetterOrDigitCount = 0; 
    196  
    197     for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) 
    198     { 
    199       String[] fragments = statistics.getTextFieldInputFragments(i); 
    200       for (String fragment : fragments) 
    201       { 
    202         String effectiveFragment = fragment.trim(); 
    203         for (int j = 0; j < effectiveFragment.length(); j++) 
    204         { 
    205           if (!Character.isWhitespace(effectiveFragment.charAt(j))) 
    206           { 
    207             if (!Character.isLetterOrDigit(effectiveFragment.charAt(j))) 
    208             { 
    209               noLetterOrDigitCount++; 
     232            else { 
     233                for (ITaskTreeNode child : node.getChildren()) { 
     234                    calculateStatistics(child, statistics); 
     235                } 
    210236            } 
    211             allCharactersCount++; 
    212           } 
    213         } 
    214       } 
    215     } 
    216      
    217     float ratio = (float) noLetterOrDigitCount / (float) allCharactersCount; 
    218      
    219     UsabilityDefectSeverity severity = null; 
    220     if (ratio > 0.1) // every 10th sign 
    221     { 
    222       severity = UsabilityDefectSeverity.HIGH; 
    223     } 
    224     else if (ratio > 0.05) // every 20th sign 
    225     { 
    226       severity = UsabilityDefectSeverity.MEDIUM; 
    227     } 
    228     else if (ratio > 0.02) // every 50th sign 
    229     { 
    230       severity = UsabilityDefectSeverity.LOW; 
    231     } 
    232     else if (ratio > 0.01) // every 100th sign 
    233     { 
    234       severity = UsabilityDefectSeverity.INFO; 
    235     } 
    236      
    237     if (severity != null) 
    238     { 
    239       Map<String, String> parameters = new HashMap<String, String>(); 
    240       parameters.put("noLetterOrDigitRatio", allCharactersCount + " entered characters of " + 
    241                      "which " + noLetterOrDigitCount + " were no letter or digit"); 
    242  
    243       results.addDefect 
    244         (new UsabilityDefect 
    245            (severity, UsabilityDefectDescription.TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO, parameters)); 
    246     } 
    247   } 
    248  
    249   //----------------------------------------------------------------------------------------------- 
    250   /** 
    251    * TODO: comment 
    252    * 
    253    * @param taskTree 
    254    * @param statistics 
    255    */ 
    256   //----------------------------------------------------------------------------------------------- 
    257   private void calculateStatistics(TaskTreeNode node, TextInputStatistics statistics) 
    258   { 
    259     if (node instanceof TextInputInteractionTask) 
    260     { 
    261       calculateStatistics((TextInputInteractionTask) node, statistics); 
    262     } 
    263     else 
    264     { 
    265       if ((node.getChildren() == null) || 
    266           (node.getChildren().size() == 0)) 
    267       { 
    268         statistics.incrementNoOfOtherInteractionTasks(); 
    269       } 
    270       else 
    271       { 
    272         for (TaskTreeNode child : node.getChildren()) 
    273         { 
    274           calculateStatistics(child, statistics); 
    275         } 
    276       } 
    277     } 
    278   } 
    279  
    280   //----------------------------------------------------------------------------------------------- 
    281   /** 
    282    * TODO: comment 
    283    * 
    284    * @param taskTree 
    285    * @param statistics 
    286    */ 
    287   //----------------------------------------------------------------------------------------------- 
    288   private void calculateStatistics(TextInputInteractionTask node, TextInputStatistics statistics) 
    289   { 
    290     String[] fragments = determineTextFragments(node.getEnteredText()); 
    291      
    292     if (node.getGUIElement() instanceof TextField) 
    293     { 
    294       statistics.addTextFieldInput(node, fragments); 
    295     } 
    296     else if (node.getGUIElement() instanceof TextArea) 
    297     { 
    298       statistics.addTextAreaInput(node, fragments); 
    299     } 
    300   } 
    301    
    302   //----------------------------------------------------------------------------------------------- 
    303   /** 
    304    * TODO: comment 
    305    * 
    306    * @param enteredText 
    307    * @return 
    308    */ 
    309   //----------------------------------------------------------------------------------------------- 
    310   private String[] determineTextFragments(String enteredText) 
    311   { 
    312     List<String> fragments = new ArrayList<String>(); 
    313      
    314     StringBuffer fragment = new StringBuffer(); 
    315     char lastChar = 0; 
    316      
    317     for (int i = 0; i < enteredText.length(); i++) 
    318     { 
    319       char currentChar = enteredText.charAt(i); 
    320        
    321       if (!isEqualCharacterType(lastChar, currentChar)) 
    322       { 
    323         // the previous fragment ended. so finalize it and start a new one 
    324         if ((fragment != null) && (fragment.length() > 0)) 
    325         { 
    326           fragments.add(fragment.toString()); 
    327           fragment = new StringBuffer(); 
    328         } 
    329       } 
    330  
    331       fragment.append(currentChar); 
    332       lastChar = currentChar; 
    333     } 
    334      
    335     if ((fragment != null) && (fragment.length() > 0)) 
    336     { 
    337       fragments.add(fragment.toString()); 
    338     } 
    339      
    340     return fragments.toArray(new String[fragments.size()]); 
    341   } 
    342  
    343   //----------------------------------------------------------------------------------------------- 
    344   /** 
    345    * TODO: comment 
    346    * 
    347    * @param lastChar 
    348    * @param currentChar 
    349    * @return 
    350    */ 
    351   //----------------------------------------------------------------------------------------------- 
    352   private boolean isEqualCharacterType(char char1, char char2) 
    353   { 
    354     return 
    355       ((char1 == char2) || 
    356        (Character.isWhitespace(char1) && Character.isWhitespace(char2)) || 
    357        (Character.isDigit(char1) && Character.isDigit(char2)) || 
    358        (Character.isLetter(char1) && Character.isLetter(char2)) || 
    359        (Character.isJavaIdentifierPart(char1) && Character.isJavaIdentifierPart(char2))); 
    360   } 
    361  
    362   //------------------------------------------------------------------------------------------------- 
    363   /** 
    364    * TODO comment 
    365    *  
    366    * @version $Revision: $ $Date: 16.07.2012$ 
    367    * @author 2012, last modified by $Author: pharms$ 
    368    */ 
    369   //------------------------------------------------------------------------------------------------- 
    370   public static class TextInputStatistics 
    371   { 
    372     /** */ 
    373     private List<Object[]> mTextFieldInputs = new ArrayList<Object[]>(); 
    374      
    375     /** */ 
    376     private List<Object[]> mTextAreaInputs = new ArrayList<Object[]>(); 
    377      
    378     /** */ 
    379     private int mOtherInteractionsCount; 
    380      
    381     //----------------------------------------------------------------------------------------------- 
    382     /** 
    383      * TODO: comment 
    384      * @param node  
    385      * @param fragments  
    386      * 
    387      */ 
    388     //----------------------------------------------------------------------------------------------- 
    389     public void addTextFieldInput(TextInputInteractionTask node, String[] fragments) 
    390     { 
    391       mTextFieldInputs.add(new Object[] { node, fragments }); 
    392     } 
    393  
    394     //----------------------------------------------------------------------------------------------- 
    395     /** 
    396      * TODO: comment 
    397      * @param node  
    398      * @param fragments  
    399      * 
    400      */ 
    401     //----------------------------------------------------------------------------------------------- 
    402     public void addTextAreaInput(TextInputInteractionTask node, String[] fragments) 
    403     { 
    404       mTextAreaInputs.add(new Object[] { node, fragments }); 
    405     } 
    406  
    407     //----------------------------------------------------------------------------------------------- 
    408     /** 
    409      * TODO: comment 
    410      * 
     237        } 
     238    } 
     239 
     240    /** 
     241     * TODO: comment 
     242     *  
     243     * @param taskTree 
     244     * @param statistics 
     245     */ 
     246    private void calculateStatistics(ITextInputEventTask node, TextInputStatistics statistics) { 
     247        String[] fragments = determineTextFragments(node.getEnteredText()); 
     248 
     249        if (node.getEventTarget() instanceof ITextField) { 
     250            statistics.addTextFieldInput(node, fragments); 
     251        } 
     252        else if (node.getEventTarget() instanceof ITextArea) { 
     253            statistics.addTextAreaInput(node, fragments); 
     254        } 
     255    } 
     256 
     257    /** 
     258     * TODO: comment 
     259     *  
     260     * @param enteredText 
    411261     * @return 
    412262     */ 
    413     //----------------------------------------------------------------------------------------------- 
    414     public int getNoOfAllInteractions() 
    415     { 
    416       return mTextFieldInputs.size() + mTextAreaInputs.size() + mOtherInteractionsCount; 
    417     } 
    418  
    419     //----------------------------------------------------------------------------------------------- 
    420     /** 
    421      * TODO: comment 
    422      * 
     263    private String[] determineTextFragments(String enteredText) { 
     264        List<String> fragments = new ArrayList<String>(); 
     265 
     266        StringBuffer fragment = new StringBuffer(); 
     267        char lastChar = 0; 
     268 
     269        for (int i = 0; i < enteredText.length(); i++) { 
     270            char currentChar = enteredText.charAt(i); 
     271 
     272            if (!isEqualCharacterType(lastChar, currentChar)) { 
     273                // the previous fragment ended. so finalize it and start a new one 
     274                if ((fragment != null) && (fragment.length() > 0)) { 
     275                    fragments.add(fragment.toString()); 
     276                    fragment = new StringBuffer(); 
     277                } 
     278            } 
     279 
     280            fragment.append(currentChar); 
     281            lastChar = currentChar; 
     282        } 
     283 
     284        if ((fragment != null) && (fragment.length() > 0)) { 
     285            fragments.add(fragment.toString()); 
     286        } 
     287 
     288        return fragments.toArray(new String[fragments.size()]); 
     289    } 
     290 
     291    /** 
     292     * TODO: comment 
     293     *  
     294     * @param lastChar 
     295     * @param currentChar 
    423296     * @return 
    424297     */ 
    425     //----------------------------------------------------------------------------------------------- 
    426     public int getNoOfTextFieldInputs() 
    427     { 
    428       return mTextFieldInputs.size(); 
    429     } 
    430  
    431     //----------------------------------------------------------------------------------------------- 
    432     /** 
    433      * TODO: comment 
    434      * 
    435      * @param i 
    436      * @return 
    437      */ 
    438     //----------------------------------------------------------------------------------------------- 
    439     public String[] getTextFieldInputFragments(int index) 
    440     { 
    441       return (String[]) mTextFieldInputs.get(index)[1]; 
    442     } 
    443  
    444     //----------------------------------------------------------------------------------------------- 
    445     /** 
    446      * TODO: comment 
    447      * 
    448      * @return 
    449      */ 
    450     //----------------------------------------------------------------------------------------------- 
    451     public int getNoOfTextAreaInputs() 
    452     { 
    453       return mTextAreaInputs.size(); 
    454     } 
    455  
    456     //----------------------------------------------------------------------------------------------- 
    457     /** 
    458      * TODO: comment 
    459      * 
    460      * @param i 
    461      * @return 
    462      */ 
    463     //----------------------------------------------------------------------------------------------- 
    464     public String[] getTextAreaInputFragments(int index) 
    465     { 
    466       return (String[]) mTextAreaInputs.get(index)[1]; 
    467     } 
    468  
    469     //----------------------------------------------------------------------------------------------- 
    470     /** 
    471      * TODO: comment 
    472      * 
    473      */ 
    474     //----------------------------------------------------------------------------------------------- 
    475     public void incrementNoOfOtherInteractionTasks() 
    476     { 
    477       mOtherInteractionsCount++; 
    478     } 
    479  
    480      
    481   } 
     298    private boolean isEqualCharacterType(char char1, char char2) { 
     299        return 
     300            ((char1 == char2) || 
     301            (Character.isWhitespace(char1) && Character.isWhitespace(char2)) || 
     302            (Character.isDigit(char1) && Character.isDigit(char2)) || 
     303            (Character.isLetter(char1) && Character.isLetter(char2)) || 
     304            (Character.isJavaIdentifierPart(char1) && Character.isJavaIdentifierPart(char2))); 
     305    } 
     306 
     307    /** 
     308     * TODO comment 
     309     *  
     310     * @version $Revision: $ $Date: 16.07.2012$ 
     311     * @author 2012, last modified by $Author: pharms$ 
     312     */ 
     313    public static class TextInputStatistics { 
     314         
     315        /** */ 
     316        private List<Object[]> textFieldInputs = new ArrayList<Object[]>(); 
     317 
     318        /** */ 
     319        private List<Object[]> textAreaInputs = new ArrayList<Object[]>(); 
     320 
     321        /** */ 
     322        private int otherEventsCount; 
     323 
     324        /** 
     325         * TODO: comment 
     326         *  
     327         * @param node 
     328         * @param fragments 
     329         *  
     330         */ 
     331        public void addTextFieldInput(ITextInputEventTask node, String[] fragments) { 
     332            textFieldInputs.add(new Object[] { node, fragments }); 
     333        } 
     334 
     335        /** 
     336         * TODO: comment 
     337         *  
     338         * @param node 
     339         * @param fragments 
     340         *  
     341         */ 
     342        public void addTextAreaInput(ITextInputEventTask node, String[] fragments) { 
     343            textAreaInputs.add(new Object[] { node, fragments }); 
     344        } 
     345 
     346        /** 
     347         * TODO: comment 
     348         *  
     349         * @return 
     350         */ 
     351        public int getNoOfAllEvents() { 
     352            return textFieldInputs.size() + textAreaInputs.size() + otherEventsCount; 
     353        } 
     354 
     355        /** 
     356         * TODO: comment 
     357         *  
     358         * @return 
     359         */ 
     360        public int getNoOfTextFieldInputs() { 
     361            return textFieldInputs.size(); 
     362        } 
     363 
     364        /** 
     365         * TODO: comment 
     366         *  
     367         * @param i 
     368         * @return 
     369         */ 
     370        public String[] getTextFieldInputFragments(int index) { 
     371            return (String[]) textFieldInputs.get(index)[1]; 
     372        } 
     373 
     374        /** 
     375         * TODO: comment 
     376         *  
     377         * @return 
     378         */ 
     379        public int getNoOfTextAreaInputs() { 
     380            return textAreaInputs.size(); 
     381        } 
     382 
     383        /** 
     384         * TODO: comment 
     385         *  
     386         * @param i 
     387         * @return 
     388         */ 
     389        public String[] getTextAreaInputFragments(int index) { 
     390            return (String[]) textAreaInputs.get(index)[1]; 
     391        } 
     392 
     393        /** 
     394         * TODO: comment 
     395         *  
     396         */ 
     397        public void incrementNoOfOtherEventTasks() { 
     398            otherEventsCount++; 
     399        } 
     400 
     401    } 
    482402 
    483403} 

  • trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefect.java

    r477 r561  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: UsabilityDefect.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: pharms $  $Date: 16.07.2012 $ 
    … …  
    54// Creation  : 2012 by pharms 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
     7 
    88package de.ugoe.cs.quest.usability; 
    99 
    1010import java.util.Map; 
    1111 
    12 //------------------------------------------------------------------------------------------------- 
    1312/** 
    1413 * TODO comment 
    … …  
    1716 * @author 2012, last modified by $Author: pharms$ 
    1817 */ 
    19 //------------------------------------------------------------------------------------------------- 
    20 public class UsabilityDefect 
    21 { 
     18public class UsabilityDefect { 
    2219 
    23   /** */ 
    24   private UsabilityDefectSeverity mSeverity; 
    25    
    26   /** */ 
    27   private UsabilityDefectDescription mDescription; 
     20    /** */ 
     21    private UsabilityDefectSeverity severity; 
    2822 
    29   /** */ 
    30   private Map<String, String> mDescriptionParameters; 
     23    /** */ 
     24    private UsabilityDefectDescription description; 
    3125 
    32   //----------------------------------------------------------------------------------------------- 
    33   /** 
    34    * TODO: comment 
    35    * 
    36    * @param medium 
    37    * @param highTextInputRatio 
    38    */ 
    39   //----------------------------------------------------------------------------------------------- 
    40   public UsabilityDefect(UsabilityDefectSeverity    severity, 
    41                          UsabilityDefectDescription description) 
    42   { 
    43     this(severity, description, null); 
    44   } 
     26    /** */ 
     27    private Map<String, String> descriptionParameters; 
    4528 
    46   //----------------------------------------------------------------------------------------------- 
    47   /** 
    48    * TODO: comment 
    49    * 
    50    * @param medium 
    51    * @param highTextInputRatio 
    52    */ 
    53   //----------------------------------------------------------------------------------------------- 
    54   public UsabilityDefect(UsabilityDefectSeverity    severity, 
    55                          UsabilityDefectDescription description, 
    56                          Map<String, String>        parameters) 
    57   { 
    58     mSeverity = severity; 
    59     mDescription = description; 
    60     mDescriptionParameters = parameters; 
    61   } 
     29    /** 
     30     * TODO: comment 
     31     *  
     32     * @param medium 
     33     * @param highTextInputRatio 
     34     */ 
     35    public UsabilityDefect(UsabilityDefectSeverity severity, UsabilityDefectDescription description) 
     36    { 
     37        this(severity, description, null); 
     38    } 
    6239 
    63   //----------------------------------------------------------------------------------------------- 
    64   /** 
    65    * TODO: comment 
    66    * 
    67    * @return 
    68    */ 
    69   //----------------------------------------------------------------------------------------------- 
    70   public UsabilityDefectSeverity getSeverity() 
    71   { 
    72     return mSeverity; 
    73   } 
     40    /** 
     41     * TODO: comment 
     42     *  
     43     * @param medium 
     44     * @param highTextInputRatio 
     45     */ 
     46    public UsabilityDefect(UsabilityDefectSeverity    severity, 
     47                           UsabilityDefectDescription description, 
     48                           Map<String, String>        parameters) 
     49    { 
     50        this.severity = severity; 
     51        this.description = description; 
     52        this.descriptionParameters = parameters; 
     53    } 
    7454 
    75   //----------------------------------------------------------------------------------------------- 
    76   /** 
    77    * @param severity the severity to set 
    78    */ 
    79   //----------------------------------------------------------------------------------------------- 
    80   public void setSeverity(UsabilityDefectSeverity severity) 
    81   { 
    82     mSeverity = severity; 
    83   } 
     55    /** 
     56     * TODO: comment 
     57     *  
     58     * @return 
     59     */ 
     60    public UsabilityDefectSeverity getSeverity() { 
     61        return severity; 
     62    } 
    8463 
    85   //----------------------------------------------------------------------------------------------- 
    86   /** 
    87    * @param description the description to set 
    88    */ 
    89   //----------------------------------------------------------------------------------------------- 
    90   public void setDescription(UsabilityDefectDescription description) 
    91   { 
    92     mDescription = description; 
    93   } 
     64    /** 
     65     * @param severity 
     66     *            the severity to set 
     67     */ 
     68    public void setSeverity(UsabilityDefectSeverity severity) { 
     69        this.severity = severity; 
     70    } 
    9471 
    95   //----------------------------------------------------------------------------------------------- 
    96   /** 
     72    /** 
     73     * @param description 
     74     *            the description to set 
     75     */ 
     76    public void setDescription(UsabilityDefectDescription description) { 
     77        this.description = description; 
     78    } 
     79 
     80    /** 
    9781   *  
    9882   */ 
    99   //----------------------------------------------------------------------------------------------- 
    100   public String getParameterizedDescription() 
    101   { 
    102     return mDescription.toString(mDescriptionParameters); 
    103   } 
     83    public String getParameterizedDescription() { 
     84        return description.toString(descriptionParameters); 
     85    } 
    10486 
    105   //----------------------------------------------------------------------------------------------- 
    106   /* (non-Javadoc) 
    107    * @see java.lang.Object#equals(java.lang.Object) 
    108    */ 
    109   //----------------------------------------------------------------------------------------------- 
    110   @Override 
    111   public boolean equals(Object obj) 
    112   { 
    113     if (obj instanceof UsabilityDefect) 
    114     { 
    115       return 
    116         (mSeverity == ((UsabilityDefect) obj).mSeverity) && 
    117         (mDescription == ((UsabilityDefect) obj).mDescription); 
     87    /* 
     88     * (non-Javadoc) 
     89     *  
     90     * @see java.lang.Object#equals(java.lang.Object) 
     91     */ 
     92    @Override 
     93    public boolean equals(Object obj) { 
     94        if (obj instanceof UsabilityDefect) { 
     95            return 
     96                (severity == ((UsabilityDefect) obj).severity) && 
     97                (description == ((UsabilityDefect) obj).description); 
     98        } 
     99        else { 
     100            return false; 
     101        } 
    118102    } 
    119     else 
    120     { 
    121       return false; 
     103 
     104    /* 
     105     * (non-Javadoc) 
     106     *  
     107     * @see java.lang.Object#hashCode() 
     108     */ 
     109    @Override 
     110    public int hashCode() { 
     111        return severity.hashCode() + description.hashCode(); 
    122112    } 
    123   } 
    124113 
    125   //----------------------------------------------------------------------------------------------- 
    126   /* (non-Javadoc) 
    127    * @see java.lang.Object#hashCode() 
    128    */ 
    129   //----------------------------------------------------------------------------------------------- 
    130   @Override 
    131   public int hashCode() 
    132   { 
    133     return mSeverity.hashCode() + mDescription.hashCode(); 
    134   } 
    135  
    136   //----------------------------------------------------------------------------------------------- 
    137   /* (non-Javadoc) 
    138    * @see java.lang.Object#toString() 
    139    */ 
    140   //----------------------------------------------------------------------------------------------- 
    141   @Override 
    142   public String toString() 
    143   { 
    144     return "UsabilityDefect(" + mSeverity.name() + ", " + mDescription.name() + ")"; 
    145   } 
     114    /* 
     115     * (non-Javadoc) 
     116     *  
     117     * @see java.lang.Object#toString() 
     118     */ 
     119    @Override 
     120    public String toString() { 
     121        return "UsabilityDefect(" + severity.name() + ", " + description.name() + ")"; 
     122    } 
    146123 
    147124} 

  • trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefectDescription.java

    r496 r561  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: UsabilityDefectDescriptions.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: pharms $  $Date: 18.07.2012 $ 
    … …  
    54// Creation  : 2012 by pharms 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
    87package de.ugoe.cs.quest.usability; 
    98 
    … …  
    1817import javax.xml.bind.Unmarshaller; 
    1918 
    20 //------------------------------------------------------------------------------------------------- 
    2119/** 
    2220 * TODO comment 
    … …  
    2523 * @author 2012, last modified by $Author: pharms$ 
    2624 */ 
    27 //------------------------------------------------------------------------------------------------- 
    28 public enum UsabilityDefectDescription 
    29 { 
    30   TEXT_FIELD_INPUT_RATIO, 
    31   TEXT_FIELD_INPUT_REPETITIONS, 
    32   TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO; 
     25public enum UsabilityDefectDescription { 
     26     
     27    TEXT_FIELD_INPUT_RATIO, 
     28    TEXT_FIELD_INPUT_REPETITIONS, 
     29    TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO; 
    3330 
    34   /** */ 
    35   private static final String DEFAULT_MESSAGES_FILE = "defectDescriptions_en.xml"; 
    36    
    37   /** */ 
    38   private static DefectDescriptions sDefectDescriptions; 
     31    /** */ 
     32    private static final String DEFAULT_MESSAGES_FILE = "defectDescriptions_en.xml"; 
    3933 
    40   /** */ 
    41   private DefectDescription mDefectDescription; 
    42    
    43   //----------------------------------------------------------------------------------------------- 
    44   /** 
    45    * TODO: comment 
    46    * 
    47    * @param name 
    48    * @param ordinal 
    49    */ 
    50   //----------------------------------------------------------------------------------------------- 
    51   private UsabilityDefectDescription() 
    52   { 
    53     init(); 
    54   } 
     34    /** */ 
     35    private static DefectDescriptions sDefectDescriptions; 
    5536 
    56   //----------------------------------------------------------------------------------------------- 
    57   /** 
    58    * TODO: comment 
    59    * 
    60    */ 
    61   //----------------------------------------------------------------------------------------------- 
    62   @SuppressWarnings("unchecked") 
    63   private void init() 
    64   { 
    65     synchronized (this.getClass()) 
    66     { 
    67       if (sDefectDescriptions == null) 
    68       { 
    69         InputStream inputStream = ClassLoader.getSystemResourceAsStream(DEFAULT_MESSAGES_FILE); 
     37    /** */ 
     38    private DefectDescription defectDescription; 
    7039 
    71         try 
    72         { 
    73           String packageName = DefectDescriptions.class.getPackage().getName(); 
    74           JAXBContext jaxbContext = JAXBContext.newInstance(packageName); 
    75           Unmarshaller unmarshaller = jaxbContext.createUnmarshaller(); 
    76          
    77           sDefectDescriptions = 
    78             ((JAXBElement<DefectDescriptions>) unmarshaller.unmarshal(inputStream)).getValue(); 
     40    /** 
     41     * TODO: comment 
     42     *  
     43     * @param name 
     44     * @param ordinal 
     45     */ 
     46    private UsabilityDefectDescription() { 
     47        init(); 
     48    } 
     49 
     50    /** 
     51     * TODO: comment 
     52     *  
     53     */ 
     54    @SuppressWarnings("unchecked") 
     55    private void init() { 
     56        synchronized (this.getClass()) { 
     57            if (sDefectDescriptions == null) { 
     58                InputStream inputStream = 
     59                    ClassLoader.getSystemResourceAsStream(DEFAULT_MESSAGES_FILE); 
     60 
     61                try { 
     62                    String packageName = DefectDescriptions.class.getPackage().getName(); 
     63                    JAXBContext jaxbContext = JAXBContext.newInstance(packageName); 
     64                    Unmarshaller unmarshaller = jaxbContext.createUnmarshaller(); 
     65 
     66                    sDefectDescriptions = 
     67                        ((JAXBElement<DefectDescriptions>) unmarshaller.unmarshal(inputStream)) 
     68                            .getValue(); 
     69                } 
     70                catch (Exception e) { 
     71                    throw new RuntimeException 
     72                        ("error while initializing usability defect descriptions", e); 
     73                } 
     74                finally { 
     75                    if (inputStream != null) { 
     76                        try { 
     77                            inputStream.close(); 
     78                        } 
     79                        catch (IOException e) { 
     80                            // ignore 
     81                        } 
     82                    } 
     83                } 
     84            } 
    7985        } 
    80         catch (Exception e) 
    81         { 
    82           throw new RuntimeException("error while initializing usability defect descriptions", e); 
     86 
     87        for (DefectDescription description : sDefectDescriptions.getDefectDescription()) { 
     88            if (this.name().equals(description.getDefectId())) { 
     89                defectDescription = description; 
     90                break; 
     91            } 
    8392        } 
    84         finally 
    85         { 
    86           if (inputStream != null) 
    87           { 
    88             try 
    89             { 
    90               inputStream.close(); 
    91             } 
    92             catch (IOException e) 
    93             { 
    94               // ignore 
    95             } 
    96           } 
     93 
     94        if (defectDescription == null) { 
     95            throw new RuntimeException 
     96                ("error while initializing usability defect descriptions. No " + 
     97                 "description text available for description " + this.name()); 
    9798        } 
    98       } 
    9999    } 
    100      
    101     for (DefectDescription description : sDefectDescriptions.getDefectDescription()) 
    102     { 
    103       if (this.name().equals(description.getDefectId())) 
    104       { 
    105         mDefectDescription = description; 
    106         break; 
    107       } 
    108     } 
    109      
    110     if (mDefectDescription == null) 
    111     { 
    112       throw new RuntimeException("error while initializing usability defect descriptions. No " + 
    113                                  "description text available for description " + this.name()); 
    114     } 
    115   } 
    116100 
    117   //----------------------------------------------------------------------------------------------- 
    118   /** 
     101    /** 
    119102   *  
    120103   */ 
    121   //----------------------------------------------------------------------------------------------- 
    122   public String[] getDescriptionParameters() 
    123   { 
    124     List<String> parameters = new ArrayList<String>(); 
    125      
    126     for (Object fragment : mDefectDescription.getTextFragmentOrParameterFragment()) 
    127     { 
    128       if (fragment instanceof ParameterFragment) 
    129       { 
    130         parameters.add(((ParameterFragment) fragment).getParameterName()); 
    131       } 
     104    public String[] getDescriptionParameters() { 
     105        List<String> parameters = new ArrayList<String>(); 
     106 
     107        for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) { 
     108            if (fragment instanceof ParameterFragment) { 
     109                parameters.add(((ParameterFragment) fragment).getParameterName()); 
     110            } 
     111        } 
     112 
     113        return parameters.toArray(new String[parameters.size()]); 
    132114    } 
    133      
    134     return parameters.toArray(new String[parameters.size()]); 
    135   } 
    136    
    137   //----------------------------------------------------------------------------------------------- 
    138   /** 
     115 
     116    /** 
    139117   *  
    140118   */ 
    141   //----------------------------------------------------------------------------------------------- 
    142   public String toString(Map<String, String> parameters) throws IllegalArgumentException 
    143   { 
    144     StringBuffer result = new StringBuffer(); 
    145      
    146     for (Object fragment : mDefectDescription.getTextFragmentOrParameterFragment()) 
    147     { 
    148       if (result.length() > 0) 
    149       { 
    150         result.append(" "); 
    151       } 
    152        
    153       if (fragment instanceof ParameterFragment) 
    154       { 
    155         String value = null; 
    156         if (parameters != null) 
    157         { 
    158           value = parameters.get(((ParameterFragment) fragment).getParameterName()); 
     119    public String toString(Map<String, String> parameters) throws IllegalArgumentException { 
     120        StringBuffer result = new StringBuffer(); 
     121 
     122        for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) { 
     123            if (result.length() > 0) { 
     124                result.append(" "); 
     125            } 
     126 
     127            if (fragment instanceof ParameterFragment) { 
     128                String value = null; 
     129                if (parameters != null) { 
     130                    value = parameters.get(((ParameterFragment) fragment).getParameterName()); 
     131                } 
     132 
     133                if (value != null) { 
     134                    result.append(value); 
     135                } 
     136                else { 
     137                    throw new IllegalArgumentException 
     138                        ("required parameter \"" + 
     139                         ((ParameterFragment) fragment).getParameterName() + 
     140                         "\" for usability defect description " + this.name() + " not provided"); 
     141                } 
     142            } 
     143            else { 
     144                result.append(getFragmentString(fragment)); 
     145            } 
    159146        } 
    160          
    161         if (value != null) 
    162         { 
    163           result.append(value); 
     147 
     148        return result.toString(); 
     149    } 
     150 
     151    /* 
     152     * (non-Javadoc) 
     153     *  
     154     * @see java.lang.Enum#toString() 
     155     */ 
     156    @Override 
     157    public String toString() { 
     158        StringBuffer result = new StringBuffer(); 
     159 
     160        int paramCount = 1; 
     161        for (Object fragment : defectDescription.getTextFragmentOrParameterFragment()) { 
     162            if (result.length() > 0) { 
     163                result.append(" "); 
     164            } 
     165 
     166            if (fragment instanceof ParameterFragment) { 
     167                result.append("<parameter"); 
     168                result.append(paramCount++); 
     169                result.append(">"); 
     170            } 
     171            else { 
     172                result.append(getFragmentString(fragment)); 
     173            } 
    164174        } 
    165         else 
    166         { 
    167           throw new IllegalArgumentException 
    168             ("required parameter \"" + ((ParameterFragment) fragment).getParameterName() + 
    169              "\" for usability defect description " + this.name() + " not provided"); 
     175 
     176        return result.toString(); 
     177    } 
     178 
     179    /** 
     180     * TODO: comment 
     181     *  
     182     * @param fragment 
     183     * @return 
     184     */ 
     185    private String getFragmentString(Object fragment) { 
     186        String fragmentStr = fragment.toString().trim(); 
     187 
     188        fragmentStr = fragmentStr.replaceAll("\n", " "); 
     189 
     190        while (fragmentStr.indexOf("  ") > -1) { 
     191            fragmentStr = fragmentStr.replaceAll("  ", " "); 
    170192        } 
    171       } 
    172       else 
    173       { 
    174         result.append(getFragmentString(fragment)); 
    175       } 
     193 
     194        return fragmentStr; 
    176195    } 
    177      
    178     return result.toString(); 
    179   } 
    180  
    181   //----------------------------------------------------------------------------------------------- 
    182   /* (non-Javadoc) 
    183    * @see java.lang.Enum#toString() 
    184    */ 
    185   //----------------------------------------------------------------------------------------------- 
    186   @Override 
    187   public String toString() 
    188   { 
    189     StringBuffer result = new StringBuffer(); 
    190      
    191     int paramCount = 1; 
    192     for (Object fragment : mDefectDescription.getTextFragmentOrParameterFragment()) 
    193     { 
    194       if (result.length() > 0) 
    195       { 
    196         result.append(" "); 
    197       } 
    198        
    199       if (fragment instanceof ParameterFragment) 
    200       { 
    201         result.append("<parameter"); 
    202         result.append(paramCount++); 
    203         result.append(">"); 
    204       } 
    205       else 
    206       { 
    207         result.append(getFragmentString(fragment)); 
    208       } 
    209     } 
    210      
    211     return result.toString(); 
    212   } 
    213  
    214   //----------------------------------------------------------------------------------------------- 
    215   /** 
    216    * TODO: comment 
    217    * 
    218    * @param fragment 
    219    * @return 
    220    */ 
    221   //----------------------------------------------------------------------------------------------- 
    222   private String getFragmentString(Object fragment) 
    223   { 
    224     String fragmentStr = fragment.toString().trim(); 
    225      
    226     fragmentStr = fragmentStr.replaceAll("\n", " "); 
    227      
    228     while (fragmentStr.indexOf("  ") > -1) 
    229     { 
    230       fragmentStr = fragmentStr.replaceAll("  ", " "); 
    231     } 
    232      
    233     return fragmentStr; 
    234   } 
    235196 
    236197} 

  • trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityDefectSeverity.java

    r442 r561  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: UsabilityDefectSeverity.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: pharms $  $Date: 16.07.2012 $ 
    … …  
    54// Creation  : 2012 by pharms 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
     7 
    88package de.ugoe.cs.quest.usability; 
    99 
    10 //------------------------------------------------------------------------------------------------- 
    1110/** 
    1211 * TODO comment 
    … …  
    1514 * @author 2012, last modified by $Author: pharms$ 
    1615 */ 
    17 //------------------------------------------------------------------------------------------------- 
    18 public enum UsabilityDefectSeverity 
    19 { 
    20   INFO, 
    21   LOW, 
    22   MEDIUM, 
    23   HIGH; 
     16public enum UsabilityDefectSeverity { 
     17     
     18    INFO, LOW, MEDIUM, HIGH; 
     19 
    2420} 

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

    r442 r561  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: UsabilityEvaluationManager.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: pharms $  $Date: 16.07.2012 $ 
    … …  
    54// Creation  : 2012 by pharms 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
    87package de.ugoe.cs.quest.usability; 
    98 
    … …  
    1211import java.util.logging.Logger; 
    1312 
    14 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; 
     13import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; 
    1514 
    16 //------------------------------------------------------------------------------------------------- 
    1715/** 
    1816 * TODO comment 
    … …  
    2119 * @author 2012, last modified by $Author: pharms$ 
    2220 */ 
    23 //------------------------------------------------------------------------------------------------- 
    24 public class UsabilityEvaluationManager 
    25 { 
    26   /** */ 
    27   private static Logger LOG = Logger.getLogger(UsabilityEvaluationManager.class.getName()); 
     21public class UsabilityEvaluationManager { 
     22     
     23    /** */ 
     24    private static Logger LOG = Logger.getLogger(UsabilityEvaluationManager.class.getName()); 
    2825 
    29   /** */ 
    30   private List<UsabilityEvaluationRule> mRules = new ArrayList<UsabilityEvaluationRule>(); 
    31    
    32   //----------------------------------------------------------------------------------------------- 
    33   /** 
    34    * TODO: comment 
    35    * 
    36    */ 
    37   //----------------------------------------------------------------------------------------------- 
    38   public UsabilityEvaluationManager() 
    39   { 
    40     super(); 
    41     init(); 
    42   } 
     26    /** */ 
     27    private List<UsabilityEvaluationRule> rules = new ArrayList<UsabilityEvaluationRule>(); 
    4328 
    44   //----------------------------------------------------------------------------------------------- 
    45   /** 
    46    * TODO: comment 
    47    * 
    48    */ 
    49   //----------------------------------------------------------------------------------------------- 
    50   private void init() 
    51   { 
    52     mRules.add(new TextInputStatisticsRule()); 
    53   } 
     29    /** 
     30     * TODO: comment 
     31     *  
     32     */ 
     33    public UsabilityEvaluationManager() { 
     34        super(); 
     35        init(); 
     36    } 
    5437 
    55   //----------------------------------------------------------------------------------------------- 
    56   /** 
    57    * TODO: comment 
    58    * 
    59    * @param taskTree 
    60    */ 
    61   //----------------------------------------------------------------------------------------------- 
    62   public UsabilityEvaluationResult evaluateUsability(TaskTree taskTree) 
    63   { 
    64     LOG.info("evaluating usability of task tree " + taskTree); 
    65      
    66     List<UsabilityEvaluationResult> results = new ArrayList<UsabilityEvaluationResult>(); 
    67      
    68     for (UsabilityEvaluationRule rule : mRules) 
    69     { 
    70       LOG.info("applying rule " + rule.getClass().getSimpleName()); 
    71       UsabilityEvaluationResult result = rule.evaluate(taskTree); 
    72       results.add(result); 
    73       LOG.info("the rule found " + result.getAllDefects().size() + " usability defects, of " + 
    74                 "which " + result.getSevereDefects().size() + " are severe."); 
     38    /** 
     39     * TODO: comment 
     40     *  
     41     */ 
     42    private void init() { 
     43        rules.add(new TextInputStatisticsRule()); 
    7544    } 
    76      
    77     UsabilityEvaluationResult result = mergeResults(results); 
    78     LOG.info("the evaluation result contains " + result.getAllDefects().size() + " defects, of " + 
    79              "which " + result.getSevereDefects().size() + " are severe."); 
    80     return result; 
    81   } 
    8245 
    83   //----------------------------------------------------------------------------------------------- 
    84   /** 
    85    * TODO: comment 
    86    * 
    87    * @param results 
    88    * @return 
    89    */ 
    90   //----------------------------------------------------------------------------------------------- 
    91   private UsabilityEvaluationResult mergeResults(List<UsabilityEvaluationResult> results) 
    92   { 
    93     UsabilityEvaluationResult result = new UsabilityEvaluationResult(); 
    94      
    95     for (UsabilityEvaluationResult ruleResult : results) 
    96     { 
    97       for (UsabilityDefect defect : ruleResult.getAllDefects()) 
    98       { 
    99         result.addDefect(defect); 
    100       } 
     46    /** 
     47     * TODO: comment 
     48     *  
     49     * @param taskTree 
     50     */ 
     51    public UsabilityEvaluationResult evaluateUsability(ITaskTree taskTree) { 
     52        LOG.info("evaluating usability of task tree " + taskTree); 
     53 
     54        List<UsabilityEvaluationResult> results = new ArrayList<UsabilityEvaluationResult>(); 
     55 
     56        for (UsabilityEvaluationRule rule : rules) { 
     57            LOG.info("applying rule " + rule.getClass().getSimpleName()); 
     58            UsabilityEvaluationResult result = rule.evaluate(taskTree); 
     59            results.add(result); 
     60            LOG.info("the rule found " + result.getAllDefects().size() + " usability defects, of " + 
     61                     "which " + result.getSevereDefects().size() + " are severe."); 
     62        } 
     63 
     64        UsabilityEvaluationResult result = mergeResults(results); 
     65        LOG.info("the evaluation result contains " + result.getAllDefects().size() + 
     66                 " defects, of which " + result.getSevereDefects().size() + " are severe."); 
     67        return result; 
    10168    } 
    102      
    103     return result; 
    104   } 
    105    
     69 
     70    /** 
     71     * TODO: comment 
     72     *  
     73     * @param results 
     74     * @return 
     75     */ 
     76    private UsabilityEvaluationResult mergeResults(List<UsabilityEvaluationResult> results) { 
     77        UsabilityEvaluationResult result = new UsabilityEvaluationResult(); 
     78 
     79        for (UsabilityEvaluationResult ruleResult : results) { 
     80            for (UsabilityDefect defect : ruleResult.getAllDefects()) { 
     81                result.addDefect(defect); 
     82            } 
     83        } 
     84 
     85        return result; 
     86    } 
     87 
    10688} 

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

    r442 r561  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: UsabilityEvaluationResult.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: pharms $  $Date: 16.07.2012 $ 
    … …  
    54// Creation  : 2012 by pharms 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
     7 
    88package de.ugoe.cs.quest.usability; 
    99 
    … …  
    1111import java.util.List; 
    1212 
    13 //------------------------------------------------------------------------------------------------- 
    1413/** 
    1514 * TODO comment 
    … …  
    1817 * @author 2012, last modified by $Author: pharms$ 
    1918 */ 
    20 //------------------------------------------------------------------------------------------------- 
    21 public class UsabilityEvaluationResult 
    22 { 
    23   /** */ 
    24   private List<UsabilityDefect> mDefects = new ArrayList<UsabilityDefect>(); 
     19public class UsabilityEvaluationResult { 
     20     
     21    /** */ 
     22    private List<UsabilityDefect> defects = new ArrayList<UsabilityDefect>(); 
    2523 
    26   //----------------------------------------------------------------------------------------------- 
    27   /** 
    28    * TODO: comment 
    29    * 
    30    * @param defect 
    31    */ 
    32   //----------------------------------------------------------------------------------------------- 
    33   public void addDefect(UsabilityDefect defect) 
    34   { 
    35     mDefects.add(defect); 
    36   } 
     24    /** 
     25     * TODO: comment 
     26     *  
     27     * @param defect 
     28     */ 
     29    public void addDefect(UsabilityDefect defect) { 
     30        defects.add(defect); 
     31    } 
    3732 
    38   //----------------------------------------------------------------------------------------------- 
    39   /** 
    40    * TODO: comment 
    41    * 
    42    * @return 
    43    */ 
    44   //----------------------------------------------------------------------------------------------- 
    45   public List<UsabilityDefect> getAllDefects() 
    46   { 
    47     return mDefects; 
    48   } 
     33    /** 
     34     * TODO: comment 
     35     *  
     36     * @return 
     37     */ 
     38    public List<UsabilityDefect> getAllDefects() { 
     39        return defects; 
     40    } 
    4941 
    50   //----------------------------------------------------------------------------------------------- 
    51   /** 
    52    * TODO: comment 
    53    * 
    54    * @return 
    55    */ 
    56   //----------------------------------------------------------------------------------------------- 
    57   public List<UsabilityDefect> getSevereDefects() 
    58   { 
    59     List<UsabilityDefect> severeDefects = new ArrayList<UsabilityDefect>(); 
    60      
    61     for (UsabilityDefect defect : mDefects) 
    62     { 
    63       if (defect.getSeverity() == UsabilityDefectSeverity.HIGH) 
    64       { 
    65         severeDefects.add(defect); 
    66       } 
     42    /** 
     43     * TODO: comment 
     44     *  
     45     * @return 
     46     */ 
     47    public List<UsabilityDefect> getSevereDefects() { 
     48        List<UsabilityDefect> severeDefects = new ArrayList<UsabilityDefect>(); 
     49 
     50        for (UsabilityDefect defect : defects) { 
     51            if (defect.getSeverity() == UsabilityDefectSeverity.HIGH) { 
     52                severeDefects.add(defect); 
     53            } 
     54        } 
     55 
     56        return severeDefects; 
    6757    } 
    68      
    69     return severeDefects; 
    70   } 
    7158 
    7259} 

  • trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability/UsabilityEvaluationRule.java

    r442 r561  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: UsabilityEvaluationRule.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: pharms $  $Date: 16.07.2012 $ 
    … …  
    54// Creation  : 2012 by pharms 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
     7 
    88package de.ugoe.cs.quest.usability; 
    99 
    10 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; 
     10import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; 
    1111 
    12 //------------------------------------------------------------------------------------------------- 
    1312/** 
    1413 * TODO comment 
    … …  
    1716 * @author 2012, last modified by $Author: pharms$ 
    1817 */ 
    19 //------------------------------------------------------------------------------------------------- 
    20 public interface UsabilityEvaluationRule 
    21 { 
     18public interface UsabilityEvaluationRule { 
    2219 
    23   //----------------------------------------------------------------------------------------------- 
    24   /** 
    25    * TODO: comment 
    26    * 
    27    * @param taskTree 
    28    * @return 
    29    */ 
    30   //----------------------------------------------------------------------------------------------- 
    31   UsabilityEvaluationResult evaluate(TaskTree taskTree); 
     20    /** 
     21     * TODO: comment 
     22     *  
     23     * @param taskTree 
     24     * @return 
     25     */ 
     26    UsabilityEvaluationResult evaluate(ITaskTree taskTree); 
    3227 
    3328} 
Note: See TracChangeset for help on using the changeset viewer.