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

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