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