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