test/tck/ConcurrentHashMap8Test.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

import junit.framework.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMap8Test extends JSR166TestCase {
    public static void main(String[] args) {
        junit.textui.TestRunner.run(suite());
    }
    public static Test suite() {
        return new TestSuite(ConcurrentHashMap8Test.class);
    }

    /**
     * Returns a new map from Integers 1-5 to Strings "A"-"E".
     */
    private static ConcurrentHashMap map5() {
        ConcurrentHashMap map = new ConcurrentHashMap(5);
        assertTrue(map.isEmpty());
        map.put(one, "A");
        map.put(two, "B");
        map.put(three, "C");
        map.put(four, "D");
        map.put(five, "E");
        assertFalse(map.isEmpty());
        assertEquals(5, map.size());
        return map;
    }

    /**
     * computeIfAbsent adds when the given key is not present
     */
    public void testComputeIfAbsent() {
        ConcurrentHashMap map = map5();
        map.computeIfAbsent(six, (x) -> "Z");
        assertTrue(map.containsKey(six));
    }

    /**
     * computeIfAbsent does not replace  if the key is already present
     */
    public void testComputeIfAbsent2() {
        ConcurrentHashMap map = map5();
        assertEquals("A", map.computeIfAbsent(one, (x) -> "Z"));
    }

    /**
     * computeIfAbsent does not add if function returns null
     */
    public void testComputeIfAbsent3() {
        ConcurrentHashMap map = map5();
        map.computeIfAbsent(six, (x) -> null);
        assertFalse(map.containsKey(six));
    }
    
    /**
     * computeIfPresent does not replace  if the key is already present
     */
    public void testComputeIfPresent() {
        ConcurrentHashMap map = map5();
        map.computeIfPresent(six, (x, y) -> "Z");
        assertFalse(map.containsKey(six));
    }

    /**
     * computeIfPresent adds when the given key is not present
     */
    public void testComputeIfPresent2() {
        ConcurrentHashMap map = map5();
        assertEquals("Z", map.computeIfPresent(one, (x, y) -> "Z"));
    }

    /**
     * compute does not replace  if the function returns null
     */
    public void testCompute() {
        ConcurrentHashMap map = map5();
        map.compute(six, (x, y) -> null);
        assertFalse(map.containsKey(six));
    }

    /**
     * compute adds when the given key is not present
     */
    public void testCompute2() {
        ConcurrentHashMap map = map5();
        assertEquals("Z", map.compute(six, (x, y) -> "Z"));
    }

    /**
     * compute replaces when the given key is present
     */
    public void testCompute3() {
        ConcurrentHashMap map = map5();
        assertEquals("Z", map.compute(one, (x, y) -> "Z"));
    }

    /**
     * compute removes when the given key is present and function returns null
     */
    public void testCompute4() {
        ConcurrentHashMap map = map5();
        map.compute(one, (x, y) -> null);
        assertFalse(map.containsKey(one));
    }

    /**
     * merge adds when the given key is not present
     */
    public void testMerge1() {
        ConcurrentHashMap map = map5();
        assertEquals("Y", map.merge(six, "Y", (x, y) -> "Z"));
    }

    /**
     * merge replaces when the given key is present
     */
    public void testMerge2() {
        ConcurrentHashMap map = map5();
        assertEquals("Z", map.merge(one, "Y", (x, y) -> "Z"));
    }

    /**
     * merge removes when the given key is present and function returns null
     */
    public void testMerge3() {
        ConcurrentHashMap map = map5();
        map.merge(one, "Y", (x, y) -> null);
        assertFalse(map.containsKey(one));
    }


}
Revision:	1.1
Committed:	Thu Mar 21 19:06:54 2013 UTC (11 years, 1 month ago) by dl
Branch:	MAIN
Log Message:	test new map methods
#	User	Rev	Content
1	dl	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
4			* http://creativecommons.org/publicdomain/zero/1.0/
5			* Other contributors include Andrew Wright, Jeffrey Hayes,
6			* Pat Fisher, Mike Judd.
7			*/
8
9			import junit.framework.*;
10			import java.util.*;
11			import java.util.concurrent.ConcurrentHashMap;
12
13			public class ConcurrentHashMap8Test extends JSR166TestCase {
14			public static void main(String[] args) {
15			junit.textui.TestRunner.run(suite());
16			}
17			public static Test suite() {
18			return new TestSuite(ConcurrentHashMap8Test.class);
19			}
20
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);
26			assertTrue(map.isEmpty());
27			map.put(one, "A");
28			map.put(two, "B");
29			map.put(three, "C");
30			map.put(four, "D");
31			map.put(five, "E");
32			assertFalse(map.isEmpty());
33			assertEquals(5, map.size());
34			return map;
35			}
36
37			/**
38			* computeIfAbsent adds when the given key is not present
39			*/
40			public void testComputeIfAbsent() {
41			ConcurrentHashMap map = map5();
42			map.computeIfAbsent(six, (x) -> "Z");
43			assertTrue(map.containsKey(six));
44			}
45
46			/**
47			* computeIfAbsent does not replace if the key is already present
48			*/
49			public void testComputeIfAbsent2() {
50			ConcurrentHashMap map = map5();
51			assertEquals("A", map.computeIfAbsent(one, (x) -> "Z"));
52			}
53
54			/**
55			* computeIfAbsent does not add if function returns null
56			*/
57			public void testComputeIfAbsent3() {
58			ConcurrentHashMap map = map5();
59			map.computeIfAbsent(six, (x) -> null);
60			assertFalse(map.containsKey(six));
61			}
62
63			/**
64			* computeIfPresent does not replace if the key is already present
65			*/
66			public void testComputeIfPresent() {
67			ConcurrentHashMap map = map5();
68			map.computeIfPresent(six, (x, y) -> "Z");
69			assertFalse(map.containsKey(six));
70			}
71
72			/**
73			* computeIfPresent adds when the given key is not present
74			*/
75			public void testComputeIfPresent2() {
76			ConcurrentHashMap map = map5();
77			assertEquals("Z", map.computeIfPresent(one, (x, y) -> "Z"));
78			}
79
80			/**
81			* compute does not replace if the function returns null
82			*/
83			public void testCompute() {
84			ConcurrentHashMap map = map5();
85			map.compute(six, (x, y) -> null);
86			assertFalse(map.containsKey(six));
87			}
88
89			/**
90			* compute adds when the given key is not present
91			*/
92			public void testCompute2() {
93			ConcurrentHashMap map = map5();
94			assertEquals("Z", map.compute(six, (x, y) -> "Z"));
95			}
96
97			/**
98			* compute replaces when the given key is present
99			*/
100			public void testCompute3() {
101			ConcurrentHashMap map = map5();
102			assertEquals("Z", map.compute(one, (x, y) -> "Z"));
103			}
104
105			/**
106			* compute removes when the given key is present and function returns null
107			*/
108			public void testCompute4() {
109			ConcurrentHashMap map = map5();
110			map.compute(one, (x, y) -> null);
111			assertFalse(map.containsKey(one));
112			}
113
114			/**
115			* merge adds when the given key is not present
116			*/
117			public void testMerge1() {
118			ConcurrentHashMap map = map5();
119			assertEquals("Y", map.merge(six, "Y", (x, y) -> "Z"));
120			}
121
122			/**
123			* merge replaces when the given key is present
124			*/
125			public void testMerge2() {
126			ConcurrentHashMap map = map5();
127			assertEquals("Z", map.merge(one, "Y", (x, y) -> "Z"));
128			}
129
130			/**
131			* merge removes when the given key is present and function returns null
132			*/
133			public void testMerge3() {
134			ConcurrentHashMap map = map5();
135			map.merge(one, "Y", (x, y) -> null);
136			assertFalse(map.containsKey(one));
137			}
138
139
140
141			}