11 |
|
import java.util.AbstractMap; |
12 |
|
import java.util.Arrays; |
13 |
|
import java.util.Collection; |
14 |
– |
import java.util.Collections; |
14 |
|
import java.util.Iterator; |
15 |
|
import java.util.Map; |
16 |
|
import java.util.NoSuchElementException; |
25 |
|
|
26 |
|
public class ConcurrentHashMap8Test extends JSR166TestCase { |
27 |
|
public static void main(String[] args) { |
28 |
< |
junit.textui.TestRunner.run(suite()); |
28 |
> |
main(suite(), args); |
29 |
|
} |
30 |
|
public static Test suite() { |
31 |
|
return new TestSuite(ConcurrentHashMap8Test.class); |
162 |
|
Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet(); |
163 |
|
assertTrue(a.isEmpty()); |
164 |
|
for (int i = 0; i < n; i++) |
165 |
< |
a.add(i); |
165 |
> |
assertTrue(a.add(i)); |
166 |
|
assertEquals(n == 0, a.isEmpty()); |
167 |
|
assertEquals(n, a.size()); |
168 |
|
return a; |
172 |
|
Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet(); |
173 |
|
assertTrue(a.isEmpty()); |
174 |
|
for (int i = 0; i < elements.length; i++) |
175 |
< |
a.add(elements[i]); |
175 |
> |
assertTrue(a.add(elements[i])); |
176 |
|
assertFalse(a.isEmpty()); |
177 |
|
assertEquals(elements.length, a.size()); |
178 |
|
return a; |
250 |
|
*/ |
251 |
|
public void testAdd2() { |
252 |
|
Set full = populatedSet(3); |
253 |
< |
full.add(one); |
253 |
> |
assertFalse(full.add(one)); |
254 |
|
assertEquals(3, full.size()); |
255 |
|
} |
256 |
|
|
259 |
|
*/ |
260 |
|
public void testAdd3() { |
261 |
|
Set full = populatedSet(3); |
262 |
< |
full.add(three); |
262 |
> |
assertTrue(full.add(three)); |
263 |
> |
assertTrue(full.contains(three)); |
264 |
> |
assertFalse(full.add(three)); |
265 |
|
assertTrue(full.contains(three)); |
266 |
|
} |
267 |
|
|
274 |
|
try { |
275 |
|
full.add(three); |
276 |
|
shouldThrow(); |
277 |
< |
} catch (UnsupportedOperationException e){} |
277 |
> |
} catch (UnsupportedOperationException success) {} |
278 |
|
} |
279 |
|
|
280 |
|
/** |
286 |
|
try { |
287 |
|
full.add(null); |
288 |
|
shouldThrow(); |
289 |
< |
} catch (NullPointerException e){} |
289 |
> |
} catch (NullPointerException success) {} |
290 |
|
} |
291 |
|
|
292 |
|
/** |
298 |
|
try { |
299 |
|
map.keySet(null); |
300 |
|
shouldThrow(); |
301 |
< |
} catch (NullPointerException e) {} |
301 |
> |
} catch (NullPointerException success) {} |
302 |
|
ConcurrentHashMap.KeySetView set = map.keySet(one); |
303 |
< |
set.add(one); |
304 |
< |
set.add(six); |
305 |
< |
set.add(seven); |
303 |
> |
assertFalse(set.add(one)); |
304 |
> |
assertTrue(set.add(six)); |
305 |
> |
assertTrue(set.add(seven)); |
306 |
|
assertTrue(set.getMappedValue() == one); |
307 |
|
assertTrue(map.get(one) != one); |
308 |
|
assertTrue(map.get(six) == one); |
405 |
|
Integer[] elements = new Integer[size]; |
406 |
|
for (int i = 0; i < size; i++) |
407 |
|
elements[i] = i; |
408 |
< |
Collections.shuffle(Arrays.asList(elements)); |
408 |
> |
shuffle(elements); |
409 |
|
Collection<Integer> full = populatedSet(elements); |
410 |
|
|
411 |
|
Iterator it = full.iterator(); |
495 |
|
Integer[] elements = new Integer[size]; |
496 |
|
for (int i = 0; i < size; i++) |
497 |
|
elements[i] = i; |
498 |
< |
Collections.shuffle(Arrays.asList(elements)); |
498 |
> |
shuffle(elements); |
499 |
|
Collection<Integer> full = populatedSet(elements); |
500 |
|
|
501 |
|
assertTrue(Arrays.asList(elements).containsAll(Arrays.asList(full.toArray()))); |
515 |
|
a = new Integer[0]; |
516 |
|
assertSame(a, empty.toArray(a)); |
517 |
|
|
518 |
< |
a = new Integer[size/2]; |
518 |
> |
a = new Integer[size / 2]; |
519 |
|
Arrays.fill(a, 42); |
520 |
|
assertSame(a, empty.toArray(a)); |
521 |
|
assertNull(a[0]); |
525 |
|
Integer[] elements = new Integer[size]; |
526 |
|
for (int i = 0; i < size; i++) |
527 |
|
elements[i] = i; |
528 |
< |
Collections.shuffle(Arrays.asList(elements)); |
528 |
> |
shuffle(elements); |
529 |
|
Collection<Integer> full = populatedSet(elements); |
530 |
|
|
531 |
|
Arrays.fill(a, 42); |