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.41 by jsr166, Thu Jan 15 18:34:19 2015 UTC vs.
Revision 1.60 by jsr166, Fri Oct 5 22:12:45 2018 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
2 > * Written by Doug Lea and Martin Buchholz with assistance from
3 > * members of JCP JSR-166 Expert Group and released to the public
4 > * domain, as explained at
5   * http://creativecommons.org/publicdomain/zero/1.0/
6   * Other contributors include Andrew Wright, Jeffrey Hayes,
7   * Pat Fisher, Mike Judd.
# Line 18 | Line 19 | import java.util.Set;
19   import java.util.concurrent.ConcurrentHashMap;
20  
21   import junit.framework.Test;
21 – import junit.framework.TestSuite;
22  
23   public class ConcurrentHashMapTest extends JSR166TestCase {
24      public static void main(String[] args) {
25 <        junit.textui.TestRunner.run(suite());
25 >        main(suite(), args);
26      }
27      public static Test suite() {
28 <        return new TestSuite(ConcurrentHashMapTest.class);
28 >        class Implementation implements MapImplementation {
29 >            public Class<?> klazz() { return ConcurrentHashMap.class; }
30 >            public Map emptyMap() { return new ConcurrentHashMap(); }
31 >            public Object makeKey(int i) { return i; }
32 >            public Object makeValue(int i) { return i; }
33 >            public boolean isConcurrent() { return true; }
34 >            public boolean permitsNullKeys() { return false; }
35 >            public boolean permitsNullValues() { return false; }
36 >            public boolean supportsSetValue() { return true; }
37 >        }
38 >        return newTestSuite(
39 >            ConcurrentHashMapTest.class,
40 >            MapTest.testSuite(new Implementation()));
41      }
42  
43      /**
44       * Returns a new map from Integers 1-5 to Strings "A"-"E".
45       */
46      private static ConcurrentHashMap<Integer, String> map5() {
47 <        ConcurrentHashMap map = new ConcurrentHashMap<Integer, String>(5);
47 >        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>(5);
48          assertTrue(map.isEmpty());
49          map.put(one, "A");
50          map.put(two, "B");
# Line 44 | Line 56 | public class ConcurrentHashMapTest exten
56          return map;
57      }
58  
47 –    /** Re-implement Integer.compare for old java versions */
48 –    static int compare(int x, int y) { return x < y ? -1 : x > y ? 1 : 0; }
49 –
59      // classes for testing Comparable fallbacks
60      static class BI implements Comparable<BI> {
61          private final int value;
62          BI(int value) { this.value = value; }
63          public int compareTo(BI other) {
64 <            return compare(value, other.value);
64 >            return Integer.compare(value, other.value);
65          }
66          public boolean equals(Object x) {
67              return (x instanceof BI) && ((BI)x).value == value;
# Line 86 | Line 95 | public class ConcurrentHashMapTest exten
95                      break;
96              }
97              if (r == 0)
98 <                r = compare(size(), other.size());
98 >                r = Integer.compare(size(), other.size());
99              return r;
100          }
101          private static final long serialVersionUID = 0;
# Line 114 | Line 123 | public class ConcurrentHashMapTest exten
123       */
124      public void testComparableFamily() {
125          int size = 500;         // makes measured test run time -> 60ms
126 <        ConcurrentHashMap<BI, Boolean> m =
118 <            new ConcurrentHashMap<BI, Boolean>();
126 >        ConcurrentHashMap<BI, Boolean> m = new ConcurrentHashMap<>();
127          for (int i = 0; i < size; i++) {
128 <            assertTrue(m.put(new CI(i), true) == null);
128 >            assertNull(m.put(new CI(i), true));
129          }
130          for (int i = 0; i < size; i++) {
131              assertTrue(m.containsKey(new CI(i)));
# Line 131 | Line 139 | public class ConcurrentHashMapTest exten
139       */
140      public void testGenericComparable() {
141          int size = 120;         // makes measured test run time -> 60ms
142 <        ConcurrentHashMap<Object, Boolean> m =
135 <            new ConcurrentHashMap<Object, Boolean>();
142 >        ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
143          for (int i = 0; i < size; i++) {
144              BI bi = new BI(i);
145              BS bs = new BS(String.valueOf(i));
146 <            LexicographicList<BI> bis = new LexicographicList<BI>(bi);
147 <            LexicographicList<BS> bss = new LexicographicList<BS>(bs);
148 <            assertTrue(m.putIfAbsent(bis, true) == null);
146 >            LexicographicList<BI> bis = new LexicographicList<>(bi);
147 >            LexicographicList<BS> bss = new LexicographicList<>(bs);
148 >            assertNull(m.putIfAbsent(bis, true));
149              assertTrue(m.containsKey(bis));
150              if (m.putIfAbsent(bss, true) == null)
151                  assertTrue(m.containsKey(bss));
# Line 156 | Line 163 | public class ConcurrentHashMapTest exten
163       */
164      public void testGenericComparable2() {
165          int size = 500;         // makes measured test run time -> 60ms
166 <        ConcurrentHashMap<Object, Boolean> m =
160 <            new ConcurrentHashMap<Object, Boolean>();
166 >        ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
167          for (int i = 0; i < size; i++) {
168              m.put(Collections.singletonList(new BI(i)), true);
169          }
170  
171          for (int i = 0; i < size; i++) {
172 <            LexicographicList<BI> bis = new LexicographicList<BI>(new BI(i));
172 >            LexicographicList<BI> bis = new LexicographicList<>(new BI(i));
173              assertTrue(m.containsKey(bis));
174          }
175      }
# Line 174 | Line 180 | public class ConcurrentHashMapTest exten
180       */
181      public void testMixedComparable() {
182          int size = 1200;        // makes measured test run time -> 35ms
183 <        ConcurrentHashMap<Object, Object> map =
178 <            new ConcurrentHashMap<Object, Object>();
183 >        ConcurrentHashMap<Object, Object> map = new ConcurrentHashMap<>();
184          Random rng = new Random();
185          for (int i = 0; i < size; i++) {
186              Object x;
# Line 287 | Line 292 | public class ConcurrentHashMapTest exten
292          assertEquals("A", (String)map.get(one));
293          ConcurrentHashMap empty = new ConcurrentHashMap();
294          assertNull(map.get("anything"));
295 +        assertNull(empty.get("anything"));
296      }
297  
298      /**
# Line 328 | Line 334 | public class ConcurrentHashMapTest exten
334      }
335  
336      /**
337 +     * Test keySet().removeAll on empty map
338 +     */
339 +    public void testKeySet_empty_removeAll() {
340 +        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
341 +        Set<Integer> set = map.keySet();
342 +        set.removeAll(Collections.emptyList());
343 +        assertTrue(map.isEmpty());
344 +        assertTrue(set.isEmpty());
345 +        // following is test for JDK-8163353
346 +        set.removeAll(Collections.emptySet());
347 +        assertTrue(map.isEmpty());
348 +        assertTrue(set.isEmpty());
349 +    }
350 +
351 +    /**
352       * keySet.toArray returns contains all keys
353       */
354      public void testKeySetToArray() {
# Line 532 | Line 553 | public class ConcurrentHashMapTest exten
553      /**
554       * Constructor (initialCapacity, loadFactor) throws
555       * IllegalArgumentException if either argument is negative
556 <      */
556 >     */
557      public void testConstructor2() {
558          try {
559              new ConcurrentHashMap(-1, .75f);
560              shouldThrow();
561 <        } catch (IllegalArgumentException e) {}
561 >        } catch (IllegalArgumentException success) {}
562  
563          try {
564              new ConcurrentHashMap(16, -1);
565              shouldThrow();
566 <        } catch (IllegalArgumentException e) {}
566 >        } catch (IllegalArgumentException success) {}
567      }
568  
569      /**
# Line 553 | Line 574 | public class ConcurrentHashMapTest exten
574          try {
575              new ConcurrentHashMap(-1, .75f, 1);
576              shouldThrow();
577 <        } catch (IllegalArgumentException e) {}
577 >        } catch (IllegalArgumentException success) {}
578  
579          try {
580              new ConcurrentHashMap(16, -1, 1);
581              shouldThrow();
582 <        } catch (IllegalArgumentException e) {}
582 >        } catch (IllegalArgumentException success) {}
583  
584          try {
585              new ConcurrentHashMap(16, .75f, -1);
586              shouldThrow();
587 <        } catch (IllegalArgumentException e) {}
587 >        } catch (IllegalArgumentException success) {}
588      }
589  
590      /**
# Line 574 | Line 595 | public class ConcurrentHashMapTest exten
595          try {
596              new ConcurrentHashMap(null);
597              shouldThrow();
598 <        } catch (NullPointerException e) {}
598 >        } catch (NullPointerException success) {}
599      }
600  
601      /**
# Line 593 | Line 614 | public class ConcurrentHashMapTest exten
614       * get(null) throws NPE
615       */
616      public void testGet_NullPointerException() {
617 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
618          try {
597 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
619              c.get(null);
620              shouldThrow();
621          } catch (NullPointerException success) {}
# Line 604 | Line 625 | public class ConcurrentHashMapTest exten
625       * containsKey(null) throws NPE
626       */
627      public void testContainsKey_NullPointerException() {
628 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
629          try {
608 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
630              c.containsKey(null);
631              shouldThrow();
632          } catch (NullPointerException success) {}
# Line 615 | Line 636 | public class ConcurrentHashMapTest exten
636       * containsValue(null) throws NPE
637       */
638      public void testContainsValue_NullPointerException() {
639 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
640          try {
619 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
641              c.containsValue(null);
642              shouldThrow();
643          } catch (NullPointerException success) {}
# Line 626 | Line 647 | public class ConcurrentHashMapTest exten
647       * contains(null) throws NPE
648       */
649      public void testContains_NullPointerException() {
650 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
651          try {
630 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
652              c.contains(null);
653              shouldThrow();
654          } catch (NullPointerException success) {}
# Line 637 | Line 658 | public class ConcurrentHashMapTest exten
658       * put(null,x) throws NPE
659       */
660      public void testPut1_NullPointerException() {
661 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
662          try {
641 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
663              c.put(null, "whatever");
664              shouldThrow();
665          } catch (NullPointerException success) {}
# Line 648 | Line 669 | public class ConcurrentHashMapTest exten
669       * put(x, null) throws NPE
670       */
671      public void testPut2_NullPointerException() {
672 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
673          try {
652 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
674              c.put("whatever", null);
675              shouldThrow();
676          } catch (NullPointerException success) {}
# Line 659 | Line 680 | public class ConcurrentHashMapTest exten
680       * putIfAbsent(null, x) throws NPE
681       */
682      public void testPutIfAbsent1_NullPointerException() {
683 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
684          try {
663 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
685              c.putIfAbsent(null, "whatever");
686              shouldThrow();
687          } catch (NullPointerException success) {}
# Line 670 | Line 691 | public class ConcurrentHashMapTest exten
691       * replace(null, x) throws NPE
692       */
693      public void testReplace_NullPointerException() {
694 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
695          try {
674 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
696              c.replace(null, "whatever");
697              shouldThrow();
698          } catch (NullPointerException success) {}
# Line 681 | Line 702 | public class ConcurrentHashMapTest exten
702       * replace(null, x, y) throws NPE
703       */
704      public void testReplaceValue_NullPointerException() {
705 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
706          try {
685 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
707              c.replace(null, one, "whatever");
708              shouldThrow();
709          } catch (NullPointerException success) {}
# Line 692 | Line 713 | public class ConcurrentHashMapTest exten
713       * putIfAbsent(x, null) throws NPE
714       */
715      public void testPutIfAbsent2_NullPointerException() {
716 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
717          try {
696 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
718              c.putIfAbsent("whatever", null);
719              shouldThrow();
720          } catch (NullPointerException success) {}
# Line 703 | Line 724 | public class ConcurrentHashMapTest exten
724       * replace(x, null) throws NPE
725       */
726      public void testReplace2_NullPointerException() {
727 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
728          try {
707 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
729              c.replace("whatever", null);
730              shouldThrow();
731          } catch (NullPointerException success) {}
# Line 714 | Line 735 | public class ConcurrentHashMapTest exten
735       * replace(x, null, y) throws NPE
736       */
737      public void testReplaceValue2_NullPointerException() {
738 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
739          try {
718 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
740              c.replace("whatever", null, "A");
741              shouldThrow();
742          } catch (NullPointerException success) {}
# Line 725 | Line 746 | public class ConcurrentHashMapTest exten
746       * replace(x, y, null) throws NPE
747       */
748      public void testReplaceValue3_NullPointerException() {
749 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
750          try {
729 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
751              c.replace("whatever", one, null);
752              shouldThrow();
753          } catch (NullPointerException success) {}
# Line 736 | Line 757 | public class ConcurrentHashMapTest exten
757       * remove(null) throws NPE
758       */
759      public void testRemove1_NullPointerException() {
760 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
761 +        c.put("sadsdf", "asdads");
762          try {
740 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
741 –            c.put("sadsdf", "asdads");
763              c.remove(null);
764              shouldThrow();
765          } catch (NullPointerException success) {}
# Line 748 | Line 769 | public class ConcurrentHashMapTest exten
769       * remove(null, x) throws NPE
770       */
771      public void testRemove2_NullPointerException() {
772 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
773 +        c.put("sadsdf", "asdads");
774          try {
752 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
753 –            c.put("sadsdf", "asdads");
775              c.remove(null, "whatever");
776              shouldThrow();
777          } catch (NullPointerException success) {}
# Line 766 | Line 787 | public class ConcurrentHashMapTest exten
787      }
788  
789      /**
790 <     * A deserialized map equals original
790 >     * A deserialized/reserialized map equals original
791       */
792      public void testSerialization() throws Exception {
793          Map x = map5();
# Line 800 | Line 821 | public class ConcurrentHashMapTest exten
821          }
822      }
823  
824 +    /**
825 +     * Tests performance of removeAll when the other collection is much smaller.
826 +     * ant -Djsr166.tckTestClass=ConcurrentHashMapTest -Djsr166.methodFilter=testRemoveAll_performance -Djsr166.expensiveTests=true tck
827 +     */
828 +    public void testRemoveAll_performance() {
829 +        final int mapSize = expensiveTests ? 1_000_000 : 100;
830 +        final int iterations = expensiveTests ? 500 : 2;
831 +        final ConcurrentHashMap<Integer, Integer> map = new ConcurrentHashMap<>();
832 +        for (int i = 0; i < mapSize; i++)
833 +            map.put(i, i);
834 +        Set<Integer> keySet = map.keySet();
835 +        Collection<Integer> removeMe = Arrays.asList(new Integer[] { -99, -86 });
836 +        for (int i = 0; i < iterations; i++)
837 +            assertFalse(keySet.removeAll(removeMe));
838 +        assertEquals(mapSize, map.size());
839 +    }
840 +
841 +    public void testReentrantComputeIfAbsent() {
842 +        ConcurrentHashMap<Integer, Integer> map = new ConcurrentHashMap<>(16);
843 +        try {
844 +            for (int i = 0; i < 100; i++) { // force a resize
845 +                map.computeIfAbsent(i, key -> findValue(map, key));
846 +            }
847 +            fail("recursive computeIfAbsent");
848 +        } catch (IllegalStateException ex) {
849 +        }
850 +    }
851 +
852 +    private Integer findValue(ConcurrentHashMap<Integer, Integer> map,
853 +                              Integer key) {
854 +        return (key % 5 == 0) ?  key :
855 +            map.computeIfAbsent(key + 1, k -> findValue(map, k));
856 +    }
857 +
858   }

Diff Legend

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