source: branches/autoquest-core-tasktrees-alignment-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskSymbolIdentityMapTest.java @ 1735

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