Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/CheckBoxMultipleSelectionRule.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/CheckBoxMultipleSelectionRule.java	(revision 1960)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/CheckBoxMultipleSelectionRule.java	(revision 2042)
@@ -15,22 +15,26 @@
 package de.ugoe.cs.autoquest.usability;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.eventcore.gui.MouseClick;
+import de.ugoe.cs.autoquest.eventcore.gui.ValueSelection;
 import de.ugoe.cs.autoquest.eventcore.guimodel.ICheckBox;
 import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.DefaultTaskTraversingVisitor;
+import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIView;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.DefaultTaskInstanceTraversingVisitor;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTaskInstance;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.IMarkingTemporalRelationship;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.IStructuringTemporalRelationship;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.TaskMetric;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession;
 
 /**
@@ -68,124 +72,117 @@
                                    UsabilityEvaluationResult results)
     {
+        System.out.println("\n\n########################################\n");
+        final List<List<IEventTaskInstance>> actionInstancesInSameView = new LinkedList<>();
+        
+        for (IUserSession session : taskModel.getUserSessions()) {
+            for (ITaskInstance instance : session) {
+                final LinkedList<IEventTaskInstance> currentList = new LinkedList<>();
+                
+                instance.accept(new DefaultTaskInstanceTraversingVisitor() {
+                    @Override
+                    public void visit(IEventTaskInstance eventTaskInstance) {
+                        if (eventTaskInstance.getEvent().getTarget() instanceof IGUIElement) {
+                            IEventTarget target = eventTaskInstance.getEvent().getTarget();
+                            IGUIView currentView = ((IGUIElement) target).getView();
+                            
+                            IGUIView previousView = null;
+                            if (currentList.size() > 0) {
+                                target = currentList.getLast().getEvent().getTarget();
+                                previousView = ((IGUIElement) target).getView();
+                            }
+                            
+                            if ((previousView == currentView) ||
+                                ((previousView != null) && (previousView.equals(currentView))))
+                            {
+                                currentList.add(eventTaskInstance);
+                            }
+                            else {
+                                if (currentList.size() > 0) {
+                                    actionInstancesInSameView.add(new ArrayList<>(currentList));
+                                }
+                                currentList.clear();
+                                currentList.add(eventTaskInstance);
+                            }
+                        }
+                    }
+                });
+                
+                if (currentList.size() > 0) {
+                    actionInstancesInSameView.add(new ArrayList<>(currentList));
+                }
+            }
+        }
+
+        
         Map<IGUIElement, List<IGUIElement>> checkBoxGroups = statistics.getCheckBoxGroups();
         
-        CHECK_NEXT_GROUP:
-        for (List<IGUIElement> group : checkBoxGroups.values()) {
-            Set<ITask> tasksUsingGroup = new HashSet<>();
-            
-            for (IGUIElement checkBox : group) {
-                Set<ITask> tasksUsingCheckBox = getTasksUsingCheckBox(checkBox, taskModel);
+        for (Map.Entry<IGUIElement, List<IGUIElement>> group : checkBoxGroups.entrySet()) {
+            IGUIView currentView = group.getKey().getView();
+            int noOfEvents = 0;
+            int noOfGroupUsages = 0;
+            int noOfSingleCheckBoxUsages = 0;
+            
+            for (List<IEventTaskInstance> actionInstanceList : actionInstancesInSameView) {
+                IEventTarget target = actionInstanceList.get(0).getEvent().getTarget();
+                IGUIView viewOfList = ((IGUIElement) target).getView();
                 
-                for (ITask taskUsingCheckBox : tasksUsingCheckBox) {
-                    if (tasksUsingGroup.contains(taskUsingCheckBox)) {
-                        continue CHECK_NEXT_GROUP;
-                    }
-                    else {
-                        tasksUsingGroup.add(taskUsingCheckBox);
+                if ((viewOfList == currentView) ||
+                    ((viewOfList != null) && (viewOfList.equals(currentView))))
+                {
+                    noOfGroupUsages++;
+                    boolean[] checkBoxUsages = new boolean[group.getValue().size()];
+                    
+                    for (IEventTaskInstance actionInstance : actionInstanceList) {
+                        int index = 0;
+                        for (IGUIElement checkBox : group.getValue()) {
+                            if ((("JFC".equals(actionInstance.getEvent().getTarget().getPlatform())) &&
+                                 (actionInstance.getEvent().getType() instanceof MouseClick) &&
+                                 (actionInstance.getEvent().getTarget().equals(checkBox))) ||
+                                ((actionInstance.getEvent().getType() instanceof ValueSelection<?>) &&
+                                 (actionInstance.getEvent().getTarget().equals(checkBox))))
+                            {
+                                checkBoxUsages[index] = !checkBoxUsages[index];
+                                noOfEvents++;
+                            }
+                            index++;
+                        }
+                    }
+                    
+                    int noOfCheckedBoxes = 0;
+                    
+                    for (int i = 0; i < checkBoxUsages.length; i++) {
+                        if (checkBoxUsages[i]) {
+                            noOfCheckedBoxes++;
+                        }
+                    }
+                    
+                    if (noOfCheckedBoxes == 1) {
+                        noOfSingleCheckBoxUsages++;
                     }
                 }
             }
             
-            if (tasksUsingGroup.size() > 0) {
-                int eventCoverage = 0;
-                int allRecordedEvents = 0;
-                
-                for (ITask task : tasksUsingGroup) {
-                    if (task instanceof IEventTask) {
-                        eventCoverage +=
-                            taskModel.getTaskInfo(task).getMeasureValue(TaskMetric.EVENT_COVERAGE);
-                    }
-                }
-                
-                for (ITask task : taskModel.getTasks()) {
-                    if (task instanceof IEventTask) {
-                        allRecordedEvents +=
-                            taskModel.getTaskInfo(task).getMeasureValue(TaskMetric.EVENT_COVERAGE);
-                    }
-                }
-                
-                
-                UsabilitySmellIntensity intensity = UsabilitySmellIntensity.getIntensity
-                    ((int) (1000 * eventCoverage / allRecordedEvents), eventCoverage, -1);
-                    
-                if (intensity != null) {
-                    Map<String, Object> parameters = new HashMap<String, Object>();
-                    parameters.put("radioButtons", group);
-
-                    results.addSmell
-                        (intensity, UsabilitySmellDescription.CHECK_BOX_SINGLE_SELECTION,
-                         parameters);
-                }
-            }
-        }
-    }
-
-    /**
-     * 
-     */
-    private Set<ITask> getTasksUsingCheckBox(final IGUIElement checkBox, ITaskModel taskModel) {
-        final Set<ITask> tasksUsingCheckBox = new HashSet<ITask>();
-        
-        for (ITask candidate : taskModel.getTasks()) {
-            candidate.accept(new DefaultTaskTraversingVisitor() {
-                @Override
-                public void visit(IEventTask eventTask) {
-                    if (!eventTask.getInstances().isEmpty()) {
-                        IEventTaskInstance instance =
-                            (IEventTaskInstance) eventTask.getInstances().iterator().next();
-                        
-                        if (checkBox.equals(instance.getEvent().getTarget())) {
-                            tasksUsingCheckBox.add(eventTask);
-                        }
-                    }
-                }
-                
-                @Override
-                public void visit(IStructuringTemporalRelationship relationship) {
-                    if (tasksUsingCheckBox.contains(relationship)) {
-                        return;
-                    }
-                    else {
-                        for (ITask child : relationship.getChildren()) {
-                            if (tasksUsingCheckBox.contains(child)) {
-                                tasksUsingCheckBox.add(relationship);
-                                return;
-                            }
-                        }
-                        
-                        super.visit(relationship);
-                        
-                        for (ITask child : relationship.getChildren()) {
-                            if (tasksUsingCheckBox.contains(child)) {
-                                tasksUsingCheckBox.add(relationship);
-                                break;
-                            }
-                        }
-                    }
-                }
-
-                @Override
-                public void visit(IMarkingTemporalRelationship relationship) {
-                    if (tasksUsingCheckBox.contains(relationship)) {
-                        return;
-                    }
-                    else {
-                        if (tasksUsingCheckBox.contains(relationship.getMarkedTask())) {
-                            tasksUsingCheckBox.add(relationship);
-                            return;
-                        }
-                        
-                        super.visit(relationship);
-                        
-                        if (tasksUsingCheckBox.contains(relationship.getMarkedTask())) {
-                            tasksUsingCheckBox.add(relationship);
-                            return;
-                        }
-                    }
-                }
-            });
-        }
-        
-        return tasksUsingCheckBox;
+            // get a value that is 1 if for one group usage there is on average one check box usage
+            // get a value of 0 if for one group usage there is on average two check box usages
+            
+            int ratio = noOfGroupUsages > 0 ? 1000 * noOfSingleCheckBoxUsages / noOfGroupUsages : 0;
+            
+            System.out.println(currentView + "  " + ratio + "  " + noOfGroupUsages + "  " +
+                               noOfSingleCheckBoxUsages);
+            
+            UsabilitySmellIntensity intensity = UsabilitySmellIntensity.getIntensity
+                (ratio, noOfEvents, -1);
+                    
+            if (intensity != null) {
+                Map<String, Object> parameters = new HashMap<String, Object>();
+                parameters.put("allUsages", noOfGroupUsages);
+                parameters.put("singleUsages", noOfSingleCheckBoxUsages);
+                parameters.put("ratio", 100 * noOfSingleCheckBoxUsages / noOfGroupUsages);
+                parameters.put("radioButtons", group.getValue());
+
+                results.addSmell
+                    (intensity, UsabilitySmellDescription.CHECK_BOX_SINGLE_SELECTION, parameters);
+            }
+        }
     }
 
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/DataEntryMethodChangeRule.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/DataEntryMethodChangeRule.java	(revision 1960)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/DataEntryMethodChangeRule.java	(revision 2042)
@@ -29,4 +29,6 @@
 import de.ugoe.cs.autoquest.eventcore.gui.ValueSelection;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.DefaultTaskInstanceTraversingVisitor;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.DefaultTaskTraversingVisitor;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTaskInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
