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.50 by jsr166, Mon Aug 22 18:38:28 2016 UTC vs.
Revision 1.62 by jsr166, Sun Sep 29 20:40:48 2019 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 16 | Line 17 | import java.util.Map;
17   import java.util.Random;
18   import java.util.Set;
19   import java.util.concurrent.ConcurrentHashMap;
19 import java.util.concurrent.ExecutorService;
20 import java.util.concurrent.Executors;
20  
21   import junit.framework.Test;
23 import junit.framework.TestSuite;
22  
23   public class ConcurrentHashMapTest extends JSR166TestCase {
24      public static void main(String[] args) {
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 boolean isConcurrent() { return true; }
32 >            public boolean permitsNullKeys() { return false; }
33 >            public boolean permitsNullValues() { return false; }
34 >            public boolean supportsSetValue() { return true; }
35 >        }
36 >        return newTestSuite(
37 >            ConcurrentHashMapTest.class,
38 >            MapTest.testSuite(new Implementation()));
39      }
40  
41      /**
42       * Returns a new map from Integers 1-5 to Strings "A"-"E".
43       */
44      private static ConcurrentHashMap<Integer, String> map5() {
45 <        ConcurrentHashMap map = new ConcurrentHashMap<Integer, String>(5);
45 >        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>(5);
46          assertTrue(map.isEmpty());
47          map.put(one, "A");
48          map.put(two, "B");
# Line 46 | Line 54 | public class ConcurrentHashMapTest exten
54          return map;
55      }
56  
49    /** Re-implement Integer.compare for old java versions */
50    static int compare(int x, int y) {
51        return (x < y) ? -1 : (x > y) ? 1 : 0;
52    }
53
57      // classes for testing Comparable fallbacks
58      static class BI implements Comparable<BI> {
59          private final int value;
60          BI(int value) { this.value = value; }
61          public int compareTo(BI other) {
62 <            return compare(value, other.value);
62 >            return Integer.compare(value, other.value);
63          }
64          public boolean equals(Object x) {
65              return (x instanceof BI) && ((BI)x).value == value;
# Line 90 | Line 93 | public class ConcurrentHashMapTest exten
93                      break;
94              }
95              if (r == 0)
96 <                r = compare(size(), other.size());
96 >                r = Integer.compare(size(), other.size());
97              return r;
98          }
99          private static final long serialVersionUID = 0;
# Line 118 | Line 121 | public class ConcurrentHashMapTest exten
121       */
122      public void testComparableFamily() {
123          int size = 500;         // makes measured test run time -> 60ms
124 <        ConcurrentHashMap<BI, Boolean> m =
122 <            new ConcurrentHashMap<BI, Boolean>();
124 >        ConcurrentHashMap<BI, Boolean> m = new ConcurrentHashMap<>();
125          for (int i = 0; i < size; i++) {
126 <            assertTrue(m.put(new CI(i), true) == null);
126 >            assertNull(m.put(new CI(i), true));
127          }
128          for (int i = 0; i < size; i++) {
129              assertTrue(m.containsKey(new CI(i)));
# Line 135 | Line 137 | public class ConcurrentHashMapTest exten
137       */
138      public void testGenericComparable() {
139          int size = 120;         // makes measured test run time -> 60ms
140 <        ConcurrentHashMap<Object, Boolean> m =
139 <            new ConcurrentHashMap<Object, Boolean>();
140 >        ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
141          for (int i = 0; i < size; i++) {
142              BI bi = new BI(i);
143              BS bs = new BS(String.valueOf(i));
144 <            LexicographicList<BI> bis = new LexicographicList<BI>(bi);
145 <            LexicographicList<BS> bss = new LexicographicList<BS>(bs);
146 <            assertTrue(m.putIfAbsent(bis, true) == null);
144 >            LexicographicList<BI> bis = new LexicographicList<>(bi);
145 >            LexicographicList<BS> bss = new LexicographicList<>(bs);
146 >            assertNull(m.putIfAbsent(bis, true));
147              assertTrue(m.containsKey(bis));
148              if (m.putIfAbsent(bss, true) == null)
149                  assertTrue(m.containsKey(bss));
# Line 160 | Line 161 | public class ConcurrentHashMapTest exten
161       */
162      public void testGenericComparable2() {
163          int size = 500;         // makes measured test run time -> 60ms
164 <        ConcurrentHashMap<Object, Boolean> m =
164 <            new ConcurrentHashMap<Object, Boolean>();
164 >        ConcurrentHashMap<Object, Boolean> m = new ConcurrentHashMap<>();
165          for (int i = 0; i < size; i++) {
166              m.put(Collections.singletonList(new BI(i)), true);
167          }
168  
169          for (int i = 0; i < size; i++) {
170 <            LexicographicList<BI> bis = new LexicographicList<BI>(new BI(i));
170 >            LexicographicList<BI> bis = new LexicographicList<>(new BI(i));
171              assertTrue(m.containsKey(bis));
172          }
173      }
# Line 178 | Line 178 | public class ConcurrentHashMapTest exten
178       */
179      public void testMixedComparable() {
180          int size = 1200;        // makes measured test run time -> 35ms
181 <        ConcurrentHashMap<Object, Object> map =
182 <            new ConcurrentHashMap<Object, Object>();
181 >        ConcurrentHashMap<Object, Object> map = new ConcurrentHashMap<>();
182          Random rng = new Random();
183          for (int i = 0; i < size; i++) {
184              Object x;
# Line 786 | Line 785 | public class ConcurrentHashMapTest exten
785      }
786  
787      /**
788 <     * A deserialized map equals original
788 >     * A deserialized/reserialized map equals original
789       */
790      public void testSerialization() throws Exception {
791          Map x = map5();
# Line 837 | Line 836 | public class ConcurrentHashMapTest exten
836          assertEquals(mapSize, map.size());
837      }
838  
839 <    /**
840 <     * Tests performance of computeIfAbsent when the element is present.
841 <     * See JDK-8161372
842 <     * ant -Djsr166.tckTestClass=ConcurrentHashMapTest -Djsr166.methodFilter=testcomputeIfAbsent_performance -Djsr166.expensiveTests=true tck
843 <     */
844 <    public void testcomputeIfAbsent_performance() {
845 <        final int mapSize = 20;
846 <        final int iterations = expensiveTests ? (1 << 23) : mapSize * 2;
847 <        final int threads = expensiveTests ? 10 : 2;
848 <        final ConcurrentHashMap<Integer, Integer> map = new ConcurrentHashMap<>();
849 <        for (int i = 0; i < mapSize; i++)
850 <            map.put(i, i);
851 <        final ExecutorService pool = Executors.newFixedThreadPool(2);
852 <        try (PoolCleaner cleaner = cleaner(pool)) {
854 <            Runnable r = new CheckedRunnable() {
855 <                public void realRun() {
856 <                    int result = 0;
857 <                    for (int i = 0; i < iterations; i++)
858 <                        result += map.computeIfAbsent(i % mapSize, (k) -> k + k);
859 <                    if (result == -42) throw new Error();
860 <                }};
861 <            for (int i = 0; i < threads; i++)
862 <                pool.execute(r);
863 <        }
839 >    public void testReentrantComputeIfAbsent() {
840 >        ConcurrentHashMap<Integer, Integer> map = new ConcurrentHashMap<>(16);
841 >        try {
842 >            for (int i = 0; i < 100; i++) { // force a resize
843 >                map.computeIfAbsent(i, key -> findValue(map, key));
844 >            }
845 >            fail("recursive computeIfAbsent should throw IllegalStateException");
846 >        } catch (IllegalStateException success) {}
847 >    }
848 >
849 >    private Integer findValue(ConcurrentHashMap<Integer, Integer> map,
850 >                              Integer key) {
851 >        return (key % 5 == 0) ?  key :
852 >            map.computeIfAbsent(key + 1, k -> findValue(map, k));
853      }
854  
855   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines