source: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskSymbolIdentityMapTest.java @ 1285

Last change on this file since 1285 was 1285, checked in by pharms, 11 years ago
  • improved performance of task instance trie generation by using different symbol management strategies while creating the trie. This performance improvement is significant and allows to detect tasks now in a much faster manner.
File size: 36.4 KB
Line 
1//   Copyright 2012 Georg-August-Universität Göttingen, Germany
2//
3//   Licensed under the Apache License, Version 2.0 (the "License");
4//   you may not use this file except in compliance with the License.
5//   You may obtain a copy of the License at
6//
7//       http://www.apache.org/licenses/LICENSE-2.0
8//
9//   Unless required by applicable law or agreed to in writing, software
10//   distributed under the License is distributed on an "AS IS" BASIS,
11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//   See the License for the specific language governing permissions and
13//   limitations under the License.
14
15package de.ugoe.cs.autoquest.tasktrees.temporalrelation;
16
17import static org.junit.Assert.*;
18
19import java.util.ArrayList;
20import java.util.HashMap;
21import java.util.HashSet;
22import java.util.Iterator;
23import java.util.List;
24import java.util.Map;
25import java.util.Set;
26
27import org.junit.Before;
28import org.junit.Test;
29
30import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
31import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory;
32import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
33import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory;
34import de.ugoe.cs.autoquest.test.DummyGUIElement;
35import de.ugoe.cs.autoquest.test.DummyInteraction;
36import de.ugoe.cs.autoquest.usageprofiles.SymbolMap;
37
38/**
39 * <p>
40 * The class <code>SymbolMapTest</code> contains tests for the class
41 * <code>{@link SymbolMap}</code>.
42 * </p>
43 *
44 * @author Patrick Harms
45 */
46public class TaskSymbolIdentityMapTest {
47
48    /** */
49    private ITaskFactory taskFactory = new TaskFactory();
50   
51    /** */
52    Map<String, ITask> tasks = new HashMap<String, ITask>();
53   
54    @Before
55    public void setUp() {
56        tasks = new HashMap<String, ITask>();
57    }
58   
59    @Test
60    public void testSymbolMap_1() {
61        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
62       
63        assertNotNull(symbolMap);
64        assertEquals(0, symbolMap.size());
65    }
66
67    @Test
68    public void testSymbolMap_2() {
69        TaskSymbolIdentityMap<String> symbolMap1 = new TaskSymbolIdentityMap<String>();
70       
71        ITaskInstance taskInstance = createTaskInstance("symbol");
72        symbolMap1.addSymbol(taskInstance, "value");
73       
74        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>(symbolMap1);
75       
76        assertNotNull(symbolMap2);
77        assertSymbolMapEntries(symbolMap2, new ITaskInstance[] { taskInstance },
78                               new String[] { "value" });
79    }
80
81    @Test(expected = java.lang.IllegalArgumentException.class)
82    public void testSymbolMap_3() throws Exception {
83        new TaskSymbolBucketedMap<String>((TaskSymbolBucketedMap<String>) null);
84    }
85   
86    @Test
87    public void testAddSymbol_1() {
88        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
89           
90        ITaskInstance taskInstance = createTaskInstance("symbol");
91        symbolMap.addSymbol(taskInstance, "value1");
92       
93        assertNotNull(symbolMap);
94        assertSymbolMapEntries(symbolMap, new ITaskInstance[] { taskInstance },
95                               new String[] { "value1" });
96    }
97   
98    @Test
99    public void testAddSymbol_2() {
100        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
101       
102        int entryCount = 2000;
103       
104        ITaskInstance[] symbols = new ITaskInstance[entryCount];
105        String[] values = new String[entryCount];
106       
107        for (int i = 0; i < entryCount; i++) {
108            symbols[i] = createTaskInstance("symbol" + i);
109            symbolMap.addSymbol(symbols[i], "value" + i);
110            values[i] = "value" + i;
111        }
112       
113        assertNotNull(symbolMap);
114        assertSymbolMapEntries(symbolMap, symbols, values);
115    }
116   
117    @Test
118    public void testAddSymbol_3() {
119        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
120       
121        int entryCount = 2000;
122       
123        ITaskInstance[] symbols = new ITaskInstance[entryCount];
124        String[] values = new String[entryCount];
125       
126        for (int i = 0; i < entryCount; i++) {
127            symbols[i] = createTaskInstance("symbol" + i);
128            if (i % 7 == 0) {
129                values[i] = "value" + i;
130            }
131            else {
132                values[i] = null;
133            }
134           
135            symbolMap.addSymbol(symbols[i], values[i]);
136        }
137       
138        assertNotNull(symbolMap);
139        assertSymbolMapEntries(symbolMap, symbols, values);
140    }
141   
142    @Test(expected = java.lang.IllegalArgumentException.class)
143    public void testAddSymbol_4() {
144        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
145           
146        symbolMap.addSymbol(null, null);
147    }   
148   
149    @Test
150    public void testSize_1() {
151        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
152           
153        assertEquals(0, symbolMap.size());
154    }
155   
156    @Test
157    public void testSize_2() {
158        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
159           
160        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
161       
162        assertEquals(1, symbolMap.size());
163    }
164   
165    @Test
166    public void testSize_3() {
167        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
168       
169        int entryCount = 2000;
170       
171        for (int i = 0; i < entryCount; i++) {
172            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
173        }
174       
175        assertEquals(entryCount, symbolMap.size());
176    }
177   
178    @Test
179    public void testSize_4() {
180        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
181       
182        int entryCount = 2000;
183       
184        for (int i = 0; i < entryCount; i++) {
185            if (i % 7 == 0) {
186                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
187            }
188            else {
189                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
190            }
191        }
192       
193        assertEquals(entryCount, symbolMap.size());
194    }
195   
196    @Test
197    public void testSize_5() {
198        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
199       
200        int entryCount = 2000;
201       
202        for (int i = 0; i < entryCount; i++) {
203            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
204        }
205       
206        for (int i = 150; i < (entryCount - 150); i++) {
207            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
208        }
209       
210        assertEquals(2 * 150, symbolMap.size());
211    }
212   
213    @Test
214    public void testIsEmpty_1() {
215        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
216           
217        assertTrue(symbolMap.isEmpty());
218    }
219   
220    @Test
221    public void testIsEmpty_2() {
222        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
223           
224        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
225       
226        assertFalse(symbolMap.isEmpty());
227    }
228   
229    @Test
230    public void testIsEmpty_3() {
231        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
232       
233        int entryCount = 2000;
234       
235        for (int i = 0; i < entryCount; i++) {
236            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
237        }
238       
239        assertFalse(symbolMap.isEmpty());
240    }
241   
242    @Test
243    public void testIsEmpty_4() {
244        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
245       
246        int entryCount = 2000;
247       
248        for (int i = 0; i < entryCount; i++) {
249            if (i % 7 == 0) {
250                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
251            }
252            else {
253                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
254            }
255        }
256       
257        assertFalse(symbolMap.isEmpty());
258    }
259   
260    @Test
261    public void testIsEmpty_5() {
262        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
263       
264        int entryCount = 2000;
265       
266        for (int i = 0; i < entryCount; i++) {
267            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
268        }
269       
270        for (int i = 150; i < (entryCount - 150); i++) {
271            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
272        }
273       
274        assertFalse(symbolMap.isEmpty());
275    }
276   
277    @Test
278    public void testContainsSymbol_1() {
279        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
280           
281        assertFalse(symbolMap.containsSymbol(createTaskInstance("symbol")));
282    }
283   
284    @Test
285    public void testContainsSymbol_2() {
286        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
287           
288        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
289       
290        assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol1")));
291    }
292   
293    @Test
294    public void testContainsSymbol_3() {
295        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
296       
297        int entryCount = 2000;
298       
299        for (int i = 0; i < entryCount; i++) {
300            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
301        }
302       
303        for (int i = 0; i < entryCount; i++) {
304            assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
305        }
306    }
307   
308    @Test
309    public void testContainsSymbol_4() {
310        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
311       
312        int entryCount = 2000;
313       
314        for (int i = 0; i < entryCount; i++) {
315            if (i % 7 == 0) {
316                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
317            }
318            else {
319                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
320            }
321        }
322       
323        for (int i = 0; i < entryCount; i++) {
324            assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
325        }
326    }
327   
328    @Test
329    public void testContainsSymbol_5() {
330        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
331       
332        int entryCount = 2000;
333       
334        for (int i = 0; i < entryCount; i++) {
335            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
336        }
337       
338        for (int i = 150; i < (entryCount - 150); i++) {
339            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
340        }
341       
342        for (int i = 0; i < 150; i++) {
343            assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
344        }
345       
346        for (int i = 150; i < (entryCount - 150); i++) {
347            assertFalse(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
348        }
349       
350        for (int i = (entryCount - 150); i < entryCount; i++) {
351            assertTrue(symbolMap.containsSymbol(createTaskInstance("symbol" + i)));
352        }
353    }
354   
355    @Test(expected = java.lang.IllegalArgumentException.class)
356    public void testContainsSymbol_6() {
357        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
358           
359        symbolMap.containsSymbol(null);
360    }   
361
362    @Test
363    public void testGetValue_1() {
364        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
365           
366        assertNull(symbolMap.getValue(createTaskInstance("symbol")));
367    }
368   
369    @Test
370    public void testGetValue_2() {
371        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
372           
373        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
374       
375        assertNotNull(symbolMap.getValue(createTaskInstance("symbol1")));
376    }
377   
378    @Test
379    public void testGetValue_3() {
380        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
381           
382        symbolMap.addSymbol(createTaskInstance("symbol1"), null);
383       
384        assertNull(symbolMap.getValue(createTaskInstance("symbol1")));
385    }
386   
387    @Test
388    public void testGetValue_4() {
389        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
390       
391        int entryCount = 2000;
392       
393        for (int i = 0; i < entryCount; i++) {
394            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
395        }
396       
397        for (int i = 0; i < entryCount; i++) {
398            assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
399        }
400    }
401   
402    @Test
403    public void testGetValue_5() {
404        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
405       
406        int entryCount = 2000;
407       
408        for (int i = 0; i < entryCount; i++) {
409            if (i % 7 == 0) {
410                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
411            }
412            else {
413                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
414            }
415        }
416       
417        for (int i = 0; i < entryCount; i++) {
418            if (i % 7 == 0) {
419                assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
420            }
421            else {
422                assertNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
423            }
424        }
425    }
426   
427    @Test
428    public void testGetValue_6() {
429        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
430       
431        int entryCount = 2000;
432       
433        for (int i = 0; i < entryCount; i++) {
434            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
435        }
436       
437        for (int i = 150; i < (entryCount - 150); i++) {
438            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
439        }
440       
441        for (int i = 0; i < 150; i++) {
442            assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
443        }
444       
445        for (int i = 150; i < (entryCount - 150); i++) {
446            assertNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
447        }
448       
449        for (int i = (entryCount - 150); i < entryCount; i++) {
450            assertNotNull(symbolMap.getValue(createTaskInstance("symbol" + i)));
451        }
452    }
453   
454    @Test(expected = java.lang.IllegalArgumentException.class)
455    public void testGetValue_7() {
456        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
457           
458        symbolMap.getValue(null);
459    }   
460
461    @Test
462    public void testRemoveSymbol_1() {
463        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
464           
465        assertNull(symbolMap.removeSymbol(createTaskInstance("symbol")));
466    }
467   
468    @Test
469    public void testRemoveSymbol_2() {
470        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
471           
472        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
473       
474        assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol1")));
475        assertEquals(0, symbolMap.size());
476    }
477   
478    @Test
479    public void testRemoveSymbol_3() {
480        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
481           
482        symbolMap.addSymbol(createTaskInstance("symbol1"), null);
483       
484        assertNull(symbolMap.removeSymbol(createTaskInstance("symbol1")));
485        assertEquals(0, symbolMap.size());
486    }
487   
488    @Test
489    public void testRemoveSymbol_4() {
490        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
491       
492        int entryCount = 2000;
493       
494        for (int i = 0; i < entryCount; i++) {
495            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
496        }
497       
498        for (int i = 0; i < entryCount; i++) {
499            assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
500        }
501       
502        assertEquals(0, symbolMap.size());
503    }
504   
505    @Test
506    public void testRemoveSymbol_5() {
507        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
508       
509        int entryCount = 2000;
510       
511        for (int i = 0; i < entryCount; i++) {
512            if (i % 7 == 0) {
513                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
514            }
515            else {
516                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
517            }
518        }
519       
520        for (int i = 0; i < entryCount; i++) {
521            if (i % 7 == 0) {
522                assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
523            }
524            else {
525                assertNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
526            }
527        }
528       
529        assertEquals(0, symbolMap.size());
530    }
531   
532    @Test
533    public void testRemoveSymbol_6() {
534        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
535       
536        int entryCount = 2000;
537       
538        for (int i = 0; i < entryCount; i++) {
539            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
540        }
541       
542        for (int i = 150; i < (entryCount - 150); i++) {
543            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
544        }
545       
546        for (int i = 0; i < 150; i++) {
547            assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
548        }
549       
550        for (int i = 150; i < (entryCount - 150); i++) {
551            assertNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
552        }
553       
554        for (int i = (entryCount - 150); i < entryCount; i++) {
555            assertNotNull(symbolMap.removeSymbol(createTaskInstance("symbol" + i)));
556        }
557       
558        assertEquals(0, symbolMap.size());
559    }
560   
561    @Test(expected = java.lang.IllegalArgumentException.class)
562    public void testRemoveSymbol_7() {
563        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
564           
565        symbolMap.removeSymbol(null);
566    }   
567   
568    @Test
569    public void testGetSymbols_1() {
570        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
571           
572        assertNotNull(symbolMap.getSymbols());
573        assertEquals(0, symbolMap.getSymbols().size());
574    }
575   
576    @Test
577    public void testGetSymbols_2() {
578        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
579         
580        ITaskInstance task = createTaskInstance("symbol1");
581        symbolMap.addSymbol(task, "value1");
582       
583        assertNotNull(symbolMap.getSymbols());
584        assertEquals(1, symbolMap.getSymbols().size());
585        assertEquals(task, symbolMap.getSymbols().iterator().next());
586    }
587   
588    @Test
589    public void testGetSymbols_3() {
590        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
591           
592        ITaskInstance task = createTaskInstance("symbol1");
593        symbolMap.addSymbol(task, null);
594       
595        assertNotNull(symbolMap.getSymbols());
596        assertEquals(1, symbolMap.getSymbols().size());
597        assertEquals(task, symbolMap.getSymbols().iterator().next());
598    }
599   
600    @Test
601    public void testGetSymbols_4() {
602        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
603        Set<ITaskInstance> expectedSymbols = new HashSet<ITaskInstance>();
604       
605        int entryCount = 2000;
606       
607        for (int i = 0; i < entryCount; i++) {
608            ITaskInstance task = createTaskInstance("symbol" + i);
609            symbolMap.addSymbol(task, "value" + i);
610            expectedSymbols.add(task);
611        }
612       
613        assertNotNull(symbolMap.getSymbols());
614        assertEquals(entryCount, symbolMap.getSymbols().size());
615       
616        Iterator<ITaskInstance> iterator = symbolMap.getSymbols().iterator();
617        for (int i = 0; i < entryCount; i++) {
618            assertTrue(iterator.hasNext());
619            expectedSymbols.remove(iterator.next());
620        }
621       
622        assertTrue(expectedSymbols.isEmpty());
623        assertFalse(iterator.hasNext());
624    }
625   
626    @Test
627    public void testGetSymbols_5() {
628        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
629        Set<ITaskInstance> expectedSymbols = new HashSet<ITaskInstance>();
630       
631        int entryCount = 2000;
632       
633        for (int i = 0; i < entryCount; i++) {
634            ITaskInstance task = createTaskInstance("symbol" + i);
635           
636            if (i % 7 == 0) {
637                symbolMap.addSymbol(task, "value" + i);
638            }
639            else {
640                symbolMap.addSymbol(task, null);
641            }
642           
643            expectedSymbols.add(task);
644        }
645       
646        assertNotNull(symbolMap.getSymbols());
647        assertEquals(entryCount, symbolMap.getSymbols().size());
648       
649        Iterator<ITaskInstance> iterator = symbolMap.getSymbols().iterator();
650        for (int i = 0; i < entryCount; i++) {
651            assertTrue(iterator.hasNext());
652            expectedSymbols.remove(iterator.next());
653        }
654       
655        assertTrue(expectedSymbols.isEmpty());
656        assertFalse(iterator.hasNext());
657    }
658   
659    @Test
660    public void testGetSymbols_6() {
661        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
662        List<ITaskInstance> expectedSymbols = new ArrayList<ITaskInstance>();
663       
664        int entryCount = 2000;
665       
666        for (int i = 0; i < entryCount; i++) {
667            ITaskInstance task = createTaskInstance("symbol" + i);
668            symbolMap.addSymbol(task, "value" + i);
669            expectedSymbols.add(task);
670        }
671       
672        for (int i = 150; i < (entryCount - 150); i++) {
673            symbolMap.removeSymbol(expectedSymbols.remove(150));
674        }
675       
676        assertNotNull(symbolMap.getSymbols());
677        assertEquals(2 * 150, symbolMap.getSymbols().size());
678       
679        Iterator<ITaskInstance> iterator = symbolMap.getSymbols().iterator();
680        for (int i = 0; i < 2 * 150; i++) {
681            assertTrue(iterator.hasNext());
682            expectedSymbols.remove(iterator.next());
683        }
684       
685        assertTrue(expectedSymbols.isEmpty());
686        assertFalse(iterator.hasNext());
687    }
688   
689    @Test
690    public void testGetValues_1() {
691        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
692           
693        assertNotNull(symbolMap.getValues());
694        assertEquals(0, symbolMap.getValues().size());
695    }
696   
697    @Test
698    public void testGetValues_2() {
699        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
700           
701        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
702       
703        assertNotNull(symbolMap.getValues());
704        assertEquals(1, symbolMap.getValues().size());
705        assertEquals("value1", symbolMap.getValues().iterator().next());
706    }
707   
708    @Test
709    public void testGetValues_3() {
710        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
711           
712        symbolMap.addSymbol(createTaskInstance("symbol1"), null);
713       
714        assertNotNull(symbolMap.getValues());
715        assertEquals(1, symbolMap.getValues().size());
716        assertNull(symbolMap.getValues().iterator().next());
717    }
718   
719    @Test
720    public void testGetValues_4() {
721        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
722        Set<String> expectedValues = new HashSet<String>();
723       
724        int entryCount = 2000;
725       
726        for (int i = 0; i < entryCount; i++) {
727            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
728            expectedValues.add("value" + i);
729        }
730       
731        assertNotNull(symbolMap.getValues());
732        assertEquals(entryCount, symbolMap.getValues().size());
733       
734        Iterator<String> iterator = symbolMap.getValues().iterator();
735        for (int i = 0; i < entryCount; i++) {
736            assertTrue(iterator.hasNext());
737            expectedValues.remove(iterator.next());
738        }
739       
740        assertTrue(expectedValues.isEmpty());
741        assertFalse(iterator.hasNext());
742    }
743   
744    @Test
745    public void testGetValues_5() {
746        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
747        Set<String> expectedValues = new HashSet<String>();
748       
749        int entryCount = 2000;
750       
751        for (int i = 0; i < entryCount; i++) {
752            if (i % 7 == 0) {
753                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
754                expectedValues.add("value" + i);
755            }
756            else {
757                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
758                expectedValues.add(null);
759            }
760        }
761       
762        assertNotNull(symbolMap.getValues());
763        assertEquals(entryCount, symbolMap.getValues().size());
764       
765        Iterator<String> iterator = symbolMap.getValues().iterator();
766        for (int i = 0; i < entryCount; i++) {
767            assertTrue(iterator.hasNext());
768            expectedValues.remove(iterator.next());
769        }
770       
771        assertTrue(expectedValues.isEmpty());
772        assertFalse(iterator.hasNext());
773    }
774   
775    @Test
776    public void testGetValues_6() {
777        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
778        Set<String> expectedValues = new HashSet<String>();
779       
780        int entryCount = 2000;
781       
782        for (int i = 0; i < entryCount; i++) {
783            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
784            expectedValues.add("value" + i);
785        }
786       
787        for (int i = 150; i < (entryCount - 150); i++) {
788            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
789            expectedValues.remove("value" + i);
790        }
791       
792        assertNotNull(symbolMap.getValues());
793        assertEquals(2 * 150, symbolMap.getValues().size());
794       
795        Iterator<String> iterator = symbolMap.getValues().iterator();
796        for (int i = 0; i < 2 * 150; i++) {
797            assertTrue(iterator.hasNext());
798            expectedValues.remove(iterator.next());
799        }
800       
801        assertTrue(expectedValues.isEmpty());
802        assertFalse(iterator.hasNext());
803    }
804   
805    @Test
806    public void testClear_1() {
807        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
808       
809        symbolMap.clear();
810        assertEquals(0, symbolMap.getValues().size());
811    }
812   
813    @Test
814    public void testClear_2() {
815        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
816           
817        symbolMap.addSymbol(createTaskInstance("symbol1"), "value1");
818       
819        symbolMap.clear();
820        assertEquals(0, symbolMap.getValues().size());
821    }
822   
823    @Test
824    public void testClear_3() {
825        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
826           
827        symbolMap.addSymbol(createTaskInstance("symbol1"), null);
828       
829        symbolMap.clear();
830        assertEquals(0, symbolMap.getValues().size());
831    }
832   
833    @Test
834    public void testClear_4() {
835        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
836       
837        int entryCount = 2000;
838       
839        for (int i = 0; i < entryCount; i++) {
840            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
841        }
842       
843        symbolMap.clear();
844        assertEquals(0, symbolMap.getValues().size());
845    }
846   
847    @Test
848    public void testClear_5() {
849        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
850       
851        int entryCount = 2000;
852       
853        for (int i = 0; i < entryCount; i++) {
854            if (i % 7 == 0) {
855                symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
856            }
857            else {
858                symbolMap.addSymbol(createTaskInstance("symbol" + i), null);
859            }
860        }
861       
862        symbolMap.clear();
863        assertEquals(0, symbolMap.getValues().size());
864    }
865   
866    @Test
867    public void testClear_6() {
868        SymbolMap<ITaskInstance, String> symbolMap = new TaskSymbolIdentityMap<String>();
869       
870        int entryCount = 2000;
871       
872        for (int i = 0; i < entryCount; i++) {
873            symbolMap.addSymbol(createTaskInstance("symbol" + i), "value" + i);
874        }
875       
876        for (int i = 150; i < (entryCount - 150); i++) {
877            symbolMap.removeSymbol(createTaskInstance("symbol" + i));
878        }
879       
880        symbolMap.clear();
881        assertEquals(0, symbolMap.getValues().size());
882    }
883   
884    @Test
885    public void testEquals_1() {
886        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>();
887       
888        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>();
889       
890        assertTrue(symbolMap1.equals(symbolMap2));
891    }
892   
893    @Test
894    public void testEquals_2() {
895        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>();
896           
897        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>();
898           
899        symbolMap1.addSymbol(createTaskInstance("symbol1"), "value1");
900       
901        assertFalse(symbolMap1.equals(symbolMap2));
902    }
903   
904    @Test
905    public void testEquals_3() {
906        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>();
907           
908        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>();
909       
910        ITaskInstance task = createTaskInstance("symbol1");
911        symbolMap1.addSymbol(task, "value1");
912        symbolMap2.addSymbol(task, "value1");
913       
914        assertTrue(symbolMap1.equals(symbolMap2));
915    }
916
917    @Test
918    public void testEquals_4() {
919        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>();
920               
921        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>();
922       
923        int entryCount = 1000;
924       
925        for (int i = 0; i < entryCount; i++) {
926            ITaskInstance task = createTaskInstance("symbol1");
927            symbolMap1.addSymbol(task, "value" + i);
928            assertFalse(symbolMap1.equals(symbolMap2));
929            symbolMap2.addSymbol(task, "value" + i);
930            assertTrue(symbolMap1.equals(symbolMap2));
931        }
932    }
933   
934    @Test
935    public void testEquals_5() {
936        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>();
937               
938        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>();
939       
940        int entryCount = 1000;
941       
942        for (int i = 0; i < entryCount; i++) {
943            ITaskInstance task = createTaskInstance("symbol" + i);
944            if (i % 7 == 0) {
945                symbolMap1.addSymbol(task, "value" + i);
946                assertFalse(symbolMap1.equals(symbolMap2));
947                symbolMap2.addSymbol(task, "value" + i);
948                assertTrue(symbolMap1.equals(symbolMap2));
949            }
950            else {
951                symbolMap1.addSymbol(task, null);
952                assertFalse(symbolMap1.equals(symbolMap2));
953                symbolMap2.addSymbol(task, null);
954                assertTrue(symbolMap1.equals(symbolMap2));
955            }
956        }
957    }
958   
959    @Test
960    public void testEquals_6() {
961        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>();
962               
963        SymbolMap<ITaskInstance, String> symbolMap2 = new TaskSymbolIdentityMap<String>();
964       
965        int entryCount = 1000;
966       
967        ITaskInstance[] taskInstances = new ITaskInstance[entryCount];
968       
969        for (int i = 0; i < entryCount; i++) {
970            ITaskInstance task = createTaskInstance("symbol" + i);
971            taskInstances[i] = task;
972            symbolMap1.addSymbol(task, "value" + i);
973            assertFalse(symbolMap1.equals(symbolMap2));
974            symbolMap2.addSymbol(task, "value" + i);
975            assertTrue(symbolMap1.equals(symbolMap2));
976        }
977       
978        for (int i = 150; i < (entryCount - 150); i++) {
979            symbolMap1.removeSymbol(taskInstances[i]);
980            assertFalse(symbolMap1.equals(symbolMap2));
981            symbolMap2.removeSymbol(taskInstances[i]);
982            assertTrue(symbolMap1.equals(symbolMap2));
983        }
984    }
985   
986    @Test
987    public void testPerformance_Contains_1() {
988        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>();
989        int mapSize = 100000;
990        int noOfLookups = 1000000;
991       
992        ITaskInstance[] taskInstances = new ITaskInstance[mapSize];
993       
994        for (int i = 0; i < mapSize; i++) {
995            ITaskInstance task = createTaskInstance("symbol" + i);
996            taskInstances[i] = task;
997            symbolMap1.addSymbol(task, "value" + i);
998        }
999       
1000        long start = System.currentTimeMillis();
1001        for (int i = 0; i < noOfLookups; i++) {
1002            symbolMap1.containsSymbol(taskInstances[noOfLookups % mapSize]);
1003        }
1004       
1005        System.out.println(noOfLookups + " look ups in a map of size " + mapSize + " took " +
1006                           (System.currentTimeMillis() - start));
1007    }
1008   
1009    @Test
1010    public void testPerformance_GetValue_1() {
1011        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>();
1012        int mapSize = 100000;
1013        int noOfLookups = 1000000;
1014       
1015        ITaskInstance[] taskInstances = new ITaskInstance[mapSize];
1016       
1017        for (int i = 0; i < mapSize; i++) {
1018            ITaskInstance task = createTaskInstance("symbol" + i);
1019            taskInstances[i] = task;
1020            symbolMap1.addSymbol(task, "value" + i);
1021        }
1022       
1023        long start = System.currentTimeMillis();
1024        for (int i = 0; i < noOfLookups; i++) {
1025            symbolMap1.getValue(taskInstances[noOfLookups % mapSize]);
1026        }
1027       
1028        System.out.println(noOfLookups + " value retrievals in a map of size " + mapSize +
1029                           " took " + (System.currentTimeMillis() - start));
1030    }
1031   
1032   
1033    @Test
1034    public void testPerformance_AddRemove_1() {
1035        SymbolMap<ITaskInstance, String> symbolMap1 = new TaskSymbolIdentityMap<String>();
1036        int mapSize = 100000;
1037        int noOfLookups = 1000000;
1038       
1039        ITaskInstance[] taskInstances = new ITaskInstance[mapSize];
1040       
1041        for (int i = 0; i < mapSize; i++) {
1042            ITaskInstance task = createTaskInstance("symbol" + i);
1043            taskInstances[i] = task;
1044            symbolMap1.addSymbol(task, "value" + i);
1045        }
1046       
1047        long start = System.currentTimeMillis();
1048        for (int i = 0; i < noOfLookups; i++) {
1049            ITaskInstance task = taskInstances[noOfLookups % mapSize];
1050            symbolMap1.addSymbol(task, symbolMap1.removeSymbol(task));
1051        }
1052       
1053        System.out.println(noOfLookups + " adds and removes in a map of size " + mapSize +
1054                           " took " + (System.currentTimeMillis() - start));
1055    }
1056    /**
1057     * <p>
1058     * TODO: comment
1059     * </p>
1060     *
1061     * @param string
1062     * @return
1063     */
1064    private ITaskInstance createTaskInstance(String id) {
1065        ITask task = tasks.get(id);
1066       
1067        if (task == null) {
1068            task = taskFactory.createNewEventTask
1069                (new DummyInteraction(id, 0), new DummyGUIElement("default"));
1070           
1071            tasks.put(id, task);
1072        }
1073       
1074        return taskFactory.createNewTaskInstance(task);
1075    }
1076
1077    private void assertSymbolMapEntries(SymbolMap<ITaskInstance, String> symbolMap,
1078                                        ITaskInstance[]                  symbols,
1079                                        String[]                         values)
1080    {
1081        assertEquals(symbols.length, symbolMap.size());
1082        assertEquals(symbols.length, symbolMap.getSymbols().size());
1083        assertEquals(values.length, symbolMap.getValues().size());
1084       
1085        for (int i = 0; i < symbols.length; i++) {
1086            assertTrue(symbolMap.containsSymbol(symbols[i]));
1087            assertEquals(values[i], symbolMap.getValue(symbols[i]));
1088            assertTrue(symbolMap.getSymbols().contains(symbols[i]));
1089            assertTrue(symbolMap.getValues().contains(values[i]));           
1090        }
1091    }
1092}
Note: See TracBrowser for help on using the repository browser.