@@ -98,5 +100,5 @@
                 int ratio = getAverageDataEntryMethodChangeRatio((ISequence) task);
                 
-                if (ratio > 0) {
+                if ((ratio > 0) && (getLeafNodes(task) > 2)) {
                     methodChangeRatios.put(task, ratio);
                 }
@@ -105,4 +107,20 @@
         
         return methodChangeRatios;
+    }
+
+    /**
+     *
+     */
+    private int getLeafNodes(ITask task) {
+        final int[] counter = new int[1];
+        
+        task.accept(new DefaultTaskTraversingVisitor() {
+            @Override
+            public void visit(IEventTask eventTask) {
+                counter[0]++;
+            }
+        });
+        
+        return counter[0];
     }
 
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/DefaultValueRule.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/DefaultValueRule.java	(revision 1960)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/DefaultValueRule.java	(revision 2042)
@@ -29,8 +29,10 @@
 
 import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.eventcore.gui.MouseClick;
 import de.ugoe.cs.autoquest.eventcore.gui.TextInput;
 import de.ugoe.cs.autoquest.eventcore.gui.ValueSelection;
 import de.ugoe.cs.autoquest.eventcore.guimodel.GUIModel;
 import de.ugoe.cs.autoquest.eventcore.guimodel.ICheckBox;
