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