1   /*
2    *  Licensed to the Apache Software Foundation (ASF) under one or more
3    *  contributor license agreements.  See the NOTICE file distributed with
4    *  this work for additional information regarding copyright ownership.
5    *  The ASF licenses this file to You under the Apache License, Version 2.0
6    *  (the "License"); you may not use this file except in compliance with
7    *  the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   *  Unless required by applicable law or agreed to in writing, software
12   *  distributed under the License is distributed on an "AS IS" BASIS,
13   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   *  See the License for the specific language governing permissions and
15   *  limitations under the License.
16   */
17  package org.apache.commons.collections.bidimap;
18  
19  import java.util.ArrayList;
20  import java.util.Arrays;
21  import java.util.Collections;
22  import java.util.Iterator;
23  import java.util.List;
24  import java.util.Map;
25  import java.util.Set;
26  import java.util.SortedMap;
27  import java.util.SortedSet;
28  import java.util.TreeMap;
29  import java.util.TreeSet;
30  
31  import org.apache.commons.collections.BulkTest;
32  import org.apache.commons.collections.SortedBidiMap;
33  import org.apache.commons.collections.map.AbstractTestSortedMap;
34  
35  /**
36   * Abstract test class for {@link SortedBidiMap} methods and contracts.
37   * 
38   * @version $Revision: 646780 $ $Date: 2008-04-10 13:48:07 +0100 (Thu, 10 Apr 2008) $
39   * 
40   * @author Matthew Hawthorne
41   * @author Stephen Colebourne
42   */
43  public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiMap {
44  
45      protected List sortedKeys = new ArrayList();
46      protected List sortedValues = new ArrayList();
47      protected SortedSet sortedNewValues = new TreeSet();
48  
49      public AbstractTestSortedBidiMap(String testName) {
50          super(testName);
51          sortedKeys.addAll(Arrays.asList(getSampleKeys()));
52          Collections.sort(sortedKeys);
53          sortedKeys = Collections.unmodifiableList(sortedKeys);
54          
55          Map map = new TreeMap();
56          for (int i = 0; i < getSampleKeys().length; i++) {
57              map.put(getSampleKeys()[i], getSampleValues()[i]);
58          }
59          sortedValues.addAll(map.values());
60          sortedValues = Collections.unmodifiableList(sortedValues);
61          
62          sortedNewValues.addAll(Arrays.asList(getNewSampleValues()));
63      }
64  
65      public AbstractTestSortedBidiMap() {
66          super();
67          sortedKeys.addAll(Arrays.asList(getSampleValues()));
68          Collections.sort(sortedKeys);
69          sortedKeys = Collections.unmodifiableList(sortedKeys);
70          
71          Map map = new TreeMap();
72          for (int i = 0; i < getSampleKeys().length; i++) {
73              map.put(getSampleValues()[i], getSampleKeys()[i]);
74          }
75          sortedValues.addAll(map.values());
76          sortedValues = Collections.unmodifiableList(sortedValues);
77          
78          sortedNewValues.addAll(Arrays.asList(getNewSampleValues()));
79      }
80  
81      //-----------------------------------------------------------------------
82      public boolean isAllowNullKey() {
83          return false;
84      }
85      public boolean isAllowNullValue() {
86          return false;
87      }
88      public Map makeConfirmedMap() {
89          return new TreeMap();
90      }
91  
92      //-----------------------------------------------------------------------
93      //-----------------------------------------------------------------------
94      public void testBidiHeadMapContains() {
95          // extra test as other tests get complex
96          SortedBidiMap sm = (SortedBidiMap) makeFullMap();
97          Iterator it = sm.keySet().iterator();
98          Object first = it.next();
99          Object toKey = it.next();
100         Object second = it.next();
101         Object firstValue = sm.get(first);
102         Object secondValue = sm.get(second);
103         
104         SortedMap head = sm.headMap(toKey);
105         assertEquals(1, head.size());
106         assertEquals(true, sm.containsKey(first));
107         assertEquals(true, head.containsKey(first));
108         assertEquals(true, sm.containsValue(firstValue));
109         assertEquals(true, head.containsValue(firstValue));
110         assertEquals(true, sm.containsKey(second));
111         assertEquals(false, head.containsKey(second));
112         assertEquals(true, sm.containsValue(secondValue));
113         assertEquals(false, head.containsValue(secondValue));
114     }
115                 
116     //-----------------------------------------------------------------------
117     public void testBidiClearByHeadMap() {
118         if (isRemoveSupported() == false) return;
119         
120         // extra test as other tests get complex
121         SortedBidiMap sm = (SortedBidiMap) makeFullMap();
122         Iterator it = sm.keySet().iterator();
123         Object first = it.next();
124         Object second = it.next();
125         Object toKey = it.next();
126         
127         Object firstValue = sm.get(first);
128         Object secondValue = sm.get(second);
129         Object toKeyValue = sm.get(toKey);
130         
131         SortedMap sub = sm.headMap(toKey);
132         int size = sm.size();
133         assertEquals(2, sub.size());
134         sub.clear();
135         assertEquals(0, sub.size());
136         assertEquals(size - 2, sm.size());
137         assertEquals(size - 2, sm.inverseBidiMap().size());
138         
139         assertEquals(false, sm.containsKey(first));
140         assertEquals(false, sm.containsValue(firstValue));
141         assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
142         assertEquals(false, sm.inverseBidiMap().containsValue(first));
143         assertEquals(false, sub.containsKey(first));
144         assertEquals(false, sub.containsValue(firstValue));
145         
146         assertEquals(false, sm.containsKey(second));
147         assertEquals(false, sm.containsValue(secondValue));
148         assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
149         assertEquals(false, sm.inverseBidiMap().containsValue(second));
150         assertEquals(false, sub.containsKey(second));
151         assertEquals(false, sub.containsValue(secondValue));
152         
153         assertEquals(true, sm.containsKey(toKey));
154         assertEquals(true, sm.containsValue(toKeyValue));
155         assertEquals(true, sm.inverseBidiMap().containsKey(toKeyValue));
156         assertEquals(true, sm.inverseBidiMap().containsValue(toKey));
157         assertEquals(false, sub.containsKey(toKey));
158         assertEquals(false, sub.containsValue(toKeyValue));
159     }
160 
161     //-----------------------------------------------------------------------
162     public void testBidiRemoveByHeadMap() {
163         if (isRemoveSupported() == false) return;
164         
165         // extra test as other tests get complex
166         SortedBidiMap sm = (SortedBidiMap) makeFullMap();
167         Iterator it = sm.keySet().iterator();
168         Object first = it.next();
169         Object second = it.next();
170         Object toKey = it.next();
171         
172         int size = sm.size();
173         SortedMap sub = sm.headMap(toKey);
174         assertEquals(2, sub.size());
175         assertEquals(true, sm.containsKey(first));
176         assertEquals(true, sub.containsKey(first));
177         assertEquals(true, sm.containsKey(second));
178         assertEquals(true, sub.containsKey(second));
179         
180         Object firstValue = sub.remove(first);
181         assertEquals(1, sub.size());
182         assertEquals(size - 1, sm.size());
183         assertEquals(size - 1, sm.inverseBidiMap().size());
184         assertEquals(false, sm.containsKey(first));
185         assertEquals(false, sm.containsValue(firstValue));
186         assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
187         assertEquals(false, sm.inverseBidiMap().containsValue(first));
188         assertEquals(false, sub.containsKey(first));
189         assertEquals(false, sub.containsValue(firstValue));
190         
191         Object secondValue = sub.remove(second);
192         assertEquals(0, sub.size());
193         assertEquals(size - 2, sm.size());
194         assertEquals(size - 2, sm.inverseBidiMap().size());
195         assertEquals(false, sm.containsKey(second));
196         assertEquals(false, sm.containsValue(secondValue));
197         assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
198         assertEquals(false, sm.inverseBidiMap().containsValue(second));
199         assertEquals(false, sub.containsKey(second));
200         assertEquals(false, sub.containsValue(secondValue));
201     }
202 
203     //-----------------------------------------------------------------------
204     public void testBidiRemoveByHeadMapEntrySet() {
205         if (isRemoveSupported() == false) return;
206         
207         // extra test as other tests get complex
208         SortedBidiMap sm = (SortedBidiMap) makeFullMap();
209         Iterator it = sm.keySet().iterator();
210         Object first = it.next();
211         Object second = it.next();
212         Object toKey = it.next();
213         
214         int size = sm.size();
215         SortedMap sub = sm.headMap(toKey);
216         Set set = sub.entrySet();
217         assertEquals(2, sub.size());
218         assertEquals(2, set.size());
219         
220         Iterator it2 = set.iterator();
221         Map.Entry firstEntry = cloneMapEntry((Map.Entry) it2.next());
222         Map.Entry secondEntry = cloneMapEntry((Map.Entry) it2.next());
223         assertEquals(true, sm.containsKey(first));
224         assertEquals(true, sub.containsKey(first));
225         assertEquals(true, set.contains(firstEntry));
226         assertEquals(true, sm.containsKey(second));
227         assertEquals(true, sub.containsKey(second));
228         assertEquals(true, set.contains(secondEntry));
229         
230         set.remove(firstEntry);
231         assertEquals(1, sub.size());
232         assertEquals(size - 1, sm.size());
233         assertEquals(size - 1, sm.inverseBidiMap().size());
234         assertEquals(false, sm.containsKey(firstEntry.getKey()));
235         assertEquals(false, sm.containsValue(firstEntry.getValue()));
236         assertEquals(false, sm.inverseBidiMap().containsKey(firstEntry.getValue()));
237         assertEquals(false, sm.inverseBidiMap().containsValue(firstEntry.getKey()));
238         assertEquals(false, sub.containsKey(firstEntry.getKey()));
239         assertEquals(false, sub.containsValue(firstEntry.getValue()));
240         assertEquals(false, set.contains(firstEntry));
241         
242         set.remove(secondEntry);
243         assertEquals(0, sub.size());
244         assertEquals(size - 2, sm.size());
245         assertEquals(size - 2, sm.inverseBidiMap().size());
246         assertEquals(false, sm.containsKey(secondEntry.getKey()));
247         assertEquals(false, sm.containsValue(secondEntry.getValue()));
248         assertEquals(false, sm.inverseBidiMap().containsKey(secondEntry.getValue()));
249         assertEquals(false, sm.inverseBidiMap().containsValue(secondEntry.getKey()));
250         assertEquals(false, sub.containsKey(secondEntry.getKey()));
251         assertEquals(false, sub.containsValue(secondEntry.getValue()));
252         assertEquals(false, set.contains(secondEntry));
253     }
254 
255     //-----------------------------------------------------------------------
256     //-----------------------------------------------------------------------
257     public void testBidiTailMapContains() {
258         // extra test as other tests get complex
259         SortedBidiMap sm = (SortedBidiMap) makeFullMap();
260         Iterator it = sm.keySet().iterator();
261         Object first = it.next();
262         Object fromKey = it.next();
263         Object second = it.next();
264         Object firstValue = sm.get(first);
265         Object fromKeyValue = sm.get(fromKey);
266         Object secondValue = sm.get(second);
267         
268         SortedMap sub = sm.tailMap(fromKey);
269         assertEquals(sm.size() - 1, sub.size());
270         assertEquals(true, sm.containsKey(first));
271         assertEquals(false, sub.containsKey(first));
272         assertEquals(true, sm.containsValue(firstValue));
273         assertEquals(false, sub.containsValue(firstValue));
274         assertEquals(true, sm.containsKey(fromKey));
275         assertEquals(true, sub.containsKey(fromKey));
276         assertEquals(true, sm.containsValue(fromKeyValue));
277         assertEquals(true, sub.containsValue(fromKeyValue));
278         assertEquals(true, sm.containsKey(second));
279         assertEquals(true, sub.containsKey(second));
280         assertEquals(true, sm.containsValue(secondValue));
281         assertEquals(true, sub.containsValue(secondValue));
282     }
283 
284     //-----------------------------------------------------------------------
285     public void testBidiClearByTailMap() {
286         if (isRemoveSupported() == false) return;
287         
288         // extra test as other tests get complex
289         SortedBidiMap sm = (SortedBidiMap) makeFullMap();
290         Iterator it = sm.keySet().iterator();
291         it.next();
292         it.next();
293         Object first = it.next();
294         Object fromKey = it.next();
295         Object second = it.next();
296         
297         Object firstValue = sm.get(first);
298         Object fromKeyValue = sm.get(fromKey);
299         Object secondValue = sm.get(second);
300         
301         SortedMap sub = sm.tailMap(fromKey);
302         int size = sm.size();
303         assertEquals(size - 3, sub.size());
304         sub.clear();
305         assertEquals(0, sub.size());
306         assertEquals(3, sm.size());
307         assertEquals(3, sm.inverseBidiMap().size());
308         
309         assertEquals(true, sm.containsKey(first));
310         assertEquals(true, sm.containsValue(firstValue));
311         assertEquals(true, sm.inverseBidiMap().containsKey(firstValue));
312         assertEquals(true, sm.inverseBidiMap().containsValue(first));
313         assertEquals(false, sub.containsKey(first));
314         assertEquals(false, sub.containsValue(firstValue));
315         
316         assertEquals(false, sm.containsKey(fromKey));
317         assertEquals(false, sm.containsValue(fromKeyValue));
318         assertEquals(false, sm.inverseBidiMap().containsKey(fromKeyValue));
319         assertEquals(false, sm.inverseBidiMap().containsValue(fromKey));
320         assertEquals(false, sub.containsKey(fromKey));
321         assertEquals(false, sub.containsValue(fromKeyValue));
322         
323         assertEquals(false, sm.containsKey(second));
324         assertEquals(false, sm.containsValue(secondValue));
325         assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
326         assertEquals(false, sm.inverseBidiMap().containsValue(second));
327         assertEquals(false, sub.containsKey(second));
328         assertEquals(false, sub.containsValue(secondValue));
329     }
330 
331     //-----------------------------------------------------------------------                
332     public void testBidiRemoveByTailMap() {
333         if (isRemoveSupported() == false) return;
334         
335         // extra test as other tests get complex
336         SortedBidiMap sm = (SortedBidiMap) makeFullMap();
337         Iterator it = sm.keySet().iterator();
338         it.next();
339         it.next();
340         Object fromKey = it.next();
341         Object first = it.next();
342         Object second = it.next();
343         
344         int size = sm.size();
345         SortedMap sub = sm.tailMap(fromKey);
346         assertEquals(true, sm.containsKey(first));
347         assertEquals(true, sub.containsKey(first));
348         assertEquals(true, sm.containsKey(second));
349         assertEquals(true, sub.containsKey(second));
350         
351         Object firstValue = sub.remove(first);
352         assertEquals(size - 3, sub.size());
353         assertEquals(size - 1, sm.size());
354         assertEquals(size - 1, sm.inverseBidiMap().size());
355         assertEquals(false, sm.containsKey(first));
356         assertEquals(false, sm.containsValue(firstValue));
357         assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
358         assertEquals(false, sm.inverseBidiMap().containsValue(first));
359         assertEquals(false, sub.containsKey(first));
360         assertEquals(false, sub.containsValue(firstValue));
361         
362         Object secondValue = sub.remove(second);
363         assertEquals(size - 4, sub.size());
364         assertEquals(size - 2, sm.size());
365         assertEquals(size - 2, sm.inverseBidiMap().size());
366         assertEquals(false, sm.containsKey(second));
367         assertEquals(false, sm.containsValue(secondValue));
368         assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
369         assertEquals(false, sm.inverseBidiMap().containsValue(second));
370         assertEquals(false, sub.containsKey(second));
371         assertEquals(false, sub.containsValue(secondValue));
372     }
373 
374     //-----------------------------------------------------------------------
375     public void testBidiRemoveByTailMapEntrySet() {
376         if (isRemoveSupported() == false) return;
377         
378         // extra test as other tests get complex
379         SortedBidiMap sm = (SortedBidiMap) makeFullMap();
380         Iterator it = sm.keySet().iterator();
381         it.next();
382         it.next();
383         Object fromKey = it.next();
384         Object first = it.next();
385         Object second = it.next();
386         
387         int size = sm.size();
388         SortedMap sub = sm.tailMap(fromKey);
389         Set set = sub.entrySet();
390         Iterator it2 = set.iterator();
391         Object fromEntry = it2.next();
392         Map.Entry firstEntry = cloneMapEntry((Map.Entry) it2.next());
393         Map.Entry secondEntry = cloneMapEntry((Map.Entry) it2.next());
394         assertEquals(true, sm.containsKey(first));
395         assertEquals(true, sub.containsKey(first));
396         assertEquals(true, set.contains(firstEntry));
397         assertEquals(true, sm.containsKey(second));
398         assertEquals(true, sub.containsKey(second));
399         assertEquals(true, set.contains(secondEntry));
400         
401         set.remove(firstEntry);
402         assertEquals(size - 3, sub.size());
403         assertEquals(size - 1, sm.size());
404         assertEquals(size - 1, sm.inverseBidiMap().size());
405         assertEquals(false, sm.containsKey(firstEntry.getKey()));
406         assertEquals(false, sm.containsValue(firstEntry.getValue()));
407         assertEquals(false, sm.inverseBidiMap().containsKey(firstEntry.getValue()));
408         assertEquals(false, sm.inverseBidiMap().containsValue(firstEntry.getKey()));
409         assertEquals(false, sub.containsKey(firstEntry.getKey()));
410         assertEquals(false, sub.containsValue(firstEntry.getValue()));
411         assertEquals(false, set.contains(firstEntry));
412         
413         set.remove(secondEntry);
414         assertEquals(size - 4, sub.size());
415         assertEquals(size - 2, sm.size());
416         assertEquals(size - 2, sm.inverseBidiMap().size());
417         assertEquals(false, sm.containsKey(secondEntry.getKey()));
418         assertEquals(false, sm.containsValue(secondEntry.getValue()));
419         assertEquals(false, sm.inverseBidiMap().containsKey(secondEntry.getValue()));
420         assertEquals(false, sm.inverseBidiMap().containsValue(secondEntry.getKey()));
421         assertEquals(false, sub.containsKey(secondEntry.getKey()));
422         assertEquals(false, sub.containsValue(secondEntry.getValue()));
423         assertEquals(false, set.contains(secondEntry));
424     }
425 
426     //-----------------------------------------------------------------------
427     //-----------------------------------------------------------------------
428     public void testBidiSubMapContains() {
429         // extra test as other tests get complex
430         SortedBidiMap sm = (SortedBidiMap) makeFullMap();
431         Iterator it = sm.keySet().iterator();
432         Object first = it.next();
433         Object fromKey = it.next();
434         Object second = it.next();
435         Object toKey = it.next();
436         Object third = it.next();
437         Object firstValue = sm.get(first);
438         Object fromKeyValue = sm.get(fromKey);
439         Object secondValue = sm.get(second);
440         Object thirdValue = sm.get(third);
441         
442         SortedMap sub = sm.subMap(fromKey, toKey);
443         assertEquals(2, sub.size());
444         assertEquals(true, sm.containsKey(first));
445         assertEquals(false, sub.containsKey(first));
446         assertEquals(true, sm.containsValue(firstValue));
447         assertEquals(false, sub.containsValue(firstValue));
448         assertEquals(true, sm.containsKey(fromKey));
449         assertEquals(true, sub.containsKey(fromKey));
450         assertEquals(true, sm.containsValue(fromKeyValue));
451         assertEquals(true, sub.containsValue(fromKeyValue));
452         assertEquals(true, sm.containsKey(second));
453         assertEquals(true, sub.containsKey(second));
454         assertEquals(true, sm.containsValue(secondValue));
455         assertEquals(true, sub.containsValue(secondValue));
456         assertEquals(true, sm.containsKey(third));
457         assertEquals(false, sub.containsKey(third));
458         assertEquals(true, sm.containsValue(thirdValue));
459         assertEquals(false, sub.containsValue(thirdValue));
460     }
461 
462     //-----------------------------------------------------------------------
463     public void testBidiClearBySubMap() {
464         if (isRemoveSupported() == false) return;
465         
466         // extra test as other tests get complex
467         SortedBidiMap sm = (SortedBidiMap) makeFullMap();
468         Iterator it = sm.keySet().iterator();
469         it.next();
470         Object fromKey = it.next();
471         Object first = it.next();
472         Object second = it.next();
473         Object toKey = it.next();
474         
475         Object fromKeyValue = sm.get(fromKey);
476         Object firstValue = sm.get(first);
477         Object secondValue = sm.get(second);
478         Object toKeyValue = sm.get(toKey);
479         
480         SortedMap sub = sm.subMap(fromKey, toKey);
481         int size = sm.size();
482         assertEquals(3, sub.size());
483         sub.clear();
484         assertEquals(0, sub.size());
485         assertEquals(size - 3, sm.size());
486         assertEquals(size - 3, sm.inverseBidiMap().size());
487         
488         assertEquals(false, sm.containsKey(fromKey));
489         assertEquals(false, sm.containsValue(fromKeyValue));
490         assertEquals(false, sm.inverseBidiMap().containsKey(fromKeyValue));
491         assertEquals(false, sm.inverseBidiMap().containsValue(fromKey));
492         assertEquals(false, sub.containsKey(fromKey));
493         assertEquals(false, sub.containsValue(fromKeyValue));
494         
495         assertEquals(false, sm.containsKey(first));
496         assertEquals(false, sm.containsValue(firstValue));
497         assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
498         assertEquals(false, sm.inverseBidiMap().containsValue(first));
499         assertEquals(false, sub.containsKey(first));
500         assertEquals(false, sub.containsValue(firstValue));
501         
502         assertEquals(false, sm.containsKey(second));
503         assertEquals(false, sm.containsValue(secondValue));
504         assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
505         assertEquals(false, sm.inverseBidiMap().containsValue(second));
506         assertEquals(false, sub.containsKey(second));
507         assertEquals(false, sub.containsValue(secondValue));
508         
509         assertEquals(true, sm.containsKey(toKey));
510         assertEquals(true, sm.containsValue(toKeyValue));
511         assertEquals(true, sm.inverseBidiMap().containsKey(toKeyValue));
512         assertEquals(true, sm.inverseBidiMap().containsValue(toKey));
513         assertEquals(false, sub.containsKey(toKey));
514         assertEquals(false, sub.containsValue(toKeyValue));
515     }
516 
517     //-----------------------------------------------------------------------
518     public void testBidiRemoveBySubMap() {
519         if (isRemoveSupported() == false) return;
520         
521         // extra test as other tests get complex
522         SortedBidiMap sm = (SortedBidiMap) makeFullMap();
523         Iterator it = sm.keySet().iterator();
524         it.next();
525         it.next();
526         Object fromKey = it.next();
527         Object first = it.next();
528         Object second = it.next();
529         Object toKey = it.next();
530         
531         int size = sm.size();
532         SortedMap sub = sm.subMap(fromKey, toKey);
533         assertEquals(true, sm.containsKey(first));
534         assertEquals(true, sub.containsKey(first));
535         assertEquals(true, sm.containsKey(second));
536         assertEquals(true, sub.containsKey(second));
537         
538         Object firstValue = sub.remove(first);
539         assertEquals(2, sub.size());
540         assertEquals(size - 1, sm.size());
541         assertEquals(size - 1, sm.inverseBidiMap().size());
542         assertEquals(false, sm.containsKey(first));
543         assertEquals(false, sm.containsValue(firstValue));
544         assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
545         assertEquals(false, sm.inverseBidiMap().containsValue(first));
546         assertEquals(false, sub.containsKey(first));
547         assertEquals(false, sub.containsValue(firstValue));
548         
549         Object secondValue = sub.remove(second);
550         assertEquals(1, sub.size());
551         assertEquals(size - 2, sm.size());
552         assertEquals(size - 2, sm.inverseBidiMap().size());
553         assertEquals(false, sm.containsKey(second));
554         assertEquals(false, sm.containsValue(secondValue));
555         assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
556         assertEquals(false, sm.inverseBidiMap().containsValue(second));
557         assertEquals(false, sub.containsKey(second));
558         assertEquals(false, sub.containsValue(secondValue));
559     }
560 
561     //-----------------------------------------------------------------------
562     public void testBidiRemoveBySubMapEntrySet() {
563         if (isRemoveSupported() == false) return;
564         
565         // extra test as other tests get complex
566         SortedBidiMap sm = (SortedBidiMap) makeFullMap();
567         Iterator it = sm.keySet().iterator();
568         it.next();
569         it.next();
570         Object fromKey = it.next();
571         Object first = it.next();
572         Object second = it.next();
573         Object toKey = it.next();
574         
575         int size = sm.size();
576         SortedMap sub = sm.subMap(fromKey, toKey);
577         Set set = sub.entrySet();
578         assertEquals(3, set.size());
579         Iterator it2 = set.iterator();
580         Object fromEntry = it2.next();
581         Map.Entry firstEntry = cloneMapEntry((Map.Entry) it2.next());
582         Map.Entry secondEntry = cloneMapEntry((Map.Entry) it2.next());
583         assertEquals(true, sm.containsKey(first));
584         assertEquals(true, sub.containsKey(first));
585         assertEquals(true, set.contains(firstEntry));
586         assertEquals(true, sm.containsKey(second));
587         assertEquals(true, sub.containsKey(second));
588         assertEquals(true, set.contains(secondEntry));
589         
590         set.remove(firstEntry);
591         assertEquals(2, sub.size());
592         assertEquals(size - 1, sm.size());
593         assertEquals(size - 1, sm.inverseBidiMap().size());
594         assertEquals(false, sm.containsKey(firstEntry.getKey()));
595         assertEquals(false, sm.containsValue(firstEntry.getValue()));
596         assertEquals(false, sm.inverseBidiMap().containsKey(firstEntry.getValue()));
597         assertEquals(false, sm.inverseBidiMap().containsValue(firstEntry.getKey()));
598         assertEquals(false, sub.containsKey(firstEntry.getKey()));
599         assertEquals(false, sub.containsValue(firstEntry.getValue()));
600         assertEquals(false, set.contains(firstEntry));
601         
602         set.remove(secondEntry);
603         assertEquals(1, sub.size());
604         assertEquals(size - 2, sm.size());
605         assertEquals(size - 2, sm.inverseBidiMap().size());
606         assertEquals(false, sm.containsKey(secondEntry.getKey()));
607         assertEquals(false, sm.containsValue(secondEntry.getValue()));
608         assertEquals(false, sm.inverseBidiMap().containsKey(secondEntry.getValue()));
609         assertEquals(false, sm.inverseBidiMap().containsValue(secondEntry.getKey()));
610         assertEquals(false, sub.containsKey(secondEntry.getKey()));
611         assertEquals(false, sub.containsValue(secondEntry.getValue()));
612         assertEquals(false, set.contains(secondEntry));
613     }
614 
615     //-----------------------------------------------------------------------    
616     public BulkTest bulkTestHeadMap() {
617         return new AbstractTestSortedMap.TestHeadMap(this);
618     }
619 
620     public BulkTest bulkTestTailMap() {
621         return new AbstractTestSortedMap.TestTailMap(this);
622     }
623 
624     public BulkTest bulkTestSubMap() {
625         return new AbstractTestSortedMap.TestSubMap(this);
626     }
627 
628 }