Index: trunk/autoquest-core-usageprofiles-test/src/test/java/de/ugoe/cs/autoquest/usageprofiles/TrieTest.java
===================================================================
--- trunk/autoquest-core-usageprofiles-test/src/test/java/de/ugoe/cs/autoquest/usageprofiles/TrieTest.java	(revision 1060)
+++ trunk/autoquest-core-usageprofiles-test/src/test/java/de/ugoe/cs/autoquest/usageprofiles/TrieTest.java	(revision 1110)
@@ -247,23 +247,187 @@
 
         @Test
+        public void testGetContextSuffix_5() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                List<String> context = new ArrayList<String>();
+                context.add("a");
+                context.add("a");
+                context.add("b");
+                List<String> expected = new ArrayList<String>();
+                expected.add("a");
+                expected.add("b");
+
+                List<String> result = fixture.getContextSuffix(context);
+
+                ListAssert.assertEquals(expected, result);
+        }
+
+        @Test
         public void testGetSequencesWithMostOccurrences_1() throws Exception {
                 Trie<String> fixture = new Trie<String>();
                 fixture.train(sequence, 3);
                 
+                // get all sequences with a minimal length of one that occur most often
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(1, 0);
+
+                assertEquals(1, result.size());
+                
                 List<String> expected = new ArrayList<String>();
                 expected.add("a");
 
-                Collection<List<String>> result = fixture.getSequencesWithMostOccurrences(1);
+                ListAssert.assertEquals(expected, result.iterator().next());
+        }
+
+        @Test
+        public void testGetSequencesWithMostOccurrences_2() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                
+                // get all sequences with a minimal length of one that occur exactly once
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(1, 1);
+
+                assertEquals(11, result.size());
+                
+                List<String> expected = new ArrayList<String>();
+                expected.add("r");
+                expected.add("a");
+                expected.add("c");
+                // rac
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.clear();
+                expected.add("a");
+                expected.add("c");
+                // ac
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("a");
+                // aca
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.clear();
+                expected.add("c");
+                // c
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("a");
+                // ca
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("d");
+                // cad
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.clear();
+                expected.add("a");
+                expected.add("d");
+                // ad
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("a");
+                // ada
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.clear();
+                expected.add("d");
+                // d
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("a");
+                // da
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("b");
+                // dab
+                ListAssert.assertContains((List<List<String>>) result, expected);
+        }
+
+        @Test
+        public void testGetSequencesWithMostOccurrences_3() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                
+                // get all sequences with a minimal length of one that occur exactly twice
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(1, 2);
+
+                assertEquals(7, result.size());
+                
+                List<String> expected = new ArrayList<String>();
+                expected.add("a");
+                expected.add("b");
+                // ab
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("r");
+                // abr
+                ListAssert.assertContains((List<List<String>>) result, expected);
+
+                expected.clear();
+                expected.add("b");
+                // b
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("r");
+                // br
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("a");
+                // bra
+                ListAssert.assertContains((List<List<String>>) result, expected);
+
+                expected.clear();
+                expected.add("r");
+                // r
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("a");
+                // ra
+                ListAssert.assertContains((List<List<String>>) result, expected);
+        }
+
+        @Test
+        public void testGetSequencesWithMostOccurrences_4() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                
+                // get all sequences with a minimal length of one that occur exactly three times
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(1, 3);
+
+                assertEquals(0, result.size());
+        }
+
+        @Test
+        public void testGetSequencesWithMostOccurrences_5() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                
+                // get all sequences with a minimal length of one that occur exactly four times
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(1, 4);
+
+                assertEquals(0, result.size());
+        }
+
+        @Test
+        public void testGetSequencesWithMostOccurrences_6() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                
+                // get all sequences with a minimal length of one that occur exactly five times
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(1, 5);
 
                 assertEquals(1, result.size());
-                ListAssert.assertEquals(expected, result.iterator().next());
-        }
-
-        @Test
-        public void testGetSequencesWithMostOccurrences_2() throws Exception {
-                Trie<String> fixture = new Trie<String>();
-                fixture.train(sequence, 3);
-                
-                Collection<List<String>> result = fixture.getSequencesWithMostOccurrences(2);
+                
+                List<String> expected = new ArrayList<String>();
+                expected.add("a");
+                ListAssert.assertContains((List<List<String>>) result, expected);
+        }
+
+        @Test
+        public void testGetSequencesWithMostOccurrences_7() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                
+                // get all sequences with a minimal length of two that occur most often
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(2, 0);
 
                 assertEquals(5, result.size());
@@ -292,9 +456,116 @@
 
         @Test
