source: trunk/autoquest-core-usageprofiles-test/src/test/java/de/ugoe/cs/autoquest/usageprofiles/SymbolMapTest.java @ 1251

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