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

Comparing jsr166/src/test/tck/ConcurrentSkipListMapTest.java (file contents):
Revision 1.6 by dl, Wed Apr 19 15:10:54 2006 UTC vs.
Revision 1.11 by jsr166, Mon Nov 16 05:30:07 2009 UTC

# Line 11 | Line 11 | import java.io.*;
11  
12   public class ConcurrentSkipListMapTest extends JSR166TestCase {
13      public static void main(String[] args) {
14 <        junit.textui.TestRunner.run (suite());  
14 >        junit.textui.TestRunner.run (suite());
15      }
16      public static Test suite() {
17          return new TestSuite(ConcurrentSkipListMapTest.class);
# Line 20 | Line 20 | public class ConcurrentSkipListMapTest e
20      /**
21       * Create a map from Integers 1-5 to Strings "A"-"E".
22       */
23 <    private static ConcurrentSkipListMap map5() {  
23 >    private static ConcurrentSkipListMap map5() {
24          ConcurrentSkipListMap map = new ConcurrentSkipListMap();
25          assertTrue(map.isEmpty());
26          map.put(one, "A");
# Line 43 | Line 43 | public class ConcurrentSkipListMapTest e
43      }
44  
45      /**
46 <     *  
46 >     *
47       */
48      public void testConstructFromSorted() {
49          ConcurrentSkipListMap map = map5();
# Line 169 | Line 169 | public class ConcurrentSkipListMapTest e
169          Iterator i = s.iterator();
170          Integer last = (Integer)i.next();
171          assertEquals(last, one);
172 +        int count = 1;
173          while (i.hasNext()) {
174              Integer k = (Integer)i.next();
175              assertTrue(last.compareTo(k) < 0);
176              last = k;
177 +            ++count;
178          }
179 +        assertEquals(count ,5);
180 +    }
181 +
182 +    /**
183 +     * descending iterator of key set is inverse ordered
184 +     */
185 +    public void testKeySetDescendingIteratorOrder() {
186 +        ConcurrentSkipListMap map = map5();
187 +        NavigableSet s = map.navigableKeySet();
188 +        Iterator i = s.descendingIterator();
189 +        Integer last = (Integer)i.next();
190 +        assertEquals(last, five);
191 +        int count = 1;
192 +        while (i.hasNext()) {
193 +            Integer k = (Integer)i.next();
194 +            assertTrue(last.compareTo(k) > 0);
195 +            last = k;
196 +            ++count;
197 +        }
198 +        assertEquals(count ,5);
199      }
200  
201      /**
# Line 185 | Line 207 | public class ConcurrentSkipListMapTest e
207          Iterator i = s.iterator();
208          Integer last = (Integer)i.next();
209          assertEquals(last, five);
210 +        int count = 1;
211          while (i.hasNext()) {
212              Integer k = (Integer)i.next();
213              assertTrue(last.compareTo(k) > 0);
214              last = k;
215 +            ++count;
216          }
217 +        assertEquals(count, 5);
218      }
219  
220 +    /**
221 +     *  descending iterator of descendingKeySet is ordered
222 +     */
223 +    public void testDescendingKeySetDescendingIteratorOrder() {
224 +        ConcurrentSkipListMap map = map5();
225 +        NavigableSet s = map.descendingKeySet();
226 +        Iterator i = s.descendingIterator();
227 +        Integer last = (Integer)i.next();
228 +        assertEquals(last, one);
229 +        int count = 1;
230 +        while (i.hasNext()) {
231 +            Integer k = (Integer)i.next();
232 +            assertTrue(last.compareTo(k) < 0);
233 +            last = k;
234 +            ++count;
235 +        }
236 +        assertEquals(count, 5);
237 +    }
238  
239      /**
240       *  Values.toArray contains all values
# Line 233 | Line 276 | public class ConcurrentSkipListMapTest e
276          Iterator it = s.iterator();
277          while (it.hasNext()) {
278              Map.Entry e = (Map.Entry) it.next();
279 <            assertTrue(
279 >            assertTrue(
280                         (e.getKey().equals(one) && e.getValue().equals("A")) ||
281                         (e.getKey().equals(two) && e.getValue().equals("B")) ||
282                         (e.getKey().equals(three) && e.getValue().equals("C")) ||
# Line 252 | Line 295 | public class ConcurrentSkipListMapTest e
295          Iterator it = s.iterator();
296          while (it.hasNext()) {
297              Map.Entry e = (Map.Entry) it.next();
298 <            assertTrue(
298 >            assertTrue(
299                         (e.getKey().equals(one) && e.getValue().equals("A")) ||
300                         (e.getKey().equals(two) && e.getValue().equals("B")) ||
301                         (e.getKey().equals(three) && e.getValue().equals("C")) ||
# Line 474 | Line 517 | public class ConcurrentSkipListMapTest e
517          try {
518              e.setValue("X");
519              fail();
520 <        } catch(UnsupportedOperationException success) {}
520 >        } catch (UnsupportedOperationException success) {}
521          e = map.higherEntry(zero);
522          assertEquals(one, e.getKey());
523          try {
524              e.setValue("X");
525              fail();
526 <        } catch(UnsupportedOperationException success) {}
526 >        } catch (UnsupportedOperationException success) {}
527          e = map.floorEntry(one);
528          assertEquals(one, e.getKey());
529          try {
530              e.setValue("X");
531              fail();
532 <        } catch(UnsupportedOperationException success) {}
532 >        } catch (UnsupportedOperationException success) {}
533          e = map.ceilingEntry(five);
534          assertEquals(five, e.getKey());
535          try {
536              e.setValue("X");
537              fail();
538 <        } catch(UnsupportedOperationException success) {}
538 >        } catch (UnsupportedOperationException success) {}
539      }
540  
541  
# Line 648 | Line 691 | public class ConcurrentSkipListMapTest e
691          for (int i = 1; i <= 5; ++i) {
692              assertTrue(s.indexOf(String.valueOf(i)) >= 0);
693          }
694 <    }        
694 >    }
695  
696      // Exception tests
697  
# Line 660 | Line 703 | public class ConcurrentSkipListMapTest e
703              ConcurrentSkipListMap c = map5();
704              c.get(null);
705              shouldThrow();
706 <        } catch(NullPointerException e){}
706 >        } catch (NullPointerException e) {}
707      }
708  
709      /**
# Line 671 | Line 714 | public class ConcurrentSkipListMapTest e
714              ConcurrentSkipListMap c = map5();
715              c.containsKey(null);
716              shouldThrow();
717 <        } catch(NullPointerException e){}
717 >        } catch (NullPointerException e) {}
718      }
719  
720      /**
# Line 682 | Line 725 | public class ConcurrentSkipListMapTest e
725              ConcurrentSkipListMap c = new ConcurrentSkipListMap();
726              c.containsValue(null);
727              shouldThrow();
728 <        } catch(NullPointerException e){}
728 >        } catch (NullPointerException e) {}
729      }
730  
731  
# Line 694 | Line 737 | public class ConcurrentSkipListMapTest e
737              ConcurrentSkipListMap c = map5();
738              c.put(null, "whatever");
739              shouldThrow();
740 <        } catch(NullPointerException e){}
740 >        } catch (NullPointerException e) {}
741      }
742  
743      /**
# Line 705 | Line 748 | public class ConcurrentSkipListMapTest e
748              ConcurrentSkipListMap c = map5();
749              c.putIfAbsent(null, "whatever");
750              shouldThrow();
751 <        } catch(NullPointerException e){}
751 >        } catch (NullPointerException e) {}
752      }
753  
754      /**
# Line 716 | Line 759 | public class ConcurrentSkipListMapTest e
759              ConcurrentSkipListMap c = map5();
760              c.replace(null, "whatever");
761              shouldThrow();
762 <        } catch(NullPointerException e){}
762 >        } catch (NullPointerException e) {}
763      }
764  
765      /**
# Line 727 | Line 770 | public class ConcurrentSkipListMapTest e
770              ConcurrentSkipListMap c = map5();
771              c.replace(null, one, "whatever");
772              shouldThrow();
773 <        } catch(NullPointerException e){}
773 >        } catch (NullPointerException e) {}
774      }
775  
776      /**
# Line 739 | Line 782 | public class ConcurrentSkipListMapTest e
782              c.put("sadsdf", "asdads");
783              c.remove(null);
784              shouldThrow();
785 <        } catch(NullPointerException e){}
785 >        } catch (NullPointerException e) {}
786      }
787  
788      /**
# Line 751 | Line 794 | public class ConcurrentSkipListMapTest e
794              c.put("sadsdf", "asdads");
795              c.remove(null, "whatever");
796              shouldThrow();
797 <        } catch(NullPointerException e){}
797 >        } catch (NullPointerException e) {}
798      }
799  
800      /**
# Line 762 | Line 805 | public class ConcurrentSkipListMapTest e
805              ConcurrentSkipListMap c = new ConcurrentSkipListMap();
806              c.put("sadsdf", "asdads");
807              assertFalse(c.remove("sadsdf", null));
808 <        } catch(NullPointerException e){
808 >        } catch (NullPointerException e) {
809              fail();
810          }
811      }
# Line 785 | Line 828 | public class ConcurrentSkipListMapTest e
828              assertEquals(q.size(), r.size());
829              assertTrue(q.equals(r));
830              assertTrue(r.equals(q));
831 <        } catch(Exception e){
831 >        } catch (Exception e) {
832              e.printStackTrace();
833              unexpectedException();
834          }
# Line 798 | Line 841 | public class ConcurrentSkipListMapTest e
841       */
842      public void testSubMapContents() {
843          ConcurrentSkipListMap map = map5();
844 <        NavigableMap sm = map.navigableSubMap(two, true, four, false);
844 >        NavigableMap sm = map.subMap(two, true, four, false);
845          assertEquals(two, sm.firstKey());
846          assertEquals(three, sm.lastKey());
847          assertEquals(2, sm.size());
# Line 820 | Line 863 | public class ConcurrentSkipListMapTest e
863          k = (Integer)(r.next());
864          assertEquals(two, k);
865          assertFalse(r.hasNext());
866 <        
866 >
867          Iterator j = sm.keySet().iterator();
868          j.next();
869          j.remove();
# Line 836 | Line 879 | public class ConcurrentSkipListMapTest e
879  
880      public void testSubMapContents2() {
881          ConcurrentSkipListMap map = map5();
882 <        NavigableMap sm = map.navigableSubMap(two, true, three, false);
882 >        NavigableMap sm = map.subMap(two, true, three, false);
883          assertEquals(1, sm.size());
884          assertEquals(two, sm.firstKey());
885          assertEquals(two, sm.lastKey());
# Line 854 | Line 897 | public class ConcurrentSkipListMapTest e
897          k = (Integer)(r.next());
898          assertEquals(two, k);
899          assertFalse(r.hasNext());
900 <        
900 >
901          Iterator j = sm.keySet().iterator();
902          j.next();
903          j.remove();
# Line 871 | Line 914 | public class ConcurrentSkipListMapTest e
914       */
915      public void testHeadMapContents() {
916          ConcurrentSkipListMap map = map5();
917 <        NavigableMap sm = map.navigableHeadMap(four, false);
917 >        NavigableMap sm = map.headMap(four, false);
918          assertTrue(sm.containsKey(one));
919          assertTrue(sm.containsKey(two));
920          assertTrue(sm.containsKey(three));
# Line 897 | Line 940 | public class ConcurrentSkipListMapTest e
940       */
941      public void testTailMapContents() {
942          ConcurrentSkipListMap map = map5();
943 <        NavigableMap sm = map.navigableTailMap(two, true);
943 >        NavigableMap sm = map.tailMap(two, true);
944          assertFalse(sm.containsKey(one));
945          assertTrue(sm.containsKey(two));
946          assertTrue(sm.containsKey(three));
# Line 941 | Line 984 | public class ConcurrentSkipListMapTest e
984          assertEquals("E", e.getValue());
985          assertFalse(i.hasNext());
986  
987 <        NavigableMap ssm = sm.navigableTailMap(four, true);
987 >        NavigableMap ssm = sm.tailMap(four, true);
988          assertEquals(four, ssm.firstKey());
989          assertEquals(five, ssm.lastKey());
990          assertTrue(ssm.remove(four) != null);
# Line 970 | Line 1013 | public class ConcurrentSkipListMapTest e
1013          check(map,                 0, mapSize - 1, true);
1014          check(map.descendingMap(), 0, mapSize - 1, false);
1015  
1016 <        bashSubMap(map.navigableSubMap(0, true, mapSize, false),
1016 >        bashSubMap(map.subMap(0, true, mapSize, false),
1017                     0, mapSize - 1, true);
1018      }
1019  
# Line 978 | Line 1021 | public class ConcurrentSkipListMapTest e
1021          NavigableMap<Integer, Integer> result = null;
1022          try {
1023              result = (NavigableMap<Integer, Integer>) cl.newInstance();
1024 <        } catch(Exception e) {
1024 >        } catch (Exception e) {
1025              fail();
1026          }
1027          assertEquals(result.size(), 0);
# Line 1003 | Line 1046 | public class ConcurrentSkipListMapTest e
1046          }
1047  
1048          // Remove a bunch of entries with iterator
1049 <        for(Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) {
1049 >        for (Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) {
1050              if (rnd.nextBoolean()) {
1051                  bs.clear(it.next());
1052                  it.remove();
# Line 1028 | Line 1071 | public class ConcurrentSkipListMapTest e
1071          }
1072  
1073          // Remove a bunch of entries with iterator
1074 <        for(Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) {
1074 >        for (Iterator<Integer> it = map.keySet().iterator(); it.hasNext(); ) {
1075              if (rnd.nextBoolean()) {
1076                  bs.clear(it.next());
1077                  it.remove();
# Line 1044 | Line 1087 | public class ConcurrentSkipListMapTest e
1087                  try {
1088                      map.put(key, 2 * key);
1089                      fail();
1090 <                } catch(IllegalArgumentException e) {
1090 >                } catch (IllegalArgumentException e) {
1091                      // expected
1092                  }
1093              }
# Line 1077 | Line 1120 | public class ConcurrentSkipListMapTest e
1120  
1121          // headMap - pick direction and endpoint inclusion randomly
1122          boolean incl = rnd.nextBoolean();
1123 <        NavigableMap<Integer,Integer> hm = map.navigableHeadMap(midPoint, incl);
1123 >        NavigableMap<Integer,Integer> hm = map.headMap(midPoint, incl);
1124          if (ascending) {
1125              if (rnd.nextBoolean())
1126                  bashSubMap(hm, min, midPoint - (incl ? 0 : 1), true);
# Line 1094 | Line 1137 | public class ConcurrentSkipListMapTest e
1137  
1138          // tailMap - pick direction and endpoint inclusion randomly
1139          incl = rnd.nextBoolean();
1140 <        NavigableMap<Integer,Integer> tm = map.navigableTailMap(midPoint,incl);
1140 >        NavigableMap<Integer,Integer> tm = map.tailMap(midPoint,incl);
1141          if (ascending) {
1142              if (rnd.nextBoolean())
1143                  bashSubMap(tm, midPoint + (incl ? 0 : 1), max, true);
# Line 1119 | Line 1162 | public class ConcurrentSkipListMapTest e
1162          boolean lowIncl = rnd.nextBoolean();
1163          boolean highIncl = rnd.nextBoolean();
1164          if (ascending) {
1165 <            NavigableMap<Integer,Integer> sm = map.navigableSubMap(
1165 >            NavigableMap<Integer,Integer> sm = map.subMap(
1166                  endpoints[0], lowIncl, endpoints[1], highIncl);
1167              if (rnd.nextBoolean())
1168                  bashSubMap(sm, endpoints[0] + (lowIncl ? 0 : 1),
# Line 1128 | Line 1171 | public class ConcurrentSkipListMapTest e
1171                  bashSubMap(sm.descendingMap(), endpoints[0] + (lowIncl ? 0 : 1),
1172                             endpoints[1] - (highIncl ? 0 : 1), false);
1173          } else {
1174 <            NavigableMap<Integer,Integer> sm = map.navigableSubMap(
1174 >            NavigableMap<Integer,Integer> sm = map.subMap(
1175                  endpoints[1], highIncl, endpoints[0], lowIncl);
1176              if (rnd.nextBoolean())
1177                  bashSubMap(sm, endpoints[0] + (lowIncl ? 0 : 1),
# Line 1242 | Line 1285 | public class ConcurrentSkipListMapTest e
1285              try {
1286                  map.firstKey();
1287                  fail();
1288 <            } catch(NoSuchElementException e) {
1288 >            } catch (NoSuchElementException e) {
1289                  // expected
1290              }
1291              try {
1292                  map.lastKey();
1293                  fail();
1294 <            } catch(NoSuchElementException e) {
1294 >            } catch (NoSuchElementException e) {
1295                  // expected
1296              }
1297          }
# Line 1264 | Line 1307 | public class ConcurrentSkipListMapTest e
1307      static boolean eq(Integer i, int j) {
1308          return i == null ? j == -1 : i == j;
1309      }
1310 <    
1310 >
1311   }

Diff Legend

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