Ignore:
Timestamp:
01/16/13 17:51:51 (11 years ago)
Author:
adeicke
Message:
  • Removed lombok related annotations and util class
  • Added comments and formating due to match project defaults
Location:
trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/evaluation/rule
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/evaluation/rule/evaluator/NoLetterOrDigitTextInputsEvaluator.java

    r1030 r1040  
     1//   Copyright 2012 Georg-August-Universität Göttingen, Germany 
     2// 
     3//   Licensed under the Apache License, Version 2.0 (the "License"); 
     4//   you may not use this file except in compliance with the License. 
     5//   You may obtain a copy of the License at 
     6// 
     7//       http://www.apache.org/licenses/LICENSE-2.0 
     8// 
     9//   Unless required by applicable law or agreed to in writing, software 
     10//   distributed under the License is distributed on an "AS IS" BASIS, 
     11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     12//   See the License for the specific language governing permissions and 
     13//   limitations under the License. 
     14 
    115package de.ugoe.cs.autoquest.usability.evaluation.rule.evaluator; 
    216 
     
    1630import de.ugoe.cs.autoquest.usability.tasktree.filter.TaskTreeFilter; 
    1731 
     32/** 
     33 * <p> 
     34 * TODO comment 
     35 * </p> 
     36 *  
     37 * @author Alexander Deicke 
     38 */ 
    1839public class NoLetterOrDigitTextInputsEvaluator extends RuleEvaluator { 
    1940 
    20     public NoLetterOrDigitTextInputsEvaluator(UsabilityRule evaluatedUsabilityRule, ITaskTree taskTree) { 
     41    public NoLetterOrDigitTextInputsEvaluator(UsabilityRule evaluatedUsabilityRule, 
     42                                              ITaskTree taskTree) 
     43    { 
    2144        super(evaluatedUsabilityRule, taskTree); 
    2245    } 
     
    2548    protected FilterStatistic nodesUnderEvaluation(ITaskTree taskTree) { 
    2649        Optional<FilterStatistic> cachedNodes = loadFromCache(TEXT_INPUT); 
    27         return cachedNodes.isPresent() ? cachedNodes.get() : cacheAndReturnNodes(taskTree, TEXT_INPUT); 
     50        return cachedNodes.isPresent() ? cachedNodes.get() : cacheAndReturnNodes(taskTree, 
     51                                                                                 TEXT_INPUT); 
    2852    } 
    29      
     53 
    3054    @Override 
    3155    protected FilterStatistic extractNodesFromTaskTree(ITaskTree taskTree) { 
    32         return new TaskTreeFilter(new IterativeDFSFilterStrategy()) 
    33             .filterByEventType(TEXT_INPUT).from(taskTree); 
     56        return new TaskTreeFilter(new IterativeDFSFilterStrategy()).filterByEventType(TEXT_INPUT) 
     57            .from(taskTree); 
    3458    } 
    3559 
    3660    @Override 
    3761    protected float calculateEvaluationMetric() { 
    38         Multiset<String> enteredTextFragments = aggregateEnteredTextFromTextInputs(this.filteredNodes.nodesMatchedFilter()); 
     62        Multiset<String> enteredTextFragments = 
     63            aggregateEnteredTextFromTextInputs(this.filteredNodes.nodesMatchedFilter()); 
    3964        int allCharactersCount = 0; 
    4065        int noLetterOrDigitCount = 0; 
    41         for(String textFragment : enteredTextFragments.elementSet()) { 
     66        for (String textFragment : enteredTextFragments.elementSet()) { 
    4267            int occurencesOfTextFragment = enteredTextFragments.count(textFragment); 
    4368            allCharactersCount += CharMatcher.ANY.countIn(textFragment) * occurencesOfTextFragment; 
    44             noLetterOrDigitCount += CharMatcher.forPredicate(characterIsLetterOrDigitPredicate()).countIn(textFragment) * occurencesOfTextFragment; 
     69            noLetterOrDigitCount += 
     70                CharMatcher.forPredicate(characterIsLetterOrDigitPredicate()).countIn(textFragment) * 
     71                    occurencesOfTextFragment; 
    4572        } 
    46         return allCharactersCount != 0 ? (float) noLetterOrDigitCount / (float) allCharactersCount : 0; 
     73        return allCharactersCount != 0 ? (float) noLetterOrDigitCount / (float) allCharactersCount 
     74            : 0; 
    4775    } 
    4876 
    4977    @Override 
    50     protected Optional<UsabilityDefectSeverityLevel> determineSeverityLevel(float evaluationMetric) { 
     78    protected Optional<UsabilityDefectSeverityLevel> determineSeverityLevel(float evaluationMetric) 
     79    { 
    5180        Optional<UsabilityDefectSeverityLevel> recommendationSeverityLevel = Optional.absent(); 
    5281        if (evaluationMetric > 0.1) // every 10th sign 
     
    6897        return recommendationSeverityLevel; 
    6998    } 
    70   
     99 
    71100} 
  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/evaluation/rule/evaluator/RuleEvaluator.java

    r1035 r1040  
     1//   Copyright 2012 Georg-August-Universität Göttingen, Germany 
     2// 
     3//   Licensed under the Apache License, Version 2.0 (the "License"); 
     4//   you may not use this file except in compliance with the License. 
     5//   You may obtain a copy of the License at 
     6// 
     7//       http://www.apache.org/licenses/LICENSE-2.0 
     8// 
     9//   Unless required by applicable law or agreed to in writing, software 
     10//   distributed under the License is distributed on an "AS IS" BASIS, 
     11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     12//   See the License for the specific language governing permissions and 
     13//   limitations under the License. 
    114 
    215package de.ugoe.cs.autoquest.usability.evaluation.rule.evaluator; 
     
    1730import de.ugoe.cs.autoquest.usability.tasktree.filter.TaskTreeNodeFilter; 
    1831 
     32/** 
     33 * <p> 
     34 * TODO comment 
     35 * </p> 
     36 *  
     37 * @author Alexander Deicke 
     38 */ 
    1939public abstract class RuleEvaluator { 
    2040 
     
    3858 
    3959    @SuppressWarnings("rawtypes") 
    40     protected FilterStatistic cacheAndReturnNodes(ITaskTree taskTree, TaskTreeNodeFilter nodeFilter) { 
     60    protected FilterStatistic cacheAndReturnNodes(ITaskTree taskTree, TaskTreeNodeFilter nodeFilter) 
     61    { 
    4162        FilterStatistic textInputEvents = extractNodesFromTaskTree(taskTree); 
    4263        FilterStatisticCache.instance().addFilterStatistic(nodeFilter, textInputEvents); 
     
    5273            determineSeverityLevel(evaluationMetric); 
    5374        if (severityLevel.isPresent()) { 
    54             ruleEvaluationResult = 
    55                 Optional.of(createRuleEvaluationResult(severityLevel.get())); 
     75            ruleEvaluationResult = Optional.of(createRuleEvaluationResult(severityLevel.get())); 
    5676        } 
    5777        return ruleEvaluationResult; 
     
    5979 
    6080    protected abstract float calculateEvaluationMetric(); 
    61      
     81 
    6282    protected void storeEvaluationMetricForDefectDescription(String key, String value) { 
    6383        defectDescriptionMessageParameterValues.put(key, value); 
     
    6686    protected abstract Optional<UsabilityDefectSeverityLevel> determineSeverityLevel(float evaluationMetric); 
    6787 
    68     public UsabilityDefect createRuleEvaluationResult(UsabilityDefectSeverityLevel severityLevelOfDefect) { 
     88    public UsabilityDefect createRuleEvaluationResult(UsabilityDefectSeverityLevel severityLevelOfDefect) 
     89    { 
    6990        return new UsabilityDefectFactory(UsabilityDefectXmlDescriptionResolver.instance()) 
    70             .createUsabilityGuidlineRecommendation(severityLevelOfDefect, 
    71                                                    evaluatedUsabilityRule, 
     91            .createUsabilityGuidlineRecommendation(severityLevelOfDefect, evaluatedUsabilityRule, 
    7292                                                   defectDescriptionMessageParameterValues); 
    7393    } 
  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/evaluation/rule/evaluator/TextInputEntryRepetitionsEvaluator.java

    r1030 r1040  
     1//   Copyright 2012 Georg-August-Universität Göttingen, Germany 
     2// 
     3//   Licensed under the Apache License, Version 2.0 (the "License"); 
     4//   you may not use this file except in compliance with the License. 
     5//   You may obtain a copy of the License at 
     6// 
     7//       http://www.apache.org/licenses/LICENSE-2.0 
     8// 
     9//   Unless required by applicable law or agreed to in writing, software 
     10//   distributed under the License is distributed on an "AS IS" BASIS, 
     11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     12//   See the License for the specific language governing permissions and 
     13//   limitations under the License. 
     14 
    115package de.ugoe.cs.autoquest.usability.evaluation.rule.evaluator; 
    216 
    317import static de.ugoe.cs.autoquest.usability.tasktree.filter.EventTypeFilter.TEXT_INPUT; 
    418import static de.ugoe.cs.autoquest.usability.util.TextInputUtil.aggregateEnteredTextFromTextInputs; 
     19import static java.lang.String.format; 
    520 
    621import com.google.common.base.Optional; 
     
    1631import de.ugoe.cs.autoquest.usability.tasktree.filter.TaskTreeFilter; 
    1732 
     33/** 
     34 * <p> 
     35 * TODO comment 
     36 * </p> 
     37 *  
     38 * @author Alexander Deicke 
     39 */ 
    1840public class TextInputEntryRepetitionsEvaluator extends RuleEvaluator { 
    1941 
    20     public TextInputEntryRepetitionsEvaluator(UsabilityRule evaluatedUsabilityRule, ITaskTree taskTree) { 
     42    public TextInputEntryRepetitionsEvaluator(UsabilityRule evaluatedUsabilityRule, 
     43                                              ITaskTree taskTree) 
     44    { 
    2145        super(evaluatedUsabilityRule, taskTree); 
    2246    } 
     
    2549    protected FilterStatistic nodesUnderEvaluation(ITaskTree taskTree) { 
    2650        Optional<FilterStatistic> cachedNodes = loadFromCache(TEXT_INPUT); 
    27         return cachedNodes.isPresent() ? cachedNodes.get() : cacheAndReturnNodes(taskTree, TEXT_INPUT); 
     51        return cachedNodes.isPresent() ? cachedNodes.get() : cacheAndReturnNodes(taskTree, 
     52                                                                                 TEXT_INPUT); 
    2853    } 
    29      
     54 
    3055    @Override 
    3156    protected FilterStatistic extractNodesFromTaskTree(ITaskTree taskTree) { 
    32         return new TaskTreeFilter(new IterativeDFSFilterStrategy()) 
    33             .filterByEventType(TEXT_INPUT).from(taskTree); 
     57        return new TaskTreeFilter(new IterativeDFSFilterStrategy()).filterByEventType(TEXT_INPUT) 
     58            .from(taskTree); 
    3459    } 
    3560 
    3661    @Override 
    3762    protected float calculateEvaluationMetric() { 
    38         Multiset<String> enteredTextFragments = aggregateEnteredTextFromTextInputs(this.filteredNodes.nodesMatchedFilter()); 
    39         Multiset<String> orderedTextFragmentsWithMultipleOccurences = onlyTextFragmentsWithMultipleOccurences(enteredTextFragments); 
    40         if(orderedTextFragmentsWithMultipleOccurences.isEmpty()) return 0; 
    41         String wordWithHighestRepetitionInTextFragments = orderedTextFragmentsWithMultipleOccurences.iterator().next(); 
     63        Multiset<String> enteredTextFragments = 
     64            aggregateEnteredTextFromTextInputs(this.filteredNodes.nodesMatchedFilter()); 
     65        Multiset<String> orderedTextFragmentsWithMultipleOccurences = 
     66            onlyTextFragmentsWithMultipleOccurences(enteredTextFragments); 
     67        if (orderedTextFragmentsWithMultipleOccurences.isEmpty()) 
     68            return 0; 
     69        String wordWithHighestRepetitionInTextFragments = 
     70            orderedTextFragmentsWithMultipleOccurences.iterator().next(); 
    4271        int numberOfRepeatedWords = orderedTextFragmentsWithMultipleOccurences.entrySet().size(); 
    43         int maxRepetitions = orderedTextFragmentsWithMultipleOccurences.count(wordWithHighestRepetitionInTextFragments); 
     72        int maxRepetitions = 
     73            orderedTextFragmentsWithMultipleOccurences 
     74                .count(wordWithHighestRepetitionInTextFragments); 
     75        storeEvaluationMetricForDefectDescription("textRepetitionRatio", 
     76                                                  format("textRepetitionRatio %s repeated tokens, up to %s repetitions per token", 
     77                                                         numberOfRepeatedWords, maxRepetitions)); 
    4478        return Math.max(numberOfRepeatedWords, maxRepetitions); 
    4579    } 
    46      
    47     private Multiset<String> onlyTextFragmentsWithMultipleOccurences(final Multiset<String> allTextInputs) { 
    48         return Multisets.copyHighestCountFirst(Multisets.filter(allTextInputs, new Predicate<String>() { 
    49              
    50             @Override 
    51             public boolean apply(String word) { 
    52                 return allTextInputs.count(word) > 1; 
    53             } 
    54              
    55         })); 
     80 
     81    private Multiset<String> onlyTextFragmentsWithMultipleOccurences(final Multiset<String> allTextInputs) 
     82    { 
     83        return Multisets.copyHighestCountFirst(Multisets.filter(allTextInputs, 
     84                                                                new Predicate<String>() { 
     85 
     86                                                                    @Override 
     87                                                                    public boolean apply(String word) 
     88                                                                    { 
     89                                                                        return allTextInputs 
     90                                                                            .count(word) > 1; 
     91                                                                    } 
     92 
     93                                                                })); 
    5694    } 
    5795 
    5896    @Override 
    59     protected Optional<UsabilityDefectSeverityLevel> determineSeverityLevel(float evaluationMetric) { 
     97    protected Optional<UsabilityDefectSeverityLevel> determineSeverityLevel(float evaluationMetric) 
     98    { 
    6099        Optional<UsabilityDefectSeverityLevel> recommendationSeverityLevel = Optional.absent(); 
    61100        if (evaluationMetric > 10) { 
     
    73112        return recommendationSeverityLevel; 
    74113    } 
    75      
     114 
    76115} 
  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/evaluation/rule/evaluator/TextInputRatioEvaluator.java

    r1030 r1040  
     1//   Copyright 2012 Georg-August-Universität Göttingen, Germany 
     2// 
     3//   Licensed under the Apache License, Version 2.0 (the "License"); 
     4//   you may not use this file except in compliance with the License. 
     5//   You may obtain a copy of the License at 
     6// 
     7//       http://www.apache.org/licenses/LICENSE-2.0 
     8// 
     9//   Unless required by applicable law or agreed to in writing, software 
     10//   distributed under the License is distributed on an "AS IS" BASIS, 
     11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     12//   See the License for the specific language governing permissions and 
     13//   limitations under the License. 
     14 
    115package de.ugoe.cs.autoquest.usability.evaluation.rule.evaluator; 
    216 
     
    1529import de.ugoe.cs.autoquest.usability.tasktree.filter.TaskTreeFilter; 
    1630 
     31/** 
     32 * <p> 
     33 * TODO comment 
     34 * </p> 
     35 *  
     36 * @author Alexander Deicke 
     37 */ 
    1738public class TextInputRatioEvaluator extends RuleEvaluator { 
    1839 
     
    2445    protected FilterStatistic nodesUnderEvaluation(ITaskTree taskTree) { 
    2546        Optional<FilterStatistic> cachedNodes = loadFromCache(TEXT_INPUT); 
    26         return cachedNodes.isPresent() ? cachedNodes.get() : cacheAndReturnNodes(taskTree, TEXT_INPUT); 
     47        return cachedNodes.isPresent() ? cachedNodes.get() : cacheAndReturnNodes(taskTree, 
     48                                                                                 TEXT_INPUT); 
    2749    } 
    2850 
    2951    @Override 
    3052    protected FilterStatistic extractNodesFromTaskTree(ITaskTree taskTree) { 
    31         return new TaskTreeFilter(new IterativeDFSFilterStrategy()).filterByEventType(TEXT_INPUT).from(taskTree); 
     53        return new TaskTreeFilter(new IterativeDFSFilterStrategy()).filterByEventType(TEXT_INPUT) 
     54            .from(taskTree); 
    3255    } 
    3356 
     
    3861        return textInputEvents / (textInputEvents + nonTextInputEvents); 
    3962    } 
    40      
     63 
    4164    private int nrOfEventNodesNotMatchedFilter() { 
    42         return Iterables.size( 
    43             Iterables.filter(this.filteredNodes.nodesNotMatchedFilter(), new Predicate<ITaskTreeNode>() { 
    44              
    45                 @Override 
    46                 public boolean apply(ITaskTreeNode node) { 
    47                     return  (node.getChildren() == null) || (node.getChildren().size() == 0); 
    48                 } 
    49             }) 
    50         ); 
     65        return Iterables.size(Iterables.filter(this.filteredNodes.nodesNotMatchedFilter(), 
     66                                              new Predicate<ITaskTreeNode>() { 
     67 
     68                                                   @Override 
     69                                                   public boolean apply(ITaskTreeNode node) { 
     70                                                       return (node.getChildren() == null) || 
     71                                                           (node.getChildren().size() == 0); 
     72                                                   } 
     73                                               })); 
    5174    } 
    5275 
    5376    @Override 
    54     protected Optional<UsabilityDefectSeverityLevel> determineSeverityLevel(float evaluationMetric) { 
     77    protected Optional<UsabilityDefectSeverityLevel> determineSeverityLevel(float evaluationMetric) 
     78    { 
    5579        Optional<UsabilityDefectSeverityLevel> recommendationSeverityLevel = Optional.absent(); 
    5680        if (evaluationMetric > 0.9) { 
  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/evaluation/rule/set/EmptyUsabilityRuleset.java

    r1034 r1040  
     1//   Copyright 2012 Georg-August-Universität Göttingen, Germany 
     2// 
     3//   Licensed under the Apache License, Version 2.0 (the "License"); 
     4//   you may not use this file except in compliance with the License. 
     5//   You may obtain a copy of the License at 
     6// 
     7//       http://www.apache.org/licenses/LICENSE-2.0 
     8// 
     9//   Unless required by applicable law or agreed to in writing, software 
     10//   distributed under the License is distributed on an "AS IS" BASIS, 
     11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     12//   See the License for the specific language governing permissions and 
     13//   limitations under the License. 
     14 
    115package de.ugoe.cs.autoquest.usability.evaluation.rule.set; 
    216 
     
    1024import de.ugoe.cs.autoquest.usability.evaluation.result.UsabilityDefect; 
    1125 
     26/** 
     27 * <p> 
     28 * TODO comment 
     29 * </p> 
     30 *  
     31 * @author Alexander Deicke 
     32 */ 
    1233public class EmptyUsabilityRuleset implements UsabilityRuleset { 
    13      
     34 
    1435    private enum EmptyUsabilityRule implements UsabilityRule { 
    15         ; 
     36        ; 
    1637 
    1738        @Override 
     
    2647 
    2748    } 
    28      
    29     private final EnumSet<EmptyUsabilityRule> EMPTY_USABILITY_RULESET =  
    30             EnumSet.noneOf(EmptyUsabilityRule.class); 
     49 
     50    private final EnumSet<EmptyUsabilityRule> EMPTY_USABILITY_RULESET = EnumSet 
     51        .noneOf(EmptyUsabilityRule.class); 
    3152 
    3253    @Override 
    3354    public EnumSet<? extends UsabilityRule> evaluationRules() { 
    34         return EMPTY_USABILITY_RULESET; 
     55        return EMPTY_USABILITY_RULESET; 
    3556    } 
    3657 
  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/evaluation/rule/set/MouseInteractionUsabilityRuleset.java

    r1034 r1040  
     1//   Copyright 2012 Georg-August-Universität Göttingen, Germany 
     2// 
     3//   Licensed under the Apache License, Version 2.0 (the "License"); 
     4//   you may not use this file except in compliance with the License. 
     5//   You may obtain a copy of the License at 
     6// 
     7//       http://www.apache.org/licenses/LICENSE-2.0 
     8// 
     9//   Unless required by applicable law or agreed to in writing, software 
     10//   distributed under the License is distributed on an "AS IS" BASIS, 
     11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     12//   See the License for the specific language governing permissions and 
     13//   limitations under the License. 
     14 
    115package de.ugoe.cs.autoquest.usability.evaluation.rule.set; 
    216 
     
    822import de.ugoe.cs.autoquest.usability.evaluation.result.UsabilityDefect; 
    923 
     24/** 
     25 * <p> 
     26 * TODO comment 
     27 * </p> 
     28 *  
     29 * @author Alexander Deicke 
     30 */ 
    1031public class MouseInteractionUsabilityRuleset implements UsabilityRuleset { 
    1132 
    1233    private enum MouseInteractionUsabilityRule implements UsabilityRule { 
    13          
     34 
    1435        MOUSE_INTERACTION { 
    1536 
     
    2546                return this.name(); 
    2647            } 
    27              
     48 
    2849        }; 
    2950 
    3051        public abstract Optional<UsabilityDefect> evaluate(ITaskTree taskTree); 
    3152    } 
    32      
    33     private final EnumSet<MouseInteractionUsabilityRule> MOUSE_INTERACTION_USABILITY_RULESET = EnumSet 
    34             .allOf(MouseInteractionUsabilityRule.class); 
    35      
     53 
     54    private final EnumSet<MouseInteractionUsabilityRule> MOUSE_INTERACTION_USABILITY_RULESET = 
     55        EnumSet.allOf(MouseInteractionUsabilityRule.class); 
     56 
    3657    @Override 
    3758    public EnumSet<? extends UsabilityRule> evaluationRules() { 
  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/evaluation/rule/set/RulesetFactory.java

    r1030 r1040  
     1//   Copyright 2012 Georg-August-Universität Göttingen, Germany 
     2// 
     3//   Licensed under the Apache License, Version 2.0 (the "License"); 
     4//   you may not use this file except in compliance with the License. 
     5//   You may obtain a copy of the License at 
     6// 
     7//       http://www.apache.org/licenses/LICENSE-2.0 
     8// 
     9//   Unless required by applicable law or agreed to in writing, software 
     10//   distributed under the License is distributed on an "AS IS" BASIS, 
     11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     12//   See the License for the specific language governing permissions and 
     13//   limitations under the License. 
     14 
    115package de.ugoe.cs.autoquest.usability.evaluation.rule.set; 
    216 
    3 import lombok.AccessLevel; 
    4 import lombok.NoArgsConstructor; 
     17/** 
     18 * <p> 
     19 * TODO comment 
     20 * </p> 
     21 *  
     22 * @author Alexander Deicke 
     23 */ 
     24public class RulesetFactory { 
    525 
    6 @NoArgsConstructor(access = AccessLevel.PRIVATE) 
    7 public class RulesetFactory { 
    8      
     26    private RulesetFactory() { 
     27        // no instantiation allowed 
     28    } 
     29 
    930    public static EmptyUsabilityRuleset emptyUsabilityRuleset() { 
    10         return new EmptyUsabilityRuleset(); 
     31        return new EmptyUsabilityRuleset(); 
    1132    } 
    12      
     33 
    1334    public static TextInputUsabiliyRuleset textInputUsabiliyRuleset() { 
    14         return new TextInputUsabiliyRuleset(); 
     35        return new TextInputUsabiliyRuleset(); 
    1536    } 
    16      
     37 
    1738    public static MouseInteractionUsabilityRuleset mouseInteractionUsabiliyRuleset() { 
    1839        return new MouseInteractionUsabilityRuleset(); 
  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/evaluation/rule/set/TextInputUsabiliyRuleset.java

    r1034 r1040  
     1//   Copyright 2012 Georg-August-Universität Göttingen, Germany 
     2// 
     3//   Licensed under the Apache License, Version 2.0 (the "License"); 
     4//   you may not use this file except in compliance with the License. 
     5//   You may obtain a copy of the License at 
     6// 
     7//       http://www.apache.org/licenses/LICENSE-2.0 
     8// 
     9//   Unless required by applicable law or agreed to in writing, software 
     10//   distributed under the License is distributed on an "AS IS" BASIS, 
     11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     12//   See the License for the specific language governing permissions and 
     13//   limitations under the License. 
    114 
    215package de.ugoe.cs.autoquest.usability.evaluation.rule.set; 
     
    1225import de.ugoe.cs.autoquest.usability.evaluation.rule.evaluator.TextInputRatioEvaluator; 
    1326 
     27/** 
     28 * <p> 
     29 * TODO comment 
     30 * </p> 
     31 *  
     32 * @author Alexander Deicke 
     33 */ 
    1434public class TextInputUsabiliyRuleset implements UsabilityRuleset { 
    1535 
     
    1737 
    1838        TEXT_FIELD_INPUT_RATIO { 
    19              
     39 
    2040            @Override 
    2141            public Optional<UsabilityDefect> evaluate(ITaskTree taskTree) { 
     
    5676            } 
    5777 
     78        }; 
    5879 
    59         }; 
    60          
    6180        public abstract Optional<UsabilityDefect> evaluate(ITaskTree taskTree); 
    6281 
  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/evaluation/rule/set/UsabilityRule.java

    r1030 r1040  
     1//   Copyright 2012 Georg-August-Universität Göttingen, Germany 
     2// 
     3//   Licensed under the Apache License, Version 2.0 (the "License"); 
     4//   you may not use this file except in compliance with the License. 
     5//   You may obtain a copy of the License at 
     6// 
     7//       http://www.apache.org/licenses/LICENSE-2.0 
     8// 
     9//   Unless required by applicable law or agreed to in writing, software 
     10//   distributed under the License is distributed on an "AS IS" BASIS, 
     11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     12//   See the License for the specific language governing permissions and 
     13//   limitations under the License. 
     14 
    115package de.ugoe.cs.autoquest.usability.evaluation.rule.set; 
    216 
     
    620import de.ugoe.cs.autoquest.usability.evaluation.result.UsabilityDefect; 
    721 
     22/** 
     23 * <p> 
     24 * TODO comment 
     25 * </p> 
     26 *  
     27 * @author Alexander Deicke 
     28 */ 
    829public interface UsabilityRule { 
    9      
     30 
    1031    public String ruleIdentifier(); 
    11      
     32 
    1233    public Optional<UsabilityDefect> evaluate(ITaskTree taskTree); 
    1334 
  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/evaluation/rule/set/UsabilityRuleset.java

    r1034 r1040  
     1//   Copyright 2012 Georg-August-Universität Göttingen, Germany 
     2// 
     3//   Licensed under the Apache License, Version 2.0 (the "License"); 
     4//   you may not use this file except in compliance with the License. 
     5//   You may obtain a copy of the License at 
     6// 
     7//       http://www.apache.org/licenses/LICENSE-2.0 
     8// 
     9//   Unless required by applicable law or agreed to in writing, software 
     10//   distributed under the License is distributed on an "AS IS" BASIS, 
     11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     12//   See the License for the specific language governing permissions and 
     13//   limitations under the License. 
     14 
    115package de.ugoe.cs.autoquest.usability.evaluation.rule.set; 
    216 
    317import java.util.EnumSet; 
    418 
    5  
     19/** 
     20 * <p> 
     21 * TODO comment 
     22 * </p> 
     23 *  
     24 * @author Alexander Deicke 
     25 */ 
    626public interface UsabilityRuleset { 
    727 
    828    public EnumSet<? extends UsabilityRule> evaluationRules(); 
    9      
     29 
    1030} 
Note: See TracChangeset for help on using the changeset viewer.