Java > Open Source Codes > org > apache > commons > collections > TestDoubleOrderedMap


1 /*
2  * Copyright 2001-2004 The Apache Software Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.apache.commons.collections;
17
18 import java.util.Collection ;
19 import java.util.ConcurrentModificationException ;
20 import java.util.HashMap ;
21 import java.util.HashSet ;
22 import java.util.Iterator ;
23 import java.util.LinkedList ;
24 import java.util.Map ;
25 import java.util.NoSuchElementException ;
26 import java.util.Set ;
27
28 import junit.framework.Test;
29
30 import org.apache.commons.collections.map.AbstractTestMap;
31
32 /**
33  * Class TestDoubleOrderedMap
34  * <p>
35  * Test cases for DoubleOrderedMap. This class cannot
36  * implement TestMap.SupportsPut, because it is a special
37  * Map that does not support duplicate keys, duplicate
38  * values, or null values.
39  *
40  * @version $Revision: 1.15 $ $Date: 2004/02/18 01:20:35 $
41  *
42  * @author Marc Johnson
43  * @author Stephen Colebourne
44  */
45 public class TestDoubleOrderedMap extends AbstractTestMap {
46
47     /**
48      * constructor
49      *
50      * @param name
51      */
52     public TestDoubleOrderedMap(final String name) {
53         super(name);
54     }
55
56     /**
57      * create a suite of the tests in this class
58      *
59      * @return the test suite
60      */
61     public static Test suite() {
62         return BulkTest.makeSuite(TestDoubleOrderedMap.class);
63     }
64
65     /**
66      * The default comparator in double ordered map does not allow null keys.
67      **/
68     public boolean isAllowNullKey() {
69         return false;
70     }
71
72     /**
73      * The default comparator in double ordered map does not allow null keys,
74      * and values are keys in this map.
75      **/
76     public boolean isAllowNullValue() {
77         return false;
78     }
79
80     /**
81      * Double ordered map does not support duplicate values
82      **/
83     public boolean isAllowDuplicateValues() {
84         return false;
85     }
86     
87     /**
88      * Change the Map.put() test because it tries put with the same key
89      * which is invalid in the modified double ordered map contract. (The
90      * DoubleOrderedMap documentation states that an IllegalArgumentException
91      * is thrown when a key is tried to be put into the map again. This
92      * differs from the standard Map contract which would replace the value
93      * for that key and return it.
94      */
95     public boolean isPutChangeSupported() {
96         return false;
97     }
98
99     /**
100      * setValue() is not supported as it can change the map.
101      */
102     public boolean isSetValueSupported() {
103         return false;
104     }
105
106     public Map makeEmptyMap() {
107         return new DoubleOrderedMap();
108     }
109
110     protected Map makeMap() {
111         return new DoubleOrderedMap();
112     }
113
114     /**
115      * test size() method
116      */
117     public void testSize() {
118
119         Map m = makeMap();
120
121         assertEquals(0, m.size());
122
123         LocalTestNode nodes[] = makeLocalNodes();
124
125         for (int k = 0; k < nodes.length; k++) {
126             m.put(nodes[k].getKey(), nodes[k].getValue());
127             assertEquals(k + 1, m.size());
128         }
129
130         int count = m.size();
131
132         for (int k = 0; k < nodes.length; k++) {
133             m.remove(nodes[k].getKey());
134
135             --count;
136
137             assertEquals(count, m.size());
138
139             // failed remove should not affect size
140 m.remove(nodes[k].getKey());
141             assertEquals(count, m.size());
142         }
143     }
144
145     /**
146      * test IsEmpty() method
147      */
148     public void testIsEmpty() {
149
150         Map m = makeMap();
151
152         assertTrue(m.isEmpty());
153
154         LocalTestNode nodes[] = makeLocalNodes();
155
156         for (int k = 0; k < nodes.length; k++) {
157             m.put(nodes[k].getKey(), nodes[k].getValue());
158             assertTrue(!m.isEmpty());
159         }
160
161         int count = m.size();
162
163         for (int k = 0; k < nodes.length; k++) {
164             m.remove(nodes[k].getKey());
165
166             --count;
167
168             if (count == 0) {
169                 assertTrue(m.isEmpty());
170             } else {
171                 assertTrue(!m.isEmpty());
172             }
173
174             // failed remove should not affect emptiness
175 m.remove(nodes[k].getKey());
176
177             if (count == 0) {
178                 assertTrue(m.isEmpty());
179             } else {
180                 assertTrue(!m.isEmpty());
181             }
182         }
183     }
184
185     /**
186      * test containsKey() method
187      */
188     public void testContainsKey() {
189
190         Map m = makeMap();
191
192         try {
193             m.containsKey(new Object ());
194             fail("should have caught ClassCastException");
195         } catch (ClassCastException ignored) {}
196
197         try {
198             m.containsKey(null);
199             fail("should have caught NullPointerException");
200         } catch (NullPointerException ignored) {}
201
202         assertTrue(!m.containsKey("foo"));
203
204         LocalTestNode nodes[] = makeLocalNodes();
205
206         for (int k = 0; k < nodes.length; k++) {
207             m.put(nodes[k].getKey(), nodes[k]);
208             assertTrue(m.containsKey(nodes[k].getKey()));
209         }
210
211         assertTrue(!m.containsKey(new Integer (-1)));
212
213         try {
214             m.containsKey("foo");
215             fail("Should have caught ClassCastException");
216         } catch (ClassCastException ignored) {}
217
218         for (int k = 0; k < nodes.length; k++) {
219             m.remove(nodes[k].getKey());
220             assertTrue(!m.containsKey(nodes[k].getKey()));
221         }
222     }
223
224     /**
225      * test containsValue() method
226      */
227     public void testContainsValue() {
228
229         Map m = (DoubleOrderedMap) makeMap();
230         LocalTestNode nodes[] = makeLocalNodes();
231
232         for (int k = 0; k < nodes.length; k++) {
233             m.put(nodes[k].getKey(), nodes[k]);
234             assertTrue(m.containsValue(nodes[k]));
235         }
236
237         for (int k = 0; k < nodes.length; k++) {
238             m.remove(nodes[k].getKey());
239             assertTrue(!m.containsValue(nodes[k]));
240         }
241     }
242
243     /**
244      * test get() method
245      */
246     public void testGet() {
247
248         Map m = makeMap();
249
250         try {
251             m.get(new Object ());
252             fail("should have caught ClassCastException");
253         } catch (ClassCastException ignored) {}
254
255         try {
256             m.get(null);
257             fail("should have caught NullPointerException");
258         } catch (NullPointerException ignored) {}
259
260         assertNull(m.get("foo"));
261
262         LocalTestNode nodes[] = makeLocalNodes();
263
264         for (int k = 0; k < nodes.length; k++) {
265             m.put(nodes[k].getKey(), nodes[k]);
266             assertSame(m.get(nodes[k].getKey()), nodes[k]);
267         }
268
269         assertNull(m.get(new Integer (-1)));
270
271         try {
272             m.get("foo");
273             fail("Should have caught ClassCastException");
274         } catch (ClassCastException ignored) {}
275
276         for (int k = 0; k < nodes.length; k++) {
277             assertNotNull(m.get(nodes[k].getKey()));
278             m.remove(nodes[k].getKey());
279             assertNull(m.get(nodes[k].getKey()));
280         }
281     }
282
283     /**
284      * test put() method
285      */
286     public void testPut() {
287
288         Map m = makeMap();
289
290         try {
291             m.put(new Object (), "foo");
292             fail("should have caught ClassCastException");
293         } catch (ClassCastException ignored) {}
294
295         try {
296             m.put(null, "foo");
297             fail("should have caught NullPointerException");
298         } catch (NullPointerException ignored) {}
299
300         try {
301             m.put("foo", null);
302             fail("should have caught NullPointerException");
303         } catch (NullPointerException ignored) {}
304
305         try {
306             m.put("foo", new Object ());
307             fail("should have caught ClassCastException");
308         } catch (ClassCastException ignored) {}
309
310         LocalTestNode[] nodes = makeLocalNodes();
311
312         for (int k = 0; k < nodes.length; k++) {
313             assertNull(m.put(nodes[k].getKey(), nodes[k].getValue()));
314
315             try {
316                 m.put(nodes[k].getKey(), "foo");
317             } catch (IllegalArgumentException ignored) {}
318         }
319     }
320
321     /**
322      * test remove() method
323      */
324     public void testRemove() {
325
326         DoubleOrderedMap m = (DoubleOrderedMap) makeMap();
327         LocalTestNode nodes[] = makeLocalNodes();
328
329         for (int k = 0; k < nodes.length; k++) {
330             m.put(nodes[k].getKey(), nodes[k]);
331         }
332
333         try {
334             m.remove(null);
335             fail("should have caught NullPointerException");
336         } catch (NullPointerException ignored) {}
337
338         try {
339             m.remove(new Object ());
340             fail("should have caught ClassCastException");
341         } catch (ClassCastException ignored) {}
342
343         assertNull(m.remove(new Integer (-1)));
344
345         try {
346             m.remove("foo");
347             fail("should have caught ClassCastException");
348         } catch (ClassCastException ignored) {}
349
350         for (int k = 0; k < nodes.length; k += 2) {
351             Comparable key = nodes[k].getKey();
352
353             assertNotNull(m.get(key));
354             assertSame(nodes[k], m.remove(key));
355             assertNull(m.remove(key));
356             assertNull(m.get(key));
357         }
358
359         for (int k = 1; k < nodes.length; k += 2) {
360             Comparable key = nodes[k].getKey();
361
362             assertNotNull(m.get(key));
363             assertSame(nodes[k], m.remove(key));
364             assertNull(m.remove(key));
365             assertNull(m.get(key));
366         }
367
368         assertTrue(m.isEmpty());
369     }
370
371     /**
372      * Method testPutAll
373      */
374     public void testPutAll() {
375
376         Map m = (DoubleOrderedMap) makeMap();
377         LocalTestNode nodes[] = makeLocalNodes();
378
379         for (int k = 0; k < nodes.length; k++) {
380             m.put(nodes[k].getKey(), nodes[k]);
381         }
382
383         Map m1 = new HashMap ();
384
385         m1.put(null, "foo");
386
387         try {
388             m.putAll(m1);
389             fail("Should have caught NullPointerException");
390         } catch (NullPointerException ignored) {}
391
392         m1 = new HashMap ();
393
394         m1.put(new Object (), "bar");
395
396         try {
397             m.putAll(m1);
398             fail("Should have caught ClassCastException");
399         } catch (ClassCastException ignored) {}
400
401         m1 = new HashMap ();
402
403         m1.put("fubar", null);
404
405         try {
406             m.putAll(m1);
407             fail("Should have caught NullPointerException");
408         } catch (NullPointerException ignored) {}
409
410         m1 = new HashMap ();
411
412         m1.put("fubar", new Object ());
413
414         try {
415             m.putAll(m1);
416             fail("Should have caught ClassCastException");
417         } catch (ClassCastException ignored) {}
418
419         assertEquals(nodes.length, m.size());
420
421         m = (DoubleOrderedMap) makeMap();
422         m1 = new HashMap ();
423
424         for (int k = 0; k < nodes.length; k++) {
425             m1.put(nodes[k].getKey(), nodes[k].getValue());
426         }
427
428         m.putAll(m1);
429         assertEquals(nodes.length, m.size());
430
431         for (int k = 0; k < nodes.length; k++) {
432             assertSame(nodes[k].getValue(), m.get(nodes[k].getKey()));
433         }
434     }
435
436     /**
437      * test clear() method
438      */
439     public void testClear() {
440
441         Map m = (DoubleOrderedMap) makeMap();
442         LocalTestNode nodes[] = makeLocalNodes();
443
444         for (int k = 0; k < nodes.length; k++) {
445             m.put(nodes[k].getKey(), nodes[k].getValue());
446             assertTrue(!m.isEmpty());
447         }
448
449         assertTrue(!m.isEmpty());
450
451         for (int k = 0; k < nodes.length; k++) {
452             assertTrue(m.containsKey(nodes[k].getKey()));
453             assertTrue(m.containsValue(nodes[k].getValue()));
454         }
455
456         m.clear();
457         assertTrue(m.isEmpty());
458
459         for (int k = 0; k < nodes.length; k++) {
460             assertTrue(!m.containsKey(nodes[k].getKey()));
461             assertTrue(!m.containsValue(nodes[k].getValue()));
462         }
463     }
464
465     /**
466      * test keySet() method
467      */
468     public void testKeySet() {
469
470         testKeySet((DoubleOrderedMap) makeMap());
471
472         Map m = (DoubleOrderedMap) makeMap();
473         LocalTestNode nodes[] = makeLocalNodes();
474
475         for (int k = 0; k < nodes.length; k++) {
476             m.put(nodes[k].getKey(), nodes[k]);
477         }
478
479         testKeySet(m);
480
481         m = (DoubleOrderedMap) makeMap();
482
483         for (int k = 0; k < nodes.length; k++) {
484             m.put(nodes[k].getKey(), nodes[k]);
485         }
486
487         int count = m.size();
488
489         for (Iterator iter = m.keySet().iterator(); iter.hasNext(); ) {
490             iter.next();
491             iter.remove();
492
493             --count;
494
495             assertEquals(count, m.size());
496         }
497
498         assertTrue(m.isEmpty());
499
500         m = (DoubleOrderedMap) makeMap();
501
502         for (int k = 0; k < nodes.length; k++) {
503             m.put(nodes[k].getKey(), nodes[k]);
504         }
505
506         Set s = m.keySet();
507
508         try {
509             s.remove(null);
510             fail("should have caught NullPointerException");
511         } catch (NullPointerException ignored) {}
512
513         try {
514             s.remove(new Object ());
515             fail("should have caught ClassCastException");
516         } catch (ClassCastException ignored) {}
517
518         for (int k = 0; k < nodes.length; k++) {
519             Comparable key = nodes[k].getKey();
520
521             assertTrue(s.remove(key));
522             assertTrue(!s.contains(key));
523             assertTrue(!m.containsKey(key));
524             assertTrue(!m.containsValue(nodes[k]));
525         }
526
527         assertTrue(m.isEmpty());
528
529         m = (DoubleOrderedMap) makeMap();
530
531         Collection c1 = new LinkedList ();
532         Collection c2 = new LinkedList ();
533
534         c2.add(new Integer (-99));
535
536         for (int k = 0; k < nodes.length; k++) {
537             m.put(nodes[k].getKey(), nodes[k]);
538             c1.add(nodes[k].getKey());
539             c2.add(nodes[k].getKey());
540         }
541
542         assertTrue(m.keySet().containsAll(c1));
543         assertTrue(!m.keySet().containsAll(c2));
544
545         m = (DoubleOrderedMap) makeMap();
546         c1 = new LinkedList ();
547
548         c1.add(new Integer (-55));
549
550         try {
551             m.keySet().addAll(c1);
552             fail("should have caught exception of addAll()");
553         } catch (UnsupportedOperationException ignored) {}
554
555         for (int k = 0; k < nodes.length; k++) {
556             m.put(nodes[k].getKey(), nodes[k]);
557             c1.add(nodes[k].getKey());
558         }
559
560         assertTrue(!m.keySet().retainAll(c1));
561         assertEquals(nodes.length, m.size());
562
563         m = (DoubleOrderedMap) makeMap();
564         c1 = new LinkedList ();
565
566         for (int k = 0; k < nodes.length; k++) {
567             m.put(nodes[k].getKey(), nodes[k]);
568
569             if (k % 2 == 1) {
570                 c1.add(nodes[k].getKey());
571             }
572         }
573
574         assertTrue(m.keySet().retainAll(c1));
575         assertEquals(nodes.length / 2, m.size());
576
577         m = (DoubleOrderedMap) makeMap();
578         c1 = new LinkedList ();
579
580         for (int k = 0; k < nodes.length; k++) {
581             m.put(nodes[k].getKey(), nodes[k]);
582         }
583
584         assertTrue(m.keySet().retainAll(c1));
585         assertEquals(0, m.size());
586
587         m = (DoubleOrderedMap) makeMap();
588         c1 = new LinkedList ();
589
590         for (int k = 0; k < nodes.length; k++) {
591             m.put(nodes[k].getKey(), nodes[k]);
592         }
593
594         assertTrue(!m.keySet().removeAll(c1));
595         assertEquals(nodes.length, m.size());
596
597         m = (DoubleOrderedMap) makeMap();
598         c1 = new LinkedList ();
599
600         for (int k = 0; k < nodes.length; k++) {
601             m.put(nodes[k].getKey(), nodes[k]);
602
603             if (k % 2 == 0) {
604                 c1.add(nodes[k].getKey());
605             }
606         }
607
608         assertTrue(m.keySet().removeAll(c1));
609         assertEquals(nodes.length / 2, m.size());
610
611         m = (DoubleOrderedMap) makeMap();
612         c1 = new LinkedList ();
613
614         for (int k = 0; k < nodes.length; k++) {
615             m.put(nodes[k].getKey(), nodes[k]);
616             c1.add(nodes[k].getKey());
617         }
618
619         assertTrue(m.keySet().removeAll(c1));
620         assertEquals(0, m.size());
621
622         m = (DoubleOrderedMap) makeMap();
623
624         for (int k = 0; k < nodes.length; k++) {
625             m.put(nodes[k].getKey(), nodes[k]);
626         }
627
628         m.keySet().clear();
629         assertEquals(0, m.size());
630     }
631
632     /**
633      * test values() method
634      */
635     public void testValues() {
636
637         testValues((DoubleOrderedMap) makeMap());
638
639         Map m = (DoubleOrderedMap) makeMap();
640         LocalTestNode nodes[] = makeLocalNodes();
641
642         for (int k = 0; k < nodes.length; k++) {
643             m.put(nodes[k].getKey(), nodes[k]);
644         }
645
646         testValues(m);
647
648         m = (DoubleOrderedMap) makeMap();
649
650         for (int k = 0; k < nodes.length; k++) {
651             m.put(nodes[k].getKey(), nodes[k]);
652         }
653
654         int count = m.size();
655
656         for (Iterator iter = m.values().iterator(); iter.hasNext(); ) {
657             iter.next();
658             iter.remove();
659
660             --count;
661
662             assertEquals(count, m.size());
663         }
664
665         assertTrue(m.isEmpty());
666
667         m = (DoubleOrderedMap) makeMap();
668
669         for (int k = 0; k < nodes.length; k++) {
670             m.put(nodes[k].getKey(), nodes[k]);
671         }
672
673         count = m.size();
674
675         Collection s = m.values();
676
677         for (int k = 0; k < count; k++) {
678             assertTrue(s.remove(nodes[k]));
679             assertTrue(!s.contains(nodes[k]));
680             assertTrue(!m.containsKey(nodes[k].getKey()));
681             assertTrue(!m.containsValue(nodes[k]));
682         }
683
684         assertTrue(m.isEmpty());
685
686         m = (DoubleOrderedMap) makeMap();
687
688         Collection c1 = new LinkedList ();
689         Collection c2 = new LinkedList ();
690
691         c2.add(new LocalTestNode(-123));
692
693         for (int k = 0; k < nodes.length; k++) {
694             m.put(nodes[k].getKey(), nodes[k]);
695             c1.add(nodes[k]);
696             c2.add(nodes[k]);
697         }
698
699         assertTrue(m.values().containsAll(c1));
700         assertTrue(!m.values().containsAll(c2));
701
702         m = (DoubleOrderedMap) makeMap();
703         c1 = new LinkedList ();
704
705         for (int k = 0; k < nodes.length; k++) {
706             m.put(nodes[k].getKey(), nodes[k]);
707             c1.add(nodes[k]);
708         }
709
710         try {
711             m.values().addAll(c1);
712             fail("should have caught exception of addAll()");
713         } catch (UnsupportedOperationException ignored) {}
714
715         m = (DoubleOrderedMap) makeMap();
716         c1 = new LinkedList ();
717
718         for (int k = 0; k < nodes.length; k++) {
719             m.put(nodes[k].getKey(), nodes[k]);
720             c1.add(nodes[k]);
721         }
722
723         assertTrue(!m.values().retainAll(c1));
724         assertEquals(nodes.length, m.size());
725
726         m = (DoubleOrderedMap) makeMap();
727         c1 = new LinkedList ();
728
729         for (int k = 0; k < nodes.length; k++) {
730             m.put(nodes[k].getKey(), nodes[k]);
731
732             if (k % 2 == 1) {
733                 c1.add(nodes[k]);
734             }
735         }
736
737         assertTrue(m.values().retainAll(c1));
738         assertEquals(nodes.length / 2, m.size());
739
740         m = (DoubleOrderedMap) makeMap();
741         c1 = new LinkedList ();
742
743         for (int k = 0; k < nodes.length; k++) {
744             m.put(nodes[k].getKey(), nodes[k]);
745         }
746
747         assertTrue(m.values().retainAll(c1));
748         assertEquals(0, m.size());
749
750         m = (DoubleOrderedMap) makeMap();
751         c1 = new LinkedList ();
752
753         for (int k = 0; k < nodes.length; k++) {
754             m.put(nodes[k].getKey(), nodes[k]);
755         }
756
757         assertTrue(!m.values().removeAll(c1));
758         assertEquals(nodes.length, m.size());
759
760         m = (DoubleOrderedMap) makeMap();
761         c1 = new LinkedList ();
762
763         for (int k = 0; k < nodes.length; k++) {
764             m.put(nodes[k].getKey(), nodes[k]);
765
766             if (k % 2 == 0) {
767                 c1.add(nodes[k]);
768             }
769         }
770
771         assertTrue(m.values().removeAll(c1));
772         assertEquals(nodes.length / 2, m.size());
773
774         m = (DoubleOrderedMap) makeMap();
775         c1 = new LinkedList ();
776
777         for (int k = 0; k < nodes.length; k++) {
778             m.put(nodes[k].getKey(), nodes[k]);
779             c1.add(nodes[k]);
780         }
781
782         assertTrue(m.values().removeAll(c1));
783         assertEquals(0, m.size());
784
785         m = (DoubleOrderedMap) makeMap();
786
787         for (int k = 0; k < nodes.length; k++) {
788             m.put(nodes[k].getKey(), nodes[k]);
789         }
790
791         m.values().clear();
792         assertEquals(0, m.size());
793     }
794
795     /**
796      * test entrySet() method
797      */
798     public void testEntrySet() {
799
800         testEntrySet((DoubleOrderedMap) makeMap());
801
802         Map m = (DoubleOrderedMap) makeMap();
803         LocalTestNode nodes[] = makeLocalNodes();
804
805         for (int k = 0; k < nodes.length; k++) {
806             m.put(nodes[k].getKey(), nodes[k]);
807         }
808
809         testEntrySet(m);
810
811         m = (DoubleOrderedMap) makeMap();
812
813         for (int k = 0; k < nodes.length; k++) {
814             m.put(nodes[k].getKey(), nodes[k]);
815         }
816
817         try {
818             ((Map.Entry ) m.entrySet().iterator().next())
819                 .setValue(new LocalTestNode(-1));
820             fail("Should have caught UnsupportedOperationException");
821         } catch (UnsupportedOperationException ignored) {}
822
823         int count = m.size();
824
825         for (Iterator iter = m.entrySet().iterator(); iter.hasNext(); ) {
826             iter.next();
827             iter.remove();
828
829             --count;
830
831             assertEquals(count, m.size());
832         }
833
834         assertTrue(m.isEmpty());
835
836         m = (DoubleOrderedMap) makeMap();
837
838         Collection c1 = new LinkedList ();
839
840         for (int k = 0; k < nodes.length; k++) {
841             m.put(nodes[k].getKey(), nodes[k]);
842             c1.add(nodes[k].getKey());
843         }
844
845         try {
846             m.entrySet().addAll(c1);
847             fail("should have caught exception of addAll()");
848         } catch (UnsupportedOperationException ignored) {}
849
850         m = (DoubleOrderedMap) makeMap();
851
852         for (int k = 0; k < nodes.length; k++) {
853             m.put(nodes[k].getKey(), nodes[k]);
854         }
855
856         m.entrySet().clear();
857         assertEquals(0, m.size());
858
859         m = (DoubleOrderedMap) makeMap();
860
861         for (int k = 0; k < nodes.length; k++) {
862             m.put(nodes[k].getKey(), nodes[k]);
863         }
864
865         int x = 0;
866
867         for (Iterator iter = m.entrySet().iterator(); iter.hasNext(); ) {
868             Map.Entry entry = (Map.Entry ) iter.next();
869
870             assertSame(entry.getKey(), nodes[x].getKey());
871             assertSame(entry.getValue(), nodes[x]);
872
873             x++;
874         }
875     }
876
877     /**
878      * Method testEquals
879      */
880     public void testEquals() {
881
882         Map m = (DoubleOrderedMap) makeMap();
883         LocalTestNode nodes[] = makeLocalNodes();
884
885         for (int k = 0; k < nodes.length; k++) {
886             m.put(nodes[k].getKey(), nodes[k]);
887         }
888
889         assertTrue(!m.equals(null));
890         assertEquals(m, m);
891
892         Map m1 = new HashMap ();
893
894         for (int k = 0; k < nodes.length; k++) {
895             m1.put(nodes[k].getKey(), nodes[k]);
896         }
897
898         assertEquals(m, m1);
899
900         m1 = (DoubleOrderedMap) makeMap();
901
902         for (int k = 0; k < (nodes.length - 1); k++) {
903             m1.put(nodes[k].getKey(), nodes[k]);
904         }
905
906         assertTrue(!m.equals(m1));
907
908         m1 = (DoubleOrderedMap) makeMap();
909
910         for (int k = 0; k < nodes.length; k++) {
911             m1.put(nodes[k].getKey(), nodes[k]);
912         }
913
914         LocalTestNode node1 = new LocalTestNode(-1000);
915
916         m1.put(node1.getKey(), node1);
917         assertTrue(!m.equals(m1));
918
919         m1 = (DoubleOrderedMap) makeMap();
920
921  &n