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

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