Index: trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/RequiredInefficientActionsRuleTest.java
===================================================================
--- trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/RequiredInefficientActionsRuleTest.java	(revision 1493)
+++ trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/RequiredInefficientActionsRuleTest.java	(revision 1493)
@@ -0,0 +1,536 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability;
+
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectDescription.INEFFICIENT_ACTIONS;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.HIGH;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.INFO;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.LOW;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.MEDIUM;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.usability.UsabilityDefect;
+
+/**
+ *
+ */
+public class RequiredInefficientActionsRuleTest extends AbstractUsabilityEvaluationTC {
+
+    /**
+     *
+     */
+    @Before
+    public void setUp() {
+        UsabilityDefectSeverity.defaultCoverageQuantile = 0;
+    }
+    
+    /**
+     *
+     */
+    @Test
+    public void testWithNormalScroll_01() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Scroll body {}" +
+            "  Interaction elem1 {}" +
+            "}";
+        
+        // no defect expected, as interactions do not form tasks
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[] {  };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testWithNormalScroll_02() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Scroll body {}" +
+            "  Interaction elem1 {}" +
+            "  Scroll body {}" +
+            "  Interaction elem1 {}" +
+            "}";
+        
+        // no defect expected, as interactions do not form tasks
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[] { };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testWithNormalScroll_03() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence {" +
+            "    Scroll body {}" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(HIGH, INEFFICIENT_ACTIONS) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testWithNormalScroll_04() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence {" +
+            "    Interaction elem1 {}" +
+            "    Scroll body {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(HIGH, INEFFICIENT_ACTIONS) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testWithNormalScroll_05() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Scroll body {}" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Scroll body {}" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(HIGH, INEFFICIENT_ACTIONS) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testWithNormalScroll_06() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Scroll body {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Scroll body {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(HIGH, INEFFICIENT_ACTIONS) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testScrollSeldomRequired_01() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Interaction elem1 {}" +
+            "    Interaction elem1 {}" +
+            "    Scroll body {}" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(LOW, INEFFICIENT_ACTIONS) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testScrollSeldomRequired_02() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 { }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 {" +
+            "      Scroll body {}" +
+            "    }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 {" +
+            "      Scroll body {}" +
+            "    }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(MEDIUM, INEFFICIENT_ACTIONS) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testScrollSeldomRequired_03() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 { }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 {" +
+            "      Scroll body {}" +
+            "    }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 {" +
+            "      Scroll body {}" +
+            "    }" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(MEDIUM, INEFFICIENT_ACTIONS) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testScrollSeldomRequired_04() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 { }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 {}" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 {" +
+            "      Scroll body {}" +
+            "    }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 {" +
+            "      Scroll body {}" +
+            "    }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+           { new UsabilityDefect(LOW, INEFFICIENT_ACTIONS) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testScrollSeldomRequired_05() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 { }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 {" +
+            "      Scroll body {}" +
+            "    }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 {" +
+            "      Scroll body {}" +
+            "    }" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+           { new UsabilityDefect(LOW, INEFFICIENT_ACTIONS) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testScrollSeldomRequired_06() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 { }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 { }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 { }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 {" +
+            "      Scroll body {}" +
+            "    }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(INFO, INEFFICIENT_ACTIONS) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testScrollSeldomRequired_07() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 { }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 { }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 { }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 {" +
+            "      Scroll body {}" +
+            "    }" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(INFO, INEFFICIENT_ACTIONS) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testScrollSeldomRequired_08() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 { }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 { }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 { }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 {" +
+            "      Scroll body {}" +
+            "    }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 { }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 { }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 { }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Optional opt1 { }" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[] { };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testScrollSeldomRequired_09() {
+        RequiredInefficientActionsRule rule = new RequiredInefficientActionsRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 { }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 { }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 { }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 {" +
+            "      Scroll body {}" +
+            "    }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 { }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 { }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 { }" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Optional opt1 { }" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[] { };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+}
Index: trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/RequiredScrollRuleTest.java
===================================================================
--- trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/RequiredScrollRuleTest.java	(revision 1427)
+++ 	(revision )
@@ -1,313 +1,0 @@
-//   Copyright 2012 Georg-August-Universität Göttingen, Germany
-//
-//   Licensed under the Apache License, Version 2.0 (the "License");
-//   you may not use this file except in compliance with the License.
-//   You may obtain a copy of the License at
-//
-//       http://www.apache.org/licenses/LICENSE-2.0
-//
-//   Unless required by applicable law or agreed to in writing, software
-//   distributed under the License is distributed on an "AS IS" BASIS,
-//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//   See the License for the specific language governing permissions and
-//   limitations under the License.
-
-package de.ugoe.cs.autoquest.usability;
-
-import static de.ugoe.cs.autoquest.usability.UsabilityDefectDescription.SCROLL_REQUIRED;
-import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.HIGH;
-import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.INFO;
-import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.LOW;
-import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.MEDIUM;
-
-import org.junit.Test;
-
-import de.ugoe.cs.autoquest.usability.UsabilityDefect;
-
-/**
- *
- */
-public class RequiredScrollRuleTest extends AbstractUsabilityEvaluationTC {
-
-    /**
-     *
-     */
-    @Test
-    public void testWithNormalScroll_01() {
-        RequiredScrollRule rule = new RequiredScrollRule();
-
-        // ===== check =====
-        String spec =
-            "UserSession {" +
-            "  Scroll body {}" +
-            "  Interaction elem1 {}" +
-            "}";
-        
-        // no defect expected, as interactions do not form tasks
-        UsabilityDefect[] expectedDefects = new UsabilityDefect[] {  };
-
-        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
-
-    }
-
-    /**
-     *
-     */
-    @Test
-    public void testWithNormalScroll_02() {
-        RequiredScrollRule rule = new RequiredScrollRule();
-
-        // ===== check =====
-        String spec =
-            "UserSession {" +
-            "  Scroll body {}" +
-            "  Interaction elem1 {}" +
-            "  Scroll body {}" +
-            "  Interaction elem1 {}" +
-            "}";
-        
-        // no defect expected, as interactions do not form tasks
-        UsabilityDefect[] expectedDefects = new UsabilityDefect[] { };
-
-        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
-
-    }
-
-    /**
-     *
-     */
-    @Test
-    public void testWithNormalScroll_03() {
-        RequiredScrollRule rule = new RequiredScrollRule();
-
-        // ===== check =====
-        String spec =
-            "UserSession {" +
-            "  Sequence {" +
-            "    Scroll body {}" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "}";
-        
-        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
-            { new UsabilityDefect(HIGH, SCROLL_REQUIRED) };
-
-        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
-
-    }
-
-    /**
-     *
-     */
-    @Test
-    public void testWithNormalScroll_04() {
-        RequiredScrollRule rule = new RequiredScrollRule();
-
-        // ===== check =====
-        String spec =
-            "UserSession {" +
-            "  Sequence seq1 {" +
-            "    Scroll body {}" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Scroll body {}" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "}";
-        
-        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
-            { new UsabilityDefect(HIGH, SCROLL_REQUIRED) };
-
-        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
-
-    }
-
-    /**
-     *
-     */
-    @Test
-    public void testOnlySeldomPreceededByScroll_01() {
-        RequiredScrollRule rule = new RequiredScrollRule();
-
-        // ===== check =====
-        String spec =
-            "UserSession {" +
-            "  Sequence seq1 {" +
-            "    Interaction elem1 {}" +
-            "    Interaction elem1 {}" +
-            "    Interaction elem1 {}" +
-            "    Scroll body {}" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "}";
-        
-        UsabilityDefect[] expectedDefects = new UsabilityDefect[] { };
-
-        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
-
-    }
-
-    /**
-     *
-     */
-    @Test
-    public void testOnlySeldomPreceededByScroll_02() {
-        RequiredScrollRule rule = new RequiredScrollRule();
-
-        // ===== check =====
-        String spec =
-            "UserSession {" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 { }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 {" +
-            "      Scroll body {}" +
-            "    }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 {" +
-            "      Scroll body {}" +
-            "    }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "}";
-        
-        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
-            { new UsabilityDefect(MEDIUM, SCROLL_REQUIRED) };
-
-        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
-
-    }
-
-    /**
-     *
-     */
-    @Test
-    public void testOnlySeldomPreceededByScroll_03() {
-        RequiredScrollRule rule = new RequiredScrollRule();
-
-        // ===== check =====
-        String spec =
-            "UserSession {" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 { }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 {}" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 {" +
-            "      Scroll body {}" +
-            "    }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 {" +
-            "      Scroll body {}" +
-            "    }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "}";
-        
-        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
-           { new UsabilityDefect(LOW, SCROLL_REQUIRED) };
-
-        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
-
-    }
-
-    /**
-     *
-     */
-    @Test
-    public void testOnlySeldomPreceededByScroll_04() {
-        RequiredScrollRule rule = new RequiredScrollRule();
-
-        // ===== check =====
-        String spec =
-            "UserSession {" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 { }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 { }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 { }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 {" +
-            "      Scroll body {}" +
-            "    }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "}";
-        
-        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
-            { new UsabilityDefect(INFO, SCROLL_REQUIRED) };
-
-        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
-
-    }
-
-    /**
-     *
-     */
-    @Test
-    public void testOnlySeldomPreceededByScroll_05() {
-        RequiredScrollRule rule = new RequiredScrollRule();
-
-        // ===== check =====
-        String spec =
-            "UserSession {" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 { }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 { }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 { }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 {" +
-            "      Scroll body {}" +
-            "    }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 { }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 { }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 { }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "  Sequence seq1 {" +
-            "    Optional opt1 { }" +
-            "    Interaction elem1 {}" +
-            "  }" +
-            "}";
-        
-        UsabilityDefect[] expectedDefects = new UsabilityDefect[] { };
-
-        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
-
-    }
-}
Index: trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/TaskCooccurrenceRuleTest.java
===================================================================
--- trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/TaskCooccurrenceRuleTest.java	(revision 1493)
+++ trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/TaskCooccurrenceRuleTest.java	(revision 1493)
@@ -0,0 +1,494 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability;
+
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectDescription.COOCCURENCE_PRECED;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectDescription.COOCCURENCE_SUCCEED;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.HIGH;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.INFO;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.LOW;
+import static de.ugoe.cs.autoquest.usability.UsabilityDefectSeverity.MEDIUM;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.usability.UsabilityDefect;
+
+/**
+ *
+ */
+public class TaskCooccurrenceRuleTest extends AbstractUsabilityEvaluationTC {
+
+    /**
+     *
+     */
+    @Before
+    public void setUp() {
+        UsabilityDefectSeverity.defaultCoverageQuantile = 0;
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testCooccurrence_01() {
+        TaskCooccurrenceRule rule = new TaskCooccurrenceRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Interaction elem1 {}" +
+            "  Interaction elem2 {}" +
+            "}";
+        
+        // no defect expected, as interactions do not form tasks
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[] {  };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testCooccurrence_02() {
+        TaskCooccurrenceRule rule = new TaskCooccurrenceRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Interaction elem1 {}" +
+            "  Interaction elem2 {}" +
+            "  Interaction elem1 {}" +
+            "  Interaction elem2 {}" +
+            "}";
+        
+        // no defect expected, as interactions do not form tasks
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[] { };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testCooccurrence_03() {
+        TaskCooccurrenceRule rule = new TaskCooccurrenceRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence {" +
+            "    Interaction elem1 {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED),
+              new UsabilityDefect(HIGH, COOCCURENCE_PRECED) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testCooccurrence_04() {
+        TaskCooccurrenceRule rule = new TaskCooccurrenceRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED),
+              new UsabilityDefect(HIGH, COOCCURENCE_PRECED) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testSeldomCooccurrence_01() {
+        TaskCooccurrenceRule rule = new TaskCooccurrenceRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction elem1 {}" +
+            "    Interaction elem2 {}" +
+            "    Interaction elem3 {}" +
+            "    Interaction elem4 {}" +
+            "    Interaction elem5 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED),
+              new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED),
+              new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED),
+              new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED),
+              new UsabilityDefect(HIGH, COOCCURENCE_PRECED),
+              new UsabilityDefect(HIGH, COOCCURENCE_PRECED),
+              new UsabilityDefect(HIGH, COOCCURENCE_PRECED),
+              new UsabilityDefect(HIGH, COOCCURENCE_PRECED) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testSeldomCooccurrence_02() {
+        TaskCooccurrenceRule rule = new TaskCooccurrenceRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction other {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq2 {" +
+            "    Interaction elem1 {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq2 {" +
+            "    Interaction elem1 {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED),
+              new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED),
+              new UsabilityDefect(LOW, COOCCURENCE_PRECED),
+              new UsabilityDefect(INFO, COOCCURENCE_PRECED) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testSeldomCooccurrence_03() {
+        TaskCooccurrenceRule rule = new TaskCooccurrenceRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction other {}" +
+            "  }" +
+            "  Sequence seq2 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq2 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(HIGH, COOCCURENCE_PRECED),
+              new UsabilityDefect(HIGH, COOCCURENCE_PRECED),
+              new UsabilityDefect(LOW, COOCCURENCE_SUCCEED),
+              new UsabilityDefect(INFO, COOCCURENCE_SUCCEED) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testSeldomCooccurrence_04() {
+        TaskCooccurrenceRule rule = new TaskCooccurrenceRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction other {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction other {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq2 {" +
+            "    Interaction elem1 {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq2 {" +
+            "    Interaction elem1 {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+           { new UsabilityDefect(LOW, COOCCURENCE_PRECED),
+             new UsabilityDefect(LOW, COOCCURENCE_PRECED),
+             new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED),
+             new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testSeldomCooccurrence_05() {
+        TaskCooccurrenceRule rule = new TaskCooccurrenceRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction other {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction other {}" +
+            "  }" +
+            "  Sequence seq2 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq2 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+           { new UsabilityDefect(HIGH, COOCCURENCE_PRECED),
+             new UsabilityDefect(HIGH, COOCCURENCE_PRECED),
+             new UsabilityDefect(LOW, COOCCURENCE_SUCCEED),
+             new UsabilityDefect(LOW, COOCCURENCE_SUCCEED) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testSeldomCooccurrence_06() {
+        TaskCooccurrenceRule rule = new TaskCooccurrenceRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction other {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction other {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction other {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq2 {" +
+            "    Interaction elem1 {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(MEDIUM, COOCCURENCE_PRECED),
+              new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED),
+              new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testSeldomCooccurrence_07() {
+        TaskCooccurrenceRule rule = new TaskCooccurrenceRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction other {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction other {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction other {}" +
+            "  }" +
+            "  Sequence seq2 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(HIGH, COOCCURENCE_PRECED),
+              new UsabilityDefect(HIGH, COOCCURENCE_PRECED),
+              new UsabilityDefect(MEDIUM, COOCCURENCE_SUCCEED) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testSeldomCooccurrence_08() {
+        TaskCooccurrenceRule rule = new TaskCooccurrenceRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction other {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction other {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction other {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq2 {" +
+            "    Interaction elem1 {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction other {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction other {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction other {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction other {}" +
+            "    Interaction elem2 {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(MEDIUM, COOCCURENCE_PRECED),
+              new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED),
+              new UsabilityDefect(HIGH, COOCCURENCE_SUCCEED) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void testSeldomCooccurrence_09() {
+        TaskCooccurrenceRule rule = new TaskCooccurrenceRule();
+
+        // ===== check =====
+        String spec =
+            "UserSession {" +
+            "  Sequence seq1 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction other {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction other {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction other {}" +
+            "  }" +
+            "  Sequence seq2 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction elem1 {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction other {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction other {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction other {}" +
+            "  }" +
+            "  Sequence seq1 {" +
+            "    Interaction elem2 {}" +
+            "    Interaction other {}" +
+            "  }" +
+            "}";
+        
+        UsabilityDefect[] expectedDefects = new UsabilityDefect[]
+            { new UsabilityDefect(HIGH, COOCCURENCE_PRECED),
+              new UsabilityDefect(HIGH, COOCCURENCE_PRECED),
+              new UsabilityDefect(MEDIUM, COOCCURENCE_SUCCEED) };
+
+        assertUsabilityEvaluationResult(expectedDefects, rule.evaluate(createTaskModel(spec)));
+
+    }
+}
Index: trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/UsabilityDefectDescriptionTest.java
===================================================================
--- trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/UsabilityDefectDescriptionTest.java	(revision 1427)
+++ trunk/autoquest-core-usability-test/src/test/java/de/ugoe/cs/autoquest/usability/UsabilityDefectDescriptionTest.java	(revision 1493)
@@ -19,4 +19,6 @@
 
 import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.Map;
 
@@ -26,13 +28,9 @@
 
 /**
- * TODO comment
- * 
- * @version $Revision: $ $Date: 20.07.2012$
- * @author 2012, last modified by $Author: pharms$
+ * @author Patrick Harms
  */
 public class UsabilityDefectDescriptionTest {
 
     /**
-     * TODO: comment
      * 
      */
@@ -47,11 +45,10 @@
 
     /**
-     * TODO: comment
      * 
      */
     @Test
-    public void testParameterization() {
+    public void testParameterization_01() {
         for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) {
-            Map<String, String> parameters = new HashMap<String, String>();
+            Map<String, Object> parameters = new HashMap<String, Object>();
 
             for (String parameter : description.getDescriptionParameters()) {
@@ -65,3 +62,26 @@
     }
 
+
+    /**
+     * 
+     */
+    @Test
+    public void testParameterization_02() {
+        for (UsabilityDefectDescription description : UsabilityDefectDescription.values()) {
+            Map<String, Object> parameters = new HashMap<String, Object>();
+
+            for (String parameter : description.getDescriptionParameters()) {
+                List<String> values = new LinkedList<String>();
+                values.add("<parameter " + parameter + " value 1>");
+                values.add("<parameter " + parameter + " value 2>");
+                values.add("<parameter " + parameter + " value 3>");
+                parameters.put(parameter, values);
+            }
+
+            assertNotNull(description.toString(parameters));
+            assertNotSame("", description.toString(parameters));
+            System.err.println(description.toString(parameters));
+        }
+    }
+
 }