ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/TreeSubSetTest.java
Revision: 1.8
Committed: Sat Nov 21 02:07:27 2009 UTC (14 years, 5 months ago) by jsr166
Branch: MAIN
Changes since 1.7: +28 -28 lines
Log Message: 
untabify

File Contents

# User Rev Content
1 dl 1.1 /*
2     * Written by Doug Lea with assistance from members of JCP JSR-166
3     * Expert Group and released to the public domain, as explained at
4     * http://creativecommons.org/licenses/publicdomain
5     */
6    
7     import junit.framework.*;
8     import java.util.*;
9     import java.util.concurrent.*;
10     import java.io.*;
11    
12     public class TreeSubSetTest extends JSR166TestCase {
13     public static void main(String[] args) {
14 jsr166 1.8 junit.textui.TestRunner.run (suite());
15 dl 1.1 }
16     public static Test suite() {
17 jsr166 1.8 return new TestSuite(TreeSubSetTest.class);
18 dl 1.1 }
19    
20 jsr166 1.4 static class MyReverseComparator implements Comparator {
21 dl 1.1 public int compare(Object x, Object y) {
22     int i = ((Integer)x).intValue();
23     int j = ((Integer)y).intValue();
24     if (i < j) return 1;
25     if (i > j) return -1;
26     return 0;
27     }
28     }
29    
30     /**
31     * Create a set of given size containing consecutive
32     * Integers 0 ... n.
33     */
34     private NavigableSet populatedSet(int n) {
35     TreeSet q = new TreeSet();
36     assertTrue(q.isEmpty());
37    
38 jsr166 1.8 for (int i = n-1; i >= 0; i-=2)
39     assertTrue(q.add(new Integer(i)));
40     for (int i = (n & 1); i < n; i+=2)
41     assertTrue(q.add(new Integer(i)));
42 dl 1.1 assertTrue(q.add(new Integer(-n)));
43     assertTrue(q.add(new Integer(n)));
44 dl 1.3 NavigableSet s = q.subSet(new Integer(0), true, new Integer(n), false);
45 dl 1.1 assertFalse(s.isEmpty());
46 jsr166 1.8 assertEquals(n, s.size());
47 dl 1.1 return s;
48     }
49    
50     /**
51     * Create set of first 5 ints
52     */
53     private NavigableSet set5() {
54     TreeSet q = new TreeSet();
55     assertTrue(q.isEmpty());
56     q.add(one);
57     q.add(two);
58     q.add(three);
59     q.add(four);
60     q.add(five);
61     q.add(zero);
62     q.add(seven);
63 dl 1.3 NavigableSet s = q.subSet(one, true, seven, false);
64 jsr166 1.8 assertEquals(5, s.size());
65 dl 1.3 return s;
66     }
67    
68     private NavigableSet dset5() {
69     TreeSet q = new TreeSet();
70     assertTrue(q.isEmpty());
71     q.add(m1);
72     q.add(m2);
73     q.add(m3);
74     q.add(m4);
75     q.add(m5);
76     NavigableSet s = q.descendingSet();
77 jsr166 1.8 assertEquals(5, s.size());
78 dl 1.1 return s;
79     }
80    
81 jsr166 1.4 private static NavigableSet set0() {
82 jsr166 1.8 TreeSet set = new TreeSet();
83 dl 1.1 assertTrue(set.isEmpty());
84 dl 1.3 return set.tailSet(m1, false);
85     }
86    
87 jsr166 1.4 private static NavigableSet dset0() {
88 jsr166 1.8 TreeSet set = new TreeSet();
89 dl 1.3 assertTrue(set.isEmpty());
90     return set;
91 dl 1.1 }
92 jsr166 1.4
93 dl 1.1 /**
94     * A new set has unbounded capacity
95     */
96     public void testConstructor1() {
97     assertEquals(0, set0().size());
98     }
99    
100    
101     /**
102     * isEmpty is true before add, false after
103     */
104     public void testEmpty() {
105     NavigableSet q = set0();
106     assertTrue(q.isEmpty());
107     q.add(new Integer(1));
108     assertFalse(q.isEmpty());
109     q.add(new Integer(2));
110     q.pollFirst();
111     q.pollFirst();
112     assertTrue(q.isEmpty());
113     }
114    
115     /**
116     * size changes when elements added and removed
117     */
118     public void testSize() {
119     NavigableSet q = populatedSet(SIZE);
120     for (int i = 0; i < SIZE; ++i) {
121     assertEquals(SIZE-i, q.size());
122     q.pollFirst();
123     }
124     for (int i = 0; i < SIZE; ++i) {
125     assertEquals(i, q.size());
126     q.add(new Integer(i));
127     }
128     }
129    
130     /**
131     * add(null) throws NPE
132     */
133     public void testAddNull() {
134 jsr166 1.8 try {
135 dl 1.1 NavigableSet q = set0();
136     q.add(null);
137     shouldThrow();
138 jsr166 1.7 } catch (NullPointerException success) {}
139 dl 1.1 }
140    
141     /**
142     * Add of comparable element succeeds
143     */
144     public void testAdd() {
145     NavigableSet q = set0();
146     assertTrue(q.add(six));
147     }
148    
149     /**
150     * Add of duplicate element fails
151     */
152     public void testAddDup() {
153     NavigableSet q = set0();
154     assertTrue(q.add(six));
155     assertFalse(q.add(six));
156     }
157    
158     /**
159     * Add of non-Comparable throws CCE
160     */
161     public void testAddNonComparable() {
162     try {
163     NavigableSet q = set0();
164     q.add(new Object());
165     q.add(new Object());
166     q.add(new Object());
167     shouldThrow();
168 jsr166 1.7 } catch (ClassCastException success) {}
169 dl 1.1 }
170    
171    
172     /**
173     * addAll(null) throws NPE
174     */
175     public void testAddAll1() {
176     try {
177     NavigableSet q = set0();
178     q.addAll(null);
179     shouldThrow();
180 jsr166 1.7 } catch (NullPointerException success) {}
181 dl 1.1 }
182     /**
183     * addAll of a collection with null elements throws NPE
184     */
185     public void testAddAll2() {
186     try {
187     NavigableSet q = set0();
188     Integer[] ints = new Integer[SIZE];
189     q.addAll(Arrays.asList(ints));
190     shouldThrow();
191 jsr166 1.7 } catch (NullPointerException success) {}
192 dl 1.1 }
193     /**
194     * addAll of a collection with any null elements throws NPE after
195     * possibly adding some elements
196     */
197     public void testAddAll3() {
198     try {
199     NavigableSet q = set0();
200     Integer[] ints = new Integer[SIZE];
201     for (int i = 0; i < SIZE-1; ++i)
202     ints[i] = new Integer(i+SIZE);
203     q.addAll(Arrays.asList(ints));
204     shouldThrow();
205 jsr166 1.7 } catch (NullPointerException success) {}
206 dl 1.1 }
207    
208     /**
209     * Set contains all elements of successful addAll
210     */
211     public void testAddAll5() {
212     try {
213     Integer[] empty = new Integer[0];
214     Integer[] ints = new Integer[SIZE];
215     for (int i = 0; i < SIZE; ++i)
216     ints[i] = new Integer(SIZE-1- i);
217     NavigableSet q = set0();
218     assertFalse(q.addAll(Arrays.asList(empty)));
219     assertTrue(q.addAll(Arrays.asList(ints)));
220     for (int i = 0; i < SIZE; ++i)
221     assertEquals(new Integer(i), q.pollFirst());
222     }
223     finally {}
224     }
225    
226     /**
227     * poll succeeds unless empty
228     */
229     public void testPoll() {
230     NavigableSet q = populatedSet(SIZE);
231     for (int i = 0; i < SIZE; ++i) {
232     assertEquals(i, ((Integer)q.pollFirst()).intValue());
233     }
234 jsr166 1.8 assertNull(q.pollFirst());
235 dl 1.1 }
236    
237     /**
238     * remove(x) removes x and returns true if present
239     */
240     public void testRemoveElement() {
241     NavigableSet q = populatedSet(SIZE);
242     for (int i = 1; i < SIZE; i+=2) {
243     assertTrue(q.remove(new Integer(i)));
244     }
245     for (int i = 0; i < SIZE; i+=2) {
246     assertTrue(q.remove(new Integer(i)));
247     assertFalse(q.remove(new Integer(i+1)));
248     }
249     assertTrue(q.isEmpty());
250     }
251 jsr166 1.4
252 dl 1.1 /**
253     * contains(x) reports true when elements added but not yet removed
254     */
255     public void testContains() {
256     NavigableSet q = populatedSet(SIZE);
257     for (int i = 0; i < SIZE; ++i) {
258     assertTrue(q.contains(new Integer(i)));
259     q.pollFirst();
260     assertFalse(q.contains(new Integer(i)));
261     }
262     }
263    
264     /**
265     * clear removes all elements
266     */
267     public void testClear() {
268     NavigableSet q = populatedSet(SIZE);
269     q.clear();
270     assertTrue(q.isEmpty());
271     assertEquals(0, q.size());
272     q.add(new Integer(1));
273     assertFalse(q.isEmpty());
274     q.clear();
275     assertTrue(q.isEmpty());
276     }
277    
278     /**
279     * containsAll(c) is true when c contains a subset of elements
280     */
281     public void testContainsAll() {
282     NavigableSet q = populatedSet(SIZE);
283     NavigableSet p = set0();
284     for (int i = 0; i < SIZE; ++i) {
285     assertTrue(q.containsAll(p));
286     assertFalse(p.containsAll(q));
287     p.add(new Integer(i));
288     }
289     assertTrue(p.containsAll(q));
290     }
291    
292     /**
293     * retainAll(c) retains only those elements of c and reports true if changed
294     */
295     public void testRetainAll() {
296     NavigableSet q = populatedSet(SIZE);
297     NavigableSet p = populatedSet(SIZE);
298     for (int i = 0; i < SIZE; ++i) {
299     boolean changed = q.retainAll(p);
300     if (i == 0)
301     assertFalse(changed);
302     else
303     assertTrue(changed);
304    
305     assertTrue(q.containsAll(p));
306     assertEquals(SIZE-i, q.size());
307     p.pollFirst();
308     }
309     }
310    
311     /**
312     * removeAll(c) removes only those elements of c and reports true if changed
313     */
314     public void testRemoveAll() {
315     for (int i = 1; i < SIZE; ++i) {
316     NavigableSet q = populatedSet(SIZE);
317     NavigableSet p = populatedSet(i);
318     assertTrue(q.removeAll(p));
319     assertEquals(SIZE-i, q.size());
320     for (int j = 0; j < i; ++j) {
321     Integer I = (Integer)(p.pollFirst());
322     assertFalse(q.contains(I));
323     }
324     }
325     }
326    
327 jsr166 1.4
328 dl 1.1
329     /**
330     * lower returns preceding element
331     */
332     public void testLower() {
333     NavigableSet q = set5();
334     Object e1 = q.lower(three);
335     assertEquals(two, e1);
336    
337     Object e2 = q.lower(six);
338     assertEquals(five, e2);
339    
340     Object e3 = q.lower(one);
341     assertNull(e3);
342    
343     Object e4 = q.lower(zero);
344     assertNull(e4);
345    
346     }
347    
348     /**
349     * higher returns next element
350     */
351     public void testHigher() {
352     NavigableSet q = set5();
353     Object e1 = q.higher(three);
354     assertEquals(four, e1);
355    
356     Object e2 = q.higher(zero);
357     assertEquals(one, e2);
358    
359     Object e3 = q.higher(five);
360     assertNull(e3);
361    
362     Object e4 = q.higher(six);
363     assertNull(e4);
364    
365     }
366    
367     /**
368     * floor returns preceding element
369     */
370     public void testFloor() {
371     NavigableSet q = set5();
372     Object e1 = q.floor(three);
373     assertEquals(three, e1);
374    
375     Object e2 = q.floor(six);
376     assertEquals(five, e2);
377    
378     Object e3 = q.floor(one);
379     assertEquals(one, e3);
380    
381     Object e4 = q.floor(zero);
382     assertNull(e4);
383    
384     }
385    
386     /**
387     * ceiling returns next element
388     */
389     public void testCeiling() {
390     NavigableSet q = set5();
391     Object e1 = q.ceiling(three);
392     assertEquals(three, e1);
393    
394     Object e2 = q.ceiling(zero);
395     assertEquals(one, e2);
396    
397     Object e3 = q.ceiling(five);
398     assertEquals(five, e3);
399    
400     Object e4 = q.ceiling(six);
401     assertNull(e4);
402    
403     }
404    
405     /**
406     * toArray contains all elements
407     */
408     public void testToArray() {
409     NavigableSet q = populatedSet(SIZE);
410 jsr166 1.8 Object[] o = q.toArray();
411 dl 1.1 Arrays.sort(o);
412 jsr166 1.8 for (int i = 0; i < o.length; i++)
413     assertEquals(o[i], q.pollFirst());
414 dl 1.1 }
415    
416     /**
417     * toArray(a) contains all elements
418     */
419     public void testToArray2() {
420     NavigableSet q = populatedSet(SIZE);
421 jsr166 1.8 Integer[] ints = new Integer[SIZE];
422     ints = (Integer[])q.toArray(ints);
423 dl 1.1 Arrays.sort(ints);
424 jsr166 1.5 for (int i = 0; i < ints.length; i++)
425 dl 1.1 assertEquals(ints[i], q.pollFirst());
426     }
427 jsr166 1.4
428 dl 1.1 /**
429     * iterator iterates through all elements
430     */
431     public void testIterator() {
432     NavigableSet q = populatedSet(SIZE);
433     int i = 0;
434 jsr166 1.8 Iterator it = q.iterator();
435 jsr166 1.5 while (it.hasNext()) {
436 dl 1.1 assertTrue(q.contains(it.next()));
437     ++i;
438     }
439     assertEquals(i, SIZE);
440     }
441    
442     /**
443     * iterator of empty set has no elements
444     */
445     public void testEmptyIterator() {
446     NavigableSet q = set0();
447     int i = 0;
448 jsr166 1.8 Iterator it = q.iterator();
449 jsr166 1.5 while (it.hasNext()) {
450 dl 1.1 assertTrue(q.contains(it.next()));
451     ++i;
452     }
453     assertEquals(i, 0);
454     }
455    
456     /**
457     * iterator.remove removes current element
458     */
459     public void testIteratorRemove () {
460     final NavigableSet q = set0();
461     q.add(new Integer(2));
462     q.add(new Integer(1));
463     q.add(new Integer(3));
464    
465     Iterator it = q.iterator();
466     it.next();
467     it.remove();
468    
469     it = q.iterator();
470     assertEquals(it.next(), new Integer(2));
471     assertEquals(it.next(), new Integer(3));
472     assertFalse(it.hasNext());
473     }
474    
475    
476     /**
477     * toString contains toStrings of elements
478     */
479     public void testToString() {
480     NavigableSet q = populatedSet(SIZE);
481     String s = q.toString();
482     for (int i = 0; i < SIZE; ++i) {
483     assertTrue(s.indexOf(String.valueOf(i)) >= 0);
484     }
485 jsr166 1.4 }
486 dl 1.1
487     /**
488 jsr166 1.4 * A deserialized serialized set has same elements
489 dl 1.1 */
490 jsr166 1.7 public void testSerialization() throws Exception {
491 dl 1.1 NavigableSet q = populatedSet(SIZE);
492 jsr166 1.7 ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
493     ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
494     out.writeObject(q);
495     out.close();
496    
497     ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
498     ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
499     NavigableSet r = (NavigableSet)in.readObject();
500     assertEquals(q.size(), r.size());
501     while (!q.isEmpty())
502     assertEquals(q.pollFirst(), r.pollFirst());
503 dl 1.1 }
504    
505     /**
506     * subSet returns set with keys in requested range
507     */
508     public void testSubSetContents() {
509     NavigableSet set = set5();
510     SortedSet sm = set.subSet(two, four);
511     assertEquals(two, sm.first());
512     assertEquals(three, sm.last());
513     assertEquals(2, sm.size());
514     assertFalse(sm.contains(one));
515     assertTrue(sm.contains(two));
516     assertTrue(sm.contains(three));
517     assertFalse(sm.contains(four));
518     assertFalse(sm.contains(five));
519     Iterator i = sm.iterator();
520     Object k;
521     k = (Integer)(i.next());
522     assertEquals(two, k);
523     k = (Integer)(i.next());
524     assertEquals(three, k);
525     assertFalse(i.hasNext());
526     Iterator j = sm.iterator();
527     j.next();
528     j.remove();
529     assertFalse(set.contains(two));
530     assertEquals(4, set.size());
531     assertEquals(1, sm.size());
532     assertEquals(three, sm.first());
533     assertEquals(three, sm.last());
534     assertTrue(sm.remove(three));
535     assertTrue(sm.isEmpty());
536     assertEquals(3, set.size());
537     }
538    
539     public void testSubSetContents2() {
540     NavigableSet set = set5();
541     SortedSet sm = set.subSet(two, three);
542     assertEquals(1, sm.size());
543     assertEquals(two, sm.first());
544     assertEquals(two, sm.last());
545     assertFalse(sm.contains(one));
546     assertTrue(sm.contains(two));
547     assertFalse(sm.contains(three));
548     assertFalse(sm.contains(four));
549     assertFalse(sm.contains(five));
550     Iterator i = sm.iterator();
551     Object k;
552     k = (Integer)(i.next());
553     assertEquals(two, k);
554     assertFalse(i.hasNext());
555     Iterator j = sm.iterator();
556     j.next();
557     j.remove();
558     assertFalse(set.contains(two));
559     assertEquals(4, set.size());
560     assertEquals(0, sm.size());
561     assertTrue(sm.isEmpty());
562     assertFalse(sm.remove(three));
563     assertEquals(4, set.size());
564     }
565    
566     /**
567     * headSet returns set with keys in requested range
568     */
569     public void testHeadSetContents() {
570     NavigableSet set = set5();
571     SortedSet sm = set.headSet(four);
572     assertTrue(sm.contains(one));
573     assertTrue(sm.contains(two));
574     assertTrue(sm.contains(three));
575     assertFalse(sm.contains(four));
576     assertFalse(sm.contains(five));
577     Iterator i = sm.iterator();
578     Object k;
579     k = (Integer)(i.next());
580     assertEquals(one, k);
581     k = (Integer)(i.next());
582     assertEquals(two, k);
583     k = (Integer)(i.next());
584     assertEquals(three, k);
585     assertFalse(i.hasNext());
586     sm.clear();
587     assertTrue(sm.isEmpty());
588     assertEquals(2, set.size());
589     assertEquals(four, set.first());
590     }
591    
592     /**
593     * tailSet returns set with keys in requested range
594     */
595     public void testTailSetContents() {
596     NavigableSet set = set5();
597     SortedSet sm = set.tailSet(two);
598     assertFalse(sm.contains(one));
599     assertTrue(sm.contains(two));
600     assertTrue(sm.contains(three));
601     assertTrue(sm.contains(four));
602     assertTrue(sm.contains(five));
603     Iterator i = sm.iterator();
604     Object k;
605     k = (Integer)(i.next());
606     assertEquals(two, k);
607     k = (Integer)(i.next());
608     assertEquals(three, k);
609     k = (Integer)(i.next());
610     assertEquals(four, k);
611     k = (Integer)(i.next());
612     assertEquals(five, k);
613     assertFalse(i.hasNext());
614    
615     SortedSet ssm = sm.tailSet(four);
616     assertEquals(four, ssm.first());
617     assertEquals(five, ssm.last());
618     assertTrue(ssm.remove(four));
619     assertEquals(1, ssm.size());
620     assertEquals(3, sm.size());
621     assertEquals(4, set.size());
622     }
623    
624 dl 1.3 /**
625     * size changes when elements added and removed
626     */
627     public void testDescendingSize() {
628     NavigableSet q = populatedSet(SIZE);
629     for (int i = 0; i < SIZE; ++i) {
630     assertEquals(SIZE-i, q.size());
631     q.pollFirst();
632     }
633     for (int i = 0; i < SIZE; ++i) {
634     assertEquals(i, q.size());
635     q.add(new Integer(i));
636     }
637     }
638    
639     /**
640     * Add of comparable element succeeds
641     */
642     public void testDescendingAdd() {
643     NavigableSet q = dset0();
644     assertTrue(q.add(m6));
645     }
646    
647     /**
648     * Add of duplicate element fails
649     */
650     public void testDescendingAddDup() {
651     NavigableSet q = dset0();
652     assertTrue(q.add(m6));
653     assertFalse(q.add(m6));
654     }
655    
656     /**
657     * Add of non-Comparable throws CCE
658     */
659     public void testDescendingAddNonComparable() {
660     try {
661     NavigableSet q = dset0();
662     q.add(new Object());
663     q.add(new Object());
664     q.add(new Object());
665     shouldThrow();
666 jsr166 1.7 } catch (ClassCastException success) {}
667 dl 1.3 }
668    
669    
670     /**
671     * addAll(null) throws NPE
672     */
673     public void testDescendingAddAll1() {
674     try {
675     NavigableSet q = dset0();
676     q.addAll(null);
677     shouldThrow();
678 jsr166 1.7 } catch (NullPointerException success) {}
679 dl 1.3 }
680     /**
681     * addAll of a collection with null elements throws NPE
682     */
683     public void testDescendingAddAll2() {
684     try {
685     NavigableSet q = dset0();
686     Integer[] ints = new Integer[SIZE];
687     q.addAll(Arrays.asList(ints));
688     shouldThrow();
689 jsr166 1.7 } catch (NullPointerException success) {}
690 dl 1.3 }
691     /**
692     * addAll of a collection with any null elements throws NPE after
693     * possibly adding some elements
694     */
695     public void testDescendingAddAll3() {
696     try {
697     NavigableSet q = dset0();
698     Integer[] ints = new Integer[SIZE];
699     for (int i = 0; i < SIZE-1; ++i)
700     ints[i] = new Integer(i+SIZE);
701     q.addAll(Arrays.asList(ints));
702     shouldThrow();
703 jsr166 1.7 } catch (NullPointerException success) {}
704 dl 1.3 }
705    
706     /**
707     * Set contains all elements of successful addAll
708     */
709     public void testDescendingAddAll5() {
710 jsr166 1.7 Integer[] empty = new Integer[0];
711     Integer[] ints = new Integer[SIZE];
712     for (int i = 0; i < SIZE; ++i)
713     ints[i] = new Integer(SIZE-1- i);
714     NavigableSet q = dset0();
715     assertFalse(q.addAll(Arrays.asList(empty)));
716     assertTrue(q.addAll(Arrays.asList(ints)));
717     for (int i = 0; i < SIZE; ++i)
718     assertEquals(new Integer(i), q.pollFirst());
719 dl 1.3 }
720    
721     /**
722     * poll succeeds unless empty
723     */
724     public void testDescendingPoll() {
725     NavigableSet q = populatedSet(SIZE);
726     for (int i = 0; i < SIZE; ++i) {
727     assertEquals(i, ((Integer)q.pollFirst()).intValue());
728     }
729 jsr166 1.8 assertNull(q.pollFirst());
730 dl 1.3 }
731    
732     /**
733     * remove(x) removes x and returns true if present
734     */
735     public void testDescendingRemoveElement() {
736     NavigableSet q = populatedSet(SIZE);
737     for (int i = 1; i < SIZE; i+=2) {
738     assertTrue(q.remove(new Integer(i)));
739     }
740     for (int i = 0; i < SIZE; i+=2) {
741     assertTrue(q.remove(new Integer(i)));
742     assertFalse(q.remove(new Integer(i+1)));
743     }
744     assertTrue(q.isEmpty());
745     }
746 jsr166 1.4
747 dl 1.3 /**
748     * contains(x) reports true when elements added but not yet removed
749     */
750     public void testDescendingContains() {
751     NavigableSet q = populatedSet(SIZE);
752     for (int i = 0; i < SIZE; ++i) {
753     assertTrue(q.contains(new Integer(i)));
754     q.pollFirst();
755     assertFalse(q.contains(new Integer(i)));
756     }
757     }
758    
759     /**
760     * clear removes all elements
761     */
762     public void testDescendingClear() {
763     NavigableSet q = populatedSet(SIZE);
764     q.clear();
765     assertTrue(q.isEmpty());
766     assertEquals(0, q.size());
767     q.add(new Integer(1));
768     assertFalse(q.isEmpty());
769     q.clear();
770     assertTrue(q.isEmpty());
771     }
772    
773     /**
774     * containsAll(c) is true when c contains a subset of elements
775     */
776     public void testDescendingContainsAll() {
777     NavigableSet q = populatedSet(SIZE);
778     NavigableSet p = dset0();
779     for (int i = 0; i < SIZE; ++i) {
780     assertTrue(q.containsAll(p));
781     assertFalse(p.containsAll(q));
782     p.add(new Integer(i));
783     }
784     assertTrue(p.containsAll(q));
785     }
786    
787     /**
788     * retainAll(c) retains only those elements of c and reports true if changed
789     */
790     public void testDescendingRetainAll() {
791     NavigableSet q = populatedSet(SIZE);
792     NavigableSet p = populatedSet(SIZE);
793     for (int i = 0; i < SIZE; ++i) {
794     boolean changed = q.retainAll(p);
795     if (i == 0)
796     assertFalse(changed);
797     else
798     assertTrue(changed);
799    
800     assertTrue(q.containsAll(p));
801     assertEquals(SIZE-i, q.size());
802     p.pollFirst();
803     }
804     }
805    
806     /**
807     * removeAll(c) removes only those elements of c and reports true if changed
808     */
809     public void testDescendingRemoveAll() {
810     for (int i = 1; i < SIZE; ++i) {
811     NavigableSet q = populatedSet(SIZE);
812     NavigableSet p = populatedSet(i);
813     assertTrue(q.removeAll(p));
814     assertEquals(SIZE-i, q.size());
815     for (int j = 0; j < i; ++j) {
816     Integer I = (Integer)(p.pollFirst());
817     assertFalse(q.contains(I));
818     }
819     }
820     }
821    
822 jsr166 1.4
823 dl 1.3
824     /**
825     * lower returns preceding element
826     */
827     public void testDescendingLower() {
828     NavigableSet q = dset5();
829     Object e1 = q.lower(m3);
830     assertEquals(m2, e1);
831    
832     Object e2 = q.lower(m6);
833     assertEquals(m5, e2);
834    
835     Object e3 = q.lower(m1);
836     assertNull(e3);
837    
838     Object e4 = q.lower(zero);
839     assertNull(e4);
840    
841     }
842    
843     /**
844     * higher returns next element
845     */
846     public void testDescendingHigher() {
847     NavigableSet q = dset5();
848     Object e1 = q.higher(m3);
849     assertEquals(m4, e1);
850    
851     Object e2 = q.higher(zero);
852     assertEquals(m1, e2);
853    
854     Object e3 = q.higher(m5);
855     assertNull(e3);
856    
857     Object e4 = q.higher(m6);
858     assertNull(e4);
859    
860     }
861    
862     /**
863     * floor returns preceding element
864     */
865     public void testDescendingFloor() {
866     NavigableSet q = dset5();
867     Object e1 = q.floor(m3);
868     assertEquals(m3, e1);
869    
870     Object e2 = q.floor(m6);
871     assertEquals(m5, e2);
872    
873     Object e3 = q.floor(m1);
874     assertEquals(m1, e3);
875    
876     Object e4 = q.floor(zero);
877     assertNull(e4);
878    
879     }
880    
881     /**
882     * ceiling returns next element
883     */
884     public void testDescendingCeiling() {
885     NavigableSet q = dset5();
886     Object e1 = q.ceiling(m3);
887     assertEquals(m3, e1);
888    
889     Object e2 = q.ceiling(zero);
890     assertEquals(m1, e2);
891    
892     Object e3 = q.ceiling(m5);
893     assertEquals(m5, e3);
894    
895     Object e4 = q.ceiling(m6);
896     assertNull(e4);
897    
898     }
899    
900     /**
901     * toArray contains all elements
902     */
903     public void testDescendingToArray() {
904     NavigableSet q = populatedSet(SIZE);
905 jsr166 1.8 Object[] o = q.toArray();
906 dl 1.3 Arrays.sort(o);
907 jsr166 1.8 for (int i = 0; i < o.length; i++)
908     assertEquals(o[i], q.pollFirst());
909 dl 1.3 }
910    
911     /**
912     * toArray(a) contains all elements
913     */
914     public void testDescendingToArray2() {
915     NavigableSet q = populatedSet(SIZE);
916 jsr166 1.8 Integer[] ints = new Integer[SIZE];
917     ints = (Integer[])q.toArray(ints);
918 dl 1.3 Arrays.sort(ints);
919 jsr166 1.5 for (int i = 0; i < ints.length; i++)
920 dl 1.3 assertEquals(ints[i], q.pollFirst());
921     }
922 jsr166 1.4
923 dl 1.3 /**
924     * iterator iterates through all elements
925     */
926     public void testDescendingIterator() {
927     NavigableSet q = populatedSet(SIZE);
928     int i = 0;
929 jsr166 1.8 Iterator it = q.iterator();
930 jsr166 1.5 while (it.hasNext()) {
931 dl 1.3 assertTrue(q.contains(it.next()));
932     ++i;
933     }
934     assertEquals(i, SIZE);
935     }
936    
937     /**
938     * iterator of empty set has no elements
939     */
940     public void testDescendingEmptyIterator() {
941     NavigableSet q = dset0();
942     int i = 0;
943 jsr166 1.8 Iterator it = q.iterator();
944 jsr166 1.5 while (it.hasNext()) {
945 dl 1.3 assertTrue(q.contains(it.next()));
946     ++i;
947     }
948     assertEquals(i, 0);
949     }
950    
951     /**
952     * iterator.remove removes current element
953     */
954     public void testDescendingIteratorRemove () {
955     final NavigableSet q = dset0();
956     q.add(new Integer(2));
957     q.add(new Integer(1));
958     q.add(new Integer(3));
959    
960     Iterator it = q.iterator();
961     it.next();
962     it.remove();
963    
964     it = q.iterator();
965     assertEquals(it.next(), new Integer(2));
966     assertEquals(it.next(), new Integer(3));
967     assertFalse(it.hasNext());
968     }
969    
970    
971     /**
972     * toString contains toStrings of elements
973     */
974     public void testDescendingToString() {
975     NavigableSet q = populatedSet(SIZE);
976     String s = q.toString();
977     for (int i = 0; i < SIZE; ++i) {
978     assertTrue(s.indexOf(String.valueOf(i)) >= 0);
979     }
980 jsr166 1.4 }
981 dl 1.3
982     /**
983 jsr166 1.4 * A deserialized serialized set has same elements
984 dl 1.3 */
985 jsr166 1.7 public void testDescendingSerialization() throws Exception {
986 dl 1.3 NavigableSet q = populatedSet(SIZE);
987 jsr166 1.7 ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
988     ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
989     out.writeObject(q);
990     out.close();
991    
992     ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
993     ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
994     NavigableSet r = (NavigableSet)in.readObject();
995     assertEquals(q.size(), r.size());
996     while (!q.isEmpty())
997     assertEquals(q.pollFirst(), r.pollFirst());
998 dl 1.3 }
999    
1000     /**
1001     * subSet returns set with keys in requested range
1002     */
1003     public void testDescendingSubSetContents() {
1004     NavigableSet set = dset5();
1005     SortedSet sm = set.subSet(m2, m4);
1006     assertEquals(m2, sm.first());
1007     assertEquals(m3, sm.last());
1008     assertEquals(2, sm.size());
1009     assertFalse(sm.contains(m1));
1010     assertTrue(sm.contains(m2));
1011     assertTrue(sm.contains(m3));
1012     assertFalse(sm.contains(m4));
1013     assertFalse(sm.contains(m5));
1014     Iterator i = sm.iterator();
1015     Object k;
1016     k = (Integer)(i.next());
1017     assertEquals(m2, k);
1018     k = (Integer)(i.next());
1019     assertEquals(m3, k);
1020     assertFalse(i.hasNext());
1021     Iterator j = sm.iterator();
1022     j.next();
1023     j.remove();
1024     assertFalse(set.contains(m2));
1025     assertEquals(4, set.size());
1026     assertEquals(1, sm.size());
1027     assertEquals(m3, sm.first());
1028     assertEquals(m3, sm.last());
1029     assertTrue(sm.remove(m3));
1030     assertTrue(sm.isEmpty());
1031     assertEquals(3, set.size());
1032     }
1033    
1034     public void testDescendingSubSetContents2() {
1035     NavigableSet set = dset5();
1036     SortedSet sm = set.subSet(m2, m3);
1037     assertEquals(1, sm.size());
1038     assertEquals(m2, sm.first());
1039     assertEquals(m2, sm.last());
1040     assertFalse(sm.contains(m1));
1041     assertTrue(sm.contains(m2));
1042     assertFalse(sm.contains(m3));
1043     assertFalse(sm.contains(m4));
1044     assertFalse(sm.contains(m5));
1045     Iterator i = sm.iterator();
1046     Object k;
1047     k = (Integer)(i.next());
1048     assertEquals(m2, k);
1049     assertFalse(i.hasNext());
1050     Iterator j = sm.iterator();
1051     j.next();
1052     j.remove();
1053     assertFalse(set.contains(m2));
1054     assertEquals(4, set.size());
1055     assertEquals(0, sm.size());
1056     assertTrue(sm.isEmpty());
1057     assertFalse(sm.remove(m3));
1058     assertEquals(4, set.size());
1059     }
1060    
1061     /**
1062     * headSet returns set with keys in requested range
1063     */
1064     public void testDescendingHeadSetContents() {
1065     NavigableSet set = dset5();
1066     SortedSet sm = set.headSet(m4);
1067     assertTrue(sm.contains(m1));
1068     assertTrue(sm.contains(m2));
1069     assertTrue(sm.contains(m3));
1070     assertFalse(sm.contains(m4));
1071     assertFalse(sm.contains(m5));
1072     Iterator i = sm.iterator();
1073     Object k;
1074     k = (Integer)(i.next());
1075     assertEquals(m1, k);
1076     k = (Integer)(i.next());
1077     assertEquals(m2, k);
1078     k = (Integer)(i.next());
1079     assertEquals(m3, k);
1080     assertFalse(i.hasNext());
1081     sm.clear();
1082     assertTrue(sm.isEmpty());
1083     assertEquals(2, set.size());
1084     assertEquals(m4, set.first());
1085     }
1086    
1087     /**
1088     * tailSet returns set with keys in requested range
1089     */
1090     public void testDescendingTailSetContents() {
1091     NavigableSet set = dset5();
1092     SortedSet sm = set.tailSet(m2);
1093     assertFalse(sm.contains(m1));
1094     assertTrue(sm.contains(m2));
1095     assertTrue(sm.contains(m3));
1096     assertTrue(sm.contains(m4));
1097     assertTrue(sm.contains(m5));
1098     Iterator i = sm.iterator();
1099     Object k;
1100     k = (Integer)(i.next());
1101     assertEquals(m2, k);
1102     k = (Integer)(i.next());
1103     assertEquals(m3, k);
1104     k = (Integer)(i.next());
1105     assertEquals(m4, k);
1106     k = (Integer)(i.next());
1107     assertEquals(m5, k);
1108     assertFalse(i.hasNext());
1109    
1110     SortedSet ssm = sm.tailSet(m4);
1111     assertEquals(m4, ssm.first());
1112     assertEquals(m5, ssm.last());
1113     assertTrue(ssm.remove(m4));
1114     assertEquals(1, ssm.size());
1115     assertEquals(3, sm.size());
1116     assertEquals(4, set.size());
1117     }
1118    
1119 dl 1.1 }