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.16 by jsr166, Fri Nov 5 00:17:22 2010 UTC vs.
Revision 1.21 by jsr166, Sat Nov 26 05:19:17 2011 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.*;
8 > import java.util.Arrays;
9 > import java.util.BitSet;
10 > import java.util.Collection;
11 > import java.util.Comparator;
12 > import java.util.Iterator;
13 > import java.util.NavigableSet;
14 > import java.util.NoSuchElementException;
15 > import java.util.Random;
16 > import java.util.Set;
17 > import java.util.SortedSet;
18 > import java.util.concurrent.ConcurrentSkipListSet;
19  
20   public class ConcurrentSkipListSubSetTest extends JSR166TestCase {
21      public static void main(String[] args) {
# Line 97 | Line 105 | public class ConcurrentSkipListSubSetTes
105          assertEquals(0, set0().size());
106      }
107  
100 –
108      /**
109       * isEmpty is true before add, false after
110       */
# Line 168 | Line 175 | public class ConcurrentSkipListSubSetTes
175          } catch (ClassCastException success) {}
176      }
177  
171 –
178      /**
179       * addAll(null) throws NPE
180       */
# Line 239 | Line 245 | public class ConcurrentSkipListSubSetTes
245      public void testRemoveElement() {
246          NavigableSet q = populatedSet(SIZE);
247          for (int i = 1; i < SIZE; i+=2) {
248 <            assertTrue(q.remove(new Integer(i)));
248 >            assertTrue(q.contains(i));
249 >            assertTrue(q.remove(i));
250 >            assertFalse(q.contains(i));
251 >            assertTrue(q.contains(i-1));
252          }
253          for (int i = 0; i < SIZE; i+=2) {
254 <            assertTrue(q.remove(new Integer(i)));
255 <            assertFalse(q.remove(new Integer(i+1)));
254 >            assertTrue(q.contains(i));
255 >            assertTrue(q.remove(i));
256 >            assertFalse(q.contains(i));
257 >            assertFalse(q.remove(i+1));
258 >            assertFalse(q.contains(i+1));
259          }
260          assertTrue(q.isEmpty());
261      }
# Line 323 | Line 335 | public class ConcurrentSkipListSubSetTes
335          }
336      }
337  
326 –
327 –
338      /**
339       * lower returns preceding element
340       */
# Line 444 | Line 454 | public class ConcurrentSkipListSubSetTes
454              assertTrue(q.contains(it.next()));
455              ++i;
456          }
457 <        assertEquals(i, 0);
457 >        assertEquals(0, i);
458      }
459  
460      /**
# Line 466 | Line 476 | public class ConcurrentSkipListSubSetTes
476          assertFalse(it.hasNext());
477      }
478  
469 –
479      /**
480       * toString contains toStrings of elements
481       */
# Line 474 | Line 483 | public class ConcurrentSkipListSubSetTes
483          NavigableSet q = populatedSet(SIZE);
484          String s = q.toString();
485          for (int i = 0; i < SIZE; ++i) {
486 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
486 >            assertTrue(s.contains(String.valueOf(i)));
487          }
488      }
489  
# Line 482 | Line 491 | public class ConcurrentSkipListSubSetTes
491       * A deserialized serialized set has same elements
492       */
493      public void testSerialization() throws Exception {
494 <        NavigableSet q = populatedSet(SIZE);
495 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
496 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
497 <        out.writeObject(q);
498 <        out.close();
499 <
500 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
501 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
502 <        NavigableSet r = (NavigableSet)in.readObject();
503 <        assertEquals(q.size(), r.size());
504 <        while (!q.isEmpty())
505 <            assertEquals(q.pollFirst(), r.pollFirst());
494 >        NavigableSet x = populatedSet(SIZE);
495 >        NavigableSet y = serialClone(x);
496 >
497 >        assertTrue(x != y);
498 >        assertEquals(x.size(), y.size());
499 >        assertEquals(x, y);
500 >        assertEquals(y, x);
501 >        while (!x.isEmpty()) {
502 >            assertFalse(y.isEmpty());
503 >            assertEquals(x.pollFirst(), y.pollFirst());
504 >        }
505 >        assertTrue(y.isEmpty());
506      }
507  
508      /**
# Line 671 | Line 680 | public class ConcurrentSkipListSubSetTes
680          } catch (ClassCastException success) {}
681      }
682  
674 –
683      /**
684       * addAll(null) throws NPE
685       */
# Line 826 | Line 834 | public class ConcurrentSkipListSubSetTes
834          }
835      }
836  
829 –
830 –
837      /**
838       * lower returns preceding element
839       */
# Line 948 | Line 954 | public class ConcurrentSkipListSubSetTes
954              assertTrue(q.contains(it.next()));
955              ++i;
956          }
957 <        assertEquals(i, 0);
957 >        assertEquals(0, i);
958      }
959  
960      /**
# Line 970 | Line 976 | public class ConcurrentSkipListSubSetTes
976          assertFalse(it.hasNext());
977      }
978  
973 –
979      /**
980       * toString contains toStrings of elements
981       */
# Line 978 | Line 983 | public class ConcurrentSkipListSubSetTes
983          NavigableSet q = populatedSet(SIZE);
984          String s = q.toString();
985          for (int i = 0; i < SIZE; ++i) {
986 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
986 >            assertTrue(s.contains(String.valueOf(i)));
987          }
988      }
989  
# Line 986 | Line 991 | public class ConcurrentSkipListSubSetTes
991       * A deserialized serialized set has same elements
992       */
993      public void testDescendingSerialization() throws Exception {
994 <        NavigableSet q = populatedSet(SIZE);
995 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
996 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
997 <        out.writeObject(q);
998 <        out.close();
999 <
1000 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
1001 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
1002 <        NavigableSet r = (NavigableSet)in.readObject();
1003 <        assertEquals(q.size(), r.size());
1004 <        while (!q.isEmpty())
1005 <            assertEquals(q.pollFirst(), r.pollFirst());
994 >        NavigableSet x = dset5();
995 >        NavigableSet y = serialClone(x);
996 >
997 >        assertTrue(x != y);
998 >        assertEquals(x.size(), y.size());
999 >        assertEquals(x, y);
1000 >        assertEquals(y, x);
1001 >        while (!x.isEmpty()) {
1002 >            assertFalse(y.isEmpty());
1003 >            assertEquals(x.pollFirst(), y.pollFirst());
1004 >        }
1005 >        assertTrue(y.isEmpty());
1006      }
1007  
1008      /**

Diff Legend

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