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

Comparing jsr166/src/test/tck/ConcurrentHashMapTest.java (file contents):
Revision 1.35 by jsr166, Sat Jul 20 16:53:40 2013 UTC vs.
Revision 1.39 by jsr166, Tue Sep 24 17:26:27 2013 UTC

# Line 21 | Line 21 | public class ConcurrentHashMapTest exten
21      /**
22       * Returns a new map from Integers 1-5 to Strings "A"-"E".
23       */
24 <    private static ConcurrentHashMap map5() {
25 <        ConcurrentHashMap map = new ConcurrentHashMap(5);
24 >    private static ConcurrentHashMap<Integer, String> map5() {
25 >        ConcurrentHashMap map = new ConcurrentHashMap<Integer, String>(5);
26          assertTrue(map.isEmpty());
27          map.put(one, "A");
28          map.put(two, "B");
# Line 103 | Line 103 | public class ConcurrentHashMapTest exten
103       * class are found.
104       */
105      public void testComparableFamily() {
106 +        int size = 500;         // makes measured test run time -> 60ms
107          ConcurrentHashMap<BI, Boolean> m =
108              new ConcurrentHashMap<BI, Boolean>();
109 <        for (int i = 0; i < 1000; i++) {
109 >        for (int i = 0; i < size; i++) {
110              assertTrue(m.put(new CI(i), true) == null);
111          }
112 <        for (int i = 0; i < 1000; i++) {
112 >        for (int i = 0; i < size; i++) {
113              assertTrue(m.containsKey(new CI(i)));
114              assertTrue(m.containsKey(new DI(i)));
115          }
# Line 119 | Line 120 | public class ConcurrentHashMapTest exten
120       * on Comparable can be inserted and found.
121       */
122      public void testGenericComparable() {
123 +        int size = 120;         // makes measured test run time -> 60ms
124          ConcurrentHashMap<Object, Boolean> m =
125              new ConcurrentHashMap<Object, Boolean>();
126 <        for (int i = 0; i < 1000; i++) {
126 >        for (int i = 0; i < size; i++) {
127              BI bi = new BI(i);
128              BS bs = new BS(String.valueOf(i));
129              LexicographicList<BI> bis = new LexicographicList<BI>(bi);
# Line 132 | Line 134 | public class ConcurrentHashMapTest exten
134                  assertTrue(m.containsKey(bss));
135              assertTrue(m.containsKey(bis));
136          }
137 <        for (int i = 0; i < 1000; i++) {
138 <            assertTrue(m.containsKey(new ArrayList(Collections.singleton(new BI(i)))));
137 >        for (int i = 0; i < size; i++) {
138 >            assertTrue(m.containsKey(Collections.singletonList(new BI(i))));
139          }
140      }
141  
# Line 143 | Line 145 | public class ConcurrentHashMapTest exten
145       * inserted and found.
146       */
147      public void testGenericComparable2() {
148 +        int size = 500;         // makes measured test run time -> 60ms
149          ConcurrentHashMap<Object, Boolean> m =
150              new ConcurrentHashMap<Object, Boolean>();
151 <        for (int i = 0; i < 1000; i++) {
152 <            m.put(new ArrayList(Collections.singleton(new BI(i))), true);
151 >        for (int i = 0; i < size; i++) {
152 >            m.put(Collections.singletonList(new BI(i)), true);
153          }
154  
155 <        for (int i = 0; i < 1000; i++) {
155 >        for (int i = 0; i < size; i++) {
156              LexicographicList<BI> bis = new LexicographicList<BI>(new BI(i));
157              assertTrue(m.containsKey(bis));
158          }
# Line 160 | Line 163 | public class ConcurrentHashMapTest exten
163       * can be inserted and found.
164       */
165      public void testMixedComparable() {
166 <        int size = 10000;
166 >        int size = 1200;        // makes measured test run time -> 35ms
167          ConcurrentHashMap<Object, Object> map =
168              new ConcurrentHashMap<Object, Object>();
169 <        Random rng = new Random(1370014958369218000L);
169 >        Random rng = new Random();
170          for (int i = 0; i < size; i++) {
171              Object x;
172              switch (rng.nextInt(4)) {
# Line 213 | Line 216 | public class ConcurrentHashMapTest exten
216      }
217  
218      /**
219 +     * hashCode() equals sum of each key.hashCode ^ value.hashCode
220 +     */
221 +    public void testHashCode() {
222 +        ConcurrentHashMap<Integer,String> map = map5();
223 +        int sum = 0;
224 +        for (Map.Entry<Integer,String> e : map.entrySet())
225 +            sum += e.getKey().hashCode() ^ e.getValue().hashCode();
226 +        assertEquals(sum, map.hashCode());
227 +    }
228 +
229 +    /**
230       * contains returns true for contained value
231       */
232      public void testContains() {
# Line 496 | Line 510 | public class ConcurrentHashMapTest exten
510      // Exception tests
511  
512      /**
513 <     * Cannot create with negative capacity
513 >     * Cannot create with only negative capacity
514       */
515      public void testConstructor1() {
516          try {
517 <            new ConcurrentHashMap(-1,0,1);
517 >            new ConcurrentHashMap(-1);
518              shouldThrow();
519          } catch (IllegalArgumentException success) {}
520      }
521  
522      /**
523 <     * Cannot create with negative concurrency level
524 <     */
523 >     * Constructor (initialCapacity, loadFactor) throws
524 >     * IllegalArgumentException if either argument is negative
525 >      */
526      public void testConstructor2() {
527          try {
528 <            new ConcurrentHashMap(1,0,-1);
528 >            new ConcurrentHashMap(-1, .75f);
529              shouldThrow();
530 <        } catch (IllegalArgumentException success) {}
530 >        } catch (IllegalArgumentException e) {}
531 >
532 >        try {
533 >            new ConcurrentHashMap(16, -1);
534 >            shouldThrow();
535 >        } catch (IllegalArgumentException e) {}
536      }
537  
538      /**
539 <     * Cannot create with only negative capacity
539 >     * Constructor (initialCapacity, loadFactor, concurrencyLevel)
540 >     * throws IllegalArgumentException if any argument is negative
541       */
542      public void testConstructor3() {
543          try {
544 <            new ConcurrentHashMap(-1);
544 >            new ConcurrentHashMap(-1, .75f, 1);
545              shouldThrow();
546 <        } catch (IllegalArgumentException success) {}
546 >        } catch (IllegalArgumentException e) {}
547 >
548 >        try {
549 >            new ConcurrentHashMap(16, -1, 1);
550 >            shouldThrow();
551 >        } catch (IllegalArgumentException e) {}
552 >
553 >        try {
554 >            new ConcurrentHashMap(16, .75f, -1);
555 >            shouldThrow();
556 >        } catch (IllegalArgumentException e) {}
557      }
558  
559      /**
560 +     * ConcurrentHashMap(map) throws NullPointerException if the given
561 +     * map is null
562 +     */
563 +    public void testConstructor4() {
564 +        try {
565 +            new ConcurrentHashMap(null);
566 +            shouldThrow();
567 +        } catch (NullPointerException e) {}
568 +    }
569 +
570 +    /**
571 +     * ConcurrentHashMap(map) creates a new map with the same mappings
572 +     * as the given map
573 +     */
574 +    public void testConstructor5() {
575 +        ConcurrentHashMap map1 = map5();
576 +        ConcurrentHashMap map2 = new ConcurrentHashMap(map5());
577 +        assertTrue(map2.equals(map1));
578 +        map2.put(one, "F");
579 +        assertFalse(map2.equals(map1));
580 +    }
581 +
582 +
583 +    /**
584       * get(null) throws NPE
585       */
586      public void testGet_NullPointerException() {

Diff Legend

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