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

Comparing jsr166/src/test/tck/ConcurrentSkipListSetTest.java (file contents):
Revision 1.7 by jsr166, Sat Nov 21 02:07:26 2009 UTC vs.
Revision 1.10 by jsr166, Sat Nov 21 17:38:05 2009 UTC

# Line 72 | Line 72 | public class ConcurrentSkipListSetTest e
72          try {
73              ConcurrentSkipListSet q = new ConcurrentSkipListSet((Collection)null);
74              shouldThrow();
75 <        }
76 <        catch (NullPointerException success) {}
75 >        } catch (NullPointerException success) {}
76      }
77  
78      /**
# Line 84 | Line 83 | public class ConcurrentSkipListSetTest e
83              Integer[] ints = new Integer[SIZE];
84              ConcurrentSkipListSet q = new ConcurrentSkipListSet(Arrays.asList(ints));
85              shouldThrow();
86 <        }
88 <        catch (NullPointerException success) {}
86 >        } catch (NullPointerException success) {}
87      }
88  
89      /**
# Line 98 | Line 96 | public class ConcurrentSkipListSetTest e
96                  ints[i] = new Integer(i);
97              ConcurrentSkipListSet q = new ConcurrentSkipListSet(Arrays.asList(ints));
98              shouldThrow();
99 <        }
102 <        catch (NullPointerException success) {}
99 >        } catch (NullPointerException success) {}
100      }
101  
102      /**
103       * Set contains all elements of collection used to initialize
104       */
105      public void testConstructor6() {
106 <        try {
107 <            Integer[] ints = new Integer[SIZE];
108 <            for (int i = 0; i < SIZE; ++i)
109 <                ints[i] = new Integer(i);
110 <            ConcurrentSkipListSet q = new ConcurrentSkipListSet(Arrays.asList(ints));
111 <            for (int i = 0; i < SIZE; ++i)
115 <                assertEquals(ints[i], q.pollFirst());
116 <        }
117 <        finally {}
106 >        Integer[] ints = new Integer[SIZE];
107 >        for (int i = 0; i < SIZE; ++i)
108 >            ints[i] = new Integer(i);
109 >        ConcurrentSkipListSet q = new ConcurrentSkipListSet(Arrays.asList(ints));
110 >        for (int i = 0; i < SIZE; ++i)
111 >            assertEquals(ints[i], q.pollFirst());
112      }
113  
114      /**
115       * The comparator used in constructor is used
116       */
117      public void testConstructor7() {
118 <        try {
119 <            MyReverseComparator cmp = new MyReverseComparator();
120 <            ConcurrentSkipListSet q = new ConcurrentSkipListSet(cmp);
121 <            assertEquals(cmp, q.comparator());
122 <            Integer[] ints = new Integer[SIZE];
123 <            for (int i = 0; i < SIZE; ++i)
124 <                ints[i] = new Integer(i);
125 <            q.addAll(Arrays.asList(ints));
126 <            for (int i = SIZE-1; i >= 0; --i)
133 <                assertEquals(ints[i], q.pollFirst());
134 <        }
135 <        finally {}
118 >        MyReverseComparator cmp = new MyReverseComparator();
119 >        ConcurrentSkipListSet q = new ConcurrentSkipListSet(cmp);
120 >        assertEquals(cmp, q.comparator());
121 >        Integer[] ints = new Integer[SIZE];
122 >        for (int i = 0; i < SIZE; ++i)
123 >            ints[i] = new Integer(i);
124 >        q.addAll(Arrays.asList(ints));
125 >        for (int i = SIZE-1; i >= 0; --i)
126 >            assertEquals(ints[i], q.pollFirst());
127      }
128  
129      /**
# Line 172 | Line 163 | public class ConcurrentSkipListSetTest e
163              ConcurrentSkipListSet q = new ConcurrentSkipListSet();
164              q.add(null);
165              shouldThrow();
166 <        } catch (NullPointerException success) { }
166 >        } catch (NullPointerException success) {}
167      }
168  
169      /**
# Line 203 | Line 194 | public class ConcurrentSkipListSetTest e
194              q.add(new Object());
195              q.add(new Object());
196              shouldThrow();
197 <        }
207 <        catch (ClassCastException success) {}
197 >        } catch (ClassCastException success) {}
198      }
199  
200      /**
# Line 215 | Line 205 | public class ConcurrentSkipListSetTest e
205              ConcurrentSkipListSet q = new ConcurrentSkipListSet();
206              q.addAll(null);
207              shouldThrow();
208 <        }
219 <        catch (NullPointerException success) {}
208 >        } catch (NullPointerException success) {}
209      }
210      /**
211       * addAll of a collection with null elements throws NPE
# Line 227 | Line 216 | public class ConcurrentSkipListSetTest e
216              Integer[] ints = new Integer[SIZE];
217              q.addAll(Arrays.asList(ints));
218              shouldThrow();
219 <        }
231 <        catch (NullPointerException success) {}
219 >        } catch (NullPointerException success) {}
220      }
221      /**
222       * addAll of a collection with any null elements throws NPE after
# Line 242 | Line 230 | public class ConcurrentSkipListSetTest e
230                  ints[i] = new Integer(i);
231              q.addAll(Arrays.asList(ints));
232              shouldThrow();
233 <        }
246 <        catch (NullPointerException success) {}
233 >        } catch (NullPointerException success) {}
234      }
235  
236      /**
237       * Set contains all elements of successful addAll
238       */
239      public void testAddAll5() {
240 <        try {
241 <            Integer[] empty = new Integer[0];
242 <            Integer[] ints = new Integer[SIZE];
243 <            for (int i = 0; i < SIZE; ++i)
244 <                ints[i] = new Integer(SIZE-1-i);
245 <            ConcurrentSkipListSet q = new ConcurrentSkipListSet();
246 <            assertFalse(q.addAll(Arrays.asList(empty)));
247 <            assertTrue(q.addAll(Arrays.asList(ints)));
248 <            for (int i = 0; i < SIZE; ++i)
262 <                assertEquals(new Integer(i), q.pollFirst());
263 <        }
264 <        finally {}
240 >        Integer[] empty = new Integer[0];
241 >        Integer[] ints = new Integer[SIZE];
242 >        for (int i = 0; i < SIZE; ++i)
243 >            ints[i] = new Integer(SIZE-1-i);
244 >        ConcurrentSkipListSet q = new ConcurrentSkipListSet();
245 >        assertFalse(q.addAll(Arrays.asList(empty)));
246 >        assertTrue(q.addAll(Arrays.asList(ints)));
247 >        for (int i = 0; i < SIZE; ++i)
248 >            assertEquals(new Integer(i), q.pollFirst());
249      }
250  
251      /**
# Line 540 | Line 524 | public class ConcurrentSkipListSetTest e
524      /**
525       * A deserialized serialized set has same elements
526       */
527 <    public void testSerialization() {
527 >    public void testSerialization() throws Exception {
528          ConcurrentSkipListSet q = populatedSet(SIZE);
529 <        try {
530 <            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
531 <            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
532 <            out.writeObject(q);
533 <            out.close();
534 <
535 <            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
536 <            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
537 <            ConcurrentSkipListSet r = (ConcurrentSkipListSet)in.readObject();
538 <            assertEquals(q.size(), r.size());
539 <            while (!q.isEmpty())
556 <                assertEquals(q.pollFirst(), r.pollFirst());
557 <        } catch (Exception e) {
558 <            e.printStackTrace();
559 <            unexpectedException();
560 <        }
529 >        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
530 >        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
531 >        out.writeObject(q);
532 >        out.close();
533 >
534 >        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
535 >        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
536 >        ConcurrentSkipListSet r = (ConcurrentSkipListSet)in.readObject();
537 >        assertEquals(q.size(), r.size());
538 >        while (!q.isEmpty())
539 >            assertEquals(q.pollFirst(), r.pollFirst());
540      }
541  
542      /**
# Line 685 | Line 664 | public class ConcurrentSkipListSetTest e
664      /**
665       * Subsets of subsets subdivide correctly
666       */
667 <    public void testRecursiveSubSets() {
667 >    public void testRecursiveSubSets() throws Exception {
668          int setSize = 1000;
669          Class cl = ConcurrentSkipListSet.class;
670  
# Line 704 | Line 683 | public class ConcurrentSkipListSetTest e
683                     0, setSize - 1, true);
684      }
685  
686 <    static NavigableSet<Integer> newSet(Class cl) {
687 <        NavigableSet<Integer> result = null;
709 <        try {
710 <            result = (NavigableSet<Integer>) cl.newInstance();
711 <        } catch (Exception e) {
712 <            fail();
713 <        }
686 >    static NavigableSet<Integer> newSet(Class cl) throws Exception {
687 >        NavigableSet<Integer> result = (NavigableSet<Integer>) cl.newInstance();
688          assertEquals(result.size(), 0);
689          assertFalse(result.iterator().hasNext());
690          return result;
# Line 773 | Line 747 | public class ConcurrentSkipListSetTest e
747              } else {
748                  try {
749                      set.add(element);
750 <                    fail();
751 <                } catch (IllegalArgumentException e) {
778 <                    // expected
779 <                }
750 >                    shouldThrow();
751 >                } catch (IllegalArgumentException success) {}
752              }
753          }
754      }
# Line 975 | Line 947 | public class ConcurrentSkipListSetTest e
947              assertEq(rs.last(),  -1);
948              try {
949                  set.first();
950 <                fail();
951 <            } catch (NoSuchElementException e) {
980 <                // expected
981 <            }
950 >                shouldThrow();
951 >            } catch (NoSuchElementException success) {}
952              try {
953                  set.last();
954 <                fail();
955 <            } catch (NoSuchElementException e) {
986 <                // expected
987 <            }
954 >                shouldThrow();
955 >            } catch (NoSuchElementException success) {}
956          }
957      }
958  

Diff Legend

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