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.23 by jsr166, Tue Mar 15 19:47:06 2011 UTC vs.
Revision 1.29 by dl, Tue Sep 11 23:12:20 2012 UTC

# Line 8 | Line 8
8  
9   import junit.framework.*;
10   import java.util.*;
11 < import java.util.concurrent.*;
12 < import java.util.Enumeration;
13 < import java.io.*;
11 > import java.util.concurrent.ConcurrentHashMap;
12  
13   public class ConcurrentHashMapTest extends JSR166TestCase {
14      public static void main(String[] args) {
# Line 21 | Line 19 | public class ConcurrentHashMapTest exten
19      }
20  
21      /**
22 <     * Create a map from Integers 1-5 to Strings "A"-"E".
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);
# Line 42 | Line 40 | public class ConcurrentHashMapTest exten
40      public void testClear() {
41          ConcurrentHashMap map = map5();
42          map.clear();
43 <        assertEquals(map.size(), 0);
43 >        assertEquals(0, map.size());
44      }
45  
46      /**
# Line 275 | Line 273 | public class ConcurrentHashMapTest exten
273          assertEquals("Z", map.get(one));
274      }
275  
278 –
276      /**
277       * replace value fails when the given key not mapped to expected value
278       */
# Line 296 | Line 293 | public class ConcurrentHashMapTest exten
293          assertEquals("Z", map.get(one));
294      }
295  
299 –
296      /**
297       * remove removes the correct key-value pair from the map
298       */
# Line 337 | Line 333 | public class ConcurrentHashMapTest exten
333          ConcurrentHashMap map = map5();
334          String s = map.toString();
335          for (int i = 1; i <= 5; ++i) {
336 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
336 >            assertTrue(s.contains(String.valueOf(i)));
337          }
338      }
339  
# Line 483 | Line 479 | public class ConcurrentHashMapTest exten
479          } catch (NullPointerException success) {}
480      }
481  
486 –
482      /**
483       * replace(x, null) throws NPE
484       */
# Line 517 | Line 512 | public class ConcurrentHashMapTest exten
512          } catch (NullPointerException success) {}
513      }
514  
520 –
515      /**
516       * remove(null) throws NPE
517       */
# Line 555 | Line 549 | public class ConcurrentHashMapTest exten
549       * A deserialized map equals original
550       */
551      public void testSerialization() throws Exception {
552 <        ConcurrentHashMap q = map5();
552 >        Map x = map5();
553 >        Map y = serialClone(x);
554  
555 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
556 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
557 <        out.writeObject(q);
558 <        out.close();
564 <
565 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
566 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
567 <        ConcurrentHashMap r = (ConcurrentHashMap)in.readObject();
568 <        assertEquals(q.size(), r.size());
569 <        assertTrue(q.equals(r));
570 <        assertTrue(r.equals(q));
555 >        assertTrue(x != y);
556 >        assertEquals(x.size(), y.size());
557 >        assertEquals(x, y);
558 >        assertEquals(y, x);
559      }
560  
573 –
561      /**
562       * SetValue of an EntrySet entry sets value in the map.
563       */
# Line 582 | Line 569 | public class ConcurrentHashMapTest exten
569              map.put(new Integer(i), new Integer(i));
570          assertFalse(map.isEmpty());
571          Map.Entry entry1 = (Map.Entry)map.entrySet().iterator().next();
572 <
573 <        // assert that entry1 is not 16
574 <        assertTrue("entry is 16, test not valid",
575 <                   !entry1.getKey().equals(new Integer(16)));
576 <
577 <        // remove 16 (a different key) from map
578 <        // which just happens to cause entry1 to be cloned in map
579 <        map.remove(new Integer(16));
580 <        entry1.setValue("XYZ");
594 <        assertTrue(map.containsValue("XYZ")); // fails
572 >        // Unless it happens to be first (in which case remainder of
573 >        // test is skipped), remove a possibly-colliding key from map
574 >        // which, under some implementations, may cause entry1 to be
575 >        // cloned in map
576 >        if (!entry1.getKey().equals(new Integer(16))) {
577 >            map.remove(new Integer(16));
578 >            entry1.setValue("XYZ");
579 >            assertTrue(map.containsValue("XYZ")); // fails if write-through broken
580 >        }
581      }
582  
583   }

Diff Legend

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