+import de.ugoe.cs.autoquest.eventcore.guimodel.IComboBox;
 import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
 import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElementSpec;
@@ -136,21 +138,21 @@
             maxObserved = Math.max(maxObserved, selectedValue.getValue());
             
-            if (mostOftenSelected.size() > 0) {
-                ListIterator<Object> iterator = mostOftenSelected.listIterator();
-                while (iterator.hasNext()) {
-                    if (selectedValues.get(iterator.next()) < selectedValue.getValue()) {
-                        iterator.previous();
-                        iterator.add(selectedValue.getKey());
-                    
-                        while (mostOftenSelected.size() > 5) {
-                            mostOftenSelected.removeLast();
-                        }
-                    
-                        break;
-                    }
-                }
-            }
-            else {
+            boolean added = false;
+            ListIterator<Object> iterator = mostOftenSelected.listIterator();
+            while (iterator.hasNext()) {
+                if (selectedValues.get(iterator.next()) < selectedValue.getValue()) {
+                    iterator.previous();
+                    iterator.add(selectedValue.getKey());
+                    added = true;
+                    break;
+                }
+            }
+            
+            if (!added) {
                 mostOftenSelected.add(selectedValue.getKey());
+            }
+            
+            while (mostOftenSelected.size() > 5) {
+                mostOftenSelected.removeLast();
             }
         }
@@ -163,5 +165,5 @@
         }
         
