ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/TreeSubSetTest.java
Revision: 1.14
Committed: Wed Sep 1 06:41:55 2010 UTC (13 years, 8 months ago) by jsr166
Branch: MAIN
Changes since 1.13: +1 -1 lines
Log Message: 
trailing whitespace

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