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

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