();
+
+ /**
+ * the maximal observed count of a subsequence
+ */
+ private int maxCount = 0;
+
+ /**
+ * generates a simulated sequence and thereby stores the expected counts of the
+ * subsequences up to max order in a map. The technique uses integer and long values
+ * to be efficient and to allow testing with large sequences and symbol numbers. However,
+ * the technique is restricted to 1024 different symbols and a maximum tree depth of 6.
+ * The tester is also used as a trie processor to check for any node in the tree, if the
+ * trie calculated the count correctly and if it did not create too many nodes.
+ */
+ public TaskInstanceTrieTester(int noOfSymbols, int sequenceLength, int maxOrder) {
+ if (noOfSymbols > 1024) {
+ throw new IllegalArgumentException("too large number of symbols");
+ }
+ if (maxOrder > 6) {
+ throw new IllegalArgumentException("too large number of symbols");
+ }
+
+ StringBuffer dummyUserSessionDef = new StringBuffer("UserSession {");
+ for (int i = 0; i < noOfSymbols; i++) {
+ dummyUserSessionDef.append(" Event action");
+ dummyUserSessionDef.append(i);
+ dummyUserSessionDef.append(" {}");
+ }
+ dummyUserSessionDef.append("}");
+
+ IUserSession dummySession =
+ (IUserSession) decoder.decode(dummyUserSessionDef.toString());
+
+ for (int i = 0; i < dummySession.size(); i++) {
+ this.symbols.put(i, dummySession.get(i));
+ }
+
+ this.maxOrder = maxOrder;
+
+ dummyUserSessionDef = new StringBuffer("UserSession {");
+ int[] symbolIds = new int[sequenceLength];
+
+ for (int i = 0; i < sequenceLength; i++) {
+ int symbolIndex = (int) (Math.random() * noOfSymbols);
+ dummyUserSessionDef.append(" Event action");
+ dummyUserSessionDef.append(symbolIndex);
+ dummyUserSessionDef.append(" {}");
+
+ symbolIds[i] = symbolIndex;
+
+ if ((i - maxOrder + 1) >= 0) {
+ storeCounts(symbolIds, i - maxOrder + 1, i);
+ }
+ }
+ dummyUserSessionDef.append("}");
+
+ this.userSession = (IUserSession) decoder.decode(dummyUserSessionDef.toString());
+
+ for (int i = sequenceLength - maxOrder + 1; i < sequenceLength; i++) {
+ storeCounts(symbolIds, i, sequenceLength - 1);
+ }
+ }
+
+ /**
+ *
+ * stores the counts for the subsequence denoted by the start and end index (inclusive).
+ *
+ */
+ private void storeCounts(int[] sequence, int startIndex, int endIndex) {
+ long key = 0;
+
+ for (int i = startIndex; i <= endIndex; i++) {
+ key = key << 10;
+ key += 1 + sequence[i];
+
+ Integer count = this.counts.get(key);
+ if (count == null) {
+ count = 0;
+ }
+
+ //System.out.println(key + " " + (count + 1));
+
+ count++;
+ this.counts.put(key, count);
+
+ maxCount = Math.max(count, maxCount);
+ }
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.usageprofiles.TaskInstanceTrieProcessor#process(List, int)
+ */
+ @Override
+ public TrieProcessor.Result process(List sequence, int count) {
+ long key = 0;
+
+ for (ITaskInstance symbol : sequence) {
+ int symbolIndex = -1;
+
+ for (Map.Entry entry : symbols.entrySet()) {
+ if (strategy.getTaskComparator().equals(entry.getValue(), symbol)) {
+ symbolIndex = entry.getKey();
+ break;
+ }
+ }
+
+ assertTrue("could not find symbol", symbolIndex > -1);
+
+ key = key << 10;
+ key += 1 + symbolIndex;
+ }
+
+ Integer expectedCount = this.counts.remove(key);
+ assertNotNull(expectedCount);
+
+ if (count == maxCount) {
+ assertEquals(expectedCount.intValue(), count);
+ }
+ else {
+ assertTrue(count < maxCount);
+ }
+
+ assertTrue(sequence.size() <= this.maxOrder);
+
+ return TrieProcessor.Result.CONTINUE;
+ }
+
+ }
+}
Index: /branches/autoquest-core-tasktrees-alignment-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskSymbolBucketedMapTest.java
===================================================================
--- /branches/autoquest-core-tasktrees-alignment-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskSymbolBucketedMapTest.java (revision 1647)
+++ /branches/autoquest-core-tasktrees-alignment-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskSymbolBucketedMapTest.java (revision 1647)
@@ -0,0 +1,1091 @@
+// 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.tasktrees.temporalrelation;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTaskInstance;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory;
+import de.ugoe.cs.autoquest.test.DummyGUIElement;
+import de.ugoe.cs.autoquest.test.DummyInteraction;
+import de.ugoe.cs.autoquest.usageprofiles.SymbolMap;
+
+/**
+ *
+ * The class SymbolMapTest contains tests for the class
+ * {@link SymbolMap}.
+ *
+ *
+ * @author Patrick Harms
+ */
+public class TaskSymbolBucketedMapTest {
+
+ /** */
+ private ITaskFactory taskFactory = new TaskFactory();
+
+ /** */
+ Map tasks = new HashMap();
+
+ @Before
+ public void setUp() {
+ tasks = new HashMap();
+ }
+
+ @Test
+ public void testSymbolMap_1() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ assertNotNull(symbolMap);
+ assertEquals(0, symbolMap.size());
+ }
+
+ @Test
+ public void testSymbolMap_2() {
+ TaskSymbolBucketedMap symbolMap1 = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ ITaskInstance taskInstance = createTaskInstance("symbol");
+ symbolMap1.addSymbol(taskInstance, "value");
+
+ SymbolMap symbolMap2 = new TaskSymbolBucketedMap(symbolMap1);
+
+ assertNotNull(symbolMap2);
+ assertSymbolMapEntries(symbolMap2, new ITaskInstance[] { taskInstance },
+ new String[] { "value" });
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testSymbolMap_3() throws Exception {
+ new TaskSymbolBucketedMap((TaskSymbolBucketedMap) null);
+ }
+
+ @Test
+ public void testAddSymbol_1() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ ITaskInstance taskInstance = createTaskInstance("symbol");
+ symbolMap.addSymbol(taskInstance, "value1");
+
+ assertNotNull(symbolMap);
+ assertSymbolMapEntries(symbolMap, new ITaskInstance[] { taskInstance },
+ new String[] { "value1" });
+ }
+
+ @Test
+ public void testAddSymbol_2() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ ITaskInstance[] symbols = new ITaskInstance[entryCount];
+ String[] values = new String[entryCount];
+
+ for (int i = 0; i < entryCount; i++) {
+ symbols[i] = createTaskInstance("symbol" + i);
+ symbolMap.addSymbol(symbols[i], "value" + i);
+ values[i] = "value" + i;
+ }
+
+ assertNotNull(symbolMap);
+ assertSymbolMapEntries(symbolMap, symbols, values);
+ }
+
+ @Test
+ public void testAddSymbol_3() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ ITaskInstance[] symbols = new ITaskInstance[entryCount];
+ String[] values = new String[entryCount];
+
+ for (int i = 0; i < entryCount; i++) {
+ symbols[i] = createTaskInstance("symbol" + i);
+ if (i % 7 == 0) {
+ values[i] = "value" + i;
+ }
+ else {
+ values[i] = null;
+ }
+
+ symbolMap.addSymbol(symbols[i], values[i]);
+ }
+
+ assertNotNull(symbolMap);
+ assertSymbolMapEntries(symbolMap, symbols, values);
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testAddSymbol_4() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ symbolMap.addSymbol(null, null);
+ }
+
+ @Test
+ public void testSize_1() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ assertEquals(0, symbolMap.size());
+ }
+
+ @Test
+ public void testSize_2() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
+
+ assertEquals(1, symbolMap.size());
+ }
+
+ @Test
+ public void testSize_3() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+
+ assertEquals(entryCount, symbolMap.size());
+ }
+
+ @Test
+ public void testSize_4() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ if (i % 7 == 0) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+ else {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
+ }
+ }
+
+ assertEquals(entryCount, symbolMap.size());
+ }
+
+ @Test
+ public void testSize_5() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+
+ for (int i = 150; i < (entryCount - 150); i++) {
+ symbolMap.removeSymbol(createTaskInstance("symbol" + i));
+ }
+
+ assertEquals(2 * 150, symbolMap.size());
+ }
+
+ @Test
+ public void testIsEmpty_1() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ assertTrue(symbolMap.isEmpty());
+ }
+
+ @Test
+ public void testIsEmpty_2() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
+
+ assertFalse(symbolMap.isEmpty());
+ }
+
+ @Test
+ public void testIsEmpty_3() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+
+ assertFalse(symbolMap.isEmpty());
+ }
+
+ @Test
+ public void testIsEmpty_4() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ if (i % 7 == 0) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+ else {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
+ }
+ }
+
+ assertFalse(symbolMap.isEmpty());
+ }
+
+ @Test
+ public void testIsEmpty_5() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+
+ for (int i = 150; i < (entryCount - 150); i++) {
+ symbolMap.removeSymbol(createTaskInstance("symbol" + i));
+ }
+
+ assertFalse(symbolMap.isEmpty());
+ }
+
+ @Test
+ public void testContainsSymbol_1() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ assertFalse(symbolMap.containsSymbol(createTaskInstance("symbol")));
+ }
+
+ @Test
+ public void testContainsSymbol_2() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
+
+ assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol1")));
+ }
+
+ @Test
+ public void testContainsSymbol_3() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+
+ for (int i = 0; i < entryCount; i++) {
+ assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
+ }
+ }
+
+ @Test
+ public void testContainsSymbol_4() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ if (i % 7 == 0) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+ else {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
+ }
+ }
+
+ for (int i = 0; i < entryCount; i++) {
+ assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
+ }
+ }
+
+ @Test
+ public void testContainsSymbol_5() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+
+ for (int i = 150; i < (entryCount - 150); i++) {
+ symbolMap.removeSymbol(createTaskInstance("symbol" + i));
+ }
+
+ for (int i = 0; i < 150; i++) {
+ assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
+ }
+
+ for (int i = 150; i < (entryCount - 150); i++) {
+ assertFalse(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
+ }
+
+ for (int i = (entryCount - 150); i < entryCount; i++) {
+ assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
+ }
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testContainsSymbol_6() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ symbolMap.containsSymbol(null);
+ }
+
+ @Test
+ public void testGetValue_1() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ assertNull(symbolMap.getValue(createTaskInstance("symbol")));
+ }
+
+ @Test
+ public void testGetValue_2() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
+
+ assertNotNull(symbolMap.getValue(createTaskInstance("symbol1")));
+ }
+
+ @Test
+ public void testGetValue_3() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ symbolMap.addSymbol(createTaskInstance("symbol1"), null);
+
+ assertNull(symbolMap.getValue(createTaskInstance("symbol1")));
+ }
+
+ @Test
+ public void testGetValue_4() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+
+ for (int i = 0; i < entryCount; i++) {
+ assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
+ }
+ }
+
+ @Test
+ public void testGetValue_5() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ if (i % 7 == 0) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+ else {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
+ }
+ }
+
+ for (int i = 0; i < entryCount; i++) {
+ if (i % 7 == 0) {
+ assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
+ }
+ else {
+ assertNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
+ }
+ }
+ }
+
+ @Test
+ public void testGetValue_6() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+
+ for (int i = 150; i < (entryCount - 150); i++) {
+ symbolMap.removeSymbol(createTaskInstance("symbol" + i));
+ }
+
+ for (int i = 0; i < 150; i++) {
+ assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
+ }
+
+ for (int i = 150; i < (entryCount - 150); i++) {
+ assertNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
+ }
+
+ for (int i = (entryCount - 150); i < entryCount; i++) {
+ assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
+ }
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testGetValue_7() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ symbolMap.getValue(null);
+ }
+
+ @Test
+ public void testRemoveSymbol_1() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ assertNull(symbolMap.removeSymbol(createTaskInstance("symbol")));
+ }
+
+ @Test
+ public void testRemoveSymbol_2() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
+
+ assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol1")));
+ assertEquals(0, symbolMap.size());
+ }
+
+ @Test
+ public void testRemoveSymbol_3() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ symbolMap.addSymbol(createTaskInstance("symbol1"), null);
+
+ assertNull(symbolMap.removeSymbol(createTaskInstance("symbol1")));
+ assertEquals(0, symbolMap.size());
+ }
+
+ @Test
+ public void testRemoveSymbol_4() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+
+ for (int i = 0; i < entryCount; i++) {
+ assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
+ }
+
+ assertEquals(0, symbolMap.size());
+ }
+
+ @Test
+ public void testRemoveSymbol_5() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ if (i % 7 == 0) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+ else {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
+ }
+ }
+
+ for (int i = 0; i < entryCount; i++) {
+ if (i % 7 == 0) {
+ assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
+ }
+ else {
+ assertNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
+ }
+ }
+
+ assertEquals(0, symbolMap.size());
+ }
+
+ @Test
+ public void testRemoveSymbol_6() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
+ }
+
+ for (int i = 150; i < (entryCount - 150); i++) {
+ symbolMap.removeSymbol(createTaskInstance("symbol" + i));
+ }
+
+ for (int i = 0; i < 150; i++) {
+ assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
+ }
+
+ for (int i = 150; i < (entryCount - 150); i++) {
+ assertNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
+ }
+
+ for (int i = (entryCount - 150); i < entryCount; i++) {
+ assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
+ }
+
+ assertEquals(0, symbolMap.size());
+ }
+
+ @Test(expected = java.lang.IllegalArgumentException.class)
+ public void testRemoveSymbol_7() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ symbolMap.removeSymbol(null);
+ }
+
+ @Test
+ public void testGetSymbols_1() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ assertNotNull(symbolMap.getSymbols());
+ assertEquals(0, symbolMap.getSymbols().size());
+ }
+
+ @Test
+ public void testGetSymbols_2() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ ITaskInstance task = createTaskInstance("symbol1");
+ symbolMap.addSymbol(task, "value1");
+
+ assertNotNull(symbolMap.getSymbols());
+ assertEquals(1, symbolMap.getSymbols().size());
+ assertEquals(task, symbolMap.getSymbols().iterator().next());
+ }
+
+ @Test
+ public void testGetSymbols_3() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ ITaskInstance task = createTaskInstance("symbol1");
+ symbolMap.addSymbol(task, null);
+
+ assertNotNull(symbolMap.getSymbols());
+ assertEquals(1, symbolMap.getSymbols().size());
+ assertEquals(task, symbolMap.getSymbols().iterator().next());
+ }
+
+ @Test
+ public void testGetSymbols_4() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+ Set expectedSymbols = new HashSet();
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ ITaskInstance task = createTaskInstance("symbol" + i);
+ symbolMap.addSymbol(task, "value" + i);
+ expectedSymbols.add(task);
+ }
+
+ assertNotNull(symbolMap.getSymbols());
+ assertEquals(entryCount, symbolMap.getSymbols().size());
+
+ Iterator iterator = symbolMap.getSymbols().iterator();
+ for (int i = 0; i < entryCount; i++) {
+ assertTrue(iterator.hasNext());
+ expectedSymbols.remove(iterator.next());
+ }
+
+ assertTrue(expectedSymbols.isEmpty());
+ assertFalse(iterator.hasNext());
+ }
+
+ @Test
+ public void testGetSymbols_5() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+ Set expectedSymbols = new HashSet();
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ ITaskInstance task = createTaskInstance("symbol" + i);
+
+ if (i % 7 == 0) {
+ symbolMap.addSymbol(task, "value" + i);
+ }
+ else {
+ symbolMap.addSymbol(task, null);
+ }
+
+ expectedSymbols.add(task);
+ }
+
+ assertNotNull(symbolMap.getSymbols());
+ assertEquals(entryCount, symbolMap.getSymbols().size());
+
+ Iterator iterator = symbolMap.getSymbols().iterator();
+ for (int i = 0; i < entryCount; i++) {
+ assertTrue(iterator.hasNext());
+ expectedSymbols.remove(iterator.next());
+ }
+
+ assertTrue(expectedSymbols.isEmpty());
+ assertFalse(iterator.hasNext());
+ }
+
+ @Test
+ public void testGetSymbols_6() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+ List expectedSymbols = new ArrayList();
+
+ int entryCount = 2000;
+
+ for (int i = 0; i < entryCount; i++) {
+ ITaskInstance task = createTaskInstance("symbol" + i);
+ symbolMap.addSymbol(task, "value" + i);
+ expectedSymbols.add(task);
+ }
+
+ for (int i = 150; i < (entryCount - 150); i++) {
+ symbolMap.removeSymbol(expectedSymbols.remove(150));
+ }
+
+ assertNotNull(symbolMap.getSymbols());
+ assertEquals(2 * 150, symbolMap.getSymbols().size());
+
+ Iterator iterator = symbolMap.getSymbols().iterator();
+ for (int i = 0; i < 2 * 150; i++) {
+ assertTrue(iterator.hasNext());
+ expectedSymbols.remove(iterator.next());
+ }
+
+ assertTrue(expectedSymbols.isEmpty());
+ assertFalse(iterator.hasNext());
+ }
+
+ @Test
+ public void testGetValues_1() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ assertNotNull(symbolMap.getValues());
+ assertEquals(0, symbolMap.getValues().size());
+ }
+
+ @Test
+ public void testGetValues_2() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
+
+ assertNotNull(symbolMap.getValues());
+ assertEquals(1, symbolMap.getValues().size());
+ assertEquals("value1", symbolMap.getValues().iterator().next());
+ }
+
+ @Test
+ public void testGetValues_3() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+
+ symbolMap.addSymbol(createTaskInstance("symbol1"), null);
+
+ assertNotNull(symbolMap.getValues());
+ assertEquals(1, symbolMap.getValues().size());
+ assertNull(symbolMap.getValues().iterator().next());
+ }
+
+ @Test
+ public void testGetValues_4() {
+ SymbolMap symbolMap = new TaskSymbolBucketedMap
+ (new TaskInstanceComparator(TaskEquality.SEMANTICALLY_EQUAL));
+ Set