-        public void testGetSequencesWithMostOccurrences_3() throws Exception {
-                Trie<String> fixture = new Trie<String>();
-                fixture.train(sequence, 3);
-                
-                Collection<List<String>> result = fixture.getSequencesWithMostOccurrences(3);
+        public void testGetSequencesWithMostOccurrences_8() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                
+                // get all sequences with a minimal length of two that occur exactly once
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(2, 1);
+
+                assertEquals(9, result.size());
+                
+                List<String> expected = new ArrayList<String>();
+                expected.add("r");
+                expected.add("a");
+                expected.add("c");
+                // rac
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.clear();
+                expected.add("a");
+                expected.add("c");
+                // ac
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("a");
+                // aca
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.clear();
+                expected.add("c");
+                expected.add("a");
+                // ca
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("d");
+                // cad
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.clear();
+                expected.add("a");
+                expected.add("d");
+                // ad
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("a");
+                // ada
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.clear();
+                expected.add("d");
+                expected.add("a");
+                // da
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("b");
+                // dab
+                ListAssert.assertContains((List<List<String>>) result, expected);
+        }
+
+        @Test
+        public void testGetSequencesWithMostOccurrences_9() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                
+                // get all sequences with a minimal length of two that occur exactly twice
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(2, 2);
+
+                assertEquals(5, result.size());
+                
+                List<String> expected = new ArrayList<String>();
+                expected.add("a");
+                expected.add("b");
+                // ab
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("r");
+                // abr
+                ListAssert.assertContains((List<List<String>>) result, expected);
+
+                expected.clear();
+                expected.add("b");
+                expected.add("r");
+                // br
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.add("a");
+                // bra
+                ListAssert.assertContains((List<List<String>>) result, expected);
+
+                expected.clear();
+                expected.add("r");
+                expected.add("a");
+                // ra
+                ListAssert.assertContains((List<List<String>>) result, expected);
+        }
+
+        @Test
+        public void testGetSequencesWithMostOccurrences_10() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                
+                // get all sequences with a minimal length of two that occur exactly three times
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(2, 3);
+
+                assertEquals(0, result.size());
+        }
+        
+        @Test
+        public void testGetSequencesWithMostOccurrences_11() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                
+                // get all sequences with a minimal length of three that occur most often
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(3, 0);
 
                 assertEquals(2, result.size());
@@ -314,29 +585,72 @@
 
         @Test
-        public void testGetSequencesWithMostOccurrences_4() throws Exception {
-                Trie<String> fixture = new Trie<String>();
-                fixture.train(sequence, 3);
-                
-                Collection<List<String>> result = fixture.getSequencesWithMostOccurrences(4);
-
+        public void testGetSequencesWithMostOccurrences_12() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                
+                // get all sequences with a minimal length of three that occur exactly once
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(3, 1);
+
+                assertEquals(5, result.size());
+                
+                List<String> expected = new ArrayList<String>();
+                expected.add("r");
+                expected.add("a");
+                expected.add("c");
+                // rac
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.clear();
+                expected.add("a");
+                expected.add("c");
+                expected.add("a");
+                // aca
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.clear();
+                expected.add("c");
+                expected.add("a");
+                expected.add("d");
+                // cad
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.clear();
+                expected.add("a");
+                expected.add("d");
+                expected.add("a");
+                // ada
+                ListAssert.assertContains((List<List<String>>) result, expected);
+                
+                expected.clear();
+                expected.add("d");
+                expected.add("a");
+                expected.add("b");
+                // dab
+                ListAssert.assertContains((List<List<String>>) result, expected);
+        }
+
+        @Test
+        public void testGetSequencesWithMostOccurrences_13() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                
+                // get all sequences with a minimal length of four that occur most often
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(4, 0);
+
+                // none of these exist, as the tree is only trained with sequences of length 3
                 assertEquals(0, result.size());
         }
 
-	@Test
-	public void testGetContextSuffix_5() throws Exception {
-		Trie<String> fixture = new Trie<String>();
-		fixture.train(sequence, 3);
-		List<String> context = new ArrayList<String>();
-		context.add("a");
-		context.add("a");
-		context.add("b");
-		List<String> expected = new ArrayList<String>();
-		expected.add("a");
-		expected.add("b");
-
-		List<String> result = fixture.getContextSuffix(context);
-
-		ListAssert.assertEquals(expected, result);
-	}
+        @Test
+        public void testGetSequencesWithMostOccurrences_14() throws Exception {
+                Trie<String> fixture = new Trie<String>();
+                fixture.train(sequence, 3);
+                
+                // get all sequences with a minimal length of four that occur exactly once
+                Collection<List<String>> result = fixture.getSequencesWithOccurrenceCount(4, 1);
+
+                // none of these exist, as the tree is only trained with sequences of length 3
+                assertEquals(0, result.size());
+        }
 
 	@Test