-        if ((expected.length == 1) ||
+        if ((expected.length > 1) &&
             (new ChiSquareTest().chiSquareTest(expected, observed, 0.05)))
         {
@@ -218,7 +220,22 @@
      */
     private boolean isValueSelection(ITaskInstance instance) {
-        return (instance instanceof IEventTaskInstance) &&
-            ((((IEventTaskInstance) instance).getEvent().getType() instanceof TextInput) ||
-             (((IEventTaskInstance) instance).getEvent().getType() instanceof ValueSelection));
+        if (instance instanceof IEventTaskInstance) {
+            Event event = ((IEventTaskInstance) instance).getEvent();
+        
+            if ((event.getType() instanceof TextInput) ||
+                (event.getType() instanceof ValueSelection))
+            {
+                return true;
+            }
+            
+            if (("JFC".equals(event.getTarget().getPlatform())) &&
+                (event.getTarget() instanceof ICheckBox) &&
+                (event.getType() instanceof MouseClick))
+            {
+                return true;
+            }
+        }
+        
+        return false;
     }
 
@@ -439,6 +456,27 @@
                         ((ValueSelection<?>) valueChange.getEvent().getType()).getSelectedValue();
                     
-                    if ((target instanceof IRadioButton) || (target instanceof ICheckBox)) {
+                    if ((target.target instanceof IRadioButton) ||
+                        (target.target instanceof ICheckBox))
+                    {
                         selectedValue = selectedValue + " (" + target + ")";
+                    }
+                    else if (target.target instanceof IComboBox) {
+                        if (selectedValue == null) {
+                            // this may have happened due to the recording issue that selected
+                            // values of combo boxes are not logged correctly. In this case,
+                            // pretend to have the a random value selected
+                            selectedValue = "randomValueDueToRecordingBug_" + Math.random(); 
+                        }
+                    }
+                }
+                else if (valueChange.getEvent().getType() instanceof MouseClick) {
+                    if ((target.target instanceof IRadioButton) ||
+                        (target.target instanceof ICheckBox))
+                    {
+                        selectedValue = target.toString();
+                    }
+                    else {
+                        throw new IllegalStateException("the implementation needs to be extended " +
+                                                        "to fully support clicks as value changes");
                     }
                 }
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/MisleadingClickCueRule.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/MisleadingClickCueRule.java	(revision 1960)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/MisleadingClickCueRule.java	(revision 2042)
@@ -24,4 +24,5 @@
 import de.ugoe.cs.autoquest.eventcore.gui.MouseClick;
 import de.ugoe.cs.autoquest.eventcore.gui.MouseDoubleClick;
+import de.ugoe.cs.autoquest.eventcore.guimodel.IButton;
 import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
 import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIView;
@@ -65,27 +66,28 @@
                                    UsabilityEvaluationResult results)
     {
-        for (Map.Entry<IGUIView, Map<IGUIElement, Integer>> uselessClickCounter :
+        for (Map.Entry<IGUIElement, Map<IGUIView, Integer>> uselessClickCounter :
                 statistics.getUselessClickCounters().entrySet())
         {
-            for (Map.Entry<IGUIElement, Integer> counter : uselessClickCounter.getValue().entrySet())
-            {
-                int uselessClicks = counter.getValue();
-                int noOfViewDisplays = statistics.getViewOpenedCount(uselessClickCounter.getKey());
-
-                int ratio = Math.min(1000, 1000 * uselessClicks / noOfViewDisplays);
-
-                UsabilitySmellIntensity intensity =
-                    UsabilitySmellIntensity.getIntensity(ratio, uselessClicks, -1);
-
-                if (intensity != null) {
-                    Map<String, Object> parameters = new HashMap<String, Object>();
-                    parameters.put("noOfViewDisplays", noOfViewDisplays);
-                    parameters.put("uselessClicks", uselessClicks);
-                    parameters.put("element", counter.getKey());
-                    parameters.put("view", uselessClickCounter.getKey());
-
-                    results.addSmell
-                        (intensity, UsabilitySmellDescription.MISLEADING_CLICK_CUE, parameters);
-                }
+            int uselessClicks = 0;
+            int noOfViewDisplays = 0;
+            
+            for (Map.Entry<IGUIView, Integer> counter : uselessClickCounter.getValue().entrySet()) {
+                uselessClicks += counter.getValue();
+                noOfViewDisplays += statistics.getViewOpenedCount(counter.getKey());
+            }
+
+            int ratio = Math.min(1000, 1000 * uselessClicks / noOfViewDisplays);
+
+            UsabilitySmellIntensity intensity =
+                UsabilitySmellIntensity.getIntensity(ratio, uselessClicks, -1);
+
+            if (intensity != null) {
+                Map<String, Object> parameters = new HashMap<String, Object>();
+                parameters.put("noOfViewDisplays", noOfViewDisplays);
+                parameters.put("uselessClicks", uselessClicks);
+                parameters.put("element", uselessClickCounter.getKey());
+
+                results.addSmell
+                    (intensity, UsabilitySmellDescription.MISLEADING_CLICK_CUE, parameters);
             }
         }
@@ -155,5 +157,11 @@
             (target instanceof IText))
         {
-            return true;
+            // check if the parent is a button
+            IGUIElement parent = target;
+            while ((parent != null) && !(parent instanceof IButton)) {
+                parent = parent.getParent();
+            }
+            
+            return !(parent instanceof IButton);
         }
         else {
@@ -171,5 +179,5 @@
         
         /** */
-        private Map<IGUIView, Map<IGUIElement, Integer>> uselessClickCounters = new HashMap<>();
+        private Map<IGUIElement, Map<IGUIView, Integer>> uselessClickCounters = new HashMap<>();
 
         /**
@@ -199,27 +207,27 @@
          */
         private void addUselessClick(IEventTaskInstance eventTaskInstance) {
-            Map<IGUIElement, Integer> counterMap = uselessClickCounters.get
-                (((IGUIElement) eventTaskInstance.getEvent().getTarget()).getView());
+            IGUIElement target = (IGUIElement) eventTaskInstance.getEvent().getTarget();
+            
+            Map<IGUIView, Integer> counterMap = uselessClickCounters.get(target);
             
             if (counterMap == null) {
                 counterMap = new HashMap<>();
-                uselessClickCounters.put
-                    (((IGUIElement) eventTaskInstance.getEvent().getTarget()).getView(), counterMap);
-            }
-            
-            Integer counter = counterMap.get(eventTaskInstance.getEvent().getTarget());
+                uselessClickCounters.put(target, counterMap);
+            }
+            
+            Integer counter = counterMap.get(target.getView());
             
             if (counter == null) {
-                counterMap.put((IGUIElement) eventTaskInstance.getEvent().getTarget(), 1);
+                counterMap.put(target.getView(), 1);
             }
             else {
-                counterMap.put((IGUIElement) eventTaskInstance.getEvent().getTarget(), counter + 1);
-            }
-        }
-
-        /**
-         *
-         */
-        private Map<IGUIView, Map<IGUIElement, Integer>> getUselessClickCounters() {
+                counterMap.put(target.getView(), counter + 1);
+            }
+        }
+
+        /**
+         *
+         */
+        private Map<IGUIElement, Map<IGUIView, Integer>> getUselessClickCounters() {
             return uselessClickCounters;
         }
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/MissingFeedbackRule.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/MissingFeedbackRule.java	(revision 1960)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/MissingFeedbackRule.java	(revision 2042)
@@ -195,4 +195,8 @@
         
         if (clicksOnIdenticalButton != null) {
+            if (clicksOnIdenticalButton.size() > 1) {
+                //throw new IllegalStateException("not described in dissertation");
+            }
+            
             long cummulativeImpatience = 0;
             
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/TextInputStatisticsRule.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/TextInputStatisticsRule.java	(revision 1960)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/TextInputStatisticsRule.java	(revision 2042)
@@ -107,35 +107,34 @@
             int noOfUsagesOfTextField1 = statistics.getUsageCount(entry.textField1);
             int noOfUsagesOfTextField2 = statistics.getUsageCount(entry.textField2);
-            int noOfUsagesOfTextField1WithSameTextInTextField2 = entry.enteredTexts.size();
-            
-            int ratioTextField1 = 
-                1000 * noOfUsagesOfTextField1WithSameTextInTextField2 / noOfUsagesOfTextField1;
-            
-            int ratioTextField2 =
-                1000 * noOfUsagesOfTextField1WithSameTextInTextField2 / noOfUsagesOfTextField2;
-
-            createTextFieldEntryRepetitionSmell(ratioTextField1, entry.textField1,
-                                                 entry.textField2, results);
-            
-            createTextFieldEntryRepetitionSmell(ratioTextField2, entry.textField2,
-                                                 entry.textField1, results);
-            
-        }
-    }
-
-    /**
-     *
-     */
-    private void createTextFieldEntryRepetitionSmell(int                       ratioOfEqualEntries,
-                                                      ITextField                textField1,
-                                                      ITextField                textField2,
-                                                      UsabilityEvaluationResult results)
-    {
+            int numberOfEqualEntries = entry.enteredTexts.size();
+            
+            createTextFieldEntryRepetitionSmell(noOfUsagesOfTextField1, numberOfEqualEntries,
+                                                entry.textField1, entry.textField2, results);
+            
+            createTextFieldEntryRepetitionSmell(noOfUsagesOfTextField2, numberOfEqualEntries,
+                                                entry.textField2, entry.textField1, results);
+            
+        }
+    }
+
+    /**
+     *
+     */
+    private void createTextFieldEntryRepetitionSmell(int                       allEntries,
+                                                     int                       numberOfEqualEntries,
+                                                     ITextField                textField1,
+                                                     ITextField                textField2,
+                                                     UsabilityEvaluationResult results)
+    {
+        int ratio = 1000 * numberOfEqualEntries / allEntries;
+        
         UsabilitySmellIntensity severity =
-            UsabilitySmellIntensity.getIntensity(ratioOfEqualEntries);
+            UsabilitySmellIntensity.getIntensity(ratio, allEntries, -1);
         
         if (severity != null) {
             Map<String, Object> parameters = new HashMap<String, Object>();
-            parameters.put("textRepetitionRatio", (ratioOfEqualEntries / 10));
+            parameters.put("numberOfEqualEntries", numberOfEqualEntries);
+            parameters.put("numberOfAllEntries", allEntries);
+            parameters.put("textRepetitionRatio", (ratio / 10));
             parameters.put("textField1", textField1);
             parameters.put("textField2", textField2);
@@ -169,5 +168,6 @@
             int ratio = 1000 * noLetterOrDigitCount / allCharactersCount;
 
-            UsabilitySmellIntensity severity = UsabilitySmellIntensity.getIntensity(ratio);
+            UsabilitySmellIntensity severity = UsabilitySmellIntensity.getIntensity
+                (ratio, statistics.getAllInputsInto(textField).size(), -1);
 
             if (severity != null) {
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UnusedGUIElementsRule.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UnusedGUIElementsRule.java	(revision 1960)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UnusedGUIElementsRule.java	(revision 2042)
@@ -15,4 +15,5 @@
 package de.ugoe.cs.autoquest.usability;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -28,8 +29,10 @@
 import de.ugoe.cs.autoquest.eventcore.guimodel.IComboBox;
 import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
+import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIView;
 import de.ugoe.cs.autoquest.eventcore.guimodel.IListBox;
 import de.ugoe.cs.autoquest.eventcore.guimodel.IMenuButton;
 import de.ugoe.cs.autoquest.eventcore.guimodel.ITextArea;
 import de.ugoe.cs.autoquest.eventcore.guimodel.ITextField;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.DefaultTaskInstanceTraversingVisitor;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTaskInstance;
@@ -37,4 +40,5 @@
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession;
 
 /**
@@ -54,10 +58,14 @@
     public UsabilityEvaluationResult evaluate(ITaskModel taskModel) {
         UsabilityEvaluationResult results = new UsabilityEvaluationResult(taskModel);
-
-        GUIModel guiModel = getGUIModel(taskModel);
-        Set<IGUIElement> allGUIElements = getAllGUIElements(guiModel);
-        Set<IGUIElement> usedGUIElements = getUsedGUIElements(taskModel);
-        List<IGUIElement> unusedGUIElements = getUnusedGUIElements(usedGUIElements, allGUIElements);
-        handleUnusedGUIElements(unusedGUIElements, allGUIElements, results);
+        
+        Map<IGUIView, List<Set<IGUIElement>>> viewDisplays =
+            getViewDisplays(taskModel.getUserSessions());
+        
+        Map<IGUIView, Set<IGUIElement>> allGUIElements = getAllGUIElements(taskModel);
+        
+        for (Map.Entry<IGUIView, List<Set<IGUIElement>>> viewDisplay : viewDisplays.entrySet()) {
+            handleUnusedGUIElements
+                (allGUIElements, viewDisplay.getKey(), viewDisplay.getValue(), results);
+        }
 
         return results;
@@ -65,41 +73,73 @@
 
     /**
-     * <p>
-     * TODO: comment
-     * </p>
+     * @param results 
      *
-     * @param unusedGUIElements
-     * @param results
-     */
-    private void handleUnusedGUIElements(List<IGUIElement>         unusedGUIElements,
-                                         Set<IGUIElement>          allGUIElements,
-                                         UsabilityEvaluationResult results)
+     */
+    private void handleUnusedGUIElements(Map<IGUIView, Set<IGUIElement>> usedGUIElements,
+                                         IGUIView                        view,
+                                         List<Set<IGUIElement>>          viewUsages,
+                                         UsabilityEvaluationResult       results)
     {
-        int ratio = 1000 * unusedGUIElements.size() / allGUIElements.size();
-        
-        UsabilitySmellIntensity severity = UsabilitySmellIntensity.getIntensity(ratio);
-
-        if (severity != null) {
-            Map<String, Object> parameters = new HashMap<String, Object>();
-
-            parameters.put("ratio", ratio / 10);
-            parameters.put("noOfUnused", unusedGUIElements.size());
-            parameters.put("noOfAll", allGUIElements.size());
-            parameters.put("unusedGuiElements", unusedGUIElements);
-            
-            results.addSmell
-                (severity, UsabilitySmellDescription.UNUSED_GUI_ELEMENTS, parameters);
-        }
-     }
-
-    /**
-     * <p>
-     * TODO: comment
-     * </p>
+        Set<IGUIElement> allElementsInView = usedGUIElements.get(view);
+        
+        if (allElementsInView == null) {
+            return;
+        }
+        
+        Map<Integer, List<IGUIElement>> usageCounters = new HashMap<>();
+        
+        for (IGUIElement relevantElement : allElementsInView) {
+            int usageCounter = 0;
+            
+            for (Set<IGUIElement> viewUsage : viewUsages) {
+                if (viewUsage.contains(relevantElement)) {
+                    usageCounter++;
+                }
+            }
+            
+            List<IGUIElement> elementsWithSameUsage = usageCounters.get(usageCounter);
+            
+            if (elementsWithSameUsage == null) {
+                elementsWithSameUsage = new LinkedList<>();
+                usageCounters.put(usageCounter, elementsWithSameUsage);
+            }
+            
+            elementsWithSameUsage.add(relevantElement);
+        }
+        
+        int cumulativeGuiElementUsage = 0;
+        for (Set<IGUIElement> viewUsage : viewUsages) {
+            cumulativeGuiElementUsage += viewUsage.size();
+        }
+        
+        List<IGUIElement> unusedElements = usageCounters.get(0);
+        
+        if (unusedElements != null) {
+            int ratio = 1000 * unusedElements.size() / allElementsInView.size();
+
+            UsabilitySmellIntensity severity = UsabilitySmellIntensity.getIntensity
+                (ratio, cumulativeGuiElementUsage, -1);
+
+            if (severity != null) {
+                Map<String, Object> parameters = new HashMap<String, Object>();
+
+                parameters.put("ratio", ratio / 10);
+                parameters.put("allDisplays", viewUsages.size());
+                parameters.put("view", view);
+                parameters.put("unusedGuiElements", unusedElements);
+                parameters.put("allGuiElements", allElementsInView.size());
+
+                results.addSmell
+                    (severity, UsabilitySmellDescription.UNUSED_GUI_ELEMENTS, parameters);
+            }
+        }
+    }
+
+    /**
      *
-     * @param taskModel
-     * @return
-     */
-    private GUIModel getGUIModel(ITaskModel taskModel) {
+     */
+    private Map<IGUIView, Set<IGUIElement>> getAllGUIElements(ITaskModel taskModel) {
+        Map<IGUIView, Set<IGUIElement>> result = new HashMap<>();
+        
         for (ITask task : taskModel.getTasks()) {
             if (task instanceof IEventTask) {
@@ -107,6 +147,17 @@
                     Event event = ((IEventTaskInstance) instance).getEvent();
                     
-                    if (event.getTarget() instanceof IGUIElement) {
-                        return ((IGUIElement) event.getTarget()).getGUIModel();
+                    if ((event.getTarget() instanceof IGUIElement) &&
+                        (isRelevant((IGUIElement) event.getTarget())))
+                    {
+                        IGUIView view = ((IGUIElement) event.getTarget()).getView();
+                        
+                        Set<IGUIElement> elements = result.get(view);
+                        
+                        if (elements == null) {
+                            elements = new HashSet<>();
+                            result.put(view, elements);
+                        }
+                        
+                        elements.add((IGUIElement) event.getTarget());
                     }
                 }
@@ -114,135 +165,129 @@
         }
         
-        return null;
-    }
-
-    /**
-     * <p>
-     * TODO: comment
-     * </p>
-     *
-     * @param taskModel
-     */
-    private Set<IGUIElement> getUsedGUIElements(ITaskModel taskModel) {
-        Set<IGUIElement> usedGUIElements = new HashSet<IGUIElement>();
-        
-        for (ITask task : taskModel.getTasks()) {
-            if (task instanceof IEventTask) {
-                for (ITaskInstance instance : task.getInstances()) {
-                    Event event = ((IEventTaskInstance) instance).getEvent();
-                    
-                    if (event.getTarget() instanceof IGUIElement) {
-                        usedGUIElements.add((IGUIElement) event.getTarget());
+        // the problem is, that using the GUI model does not allow to find all in a specific view
+        // as the GUI model may return a merged element instead. But anyway, we can add those, which
+        // are in the GUI model and have the same view.
+        
+        GUIModel model = result.values().iterator().next().iterator().next().getGUIModel();
+        
+        GUIModel.Traverser traverser = model.getTraverser();
+
+        IGUIElement currentGUIElement = null;
+        do {
+            if (traverser.hasFirstChild()) {
+                currentGUIElement = traverser.firstChild();
+            }
+            else if (traverser.hasNextSibling()) {
+                currentGUIElement = traverser.nextSibling();
+            }
+            else {
+                while (currentGUIElement != null) {
+                    currentGUIElement = traverser.parent();
+                    if (traverser.hasNextSibling()) {
+                        currentGUIElement = traverser.nextSibling();
+                        break;
                     }
                 }
             }
-        }
-        
-        return usedGUIElements;
-    }
-    
-    /**
-     * <p>
-     * TODO: comment
-     * </p>
-     *
-     * @param taskModel
-     */
-    private Set<IGUIElement> getAllGUIElements(GUIModel guiModel) {
-        Set<IGUIElement> allGUIElements = new HashSet<IGUIElement>();
-        
-        if (guiModel != null) {
-            GUIModel.Traverser traverser = guiModel.getTraverser();
-
-            IGUIElement currentGUIElement = null;
-            do {
-                if (traverser.hasFirstChild()) {
-                    currentGUIElement = traverser.firstChild();
-                }
-                else if (traverser.hasNextSibling()) {
-                    currentGUIElement = traverser.nextSibling();
-                }
-                else {
-                    while (currentGUIElement != null) {
-                        currentGUIElement = traverser.parent();
-                        if (traverser.hasNextSibling()) {
-                            currentGUIElement = traverser.nextSibling();
-                            break;
+
+            if (isRelevant(currentGUIElement)) {
+                IGUIView view = currentGUIElement.getView();
+                
+                Set<IGUIElement> elements = result.get(view);
+                
+                if (elements == null) {
+                    elements = new HashSet<>();
+                    result.put(view, elements);
+                }
+                
+                elements.add(currentGUIElement);
+            }
+        }
+        while (currentGUIElement != null);
+        
+        return result;
+    }
+
+    /**
+     * 
+     */
+    private Map<IGUIView, List<Set<IGUIElement>>> getViewDisplays(List<IUserSession> sessions) {
+        final IGUIView[] currentView = new IGUIView[1];
+        final List<IEventTaskInstance> actionInstances = new ArrayList<>();
+        final Map<IGUIView, List<Set<IGUIElement>>> result = new HashMap<>();
+        
+        for (IUserSession session : sessions) {
+            currentView[0] = null;
+            actionInstances.clear();
+            
+            for (final ITaskInstance currentRoot : session) {
+                currentRoot.accept(new DefaultTaskInstanceTraversingVisitor() {
+                    @Override
+                    public void visit(IEventTaskInstance eventTaskInstance) {
+                        if (eventTaskInstance.getEvent().getTarget() instanceof IGUIElement) {
+                            IGUIView view =
+                                ((IGUIElement) eventTaskInstance.getEvent().getTarget()).getView();
+                            
+                            if ((currentView[0] == null) && (view != null)) {
+                                currentView[0] = view;
+                                actionInstances.clear();
+                            }
+                            else if ((currentView[0] != null) && (!currentView[0].equals(view))) {
+                                addRelevantTargets(currentView[0], actionInstances, result);
+                                
+                                currentView[0] = view;
+                                actionInstances.clear();
+                            }
+                        }
+                        
+                        if (eventTaskInstance.getEvent().getTarget() instanceof IGUIElement) {
+                            actionInstances.add(eventTaskInstance);
                         }
                     }
-                }
-
-                if (isRelevant(currentGUIElement)) {
-                    allGUIElements.add(currentGUIElement);
-                }
-            }
-            while (currentGUIElement != null);
-        }
-        
-        return allGUIElements;
-    }
-    
-    /**
-     * <p>
-     * TODO: comment
-     * </p>
+                });
+            }
+            
+            // add the used GUI elements of the last shown view in the session
+            if (currentView[0] != null) {
+                addRelevantTargets(currentView[0], actionInstances, result);
+            }
+        }
+        
+        return result;
+    }
+
+    /**
      *
-     * @param taskModel
-     */
-    private List<IGUIElement> getUnusedGUIElements(Set<IGUIElement> usedGUIElements,
-                                                   Set<IGUIElement> allGUIElements)
+     */
+    private void addRelevantTargets(IGUIView                              view,
+                                    List<IEventTaskInstance>              actionInstances,
+                                    Map<IGUIView, List<Set<IGUIElement>>> result)
     {
-        List<IGUIElement> unusedGUIElements = new LinkedList<IGUIElement>();
-        for (IGUIElement currentGUIElement : allGUIElements) {
-            if (isRelevant(currentGUIElement) &&
-                !belongsToUsedGUIElements(currentGUIElement, usedGUIElements))
-            {
-                unusedGUIElements.add(currentGUIElement);
-            }
-        }
-        
-        return unusedGUIElements;
-    }
-
-    /**
-     * <p>
-     * TODO: comment
-     * </p>
+        List<Set<IGUIElement>> usedGUIElements = result.get(view);
+        
+        if (usedGUIElements == null) {
+            usedGUIElements = new LinkedList<>();
+            result.put(view, usedGUIElements);
+        }
+        
+        Set<IGUIElement> elementsInViewDisplay = new HashSet<>();
+        
+        for (IEventTaskInstance actionInstance : actionInstances) {
+            IGUIElement element = (IGUIElement) actionInstance.getEvent().getTarget();
+            
+            while (element != null) {
+                if (isRelevant(element)) {
+                    elementsInViewDisplay.add(element);
+                }
+                
+                element = element.getParent();
+            }
+        }
+        
+        usedGUIElements.add(elementsInViewDisplay);
+    }
+
+    /**
      *
-     * @param currentGUIElement
-     * @param usedGUIElements
-     * @return
-     */
-    private boolean belongsToUsedGUIElements(IGUIElement      relevantGUIElement,
-                                             Set<IGUIElement> usedGUIElements)
-    {
-        if (usedGUIElements.contains(relevantGUIElement)) {
-            return true;
-        }
-        else {
-            // in some cases, the events are recorded for the children of the relevant GUI elements
-            // therefore, check the children, as well.
-            List<IGUIElement> children =
-                relevantGUIElement.getGUIModel().getChildren(relevantGUIElement);
-            
-            if (children != null) {
-                for (IGUIElement child : children) {
-                    if (belongsToUsedGUIElements(child, usedGUIElements)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        
-        return false;
-    }
-
-    /**
-     * <p>
-     * TODO: comment
-     * </p>
-     *
-     * @param currentGUIElement
-     * @return
      */
     private boolean isRelevant(IGUIElement currentGUIElement) {
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationManager.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationManager.java	(revision 1960)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationManager.java	(revision 2042)
@@ -16,5 +16,9 @@
 
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
 import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
 import java.util.logging.Level;
 
@@ -48,17 +52,19 @@
      */
     private void init() {
-        rules.add(new TaskTreeTestRule());
-//        rules.add(new TextInputStatisticsRule());
-//        rules.add(new MissingFeedbackRule());
-//        rules.add(new EventCoverageRatioRule());
-//        rules.add(new TargetDistanceRule());
-//        rules.add(new RequiredInefficientActionsRule());
-//        rules.add(new DataEntryMethodChangeRule());
+//        rules.add(new TaskTreeTestRule());
+        
+        rules.add(new EventCoverageRatioRule());
+        rules.add(new RequiredInefficientActionsRule());
+        rules.add(new TargetDistanceRule());
+        rules.add(new MissingFeedbackRule());
+        rules.add(new DataEntryMethodChangeRule());
+        rules.add(new CommonTaskRateRule());
+        rules.add(new TextInputStatisticsRule());
+        rules.add(new CheckBoxMultipleSelectionRule());
+        rules.add(new MisleadingClickCueRule());
+        rules.add(new DefaultCursorPositioningRule());
         rules.add(new DefaultValueRule());
-//        rules.add(new CheckBoxMultipleSelectionRule());
-//        rules.add(new CommonTaskRateRule());
-//        rules.add(new MisleadingClickCueRule());
-//        rules.add(new DefaultCursorPositioningRule());
-//        rules.add(new UnusedGUIElementsRule());
+        rules.add(new UnusedGUIElementsRule());
+        
 //        rules.add(new TaskCooccurrenceRule());
     }
@@ -67,5 +73,5 @@
      *
      */
-    public UsabilityEvaluationResult evaluateUsability(ITaskModel taskModel) {
+    public UsabilityEvaluationResult evaluateUsability(ITaskModel taskModel, int maxCount) {
         Console.traceln(Level.INFO, "evaluating usability of task model " + taskModel);
 
@@ -73,32 +79,64 @@
 
         for (UsabilityEvaluationRule rule : rules) {
-            Console.traceln(Level.INFO, "applying rule " + rule.getClass().getSimpleName());
+            Console.traceln(Level.INFO, "\napplying rule " + rule.getClass().getSimpleName());
             UsabilityEvaluationResult result = rule.evaluate(taskModel);
-            interimResults.add(result);
-            Console.traceln(Level.INFO, "the rule found " + result.getAllSmells().size() +
-                            " usability smells.");
-            
-            List<ITask> referredTasks = new ArrayList<ITask>();
-
+
+            Map<String, List<UsabilitySmell>> smellGroups = new HashMap<>();
+            
             for (UsabilitySmell smell : result.getAllSmells()) {
-                if (smell.getSmellingTask() != null) {
-                    referredTasks.add(smell.getSmellingTask());
-                }
-            }
-                
-            int counter = 0;
-            for (int i = 0; i < referredTasks.size(); i++) {
-                for (int j = 0; j < referredTasks.size(); j++) {
-                    if (isChildOf(referredTasks.get(i), referredTasks.get(j))) {
-                        counter++;
-                        break;
+                List<UsabilitySmell> smellGroup = smellGroups.get(smell.getBriefDescription());
+                
+                if (smellGroup == null) {
+                    smellGroup = new LinkedList<>();
+                    smellGroups.put(smell.getBriefDescription(), smellGroup);
+                }
+                
+                smellGroup.add(smell);
+            }
+            
+            for (Map.Entry<String, List<UsabilitySmell>> smellGroup : smellGroups.entrySet()) {
+                Console.traceln(Level.INFO, "the rule found " + smellGroup.getValue().size() +
+                                " usability smells of type \"" + smellGroup.getKey() + "\"");
+                
+                result = new UsabilityEvaluationResult(taskModel, smellGroup.getValue());
+                
+                checkDuplicates(result);
+                
+                if (maxCount < result.getAllSmells().size()) {
+                    Console.traceln(Level.INFO, "filtering for " + maxCount +
+                                    " smells of same type with highest event coverage.");
+                
+                    LinkedList<UsabilitySmell> sortedSmells = new LinkedList<>();
+                    
+                    for (UsabilitySmell smell : result.getAllSmells()) {
+                        ListIterator<UsabilitySmell> iterator = sortedSmells.listIterator();
+
+                        boolean added = false;
+                        
+                        while (iterator.hasNext()) {
+                            if (iterator.next().getIntensity().getEventCoverage() <
+                                    smell.getIntensity().getEventCoverage())
+                            {
+                                iterator.previous();
+                                iterator.add(smell);
+                                added = true;
+                                break;
+                            }
+                        }
+                    
+                        if (!added) {
+                            sortedSmells.add(smell);
+                        }
+                    
+                        while (sortedSmells.size() > maxCount) {
+                            sortedSmells.removeLast();
+                        }
                     }
-                }
-            }
-                
-            if (counter > 0) {
-                Console.traceln(Level.INFO, counter + " of the findings are duplicates in " +
-                                "that they refer to tasks whose parent tasks are also " +
-                                "referred by the findings");
+                
+                    result = new UsabilityEvaluationResult(taskModel, sortedSmells);
+                    checkDuplicates(result);
+                }
+            
+                interimResults.add(result);
             }
         }
@@ -112,11 +150,34 @@
 
     /**
-     * <p>
-     * TODO: comment
-     * </p>
      *
-     * @param iTask
-     * @param iTask2
-     * @return
+     */
+    private void checkDuplicates(UsabilityEvaluationResult result) {
+        List<ITask> referredTasks = new ArrayList<ITask>();
+
+        for (UsabilitySmell smell : result.getAllSmells()) {
+            if (smell.getSmellingTask() != null) {
+                referredTasks.add(smell.getSmellingTask());
+            }
+        }
+            
+        int counter = 0;
+        for (int i = 0; i < referredTasks.size(); i++) {
+            for (int j = 0; j < referredTasks.size(); j++) {
+                if (isChildOf(referredTasks.get(i), referredTasks.get(j))) {
+                    counter++;
+                    break;
+                }
+            }
+        }
+            
+        if (counter > 0) {
+            Console.traceln(Level.INFO, counter + " of the findings are duplicates in " +
+                            "that they refer to tasks whose parent tasks are also " +
+                            "referred by the findings");
+        }
+    }
+
+    /**
+     *
      */
     private boolean isChildOf(final ITask potChild, ITask potParent) {
Index: trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationResult.java
===================================================================
--- trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationResult.java	(revision 1960)
+++ trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationResult.java	(revision 2042)
@@ -16,4 +16,5 @@
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -41,4 +42,16 @@
     public UsabilityEvaluationResult(ITaskModel taskModel) {
         this.taskModel = taskModel;
+    }
+
+    /**
+     *
+     */
+    public UsabilityEvaluationResult(ITaskModel                 taskModel,
+                                     Collection<UsabilitySmell> smells)
+    {
+        this.taskModel = taskModel;
+        for (UsabilitySmell smell : smells) {
+            this.smells.add(smell);
+        }
     }
 
