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.43 by jsr166, Fri Feb 27 21:43:18 2015 UTC vs.
Revision 1.52 by jsr166, Wed Jan 4 06:09:58 2017 UTC

# Line 16 | Line 16 | import java.util.Map;
16   import java.util.Random;
17   import java.util.Set;
18   import java.util.concurrent.ConcurrentHashMap;
19 + import java.util.concurrent.ExecutorService;
20 + import java.util.concurrent.Executors;
21  
22   import junit.framework.Test;
23   import junit.framework.TestSuite;
24  
25   public class ConcurrentHashMapTest extends JSR166TestCase {
26      public static void main(String[] args) {
27 <        junit.textui.TestRunner.run(suite());
27 >        main(suite(), args);
28      }
29      public static Test suite() {
30          return new TestSuite(ConcurrentHashMapTest.class);
# Line 32 | Line 34 | public class ConcurrentHashMapTest exten
34       * Returns a new map from Integers 1-5 to Strings "A"-"E".
35       */
36      private static ConcurrentHashMap<Integer, String> map5() {
37 <        ConcurrentHashMap map = new ConcurrentHashMap<Integer, String>(5);
37 >        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>(5);
38          assertTrue(map.isEmpty());
39          map.put(one, "A");
40          map.put(two, "B");
# Line 45 | Line 47 | public class ConcurrentHashMapTest exten
47      }
48  
49      /** Re-implement Integer.compare for old java versions */
50 <    static int compare(int x, int y) { return x < y ? -1 : x > y ? 1 : 0; }
50 >    static int compare(int x, int y) {
51 >        return (x < y) ? -1 : (x > y) ? 1 : 0;
52 >    }
53  
54      // classes for testing Comparable fallbacks
55      static class BI implements Comparable<BI> {
# Line 329 | Line 333 | public class ConcurrentHashMapTest exten
333      }
334  
335      /**
336 +     * Test keySet().removeAll on empty map
337 +     */
338 +    public void testKeySet_empty_removeAll() {
339 +        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
340 +        Set<Integer> set = map.keySet();
341 +        set.removeAll(Collections.emptyList());
342 +        assertTrue(map.isEmpty());
343 +        assertTrue(set.isEmpty());
344 +        // following is test for JDK-8163353
345 +        set.removeAll(Collections.emptySet());
346 +        assertTrue(map.isEmpty());
347 +        assertTrue(set.isEmpty());
348 +    }
349 +
350 +    /**
351       * keySet.toArray returns contains all keys
352       */
353      public void testKeySetToArray() {
# Line 533 | Line 552 | public class ConcurrentHashMapTest exten
552      /**
553       * Constructor (initialCapacity, loadFactor) throws
554       * IllegalArgumentException if either argument is negative
555 <      */
555 >     */
556      public void testConstructor2() {
557          try {
558              new ConcurrentHashMap(-1, .75f);
# Line 594 | Line 613 | public class ConcurrentHashMapTest exten
613       * get(null) throws NPE
614       */
615      public void testGet_NullPointerException() {
616 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
617          try {
598 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
618              c.get(null);
619              shouldThrow();
620          } catch (NullPointerException success) {}
# Line 605 | Line 624 | public class ConcurrentHashMapTest exten
624       * containsKey(null) throws NPE
625       */
626      public void testContainsKey_NullPointerException() {
627 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
628          try {
609 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
629              c.containsKey(null);
630              shouldThrow();
631          } catch (NullPointerException success) {}
# Line 616 | Line 635 | public class ConcurrentHashMapTest exten
635       * containsValue(null) throws NPE
636       */
637      public void testContainsValue_NullPointerException() {
638 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
639          try {
620 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
640              c.containsValue(null);
641              shouldThrow();
642          } catch (NullPointerException success) {}
# Line 627 | Line 646 | public class ConcurrentHashMapTest exten
646       * contains(null) throws NPE
647       */
648      public void testContains_NullPointerException() {
649 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
650          try {
631 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
651              c.contains(null);
652              shouldThrow();
653          } catch (NullPointerException success) {}
# Line 638 | Line 657 | public class ConcurrentHashMapTest exten
657       * put(null,x) throws NPE
658       */
659      public void testPut1_NullPointerException() {
660 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
661          try {
642 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
662              c.put(null, "whatever");
663              shouldThrow();
664          } catch (NullPointerException success) {}
# Line 649 | Line 668 | public class ConcurrentHashMapTest exten
668       * put(x, null) throws NPE
669       */
670      public void testPut2_NullPointerException() {
671 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
672          try {
653 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
673              c.put("whatever", null);
674              shouldThrow();
675          } catch (NullPointerException success) {}
# Line 660 | Line 679 | public class ConcurrentHashMapTest exten
679       * putIfAbsent(null, x) throws NPE
680       */
681      public void testPutIfAbsent1_NullPointerException() {
682 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
683          try {
664 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
684              c.putIfAbsent(null, "whatever");
685              shouldThrow();
686          } catch (NullPointerException success) {}
# Line 671 | Line 690 | public class ConcurrentHashMapTest exten
690       * replace(null, x) throws NPE
691       */
692      public void testReplace_NullPointerException() {
693 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
694          try {
675 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
695              c.replace(null, "whatever");
696              shouldThrow();
697          } catch (NullPointerException success) {}
# Line 682 | Line 701 | public class ConcurrentHashMapTest exten
701       * replace(null, x, y) throws NPE
702       */
703      public void testReplaceValue_NullPointerException() {
704 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
705          try {
686 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
706              c.replace(null, one, "whatever");
707              shouldThrow();
708          } catch (NullPointerException success) {}
# Line 693 | Line 712 | public class ConcurrentHashMapTest exten
712       * putIfAbsent(x, null) throws NPE
713       */
714      public void testPutIfAbsent2_NullPointerException() {
715 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
716          try {
697 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
717              c.putIfAbsent("whatever", null);
718              shouldThrow();
719          } catch (NullPointerException success) {}
# Line 704 | Line 723 | public class ConcurrentHashMapTest exten
723       * replace(x, null) throws NPE
724       */
725      public void testReplace2_NullPointerException() {
726 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
727          try {
708 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
728              c.replace("whatever", null);
729              shouldThrow();
730          } catch (NullPointerException success) {}
# Line 715 | Line 734 | public class ConcurrentHashMapTest exten
734       * replace(x, null, y) throws NPE
735       */
736      public void testReplaceValue2_NullPointerException() {
737 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
738          try {
719 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
739              c.replace("whatever", null, "A");
740              shouldThrow();
741          } catch (NullPointerException success) {}
# Line 726 | Line 745 | public class ConcurrentHashMapTest exten
745       * replace(x, y, null) throws NPE
746       */
747      public void testReplaceValue3_NullPointerException() {
748 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
749          try {
730 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
750              c.replace("whatever", one, null);
751              shouldThrow();
752          } catch (NullPointerException success) {}
# Line 737 | Line 756 | public class ConcurrentHashMapTest exten
756       * remove(null) throws NPE
757       */
758      public void testRemove1_NullPointerException() {
759 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
760 +        c.put("sadsdf", "asdads");
761          try {
741 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
742 –            c.put("sadsdf", "asdads");
762              c.remove(null);
763              shouldThrow();
764          } catch (NullPointerException success) {}
# Line 749 | Line 768 | public class ConcurrentHashMapTest exten
768       * remove(null, x) throws NPE
769       */
770      public void testRemove2_NullPointerException() {
771 +        ConcurrentHashMap c = new ConcurrentHashMap(5);
772 +        c.put("sadsdf", "asdads");
773          try {
753 –            ConcurrentHashMap c = new ConcurrentHashMap(5);
754 –            c.put("sadsdf", "asdads");
774              c.remove(null, "whatever");
775              shouldThrow();
776          } catch (NullPointerException success) {}
# Line 801 | Line 820 | public class ConcurrentHashMapTest exten
820          }
821      }
822  
823 +    /**
824 +     * Tests performance of removeAll when the other collection is much smaller.
825 +     * ant -Djsr166.tckTestClass=ConcurrentHashMapTest -Djsr166.methodFilter=testRemoveAll_performance -Djsr166.expensiveTests=true tck
826 +     */
827 +    public void testRemoveAll_performance() {
828 +        final int mapSize = expensiveTests ? 1_000_000 : 100;
829 +        final int iterations = expensiveTests ? 500 : 2;
830 +        final ConcurrentHashMap<Integer, Integer> map = new ConcurrentHashMap<>();
831 +        for (int i = 0; i < mapSize; i++)
832 +            map.put(i, i);
833 +        Set<Integer> keySet = map.keySet();
834 +        Collection<Integer> removeMe = Arrays.asList(new Integer[] { -99, -86 });
835 +        for (int i = 0; i < iterations; i++)
836 +            assertFalse(keySet.removeAll(removeMe));
837 +        assertEquals(mapSize, map.size());
838 +    }
839 +
840   }

Diff Legend

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