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

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