1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
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
64
65
66
67
68
69
70
71
72
73
74
75
76
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
108
109 @Override
110 public SortedBidiMap<K, V> makeFullMap() {
111 return (SortedBidiMap<K, V>) super.makeFullMap();
112 }
113
114
115
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
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
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
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
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
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
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
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
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
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
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
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
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 }