ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/TreeSubSetTest.java
(Generate patch)

Comparing jsr166/src/test/tck/TreeSubSetTest.java (file contents):
Revision 1.11 by jsr166, Tue Dec 1 09:43:19 2009 UTC vs.
Revision 1.30 by jsr166, Sat Feb 28 20:13:46 2015 UTC

# Line 1 | Line 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
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7 < import junit.framework.*;
8 < import java.util.*;
9 < import java.util.concurrent.*;
10 < import java.io.*;
7 > import java.util.Arrays;
8 > import java.util.Comparator;
9 > import java.util.Iterator;
10 > import java.util.NavigableSet;
11 > import java.util.Set;
12 > import java.util.SortedSet;
13 > import java.util.TreeSet;
14 >
15 > import junit.framework.Test;
16 > import junit.framework.TestSuite;
17  
18   public class TreeSubSetTest extends JSR166TestCase {
19      public static void main(String[] args) {
20 <        junit.textui.TestRunner.run (suite());
20 >        junit.textui.TestRunner.run(suite());
21      }
22      public static Test suite() {
23          return new TestSuite(TreeSubSetTest.class);
# Line 24 | Line 30 | public class TreeSubSetTest extends JSR1
30      }
31  
32      /**
33 <     * Create a set of given size containing consecutive
33 >     * Returns a new set of given size containing consecutive
34       * Integers 0 ... n.
35       */
36 <    private NavigableSet populatedSet(int n) {
37 <        TreeSet q = new TreeSet();
36 >    private NavigableSet<Integer> populatedSet(int n) {
37 >        TreeSet<Integer> q = new TreeSet<Integer>();
38          assertTrue(q.isEmpty());
39  
40 <        for (int i = n-1; i >= 0; i-=2)
40 >        for (int i = n-1; i >= 0; i -= 2)
41              assertTrue(q.add(new Integer(i)));
42 <        for (int i = (n & 1); i < n; i+=2)
42 >        for (int i = (n & 1); i < n; i += 2)
43              assertTrue(q.add(new Integer(i)));
44          assertTrue(q.add(new Integer(-n)));
45          assertTrue(q.add(new Integer(n)));
# Line 44 | Line 50 | public class TreeSubSetTest extends JSR1
50      }
51  
52      /**
53 <     * Create set of first 5 ints
53 >     * Returns a new set of first 5 ints.
54       */
55      private NavigableSet set5() {
56          TreeSet q = new TreeSet();
# Line 93 | Line 99 | public class TreeSubSetTest extends JSR1
99          assertEquals(0, set0().size());
100      }
101  
96 –
102      /**
103       * isEmpty is true before add, false after
104       */
# Line 127 | Line 132 | public class TreeSubSetTest extends JSR1
132       * add(null) throws NPE
133       */
134      public void testAddNull() {
135 +        NavigableSet q = set0();
136          try {
131 –            NavigableSet q = set0();
137              q.add(null);
138              shouldThrow();
139          } catch (NullPointerException success) {}
# Line 155 | Line 160 | public class TreeSubSetTest extends JSR1
160       * Add of non-Comparable throws CCE
161       */
162      public void testAddNonComparable() {
163 +        NavigableSet q = set0();
164          try {
159 –            NavigableSet q = set0();
160 –            q.add(new Object());
165              q.add(new Object());
166              q.add(new Object());
167              shouldThrow();
168          } catch (ClassCastException success) {}
169      }
170  
167 –
171      /**
172       * addAll(null) throws NPE
173       */
174      public void testAddAll1() {
175 +        NavigableSet q = set0();
176          try {
173 –            NavigableSet q = set0();
177              q.addAll(null);
178              shouldThrow();
179          } catch (NullPointerException success) {}
180      }
181 +
182      /**
183       * addAll of a collection with null elements throws NPE
184       */
185      public void testAddAll2() {
186 +        NavigableSet q = set0();
187 +        Integer[] ints = new Integer[SIZE];
188          try {
183 –            NavigableSet q = set0();
184 –            Integer[] ints = new Integer[SIZE];
189              q.addAll(Arrays.asList(ints));
190              shouldThrow();
191          } catch (NullPointerException success) {}
192      }
193 +
194      /**
195       * addAll of a collection with any null elements throws NPE after
196       * possibly adding some elements
197       */
198      public void testAddAll3() {
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          try {
195 –            NavigableSet q = set0();
196 –            Integer[] ints = new Integer[SIZE];
197 –            for (int i = 0; i < SIZE-1; ++i)
198 –                ints[i] = new Integer(i+SIZE);
204              q.addAll(Arrays.asList(ints));
205              shouldThrow();
206          } catch (NullPointerException success) {}
# Line 232 | Line 237 | public class TreeSubSetTest extends JSR1
237       */
238      public void testRemoveElement() {
239          NavigableSet q = populatedSet(SIZE);
240 <        for (int i = 1; i < SIZE; i+=2) {
241 <            assertTrue(q.remove(new Integer(i)));
242 <        }
243 <        for (int i = 0; i < SIZE; i+=2) {
244 <            assertTrue(q.remove(new Integer(i)));
245 <            assertFalse(q.remove(new Integer(i+1)));
240 >        for (int i = 1; i < SIZE; i += 2) {
241 >            assertTrue(q.contains(i));
242 >            assertTrue(q.remove(i));
243 >            assertFalse(q.contains(i));
244 >            assertTrue(q.contains(i-1));
245 >        }
246 >        for (int i = 0; i < SIZE; i += 2) {
247 >            assertTrue(q.contains(i));
248 >            assertTrue(q.remove(i));
249 >            assertFalse(q.contains(i));
250 >            assertFalse(q.remove(i+1));
251 >            assertFalse(q.contains(i+1));
252          }
253          assertTrue(q.isEmpty());
254      }
# Line 311 | Line 322 | public class TreeSubSetTest extends JSR1
322              assertTrue(q.removeAll(p));
323              assertEquals(SIZE-i, q.size());
324              for (int j = 0; j < i; ++j) {
325 <                Integer I = (Integer)(p.pollFirst());
326 <                assertFalse(q.contains(I));
325 >                Integer x = (Integer)(p.pollFirst());
326 >                assertFalse(q.contains(x));
327              }
328          }
329      }
330  
320 –
321 –
331      /**
332       * lower returns preceding element
333       */
# Line 392 | Line 401 | public class TreeSubSetTest extends JSR1
401      }
402  
403      /**
404 <     * toArray contains all elements
404 >     * toArray contains all elements in sorted order
405       */
406      public void testToArray() {
407          NavigableSet q = populatedSet(SIZE);
408          Object[] o = q.toArray();
400 –        Arrays.sort(o);
409          for (int i = 0; i < o.length; i++)
410 <            assertEquals(o[i], q.pollFirst());
410 >            assertSame(o[i], q.pollFirst());
411      }
412  
413      /**
414 <     * toArray(a) contains all elements
414 >     * toArray(a) contains all elements in sorted order
415       */
416      public void testToArray2() {
417 <        NavigableSet q = populatedSet(SIZE);
417 >        NavigableSet<Integer> q = populatedSet(SIZE);
418          Integer[] ints = new Integer[SIZE];
419 <        ints = (Integer[])q.toArray(ints);
420 <        Arrays.sort(ints);
419 >        Integer[] array = q.toArray(ints);
420 >        assertSame(ints, array);
421          for (int i = 0; i < ints.length; i++)
422 <            assertEquals(ints[i], q.pollFirst());
422 >            assertSame(ints[i], q.pollFirst());
423      }
424  
425      /**
# Line 419 | Line 427 | public class TreeSubSetTest extends JSR1
427       */
428      public void testIterator() {
429          NavigableSet q = populatedSet(SIZE);
422 –        int i = 0;
430          Iterator it = q.iterator();
431 <        while (it.hasNext()) {
431 >        int i;
432 >        for (i = 0; it.hasNext(); i++)
433              assertTrue(q.contains(it.next()));
426 –            ++i;
427 –        }
434          assertEquals(i, SIZE);
435 +        assertIteratorExhausted(it);
436      }
437  
438      /**
439       * iterator of empty set has no elements
440       */
441      public void testEmptyIterator() {
442 <        NavigableSet q = set0();
436 <        int i = 0;
437 <        Iterator it = q.iterator();
438 <        while (it.hasNext()) {
439 <            assertTrue(q.contains(it.next()));
440 <            ++i;
441 <        }
442 <        assertEquals(i, 0);
442 >        assertIteratorExhausted(set0().iterator());
443      }
444  
445      /**
446       * iterator.remove removes current element
447       */
448 <    public void testIteratorRemove () {
448 >    public void testIteratorRemove() {
449          final NavigableSet q = set0();
450          q.add(new Integer(2));
451          q.add(new Integer(1));
# Line 456 | Line 456 | public class TreeSubSetTest extends JSR1
456          it.remove();
457  
458          it = q.iterator();
459 <        assertEquals(it.next(), 2);
460 <        assertEquals(it.next(), 3);
459 >        assertEquals(2, it.next());
460 >        assertEquals(3, it.next());
461          assertFalse(it.hasNext());
462      }
463  
464 –
464      /**
465       * toString contains toStrings of elements
466       */
# Line 469 | Line 468 | public class TreeSubSetTest extends JSR1
468          NavigableSet q = populatedSet(SIZE);
469          String s = q.toString();
470          for (int i = 0; i < SIZE; ++i) {
471 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
471 >            assertTrue(s.contains(String.valueOf(i)));
472          }
473      }
474  
# Line 477 | Line 476 | public class TreeSubSetTest extends JSR1
476       * A deserialized serialized set has same elements
477       */
478      public void testSerialization() throws Exception {
479 <        NavigableSet q = populatedSet(SIZE);
480 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
481 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
482 <        out.writeObject(q);
483 <        out.close();
484 <
485 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
486 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
487 <        NavigableSet r = (NavigableSet)in.readObject();
488 <        assertEquals(q.size(), r.size());
489 <        while (!q.isEmpty())
490 <            assertEquals(q.pollFirst(), r.pollFirst());
479 >        NavigableSet x = populatedSet(SIZE);
480 >        NavigableSet y = serialClone(x);
481 >
482 >        assertNotSame(x, y);
483 >        assertEquals(x.size(), y.size());
484 >        assertEquals(x, y);
485 >        assertEquals(y, x);
486 >        while (!x.isEmpty()) {
487 >            assertFalse(y.isEmpty());
488 >            assertEquals(x.pollFirst(), y.pollFirst());
489 >        }
490 >        assertTrue(y.isEmpty());
491      }
492  
493      /**
# Line 646 | Line 645 | public class TreeSubSetTest extends JSR1
645       * Add of non-Comparable throws CCE
646       */
647      public void testDescendingAddNonComparable() {
648 +        NavigableSet q = dset0();
649          try {
650 –            NavigableSet q = dset0();
651 –            q.add(new Object());
650              q.add(new Object());
651              q.add(new Object());
652              shouldThrow();
653          } catch (ClassCastException success) {}
654      }
655  
658 –
656      /**
657       * addAll(null) throws NPE
658       */
659      public void testDescendingAddAll1() {
660 +        NavigableSet q = dset0();
661          try {
664 –            NavigableSet q = dset0();
662              q.addAll(null);
663              shouldThrow();
664          } catch (NullPointerException success) {}
665      }
666 +
667      /**
668       * addAll of a collection with null elements throws NPE
669       */
670      public void testDescendingAddAll2() {
671 +        NavigableSet q = dset0();
672 +        Integer[] ints = new Integer[SIZE];
673          try {
674 –            NavigableSet q = dset0();
675 –            Integer[] ints = new Integer[SIZE];
674              q.addAll(Arrays.asList(ints));
675              shouldThrow();
676          } catch (NullPointerException success) {}
677      }
678 +
679      /**
680       * addAll of a collection with any null elements throws NPE after
681       * possibly adding some elements
682       */
683      public void testDescendingAddAll3() {
684 +        NavigableSet q = dset0();
685 +        Integer[] ints = new Integer[SIZE];
686 +        for (int i = 0; i < SIZE-1; ++i)
687 +            ints[i] = new Integer(i+SIZE);
688          try {
686 –            NavigableSet q = dset0();
687 –            Integer[] ints = new Integer[SIZE];
688 –            for (int i = 0; i < SIZE-1; ++i)
689 –                ints[i] = new Integer(i+SIZE);
689              q.addAll(Arrays.asList(ints));
690              shouldThrow();
691          } catch (NullPointerException success) {}
# Line 723 | Line 722 | public class TreeSubSetTest extends JSR1
722       */
723      public void testDescendingRemoveElement() {
724          NavigableSet q = populatedSet(SIZE);
725 <        for (int i = 1; i < SIZE; i+=2) {
725 >        for (int i = 1; i < SIZE; i += 2) {
726              assertTrue(q.remove(new Integer(i)));
727          }
728 <        for (int i = 0; i < SIZE; i+=2) {
728 >        for (int i = 0; i < SIZE; i += 2) {
729              assertTrue(q.remove(new Integer(i)));
730              assertFalse(q.remove(new Integer(i+1)));
731          }
# Line 802 | Line 801 | public class TreeSubSetTest extends JSR1
801              assertTrue(q.removeAll(p));
802              assertEquals(SIZE-i, q.size());
803              for (int j = 0; j < i; ++j) {
804 <                Integer I = (Integer)(p.pollFirst());
805 <                assertFalse(q.contains(I));
804 >                Integer x = (Integer)(p.pollFirst());
805 >                assertFalse(q.contains(x));
806              }
807          }
808      }
809  
811 –
812 –
810      /**
811       * lower returns preceding element
812       */
# Line 899 | Line 896 | public class TreeSubSetTest extends JSR1
896      public void testDescendingToArray2() {
897          NavigableSet q = populatedSet(SIZE);
898          Integer[] ints = new Integer[SIZE];
899 <        ints = (Integer[])q.toArray(ints);
899 >        assertSame(ints, q.toArray(ints));
900          Arrays.sort(ints);
901          for (int i = 0; i < ints.length; i++)
902              assertEquals(ints[i], q.pollFirst());
# Line 930 | Line 927 | public class TreeSubSetTest extends JSR1
927              assertTrue(q.contains(it.next()));
928              ++i;
929          }
930 <        assertEquals(i, 0);
930 >        assertEquals(0, i);
931      }
932  
933      /**
934       * iterator.remove removes current element
935       */
936 <    public void testDescendingIteratorRemove () {
936 >    public void testDescendingIteratorRemove() {
937          final NavigableSet q = dset0();
938          q.add(new Integer(2));
939          q.add(new Integer(1));
# Line 947 | Line 944 | public class TreeSubSetTest extends JSR1
944          it.remove();
945  
946          it = q.iterator();
947 <        assertEquals(it.next(), 2);
948 <        assertEquals(it.next(), 3);
947 >        assertEquals(2, it.next());
948 >        assertEquals(3, it.next());
949          assertFalse(it.hasNext());
950      }
951  
955 –
952      /**
953       * toString contains toStrings of elements
954       */
# Line 960 | Line 956 | public class TreeSubSetTest extends JSR1
956          NavigableSet q = populatedSet(SIZE);
957          String s = q.toString();
958          for (int i = 0; i < SIZE; ++i) {
959 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
959 >            assertTrue(s.contains(String.valueOf(i)));
960          }
961      }
962  
# Line 968 | Line 964 | public class TreeSubSetTest extends JSR1
964       * A deserialized serialized set has same elements
965       */
966      public void testDescendingSerialization() throws Exception {
967 <        NavigableSet q = populatedSet(SIZE);
968 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
969 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
970 <        out.writeObject(q);
971 <        out.close();
972 <
973 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
974 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
975 <        NavigableSet r = (NavigableSet)in.readObject();
976 <        assertEquals(q.size(), r.size());
977 <        while (!q.isEmpty())
978 <            assertEquals(q.pollFirst(), r.pollFirst());
967 >        NavigableSet x = dset5();
968 >        NavigableSet y = serialClone(x);
969 >
970 >        assertNotSame(x, y);
971 >        assertEquals(x.size(), y.size());
972 >        assertEquals(x.toString(), y.toString());
973 >        assertEquals(x, y);
974 >        assertEquals(y, x);
975 >        while (!x.isEmpty()) {
976 >            assertFalse(y.isEmpty());
977 >            assertEquals(x.pollFirst(), y.pollFirst());
978 >        }
979 >        assertTrue(y.isEmpty());
980      }
981  
982      /**
# Line 1101 | Line 1098 | public class TreeSubSetTest extends JSR1
1098          assertEquals(4, set.size());
1099      }
1100  
1101 +    /**
1102 +     * addAll is idempotent
1103 +     */
1104 +    public void testAddAll_idempotent() throws Exception {
1105 +        Set x = populatedSet(SIZE);
1106 +        Set y = new TreeSet(x);
1107 +        y.addAll(x);
1108 +        assertEquals(x, y);
1109 +        assertEquals(y, x);
1110 +    }
1111 +
1112   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines