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-test/src/test/java/de/ugoe/cs/quest/usability
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/AbstractUsabilityEvaluationTC.java

    r474 r561  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: AbstractUsabilityEvaluationTC.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 
     7 
    88package de.ugoe.cs.quest.usability; 
    99 
    … …  
    2121import de.ugoe.cs.quest.tasktrees.testutils.DummyTextField; 
    2222import de.ugoe.cs.quest.tasktrees.testutils.SimpleLogFormatter; 
    23 import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; 
    24 import de.ugoe.cs.quest.tasktrees.treeifc.Selection; 
    25 import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; 
    26 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; 
    27 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; 
    28 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; 
    29 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; 
    30 import de.ugoe.cs.quest.tasktrees.treeifc.TextInputInteractionTask; 
    31 import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilderImpl; 
    32 import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactoryImpl; 
    33  
    34 //------------------------------------------------------------------------------------------------- 
     23import de.ugoe.cs.quest.tasktrees.treeifc.IIteration; 
     24import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; 
     25import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; 
     26import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; 
     27import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; 
     28import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; 
     29import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; 
     30import de.ugoe.cs.quest.tasktrees.treeifc.ITextInputEventTask; 
     31import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeBuilder; 
     32import de.ugoe.cs.quest.tasktrees.treeimpl.TaskTreeNodeFactory; 
     33 
    3534/** 
    3635 * TODO comment 
    … …  
    3938 * @author 2012, last modified by $Author: pharms$ 
    4039 */ 
    41 //------------------------------------------------------------------------------------------------- 
    42 public class AbstractUsabilityEvaluationTC 
    43 { 
    44    
    45   /** */ 
    46   private TaskTreeBuilder mTaskTreeBuilder = new TaskTreeBuilderImpl(); 
    47  
    48   /** */ 
    49   private TaskTreeNodeFactory mTaskTreeNodeFactory = new TaskTreeNodeFactoryImpl(); 
    50    
    51   //----------------------------------------------------------------------------------------------- 
    52   /** 
     40public class AbstractUsabilityEvaluationTC { 
     41 
     42    /** */ 
     43    private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder(); 
     44 
     45    /** */ 
     46    private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory(); 
     47 
     48    /** 
    5349   * 
    5450   */ 
    55   //----------------------------------------------------------------------------------------------- 
    56   @Before 
    57   public void setUp() 
    58   { 
    59     Logger.getLogger("").getHandlers()[0].setFormatter(new SimpleLogFormatter()); 
    60   } 
    61  
    62   //----------------------------------------------------------------------------------------------- 
    63   /** 
     51    @Before 
     52    public void setUp() { 
     53        Logger.getLogger("").getHandlers()[0].setFormatter(new SimpleLogFormatter()); 
     54    } 
     55 
     56    /** 
    6457   * 
    6558   */ 
    66   //----------------------------------------------------------------------------------------------- 
    67   protected TaskTree createTaskTree(String spec) 
    68   { 
    69     Matcher matcher = 
    70       Pattern.compile("(\\s*(\\w+)\\s*(\\(((\\w*\\s*)*)\\))?\\s*(\\{))|(\\})").matcher(spec); 
    71        
    72     if (!matcher.find()) 
     59    protected ITaskTree createTaskTree(String spec) { 
     60        Matcher matcher = 
     61            Pattern.compile("(\\s*(\\w+)\\s*(\\(((\\w*\\s*)*)\\))?\\s*(\\{))|(\\})").matcher(spec); 
     62 
     63        if (!matcher.find()) { 
     64            if (!matcher.hitEnd()) { 
     65                throw new IllegalArgumentException("could not parse task specification"); 
     66            } 
     67        } 
     68 
     69        return taskTreeNodeFactory.createTaskTree(parseTask(matcher, new int[1])); 
     70    } 
     71 
     72    /** 
     73     * TODO: comment 
     74     *  
     75     * @param expectedDefects 
     76     * @param evaluateUsability 
     77     */ 
     78    protected void assertUsabilityEvaluationResult(UsabilityDefect[]         expectedDefects, 
     79                                                   UsabilityEvaluationResult evaluationResult) 
    7380    { 
    74       if (!matcher.hitEnd()) 
    75       { 
    76         throw new IllegalArgumentException("could not parse task specification"); 
    77       } 
    78     } 
    79  
    80     return mTaskTreeNodeFactory.createTaskTree(parseTask(matcher, new int[1])); 
    81   } 
    82  
    83   //----------------------------------------------------------------------------------------------- 
    84   /** 
    85    * TODO: comment 
    86    * 
    87    * @param expectedDefects 
    88    * @param evaluateUsability 
    89    */ 
    90   //----------------------------------------------------------------------------------------------- 
    91   protected void assertUsabilityEvaluationResult(UsabilityDefect[]         expectedDefects, 
    92                                                  UsabilityEvaluationResult evaluationResult) 
    93   { 
    94     assertEquals(expectedDefects.length, evaluationResult.getAllDefects().size()); 
    95      
    96     EXPECTED_DEFECT_ITERATION: 
    97     for (UsabilityDefect expectedDefect : expectedDefects) 
    98     { 
    99       for (UsabilityDefect defect : evaluationResult.getAllDefects()) 
    100       { 
    101         if (expectedDefect.equals(defect)) 
    102         { 
    103           System.err.println(defect.getParameterizedDescription()); 
    104           continue EXPECTED_DEFECT_ITERATION; 
    105         } 
    106       } 
    107        
    108       for (UsabilityDefect defect : evaluationResult.getAllDefects()) 
    109       { 
    110         System.err.println(defect); 
    111       } 
    112        
    113       fail("expected defect " + expectedDefect + " not found in evaluation result"); 
    114     } 
    115   } 
    116  
    117  
    118   //----------------------------------------------------------------------------------------------- 
    119   /** 
     81        assertEquals(expectedDefects.length, evaluationResult.getAllDefects().size()); 
     82 
     83        EXPECTED_DEFECT_ITERATION: 
     84        for (UsabilityDefect expectedDefect : expectedDefects) { 
     85            for (UsabilityDefect defect : evaluationResult.getAllDefects()) { 
     86                if (expectedDefect.equals(defect)) { 
     87                    System.err.println(defect.getParameterizedDescription()); 
     88                    continue EXPECTED_DEFECT_ITERATION; 
     89                } 
     90            } 
     91 
     92            for (UsabilityDefect defect : evaluationResult.getAllDefects()) { 
     93                System.err.println(defect); 
     94            } 
     95 
     96            fail("expected defect " + expectedDefect + " not found in evaluation result"); 
     97        } 
     98    } 
     99 
     100    /** 
    120101   *  
    121102   */ 
    122   //----------------------------------------------------------------------------------------------- 
    123   private TaskTreeNode parseTask(Matcher tokenMatcher, int[] typeNumbers) 
    124   { 
    125     String firstToken = tokenMatcher.group(); 
    126      
    127     if ("}".equals(firstToken)) 
    128     { 
    129       throw new IllegalArgumentException("found a closing bracket at an unexpected place"); 
    130     } 
    131      
    132     TaskTreeNode treeNode = instantiateTreeNode(tokenMatcher, typeNumbers); 
    133      
    134     if (!tokenMatcher.find()) 
    135     { 
    136       throw new IllegalArgumentException("could not parse task specification"); 
    137     } 
    138      
    139     firstToken = tokenMatcher.group(); 
    140      
    141     if (!"}".equals(firstToken)) 
    142     { 
    143       TaskTreeNode child = null; 
    144      
    145       do 
    146       { 
    147         child = parseTask(tokenMatcher, typeNumbers); 
    148          
    149         if (child != null) 
    150         { 
    151           addChild(treeNode, child); 
    152            
    153           if (!tokenMatcher.find()) 
    154           { 
     103    private ITaskTreeNode parseTask(Matcher tokenMatcher, int[] typeNumbers) { 
     104        String firstToken = tokenMatcher.group(); 
     105 
     106        if ("}".equals(firstToken)) { 
     107            throw new IllegalArgumentException("found a closing bracket at an unexpected place"); 
     108        } 
     109 
     110        ITaskTreeNode treeNode = instantiateTreeNode(tokenMatcher, typeNumbers); 
     111 
     112        if (!tokenMatcher.find()) { 
    155113            throw new IllegalArgumentException("could not parse task specification"); 
    156           } 
    157            
    158           firstToken = tokenMatcher.group(); 
    159            
    160           if ("}".equals(firstToken)) 
    161           { 
    162             break; 
    163           } 
    164         } 
    165          
    166       } 
    167       while (child != null); 
    168        
    169     } 
    170      
    171     return treeNode; 
    172   } 
    173  
    174   //----------------------------------------------------------------------------------------------- 
    175   /** 
    176    * TODO: comment 
    177    * 
    178    * @param group 
    179    * @return 
    180    */ 
    181   //----------------------------------------------------------------------------------------------- 
    182   private TaskTreeNode instantiateTreeNode(Matcher tokenMatcher, int[] typeNumbers) 
    183   { 
    184     String type = tokenMatcher.group(2); 
    185     String additionalInfo = tokenMatcher.group(4); 
    186      
    187     if ("Interaction".equals(type)) 
    188     { 
    189       return mTaskTreeNodeFactory.createNewInteractionTask 
    190         (new DummyGUIElement("dummy"), new DummyInteraction("dummy", typeNumbers[0]++)); 
    191     } 
    192     else if ("Sequence".equals(type)) 
    193     { 
    194       return mTaskTreeNodeFactory.createNewSequence(); 
    195     } 
    196     else if ("Iteration".equals(type)) 
    197     { 
    198       return mTaskTreeNodeFactory.createNewIteration(); 
    199     } 
    200     else if ("Selection".equals(type)) 
    201     { 
    202       return mTaskTreeNodeFactory.createNewSelection(); 
    203     } 
    204     else if ("TextInput".equals(type)) 
    205     { 
    206       if (additionalInfo == null) 
    207       { 
    208         fail("no simulated text provided for text input interactin task"); 
    209       } 
    210        
    211       TextInputInteractionTask task = 
    212         mTaskTreeNodeFactory.createNewTextInputInteractionTask(new DummyTextField(additionalInfo)); 
    213       
    214       task.setEnteredText(additionalInfo); 
    215       return task; 
    216     } 
    217     else 
    218     { 
    219       fail("invalid type of task tree node: " + type); 
    220       return null; 
    221     } 
    222   } 
    223  
    224   //----------------------------------------------------------------------------------------------- 
    225   /** 
    226    * TODO: comment 
    227    * 
    228    * @param treeNode 
    229    * @param child 
    230    */ 
    231   //----------------------------------------------------------------------------------------------- 
    232   private void addChild(TaskTreeNode parent, TaskTreeNode child) 
    233   { 
    234     if (parent instanceof Sequence) 
    235     { 
    236       mTaskTreeBuilder.addChild((Sequence) parent, child); 
    237     } 
    238     else if (parent instanceof Iteration) 
    239     { 
    240       if (parent.getChildren().size() <= 0) 
    241       { 
    242         mTaskTreeBuilder.setChild((Iteration) parent, child); 
    243       } 
    244       else 
    245       { 
    246         fail("can not add more than one child to an iteration"); 
    247       } 
    248     } 
    249     else if (parent instanceof Selection) 
    250     { 
    251       mTaskTreeBuilder.addChild((Selection) parent, child); 
    252     } 
    253     else if (parent instanceof TextInputInteractionTask) 
    254     { 
    255       mTaskTreeBuilder.addChild((TextInputInteractionTask) parent, child); 
    256     } 
    257     else 
    258     { 
    259       fail("can not add children to parent task tree node of type " + parent.getClass().getName()); 
    260     } 
    261   } 
     114        } 
     115 
     116        firstToken = tokenMatcher.group(); 
     117 
     118        if (!"}".equals(firstToken)) { 
     119            ITaskTreeNode child = null; 
     120 
     121            do { 
     122                child = parseTask(tokenMatcher, typeNumbers); 
     123 
     124                if (child != null) { 
     125                    addChild(treeNode, child); 
     126 
     127                    if (!tokenMatcher.find()) { 
     128                        throw new IllegalArgumentException("could not parse task specification"); 
     129                    } 
     130 
     131                    firstToken = tokenMatcher.group(); 
     132 
     133                    if ("}".equals(firstToken)) { 
     134                        break; 
     135                    } 
     136                } 
     137 
     138            } 
     139            while (child != null); 
     140 
     141        } 
     142 
     143        return treeNode; 
     144    } 
     145 
     146    /** 
     147     * TODO: comment 
     148     *  
     149     * @param group 
     150     * @return 
     151     */ 
     152    private ITaskTreeNode instantiateTreeNode(Matcher tokenMatcher, int[] typeNumbers) { 
     153        String type = tokenMatcher.group(2); 
     154        String additionalInfo = tokenMatcher.group(4); 
     155 
     156        if ("Interaction".equals(type)) { 
     157            return taskTreeNodeFactory.createNewEventTask 
     158                (new DummyInteraction("dummy", typeNumbers[0]++), new DummyGUIElement("dummy")); 
     159        } 
     160        else if ("Sequence".equals(type)) { 
     161            return taskTreeNodeFactory.createNewSequence(); 
     162        } 
     163        else if ("Iteration".equals(type)) { 
     164            return taskTreeNodeFactory.createNewIteration(); 
     165        } 
     166        else if ("Selection".equals(type)) { 
     167            return taskTreeNodeFactory.createNewSelection(); 
     168        } 
     169        else if ("TextInput".equals(type)) { 
     170            if (additionalInfo == null) { 
     171                fail("no simulated text provided for text input interactin task"); 
     172            } 
     173 
     174            ITextInputEventTask task = 
     175                taskTreeNodeFactory.createNewTextInputEventTask(new DummyTextField(additionalInfo)); 
     176 
     177            task.setEnteredText(additionalInfo); 
     178            return task; 
     179        } 
     180        else { 
     181            fail("invalid type of task tree node: " + type); 
     182            return null; 
     183        } 
     184    } 
     185 
     186    /** 
     187     * TODO: comment 
     188     *  
     189     * @param treeNode 
     190     * @param child 
     191     */ 
     192    private void addChild(ITaskTreeNode parent, ITaskTreeNode child) { 
     193        if (parent instanceof ISequence) { 
     194            taskTreeBuilder.addChild((ISequence) parent, child); 
     195        } 
     196        else if (parent instanceof IIteration) { 
     197            if (parent.getChildren().size() <= 0) { 
     198                taskTreeBuilder.setChild((IIteration) parent, child); 
     199            } 
     200            else { 
     201                fail("can not add more than one child to an iteration"); 
     202            } 
     203        } 
     204        else if (parent instanceof ISelection) { 
     205            taskTreeBuilder.addChild((ISelection) parent, child); 
     206        } 
     207        else if (parent instanceof ITextInputEventTask) { 
     208            taskTreeBuilder.addChild((ITextInputEventTask) parent, child); 
     209        } 
     210        else { 
     211            fail("can not add children to parent task tree node of type " + 
     212                 parent.getClass().getName()); 
     213        } 
     214    } 
    262215 
    263216} 

  • trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/TextInputStatisticsRuleTest.java

    r497 r561  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: TextInputStatisticsRuleTest.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 
     7 
    88package de.ugoe.cs.quest.usability; 
    99 
    … …  
    1818import org.junit.Test; 
    1919 
    20 //------------------------------------------------------------------------------------------------- 
    2120/** 
    2221 * TODO comment 
    … …  
    2524 * @author 2012, last modified by $Author: pharms$ 
    2625 */ 
    27 //------------------------------------------------------------------------------------------------- 
    28 public class TextInputStatisticsRuleTest extends AbstractUsabilityEvaluationTC 
    29 { 
    30  
    31   //----------------------------------------------------------------------------------------------- 
    32   /** 
    33    * TODO: comment 
    34    * 
    35    */ 
    36   //----------------------------------------------------------------------------------------------- 
    37   @Test 
    38   public void testWithDifferentTextInputInteractionsOnly() 
    39   { 
    40     UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); 
    41      
    42     // ===== check ===== 
    43     String spec = "TextInput (bla) {}"; 
    44     UsabilityDefect[] expectedDefects = new UsabilityDefect[] 
    45     { 
    46       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) 
    47     }; 
    48      
    49     assertUsabilityEvaluationResult 
    50       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    51      
    52     // ===== check ===== 
    53     spec = 
    54       "Sequence {" + 
    55       "  TextInput (bla) {}" + 
    56       "}"; 
    57      
    58     expectedDefects = new UsabilityDefect[] 
    59     { 
    60       new UsabilityDefect(HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) 
    61     }; 
    62      
    63     assertUsabilityEvaluationResult 
    64       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    65      
    66     // ===== check ===== 
    67     spec = 
    68       "Sequence {" + 
    69       "  TextInput (a) {}" + 
    70       "  TextInput (b) {}" + 
    71       "  TextInput (c) {}" + 
    72       "  TextInput (d) {}" + 
    73       "}"; 
    74      
    75     expectedDefects = new UsabilityDefect[] 
    76     { 
    77       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) 
    78     }; 
    79      
    80     assertUsabilityEvaluationResult 
    81       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    82      
    83     // ===== check ===== 
    84     spec = 
    85       "Selection {" + 
    86       "  TextInput (a) {}" + 
    87       "  TextInput (b) {}" + 
    88       "  TextInput (c) {}" + 
    89       "  TextInput (d) {}" + 
    90       "}"; 
    91        
    92     expectedDefects = new UsabilityDefect[] 
    93     { 
    94       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) 
    95     }; 
    96        
    97     assertUsabilityEvaluationResult 
    98       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    99        
    100     // ===== check ===== 
    101     spec = 
    102       "Iteration {" + 
    103       "  TextInput (bla) {}" + 
    104       "}"; 
    105          
    106     expectedDefects = new UsabilityDefect[] 
    107     { 
    108       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) 
    109     }; 
    110        
    111     assertUsabilityEvaluationResult 
    112       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    113          
    114     // ===== check ===== 
    115     spec = 
    116       "Sequence {" + 
    117       "  TextInput (a) {}" + 
    118       "  Sequence {" + 
    119       "    TextInput (b) {}" + 
    120       "    TextInput (c) {}" + 
    121       "    TextInput (d) {}" + 
    122       "    TextInput (e) {}" + 
    123       "  }" + 
    124       "  Iteration {" + 
    125       "    TextInput (f) {}" + 
    126       "  }" + 
    127       "  TextInput (g) {}" + 
    128       "  Selection {" + 
    129       "    TextInput (h) {}" + 
    130       "    TextInput (i) {}" + 
    131       "    TextInput (j) {}" + 
    132       "    TextInput (k) {}" + 
    133       "  }" + 
    134       "  Sequence {" + 
    135       "    TextInput (l) {}" + 
    136       "    Sequence {" + 
    137       "      TextInput (m) {}" + 
    138       "      TextInput (n) {}" + 
    139       "      TextInput (o) {}" + 
    140       "      TextInput (p) {}" + 
    141       "    }" + 
    142       "    Iteration {" + 
    143       "      TextInput (q) {}" + 
    144       "    }" + 
    145       "    TextInput (r) {}" + 
    146       "    Selection {" + 
    147       "      TextInput (s) {}" + 
    148       "      TextInput (t) {}" + 
    149       "      TextInput (u) {}" + 
    150       "      TextInput (v) {}" + 
    151       "    }" + 
    152       "  }" + 
    153       "  Selection {" + 
    154       "    TextInput (w) {}" + 
    155       "    Sequence {" + 
    156       "      TextInput (x) {}" + 
    157       "      TextInput (y) {}" + 
    158       "      TextInput (z) {}" + 
    159       "      TextInput (aa) {}" + 
    160       "    }" + 
    161       "    Iteration {" + 
    162       "      TextInput (ab) {}" + 
    163       "    }" + 
    164       "    TextInput (ac) {}" + 
    165       "    Selection {" + 
    166       "      TextInput (ad) {}" + 
    167       "      TextInput (ae) {}" + 
    168       "      TextInput (af) {}" + 
    169       "      TextInput (ag) {}" + 
    170       "    }" + 
    171       "  }" + 
    172       "  TextInput (ah) {}" + 
    173       "}"; 
    174       
    175     expectedDefects = new UsabilityDefect[] 
    176     { 
    177       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) 
    178     }; 
    179      
    180     assertUsabilityEvaluationResult 
    181       (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));    
    182   } 
    183  
    184   //----------------------------------------------------------------------------------------------- 
    185   /** 
    186    * TODO: comment 
    187    * 
    188    */ 
    189   //----------------------------------------------------------------------------------------------- 
    190   @Test 
    191   public void testCombinationsOfTextInputInteractionsAndOtherInteractions() 
    192   { 
    193     UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); 
    194      
    195     // ===== check ===== 
    196     String spec = 
    197       "Sequence {" + 
    198       "  Interaction {}" + 
    199       "  TextInput (a) {}" + 
    200       "  TextInput (b) {}" + 
    201       "  Interaction {}" + 
    202       "  TextInput (c) {}" + 
    203       "}"; 
    204        
    205     UsabilityDefect[] expectedDefects = new UsabilityDefect[] 
    206     { 
    207       new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) 
    208     }; 
    209      
    210     assertUsabilityEvaluationResult 
    211       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    212      
    213     // ===== check ===== 
    214     spec = 
    215       "Sequence {" + 
    216       "  Interaction {}" + 
    217       "  TextInput (a) {}" + 
    218       "  Interaction {}" + 
    219       "  Interaction {}" + 
    220       "  TextInput (c) {}" + 
    221       "}"; 
    222          
    223     expectedDefects = new UsabilityDefect[] 
    224     { 
    225       new UsabilityDefect(INFO, TEXT_FIELD_INPUT_RATIO) 
    226     }; 
    227      
    228     assertUsabilityEvaluationResult 
    229       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    230        
    231     // ===== check ===== 
    232     spec = 
    233       "Sequence {" + 
    234       "  Interaction {}" + 
    235       "  TextInput (a) {}" + 
    236       "  Interaction {}" + 
    237       "  Interaction {}" + 
    238       "  Interaction {}" + 
    239       "}"; 
    240            
    241     expectedDefects = new UsabilityDefect[0]; 
    242          
    243     assertUsabilityEvaluationResult 
    244       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    245          
    246     // ===== check ===== 
    247     spec = 
    248       "Selection {" + 
    249       "  Interaction {}" + 
    250       "  TextInput (a) {}" + 
    251       "  TextInput (b) {}" + 
    252       "  Interaction {}" + 
    253       "  TextInput (c) {}" + 
    254       "}"; 
    255        
    256     expectedDefects = new UsabilityDefect[] 
    257     { 
    258       new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) 
    259     }; 
    260        
    261     assertUsabilityEvaluationResult 
    262       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    263        
    264     // ===== check ===== 
    265     spec = 
    266       "Sequence {" + 
    267       "  TextInput (a) {}" + 
    268       "  Sequence {" + 
    269       "    Interaction {}" + 
    270       "    TextInput (b) {}" + 
    271       "    TextInput (c) {}" + 
    272       "    Interaction {}" + 
    273       "    TextInput (d) {}" + 
    274       "  }" + 
    275       "  Iteration {" + 
    276       "    TextInput (e) {}" + 
    277       "  }" + 
    278       "  Interaction {}" + 
    279       "  Selection {" + 
    280       "    Interaction {}" + 
    281       "    TextInput (f) {}" + 
    282       "    TextInput (g) {}" + 
    283       "    Interaction {}" + 
    284       "    TextInput (h) {}" + 
    285       "    TextInput (i) {}" + 
    286       "  }" + 
    287       "  Sequence {" + 
    288       "    TextInput (j) {}" + 
    289       "    Sequence {" + 
    290       "      TextInput (k) {}" + 
    291       "      Interaction {}" + 
    292       "      TextInput (l) {}" + 
    293       "      TextInput (m) {}" + 
    294       "      Interaction {}" + 
    295       "      TextInput (n) {}" + 
    296       "      TextInput (o) {}" + 
    297       "    }" + 
    298       "    Iteration {" + 
    299       "      Interaction {}" + 
    300       "    }" + 
    301       "    Interaction {}" + 
    302       "    Selection {" + 
    303       "      TextInput (p) {}" + 
    304       "      TextInput (q) {}" + 
    305       "      TextInput (r) {}" + 
    306       "      Interaction {}" + 
    307       "      TextInput (s) {}" + 
    308       "      TextInput (t) {}" + 
    309       "      Interaction {}" + 
    310       "      TextInput (u) {}" + 
    311       "      TextInput (v) {}" + 
    312       "    }" + 
    313       "  }" + 
    314       "  Selection {" + 
    315       "    Interaction {}" + 
    316       "    Sequence {" + 
    317       "      TextInput (w) {}" + 
    318       "      Interaction {}" + 
    319       "      TextInput (x) {}" + 
    320       "      TextInput (y) {}" + 
    321       "      Interaction {}" + 
    322       "    }" + 
    323       "    Iteration {" + 
    324       "      TextInput (z) {}" + 
    325       "    }" + 
    326       "    TextInput (aa) {}" + 
    327       "    Selection {" + 
    328       "      TextInput (ab) {}" + 
    329       "      Interaction {}" + 
    330       "      TextInput (ac) {}" + 
    331       "      TextInput (ad) {}" + 
    332       "      Interaction {}" + 
    333       "      TextInput (ae) {}" + 
    334       "    }" + 
    335       "  }" + 
    336       "  Interaction {}" + 
    337       "}"; 
    338       
    339     expectedDefects = new UsabilityDefect[] 
    340     { 
    341       new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) 
    342     }; 
    343      
    344     assertUsabilityEvaluationResult 
    345       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    346      
    347     // ===== check ===== 
    348     spec = 
    349       "Sequence {" + 
    350       "  TextInput (a) {}" + 
    351       "  Sequence {" + 
    352       "    Interaction {}" + 
    353       "    TextInput (b) {}" + 
    354       "    Interaction {}" + 
    355       "    Interaction {}" + 
    356       "    TextInput (c) {}" + 
    357       "  }" + 
    358       "  Iteration {" + 
    359       "    TextInput (d) {}" + 
    360       "  }" + 
    361       "  Interaction {}" + 
    362       "  Selection {" + 
    363       "    Interaction {}" + 
    364       "    TextInput (e) {}" + 
    365       "    Interaction {}" + 
    366       "    Interaction {}" + 
    367       "    TextInput (g) {}" + 
    368       "    Interaction {}" + 
    369       "  }" + 
    370       "  Sequence {" + 
    371       "    TextInput (i) {}" + 
    372       "    Sequence {" + 
    373       "      TextInput (j) {}" + 
    374       "      Interaction {}" + 
    375       "      TextInput (k) {}" + 
    376       "      Interaction {}" + 
    377       "      Interaction {}" + 
    378       "      TextInput (m) {}" + 
    379       "      Interaction {}" + 
    380       "    }" + 
    381       "    Iteration {" + 
    382       "      Interaction {}" + 
    383       "    }" + 
    384       "    Interaction {}" + 
    385       "    Selection {" + 
    386       "      TextInput (o) {}" + 
    387       "      Interaction {}" + 
    388       "      Interaction {}" + 
    389       "      Interaction {}" + 
    390       "      Interaction {}" + 
    391       "      TextInput (s) {}" + 
    392       "      Interaction {}" + 
    393       "      TextInput (t) {}" + 
    394       "      TextInput (u) {}" + 
    395       "    }" + 
    396       "  }" + 
    397       "  Selection {" + 
    398       "    Interaction {}" + 
    399       "    Sequence {" + 
    400       "      TextInput (v) {}" + 
    401       "      Interaction {}" + 
    402       "      Interaction {}" + 
    403       "      TextInput (x) {}" + 
    404       "      Interaction {}" + 
    405       "    }" + 
    406       "    Iteration {" + 
    407       "      TextInput (y) {}" + 
    408       "    }" + 
    409       "    TextInput (z) {}" + 
    410       "    Selection {" + 
    411       "      TextInput (aa) {}" + 
    412       "      Interaction {}" + 
    413       "      TextInput (ab) {}" + 
    414       "      Interaction {}" + 
    415       "      Interaction {}" + 
    416       "      TextInput (ad) {}" + 
    417       "    }" + 
    418       "  }" + 
    419       "  Interaction {}" + 
    420       "}"; 
    421  
    422     expectedDefects = new UsabilityDefect[] 
    423     { 
    424       new UsabilityDefect(INFO, TEXT_FIELD_INPUT_RATIO) 
    425     }; 
    426  
    427     assertUsabilityEvaluationResult 
    428       (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));    
    429   } 
    430  
    431   //----------------------------------------------------------------------------------------------- 
    432   /** 
    433    * TODO: comment 
    434    * 
    435    */ 
    436   //----------------------------------------------------------------------------------------------- 
    437   @Test 
    438   public void testTextEntryRepetitions() 
    439   { 
    440     UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); 
    441      
    442     // ===== check ===== 
    443     String spec = 
    444       "Sequence {" + 
    445       "  TextInput (a b c) {}" + 
    446       "  Sequence {" + 
    447       "    TextInput (a) {}" + 
    448       "    TextInput (b) {}" + 
    449       "    TextInput (c) {}" + 
    450       "    TextInput (a) {}" + 
    451       "  }" + 
    452       "  Iteration {" + 
    453       "    TextInput (a) {}" + 
    454       "  }" + 
    455       "  TextInput (a) {}" + 
    456       "  Selection {" + 
    457       "    TextInput (b c) {}" + 
    458       "    TextInput (a) {}" + 
    459       "    TextInput (a c) {}" + 
    460       "    TextInput (b a) {}" + 
    461       "  }" + 
    462       "  Sequence {" + 
    463       "    TextInput (b c) {}" + 
    464       "    Sequence {" + 
    465       "      TextInput (d a c) {}" + 
    466       "      TextInput (b b b a) {}" + 
    467       "      TextInput (a a c c) {}" + 
    468       "      TextInput (b b a) {}" + 
    469       "    }" + 
    470       "  }" + 
    471       "  TextInput (d) {}" + 
    472       "}"; 
    473       
    474     UsabilityDefect[] expectedDefects = new UsabilityDefect[] 
    475     { 
    476       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
    477       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_REPETITIONS) 
    478     }; 
    479      
    480     assertUsabilityEvaluationResult 
    481       (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));    
    482  
    483     // ===== check ===== 
    484     spec = 
    485       "Sequence {" + 
    486       "  TextInput (a b c d e f g h i j k l m) {}" + 
    487       "  Sequence {" + 
    488       "    TextInput (a) {}" + 
    489       "    TextInput (b) {}" + 
    490       "    TextInput (c) {}" + 
    491       "    TextInput (d) {}" + 
    492       "  }" + 
    493       "  Iteration {" + 
    494       "    TextInput (e) {}" + 
    495       "  }" + 
    496       "  TextInput (f) {}" + 
    497       "  Selection {" + 
    498       "    TextInput (g) {}" + 
    499       "    TextInput (h) {}" + 
    500       "    TextInput (i) {}" + 
    501       "    TextInput (j) {}" + 
    502       "  }" + 
    503       "  Sequence {" + 
    504       "    TextInput (k) {}" + 
    505       "    Sequence {" + 
    506       "      TextInput (l) {}" + 
    507       "      TextInput (m) {}" + 
    508       "      TextInput (n) {}" + 
    509       "      TextInput (o) {}" + 
    510       "    }" + 
    511       "  }" + 
    512       "  TextInput (p) {}" + 
    513       "}"; 
    514  
    515     expectedDefects = new UsabilityDefect[] 
    516     { 
    517       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
    518       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_REPETITIONS) 
    519     }; 
    520  
    521     assertUsabilityEvaluationResult 
    522       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    523  
    524     // ===== check ===== 
    525     spec = 
    526       "Sequence {" + 
    527       "  TextInput (a b c d e f g h i j k l m) {}" + 
    528       "  Sequence {" + 
    529       "    TextInput (a) {}" + 
    530       "    TextInput (b) {}" + 
    531       "    TextInput (c) {}" + 
    532       "    TextInput (d) {}" + 
    533       "  }" + 
    534       "  Iteration {" + 
    535       "    TextInput (e) {}" + 
    536       "  }" + 
    537       "  TextInput (a) {}" + 
    538       "  Selection {" + 
    539       "    TextInput (b) {}" + 
    540       "    TextInput (c) {}" + 
    541       "    TextInput (d) {}" + 
    542       "    TextInput (e) {}" + 
    543       "  }" + 
    544       "  Sequence {" + 
    545       "    TextInput (a) {}" + 
    546       "    Sequence {" + 
    547       "      TextInput (b) {}" + 
    548       "      TextInput (c) {}" + 
    549       "      TextInput (d) {}" + 
    550       "      TextInput (e) {}" + 
    551       "    }" + 
    552       "  }" + 
    553       "  TextInput (f) {}" + 
    554       "}"; 
    555  
    556     expectedDefects = new UsabilityDefect[] 
    557     { 
    558       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
    559       new UsabilityDefect(MEDIUM, TEXT_FIELD_INPUT_REPETITIONS) 
    560     }; 
    561  
    562     assertUsabilityEvaluationResult 
    563       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    564   
    565     // ===== check ===== 
    566     spec = 
    567       "Sequence {" + 
    568       "  TextInput (a b c d e f g h i j k l m) {}" + 
    569       "  Sequence {" + 
    570       "    TextInput (a) {}" + 
    571       "    TextInput (b) {}" + 
    572       "    TextInput (c) {}" + 
    573       "    TextInput (a) {}" + 
    574       "  }" + 
    575       "  Iteration {" + 
    576       "    TextInput (b) {}" + 
    577       "  }" + 
    578       "  TextInput (c) {}" + 
    579       "  Selection {" + 
    580       "    TextInput (a) {}" + 
    581       "    TextInput (b) {}" + 
    582       "    TextInput (c) {}" + 
    583       "    TextInput (a) {}" + 
    584       "  }" + 
    585       "  Sequence {" + 
    586       "    TextInput (b) {}" + 
    587       "    Sequence {" + 
    588       "      TextInput (c) {}" + 
    589       "      TextInput (a) {}" + 
    590       "      TextInput (b) {}" + 
    591       "      TextInput (c) {}" + 
    592       "    }" + 
    593       "  }" + 
    594       "  TextInput (a) {}" + 
    595       "}"; 
    596  
    597     expectedDefects = new UsabilityDefect[] 
    598     { 
    599       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
    600       new UsabilityDefect(MEDIUM, TEXT_FIELD_INPUT_REPETITIONS) 
    601     }; 
    602  
    603     assertUsabilityEvaluationResult 
    604       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    605     
    606     // ===== check ===== 
    607     spec = 
    608       "Sequence {" + 
    609       "  TextInput (a b c) {}" + 
    610       "  Sequence {" + 
    611       "    TextInput (a) {}" + 
    612       "    TextInput (b) {}" + 
    613       "    TextInput (c) {}" + 
    614       "  }" + 
    615       "}"; 
    616  
    617     expectedDefects = new UsabilityDefect[] 
    618     { 
    619       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
    620       new UsabilityDefect(LOW, TEXT_FIELD_INPUT_REPETITIONS) 
    621     }; 
    622  
    623     assertUsabilityEvaluationResult 
    624       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    625       
    626     // ===== check ===== 
    627     spec = 
    628       "Sequence {" + 
    629       "  TextInput (a b c) {}" + 
    630       "  Sequence {" + 
    631       "    TextInput (a) {}" + 
    632       "    TextInput (a) {}" + 
    633       "    TextInput (b) {}" + 
    634       "  }" + 
    635       "}"; 
    636  
    637     expectedDefects = new UsabilityDefect[] 
    638     { 
    639       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
    640       new UsabilityDefect(LOW, TEXT_FIELD_INPUT_REPETITIONS) 
    641     }; 
    642  
    643     assertUsabilityEvaluationResult 
    644       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    645         
    646     // ===== check ===== 
    647     spec = 
    648       "Sequence {" + 
    649       "  TextInput (a b c) {}" + 
    650       "  Sequence {" + 
    651       "    TextInput (a) {}" + 
    652       "    TextInput (d) {}" + 
    653       "    TextInput (e) {}" + 
    654       "  }" + 
    655       "}"; 
    656  
    657     expectedDefects = new UsabilityDefect[] 
    658     { 
    659       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
    660       new UsabilityDefect(INFO, TEXT_FIELD_INPUT_REPETITIONS) 
    661     }; 
    662  
    663     assertUsabilityEvaluationResult 
    664       (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
    665           
    666   } 
    667  
    668   //----------------------------------------------------------------------------------------------- 
    669   /** 
    670    * TODO: comment 
    671    * 
    672    */ 
    673   //----------------------------------------------------------------------------------------------- 
    674   @Test 
    675   public void testNoLetterOrDigitInput() 
    676   { 
    677     UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); 
    678      
    679     // ===== check ===== 
    680     String spec = 
    681       "Sequence {" + 
    682       "  TextInput (_a_b_c_) {}" + 
    683       "}"; 
    684       
    685     UsabilityDefect[] expectedDefects = new UsabilityDefect[] 
    686     { 
    687       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
    688       new UsabilityDefect(HIGH, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) 
    689     }; 
    690      
    691     assertUsabilityEvaluationResult 
    692       (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));    
    693  
    694     // ===== check ===== 
    695     spec = 
    696       "Sequence {" + 
    697       "  TextInput (12345_6789012345) {}" + 
    698       "}"; 
    699       
    700     expectedDefects = new UsabilityDefect[] 
    701     { 
    702       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
    703       new UsabilityDefect(MEDIUM, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) 
    704     }; 
    705      
    706     assertUsabilityEvaluationResult 
    707       (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));    
    708  
    709     // ===== check ===== 
    710     spec = 
    711       "Sequence {" + 
    712       "  TextInput (123456789012345678901234567890_123456789012345) {}" + 
    713       "}"; 
    714       
    715     expectedDefects = new UsabilityDefect[] 
    716     { 
    717       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
    718       new UsabilityDefect(LOW, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) 
    719     }; 
    720      
    721     assertUsabilityEvaluationResult 
    722       (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));    
    723  
    724     // ===== check ===== 
    725     spec = 
    726       "Sequence {" + 
    727       "  TextInput (1234567890123456789012345678901234567890123456789_01234567890" + 
    728       "12345678901234567890123456789012345) {}" + 
    729       "}"; 
    730       
    731     expectedDefects = new UsabilityDefect[] 
    732     { 
    733       new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
    734       new UsabilityDefect(INFO, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) 
    735     }; 
    736      
    737     assertUsabilityEvaluationResult 
    738       (expectedDefects, manager.evaluateUsability(createTaskTree(spec)));    
    739  
    740   } 
     26public class TextInputStatisticsRuleTest extends AbstractUsabilityEvaluationTC { 
     27 
     28    /** 
     29     * TODO: comment 
     30     *  
     31     */ 
     32    @Test 
     33    public void testWithDifferentTextInputInteractionsOnly() { 
     34        UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); 
     35 
     36        // ===== check ===== 
     37        String spec = 
     38            "TextInput (bla) {}"; 
     39        UsabilityDefect[] expectedDefects = new UsabilityDefect[] 
     40            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; 
     41 
     42        assertUsabilityEvaluationResult 
     43            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     44 
     45        // ===== check ===== 
     46        spec = 
     47            "Sequence {" + 
     48            "  TextInput (bla) {}" + 
     49            "}"; 
     50 
     51        expectedDefects = new UsabilityDefect[] 
     52            { new UsabilityDefect(HIGH, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO) }; 
     53 
     54        assertUsabilityEvaluationResult 
     55            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     56 
     57        // ===== check ===== 
     58        spec = 
     59            "Sequence {" + 
     60            "  TextInput (a) {}" + 
     61            "  TextInput (b) {}" + 
     62            "  TextInput (c) {}" + 
     63            "  TextInput (d) {}" + 
     64            "}"; 
     65 
     66        expectedDefects = new UsabilityDefect[] 
     67            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; 
     68 
     69        assertUsabilityEvaluationResult 
     70            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     71 
     72        // ===== check ===== 
     73        spec = 
     74            "Selection {" + 
     75            "  TextInput (a) {}" + 
     76            "  TextInput (b) {}" + 
     77            "  TextInput (c) {}" + 
     78            "  TextInput (d) {}" + 
     79            "}"; 
     80 
     81        expectedDefects = new UsabilityDefect[] 
     82            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; 
     83 
     84        assertUsabilityEvaluationResult 
     85            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     86 
     87        // ===== check ===== 
     88        spec = 
     89            "Iteration {" + 
     90            "  TextInput (bla) {}" + 
     91            "}"; 
     92 
     93        expectedDefects = new UsabilityDefect[] 
     94            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; 
     95 
     96        assertUsabilityEvaluationResult 
     97            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     98 
     99        // ===== check ===== 
     100        spec = 
     101            "Sequence {" + 
     102            "  TextInput (a) {}" + 
     103            "  Sequence {" + 
     104            "    TextInput (b) {}" + 
     105            "    TextInput (c) {}" + 
     106            "    TextInput (d) {}" + 
     107            "    TextInput (e) {}" + 
     108            "  }" + 
     109            "  Iteration {" + 
     110            "    TextInput (f) {}" + 
     111            "  }" + 
     112            "  TextInput (g) {}" + 
     113            "  Selection {" + 
     114            "    TextInput (h) {}" + 
     115            "    TextInput (i) {}" + 
     116            "    TextInput (j) {}" + 
     117            "    TextInput (k) {}" + 
     118            "  }" + 
     119            "  Sequence {" + 
     120            "    TextInput (l) {}" + 
     121            "    Sequence {" + 
     122            "      TextInput (m) {}" + 
     123            "      TextInput (n) {}" + 
     124            "      TextInput (o) {}" + 
     125            "      TextInput (p) {}" + 
     126            "    }" + 
     127            "    Iteration {" + 
     128            "      TextInput (q) {}" + 
     129            "    }" + 
     130            "    TextInput (r) {}" + 
     131            "    Selection {" + 
     132            "      TextInput (s) {}" + 
     133            "      TextInput (t) {}" + 
     134            "      TextInput (u) {}" + 
     135            "      TextInput (v) {}" + 
     136            "    }" + 
     137            "  }" + 
     138            "  Selection {" + 
     139            "    TextInput (w) {}" + 
     140            "    Sequence {" + 
     141            "      TextInput (x) {}" + 
     142            "      TextInput (y) {}" + 
     143            "      TextInput (z) {}" + 
     144            "      TextInput (aa) {}" + 
     145            "    }" + 
     146            "    Iteration {" + 
     147            "      TextInput (ab) {}" + 
     148            "    }" + 
     149            "    TextInput (ac) {}" + 
     150            "    Selection {" + 
     151            "      TextInput (ad) {}" + 
     152            "      TextInput (ae) {}" + 
     153            "      TextInput (af) {}" + 
     154            "      TextInput (ag) {}" + 
     155            "    }" + 
     156            "  }" + 
     157            "  TextInput (ah) {}" + 
     158            "}"; 
     159 
     160        expectedDefects = new UsabilityDefect[] 
     161            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO) }; 
     162 
     163        assertUsabilityEvaluationResult 
     164            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     165    } 
     166 
     167    /** 
     168     * TODO: comment 
     169     *  
     170     */ 
     171    @Test 
     172    public void testCombinationsOfTextInputInteractionsAndOtherInteractions() { 
     173        UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); 
     174 
     175        // ===== check ===== 
     176        String spec = 
     177            "Sequence {" + 
     178            "  Interaction {}" + 
     179            "  TextInput (a) {}" + 
     180            "  TextInput (b) {}" + 
     181            "  Interaction {}" + 
     182            "  TextInput (c) {}" + 
     183            "}"; 
     184 
     185        UsabilityDefect[] expectedDefects = new UsabilityDefect[] 
     186            { new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) }; 
     187 
     188        assertUsabilityEvaluationResult 
     189            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     190 
     191        // ===== check ===== 
     192        spec = 
     193            "Sequence {" + 
     194            "  Interaction {}" + 
     195            "  TextInput (a) {}" + 
     196            "  Interaction {}" + 
     197            "  Interaction {}" + 
     198            "  TextInput (c) {}" + 
     199            "}"; 
     200 
     201        expectedDefects = new UsabilityDefect[] 
     202            { new UsabilityDefect(INFO, TEXT_FIELD_INPUT_RATIO) }; 
     203 
     204        assertUsabilityEvaluationResult 
     205            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     206 
     207        // ===== check ===== 
     208        spec = 
     209            "Sequence {" + 
     210            "  Interaction {}" + 
     211            "  TextInput (a) {}" + 
     212            "  Interaction {}" + 
     213            "  Interaction {}" + 
     214            "  Interaction {}" + 
     215            "}"; 
     216 
     217        expectedDefects = new UsabilityDefect[0]; 
     218 
     219        assertUsabilityEvaluationResult 
     220            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     221 
     222        // ===== check ===== 
     223        spec = 
     224            "Selection {" + 
     225            "  Interaction {}" + 
     226            "  TextInput (a) {}" + 
     227            "  TextInput (b) {}" + 
     228            "  Interaction {}" + 
     229            "  TextInput (c) {}" + 
     230            "}"; 
     231 
     232        expectedDefects = new UsabilityDefect[] 
     233            { new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) }; 
     234 
     235        assertUsabilityEvaluationResult 
     236            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     237 
     238        // ===== check ===== 
     239        spec = 
     240            "Sequence {" + 
     241            "  TextInput (a) {}" + 
     242            "  Sequence {" + 
     243            "    Interaction {}" + 
     244            "    TextInput (b) {}" + 
     245            "    TextInput (c) {}" + 
     246            "    Interaction {}" + 
     247            "    TextInput (d) {}" + 
     248            "  }" + 
     249            "  Iteration {" + 
     250            "    TextInput (e) {}" + 
     251            "  }" + 
     252            "  Interaction {}" + 
     253            "  Selection {" + 
     254            "    Interaction {}" + 
     255            "    TextInput (f) {}" + 
     256            "    TextInput (g) {}" + 
     257            "    Interaction {}" + 
     258            "    TextInput (h) {}" + 
     259            "    TextInput (i) {}" + 
     260            "  }" + 
     261            "  Sequence {" + 
     262            "    TextInput (j) {}" + 
     263            "    Sequence {" + 
     264            "      TextInput (k) {}" + 
     265            "      Interaction {}" + 
     266            "      TextInput (l) {}" + 
     267            "      TextInput (m) {}" + 
     268            "      Interaction {}" + 
     269            "      TextInput (n) {}" + 
     270            "      TextInput (o) {}" + 
     271            "    }" + 
     272            "    Iteration {" + 
     273            "      Interaction {}" + 
     274            "    }" + 
     275            "    Interaction {}" + 
     276            "    Selection {" + 
     277            "      TextInput (p) {}" + 
     278            "      TextInput (q) {}" + 
     279            "      TextInput (r) {}" + 
     280            "      Interaction {}" + 
     281            "      TextInput (s) {}" + 
     282            "      TextInput (t) {}" + 
     283            "      Interaction {}" + 
     284            "      TextInput (u) {}" + 
     285            "      TextInput (v) {}" + 
     286            "    }" + 
     287            "  }" + 
     288            "  Selection {" + 
     289            "    Interaction {}" + 
     290            "    Sequence {" + 
     291            "      TextInput (w) {}" + 
     292            "      Interaction {}" + 
     293            "      TextInput (x) {}" + 
     294            "      TextInput (y) {}" + 
     295            "      Interaction {}" + 
     296            "    }" + 
     297            "    Iteration {" + 
     298            "      TextInput (z) {}" + 
     299            "    }" + 
     300            "    TextInput (aa) {}" + 
     301            "    Selection {" + 
     302            "      TextInput (ab) {}" + 
     303            "      Interaction {}" + 
     304            "      TextInput (ac) {}" + 
     305            "      TextInput (ad) {}" + 
     306            "      Interaction {}" + 
     307            "      TextInput (ae) {}" + 
     308            "    }" + 
     309            "  }" + 
     310            "  Interaction {}" + 
     311            "}"; 
     312 
     313        expectedDefects = new UsabilityDefect[] 
     314            { new UsabilityDefect(LOW, TEXT_FIELD_INPUT_RATIO) }; 
     315 
     316        assertUsabilityEvaluationResult 
     317            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     318 
     319        // ===== check ===== 
     320        spec = 
     321            "Sequence {" + 
     322            "  TextInput (a) {}" + 
     323            "  Sequence {" + 
     324            "    Interaction {}" + 
     325            "    TextInput (b) {}" + 
     326            "    Interaction {}" + 
     327            "    Interaction {}" + 
     328            "    TextInput (c) {}" + 
     329            "  }" + 
     330            "  Iteration {" + 
     331            "    TextInput (d) {}" + 
     332            "  }" + 
     333            "  Interaction {}" + 
     334            "  Selection {" + 
     335            "    Interaction {}" + 
     336            "    TextInput (e) {}" + 
     337            "    Interaction {}" + 
     338            "    Interaction {}" + 
     339            "    TextInput (g) {}" + 
     340            "    Interaction {}" + 
     341            "  }" + 
     342            "  Sequence {" + 
     343            "    TextInput (i) {}" + 
     344            "    Sequence {" + 
     345            "      TextInput (j) {}" + 
     346            "      Interaction {}" + 
     347            "      TextInput (k) {}" + 
     348            "      Interaction {}" + 
     349            "      Interaction {}" + 
     350            "      TextInput (m) {}" + 
     351            "      Interaction {}" + 
     352            "    }" + 
     353            "    Iteration {" + 
     354            "      Interaction {}" + 
     355            "    }" + 
     356            "    Interaction {}" + 
     357            "    Selection {" + 
     358            "      TextInput (o) {}" + 
     359            "      Interaction {}" + 
     360            "      Interaction {}" + 
     361            "      Interaction {}" + 
     362            "      Interaction {}" + 
     363            "      TextInput (s) {}" + 
     364            "      Interaction {}" + 
     365            "      TextInput (t) {}" + 
     366            "      TextInput (u) {}" + 
     367            "    }" + 
     368            "  }" + 
     369            "  Selection {" + 
     370            "    Interaction {}" + 
     371            "    Sequence {" + 
     372            "      TextInput (v) {}" + 
     373            "      Interaction {}" + 
     374            "      Interaction {}" + 
     375            "      TextInput (x) {}" + 
     376            "      Interaction {}" + 
     377            "    }" + 
     378            "    Iteration {" + 
     379            "      TextInput (y) {}" + 
     380            "    }" + 
     381            "    TextInput (z) {}" + 
     382            "    Selection {" + 
     383            "      TextInput (aa) {}" + 
     384            "      Interaction {}" + 
     385            "      TextInput (ab) {}" + 
     386            "      Interaction {}" + 
     387            "      Interaction {}" + 
     388            "      TextInput (ad) {}" + 
     389            "    }" + 
     390            "  }" + 
     391            "  Interaction {}" + 
     392            "}"; 
     393 
     394        expectedDefects = new UsabilityDefect[] 
     395            { new UsabilityDefect(INFO, TEXT_FIELD_INPUT_RATIO) }; 
     396 
     397        assertUsabilityEvaluationResult 
     398            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     399    } 
     400 
     401    /** 
     402     * TODO: comment 
     403     *  
     404     */ 
     405    @Test 
     406    public void testTextEntryRepetitions() { 
     407        UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); 
     408 
     409        // ===== check ===== 
     410        String spec = 
     411            "Sequence {" + 
     412            "  TextInput (a b c) {}" + 
     413            "  Sequence {" + 
     414            "    TextInput (a) {}" + 
     415            "    TextInput (b) {}" + 
     416            "    TextInput (c) {}" + 
     417            "    TextInput (a) {}" + 
     418            "  }" + 
     419            "  Iteration {" + 
     420            "    TextInput (a) {}" + 
     421            "  }" + 
     422            "  TextInput (a) {}" + 
     423            "  Selection {" + 
     424            "    TextInput (b c) {}" + 
     425            "    TextInput (a) {}" + 
     426            "    TextInput (a c) {}" + 
     427            "    TextInput (b a) {}" + 
     428            "  }" + 
     429            "  Sequence {" + 
     430            "    TextInput (b c) {}" + 
     431            "    Sequence {" + 
     432            "      TextInput (d a c) {}" + 
     433            "      TextInput (b b b a) {}" + 
     434            "      TextInput (a a c c) {}" + 
     435            "      TextInput (b b a) {}" + 
     436            "    }" + 
     437            "  }" + 
     438            "  TextInput (d) {}" + 
     439            "}"; 
     440 
     441        UsabilityDefect[] expectedDefects = new UsabilityDefect[] 
     442            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
     443              new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_REPETITIONS) }; 
     444 
     445        assertUsabilityEvaluationResult 
     446            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     447 
     448        // ===== check ===== 
     449        spec = 
     450            "Sequence {" + 
     451            "  TextInput (a b c d e f g h i j k l m) {}" + 
     452            "  Sequence {" + 
     453            "    TextInput (a) {}" + 
     454            "    TextInput (b) {}" + 
     455            "    TextInput (c) {}" + 
     456            "    TextInput (d) {}" + 
     457            "  }" + 
     458            "  Iteration {" + 
     459            "    TextInput (e) {}" + 
     460            "  }" + 
     461            "  TextInput (f) {}" + 
     462            "  Selection {" + 
     463            "    TextInput (g) {}" + 
     464            "    TextInput (h) {}" + 
     465            "    TextInput (i) {}" + 
     466            "    TextInput (j) {}" + 
     467            "  }" + 
     468            "  Sequence {" + 
     469            "    TextInput (k) {}" + 
     470            "    Sequence {" + 
     471            "      TextInput (l) {}" + 
     472            "      TextInput (m) {}" + 
     473            "      TextInput (n) {}" + 
     474            "      TextInput (o) {}" + 
     475            "    }" + 
     476            "  }" + 
     477            "  TextInput (p) {}" + 
     478            "}"; 
     479 
     480        expectedDefects = new UsabilityDefect[] 
     481            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
     482              new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_REPETITIONS) }; 
     483 
     484        assertUsabilityEvaluationResult 
     485            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     486 
     487        // ===== check ===== 
     488        spec = 
     489            "Sequence {" + 
     490            "  TextInput (a b c d e f g h i j k l m) {}" + 
     491            "  Sequence {" + 
     492            "    TextInput (a) {}" + 
     493            "    TextInput (b) {}" + 
     494            "    TextInput (c) {}" + 
     495            "    TextInput (d) {}" + 
     496            "  }" + 
     497            "  Iteration {" + 
     498            "    TextInput (e) {}" + 
     499            "  }" + 
     500            "  TextInput (a) {}" + 
     501            "  Selection {" + 
     502            "    TextInput (b) {}" + 
     503            "    TextInput (c) {}" + 
     504            "    TextInput (d) {}" + 
     505            "    TextInput (e) {}" + 
     506            "  }" + 
     507            "  Sequence {" + 
     508            "    TextInput (a) {}" + 
     509            "    Sequence {" + 
     510            "      TextInput (b) {}" + 
     511            "      TextInput (c) {}" + 
     512            "      TextInput (d) {}" + 
     513            "      TextInput (e) {}" + 
     514            "    }" + 
     515            "  }" + 
     516            "  TextInput (f) {}" + 
     517            "}"; 
     518 
     519        expectedDefects = new UsabilityDefect[] 
     520            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
     521              new UsabilityDefect(MEDIUM, TEXT_FIELD_INPUT_REPETITIONS) }; 
     522 
     523        assertUsabilityEvaluationResult 
     524            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     525 
     526        // ===== check ===== 
     527        spec = 
     528            "Sequence {" + 
     529            "  TextInput (a b c d e f g h i j k l m) {}" + 
     530            "  Sequence {" + 
     531            "    TextInput (a) {}" + 
     532            "    TextInput (b) {}" + 
     533            "    TextInput (c) {}" + 
     534            "    TextInput (a) {}" + 
     535            "  }" + 
     536            "  Iteration {" + 
     537            "    TextInput (b) {}" + 
     538            "  }" + 
     539            "  TextInput (c) {}" + 
     540            "  Selection {" + 
     541            "    TextInput (a) {}" + 
     542            "    TextInput (b) {}" + 
     543            "    TextInput (c) {}" + 
     544            "    TextInput (a) {}" + 
     545            "  }" + 
     546            "  Sequence {" + 
     547            "    TextInput (b) {}" + 
     548            "    Sequence {" + 
     549            "      TextInput (c) {}" + 
     550            "      TextInput (a) {}" + 
     551            "      TextInput (b) {}" + 
     552            "      TextInput (c) {}" + 
     553            "    }" + 
     554            "  }" + 
     555            "  TextInput (a) {}" + 
     556            "}"; 
     557 
     558        expectedDefects = new UsabilityDefect[] 
     559            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
     560              new UsabilityDefect(MEDIUM, TEXT_FIELD_INPUT_REPETITIONS) }; 
     561 
     562        assertUsabilityEvaluationResult 
     563            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     564 
     565        // ===== check ===== 
     566        spec = 
     567            "Sequence {" + 
     568            "  TextInput (a b c) {}" + 
     569            "  Sequence {" + 
     570            "    TextInput (a) {}" + 
     571            "    TextInput (b) {}" + 
     572            "    TextInput (c) {}" + 
     573            "  }" + 
     574            "}"; 
     575 
     576        expectedDefects = new UsabilityDefect[] 
     577            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
     578              new UsabilityDefect(LOW, TEXT_FIELD_INPUT_REPETITIONS) }; 
     579 
     580        assertUsabilityEvaluationResult 
     581            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     582 
     583        // ===== check ===== 
     584        spec = 
     585            "Sequence {" + 
     586            "  TextInput (a b c) {}" + 
     587            "  Sequence {" + 
     588            "    TextInput (a) {}" + 
     589            "    TextInput (a) {}" + 
     590            "    TextInput (b) {}" + 
     591            "  }" + 
     592            "}"; 
     593 
     594        expectedDefects = new UsabilityDefect[] 
     595            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
     596              new UsabilityDefect(LOW, TEXT_FIELD_INPUT_REPETITIONS) }; 
     597 
     598        assertUsabilityEvaluationResult 
     599            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     600 
     601        // ===== check ===== 
     602        spec = 
     603            "Sequence {" + 
     604            "  TextInput (a b c) {}" + 
     605            "  Sequence {" + 
     606            "    TextInput (a) {}" + 
     607            "    TextInput (d) {}" + 
     608            "    TextInput (e) {}" + 
     609            "  }" + 
     610            "}"; 
     611 
     612        expectedDefects = new UsabilityDefect[] 
     613            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
     614              new UsabilityDefect(INFO, TEXT_FIELD_INPUT_REPETITIONS) }; 
     615 
     616        assertUsabilityEvaluationResult 
     617            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     618 
     619    } 
     620 
     621    /** 
     622     * TODO: comment 
     623     *  
     624     */ 
     625    @Test 
     626    public void testNoLetterOrDigitInput() { 
     627        UsabilityEvaluationManager manager = new UsabilityEvaluationManager(); 
     628 
     629        // ===== check ===== 
     630        String spec = 
     631            "Sequence {" + 
     632            "  TextInput (_a_b_c_) {}" + 
     633            "}"; 
     634 
     635        UsabilityDefect[] expectedDefects = new UsabilityDefect[] 
     636            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
     637              new UsabilityDefect(HIGH, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) }; 
     638 
     639        assertUsabilityEvaluationResult 
     640            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     641 
     642        // ===== check ===== 
     643        spec = 
     644            "Sequence {" + 
     645            "  TextInput (12345_6789012345) {}" + 
     646            "}"; 
     647 
     648        expectedDefects = new UsabilityDefect[] 
     649            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
     650              new UsabilityDefect(MEDIUM, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) }; 
     651 
     652        assertUsabilityEvaluationResult 
     653            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     654 
     655        // ===== check ===== 
     656        spec = 
     657            "Sequence {" + 
     658            "  TextInput (123456789012345678901234567890_123456789012345) {}" + 
     659            "}"; 
     660 
     661        expectedDefects = new UsabilityDefect[] 
     662            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
     663              new UsabilityDefect(LOW, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) }; 
     664 
     665        assertUsabilityEvaluationResult 
     666            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     667 
     668        // ===== check ===== 
     669        spec = 
     670            "Sequence {" + 
     671            "  TextInput (1234567890123456789012345678901234567890123456789_01234567890" + 
     672            "12345678901234567890123456789012345) {}" + 
     673            "}"; 
     674 
     675        expectedDefects = new UsabilityDefect[] 
     676            { new UsabilityDefect(HIGH, TEXT_FIELD_INPUT_RATIO), 
     677              new UsabilityDefect(INFO, TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO) }; 
     678 
     679        assertUsabilityEvaluationResult 
     680            (expectedDefects, manager.evaluateUsability(createTaskTree(spec))); 
     681 
     682    } 
    741683} 

  • trunk/quest-core-usability-test/src/test/java/de/ugoe/cs/quest/usability/UsabilityDefectDescriptionTest.java

    r497 r561  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: UsabilityDefectDescriptionTest.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: pharms $  $Date: 20.07.2012 $ 
    … …  
    54// Creation  : 2012 by pharms 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
     7 
    88package de.ugoe.cs.quest.usability; 
    99 
    … …  
    1616import org.junit.Test; 
    1717 
    18 //------------------------------------------------------------------------------------------------- 
    1918/** 
    2019 * TODO comment 
    … …  
    2322 * @author 2012, last modified by $Author: pharms$ 
    2423 */ 
    25 //------------------------------------------------------------------------------------------------- 
    26 public class UsabilityDefectDescriptionTest 
    27 { 
     24public class UsabilityDefectDescriptionTest { 
    2825 
    29   //----------------------------------------------------------------------------------------------- 
    30   /** 
    31    * TODO: comment 
    32    * 
    33    */ 
    34   //----------------------------------------------------------------------------------------------- 
    35   @Test 
    36   public void testInitialization() 
    37   { 
    38     for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) 
    39     { 
    40       assertNotNull(description.toString()); 
    41       assertNotSame("", description.toString()); 
    42       System.err.println(description); 
     26    /** 
     27     * TODO: comment 
     28     *  
     29     */ 
     30    @Test 
     31    public void testInitialization() { 
     32        for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) { 
     33            assertNotNull(description.toString()); 
     34            assertNotSame("", description.toString()); 
     35            System.err.println(description); 
     36        } 
    4337    } 
    44   } 
    4538 
    46   //----------------------------------------------------------------------------------------------- 
    47   /** 
    48    * TODO: comment 
    49    * 
    50    */ 
    51   //----------------------------------------------------------------------------------------------- 
    52   @Test 
    53   public void testParameterization() 
    54   { 
    55     for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) 
    56     { 
    57       Map<String, String> parameters = new HashMap<String, String>(); 
    58        
    59       for (String parameter : description.getDescriptionParameters()) 
    60       { 
    61         parameters.put(parameter, "<parameter " + parameter + ">"); 
    62       } 
    63        
    64       assertNotNull(description.toString(parameters)); 
    65       assertNotSame("", description.toString(parameters)); 
    66       System.err.println(description.toString(parameters)); 
     39    /** 
     40     * TODO: comment 
     41     *  
     42     */ 
     43    @Test 
     44    public void testParameterization() { 
     45        for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) { 
     46            Map<String, String> parameters = new HashMap<String, String>(); 
     47 
     48            for (String parameter : description.getDescriptionParameters()) { 
     49                parameters.put(parameter, "<parameter " + parameter + ">"); 
     50            } 
     51 
     52            assertNotNull(description.toString(parameters)); 
     53            assertNotSame("", description.toString(parameters)); 
     54            System.err.println(description.toString(parameters)); 
     55        } 
    6756    } 
    68   } 
    6957 
    7058} 
Note: See TracChangeset for help on using the changeset viewer.