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

Comparing jsr166/src/test/tck/ConcurrentSkipListSubSetTest.java (file contents):
Revision 1.32 by jsr166, Sat Apr 25 04:55:30 2015 UTC vs.
Revision 1.38 by jsr166, Sun Jan 7 22:59:18 2018 UTC

# Line 30 | Line 30 | public class ConcurrentSkipListSubSetTes
30  
31      /**
32       * Returns a new set of given size containing consecutive
33 <     * Integers 0 ... n.
33 >     * Integers 0 ... n - 1.
34       */
35 <    private NavigableSet<Integer> populatedSet(int n) {
36 <        ConcurrentSkipListSet<Integer> q =
37 <            new ConcurrentSkipListSet<Integer>();
35 >    private static NavigableSet<Integer> populatedSet(int n) {
36 >        ConcurrentSkipListSet<Integer> q = new ConcurrentSkipListSet<>();
37          assertTrue(q.isEmpty());
38  
39 <        for (int i = n-1; i >= 0; i -= 2)
39 >        for (int i = n - 1; i >= 0; i -= 2)
40              assertTrue(q.add(new Integer(i)));
41          for (int i = (n & 1); i < n; i += 2)
42              assertTrue(q.add(new Integer(i)));
# Line 52 | Line 51 | public class ConcurrentSkipListSubSetTes
51      /**
52       * Returns a new set of first 5 ints.
53       */
54 <    private NavigableSet set5() {
54 >    private static NavigableSet set5() {
55          ConcurrentSkipListSet q = new ConcurrentSkipListSet();
56          assertTrue(q.isEmpty());
57          q.add(one);
# Line 70 | Line 69 | public class ConcurrentSkipListSubSetTes
69      /**
70       * Returns a new set of first 5 negative ints.
71       */
72 <    private NavigableSet dset5() {
72 >    private static NavigableSet dset5() {
73          ConcurrentSkipListSet q = new ConcurrentSkipListSet();
74          assertTrue(q.isEmpty());
75          q.add(m1);
# Line 122 | Line 121 | public class ConcurrentSkipListSubSetTes
121      public void testSize() {
122          NavigableSet q = populatedSet(SIZE);
123          for (int i = 0; i < SIZE; ++i) {
124 <            assertEquals(SIZE-i, q.size());
124 >            assertEquals(SIZE - i, q.size());
125              q.pollFirst();
126          }
127          for (int i = 0; i < SIZE; ++i) {
# Line 201 | Line 200 | public class ConcurrentSkipListSubSetTes
200      public void testAddAll3() {
201          NavigableSet q = set0();
202          Integer[] ints = new Integer[SIZE];
203 <        for (int i = 0; i < SIZE-1; ++i)
204 <            ints[i] = new Integer(i+SIZE);
203 >        for (int i = 0; i < SIZE - 1; ++i)
204 >            ints[i] = new Integer(i + SIZE);
205          try {
206              q.addAll(Arrays.asList(ints));
207              shouldThrow();
# Line 216 | Line 215 | public class ConcurrentSkipListSubSetTes
215          Integer[] empty = new Integer[0];
216          Integer[] ints = new Integer[SIZE];
217          for (int i = 0; i < SIZE; ++i)
218 <            ints[i] = new Integer(SIZE-1- i);
218 >            ints[i] = new Integer(SIZE - 1 - i);
219          NavigableSet q = set0();
220          assertFalse(q.addAll(Arrays.asList(empty)));
221          assertTrue(q.addAll(Arrays.asList(ints)));
# Line 244 | Line 243 | public class ConcurrentSkipListSubSetTes
243              assertTrue(q.contains(i));
244              assertTrue(q.remove(i));
245              assertFalse(q.contains(i));
246 <            assertTrue(q.contains(i-1));
246 >            assertTrue(q.contains(i - 1));
247          }
248          for (int i = 0; i < SIZE; i += 2) {
249              assertTrue(q.contains(i));
250              assertTrue(q.remove(i));
251              assertFalse(q.contains(i));
252 <            assertFalse(q.remove(i+1));
253 <            assertFalse(q.contains(i+1));
252 >            assertFalse(q.remove(i + 1));
253 >            assertFalse(q.contains(i + 1));
254          }
255          assertTrue(q.isEmpty());
256      }
# Line 310 | Line 309 | public class ConcurrentSkipListSubSetTes
309                  assertTrue(changed);
310  
311              assertTrue(q.containsAll(p));
312 <            assertEquals(SIZE-i, q.size());
312 >            assertEquals(SIZE - i, q.size());
313              p.pollFirst();
314          }
315      }
# Line 323 | Line 322 | public class ConcurrentSkipListSubSetTes
322              NavigableSet q = populatedSet(SIZE);
323              NavigableSet p = populatedSet(i);
324              assertTrue(q.removeAll(p));
325 <            assertEquals(SIZE-i, q.size());
325 >            assertEquals(SIZE - i, q.size());
326              for (int j = 0; j < i; ++j) {
327                  Integer x = (Integer)(p.pollFirst());
328                  assertFalse(q.contains(x));
# Line 476 | Line 475 | public class ConcurrentSkipListSubSetTes
475      }
476  
477      /**
478 <     * A deserialized serialized set has same elements
478 >     * A deserialized/reserialized set equals original
479       */
480      public void testSerialization() throws Exception {
481          NavigableSet x = populatedSet(SIZE);
# Line 618 | Line 617 | public class ConcurrentSkipListSubSetTes
617      public void testDescendingSize() {
618          NavigableSet q = populatedSet(SIZE);
619          for (int i = 0; i < SIZE; ++i) {
620 <            assertEquals(SIZE-i, q.size());
620 >            assertEquals(SIZE - i, q.size());
621              q.pollFirst();
622          }
623          for (int i = 0; i < SIZE; ++i) {
# Line 697 | Line 696 | public class ConcurrentSkipListSubSetTes
696      public void testDescendingAddAll3() {
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);
699 >        for (int i = 0; i < SIZE - 1; ++i)
700 >            ints[i] = new Integer(i + SIZE);
701          try {
702              q.addAll(Arrays.asList(ints));
703              shouldThrow();
# Line 712 | Line 711 | public class ConcurrentSkipListSubSetTes
711          Integer[] empty = new Integer[0];
712          Integer[] ints = new Integer[SIZE];
713          for (int i = 0; i < SIZE; ++i)
714 <            ints[i] = new Integer(SIZE-1- i);
714 >            ints[i] = new Integer(SIZE - 1 - i);
715          NavigableSet q = dset0();
716          assertFalse(q.addAll(Arrays.asList(empty)));
717          assertTrue(q.addAll(Arrays.asList(ints)));
# Line 741 | Line 740 | public class ConcurrentSkipListSubSetTes
740          }
741          for (int i = 0; i < SIZE; i += 2 ) {
742              assertTrue(q.remove(new Integer(i)));
743 <            assertFalse(q.remove(new Integer(i+1)));
743 >            assertFalse(q.remove(new Integer(i + 1)));
744          }
745          assertTrue(q.isEmpty());
746      }
# Line 800 | Line 799 | public class ConcurrentSkipListSubSetTes
799                  assertTrue(changed);
800  
801              assertTrue(q.containsAll(p));
802 <            assertEquals(SIZE-i, q.size());
802 >            assertEquals(SIZE - i, q.size());
803              p.pollFirst();
804          }
805      }
# Line 813 | Line 812 | public class ConcurrentSkipListSubSetTes
812              NavigableSet q = populatedSet(SIZE);
813              NavigableSet p = populatedSet(i);
814              assertTrue(q.removeAll(p));
815 <            assertEquals(SIZE-i, q.size());
815 >            assertEquals(SIZE - i, q.size());
816              for (int j = 0; j < i; ++j) {
817                  Integer x = (Integer)(p.pollFirst());
818                  assertFalse(q.contains(x));
# Line 975 | Line 974 | public class ConcurrentSkipListSubSetTes
974      }
975  
976      /**
977 <     * A deserialized serialized set has same elements
977 >     * A deserialized/reserialized set equals original
978       */
979      public void testDescendingSerialization() throws Exception {
980          NavigableSet x = dset5();

Diff Legend

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