| 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); |
| 24 |
> |
private static ConcurrentHashMap<Integer, String> map5() { |
| 25 |
> |
ConcurrentHashMap map = new ConcurrentHashMap<Integer, String>(5); |
| 26 |
|
assertTrue(map.isEmpty()); |
| 27 |
|
map.put(one, "A"); |
| 28 |
|
map.put(two, "B"); |
| 160 |
|
* can be inserted and found. |
| 161 |
|
*/ |
| 162 |
|
public void testMixedComparable() { |
| 163 |
< |
int size = 10000; |
| 164 |
< |
ConcurrentHashMap<Object, Object> map = |
| 163 |
> |
int size = 1200; // makes measured test run time -> 35ms |
| 164 |
> |
ConcurrentHashMap<Object, Object> map = |
| 165 |
|
new ConcurrentHashMap<Object, Object>(); |
| 166 |
< |
Random rng = new Random(1370014958369218000L); |
| 167 |
< |
for(int i = 0; i < size; i++) { |
| 166 |
> |
Random rng = new Random(); |
| 167 |
> |
for (int i = 0; i < size; i++) { |
| 168 |
|
Object x; |
| 169 |
< |
switch(rng.nextInt(4)) { |
| 169 |
> |
switch (rng.nextInt(4)) { |
| 170 |
|
case 0: |
| 171 |
|
x = new Object(); |
| 172 |
|
break; |
| 213 |
|
} |
| 214 |
|
|
| 215 |
|
/** |
| 216 |
+ |
* hashCode() equals sum of each key.hashCode ^ value.hashCode |
| 217 |
+ |
*/ |
| 218 |
+ |
public void testHashCode() { |
| 219 |
+ |
ConcurrentHashMap<Integer,String> map = map5(); |
| 220 |
+ |
int sum = 0; |
| 221 |
+ |
for (Map.Entry<Integer,String> e : map.entrySet()) |
| 222 |
+ |
sum += e.getKey().hashCode() ^ e.getValue().hashCode(); |
| 223 |
+ |
assertEquals(sum, map.hashCode()); |
| 224 |
+ |
} |
| 225 |
+ |
|
| 226 |
+ |
/** |
| 227 |
|
* contains returns true for contained value |
| 228 |
|
*/ |
| 229 |
|
public void testContains() { |
| 507 |
|
// Exception tests |
| 508 |
|
|
| 509 |
|
/** |
| 510 |
< |
* Cannot create with negative capacity |
| 510 |
> |
* Cannot create with only negative capacity |
| 511 |
|
*/ |
| 512 |
|
public void testConstructor1() { |
| 513 |
|
try { |
| 514 |
< |
new ConcurrentHashMap(-1,0,1); |
| 514 |
> |
new ConcurrentHashMap(-1); |
| 515 |
|
shouldThrow(); |
| 516 |
|
} catch (IllegalArgumentException success) {} |
| 517 |
|
} |
| 518 |
|
|
| 519 |
|
/** |
| 520 |
< |
* Cannot create with negative concurrency level |
| 521 |
< |
*/ |
| 520 |
> |
* Constructor (initialCapacity, loadFactor) throws |
| 521 |
> |
* IllegalArgumentException if either argument is negative |
| 522 |
> |
*/ |
| 523 |
|
public void testConstructor2() { |
| 524 |
|
try { |
| 525 |
< |
new ConcurrentHashMap(1,0,-1); |
| 525 |
> |
new ConcurrentHashMap(-1, .75f); |
| 526 |
|
shouldThrow(); |
| 527 |
< |
} catch (IllegalArgumentException success) {} |
| 527 |
> |
} catch (IllegalArgumentException e) {} |
| 528 |
> |
|
| 529 |
> |
try { |
| 530 |
> |
new ConcurrentHashMap(16, -1); |
| 531 |
> |
shouldThrow(); |
| 532 |
> |
} catch (IllegalArgumentException e) {} |
| 533 |
|
} |
| 534 |
|
|
| 535 |
|
/** |
| 536 |
< |
* Cannot create with only negative capacity |
| 536 |
> |
* Constructor (initialCapacity, loadFactor, concurrencyLevel) |
| 537 |
> |
* throws IllegalArgumentException if any argument is negative |
| 538 |
|
*/ |
| 539 |
|
public void testConstructor3() { |
| 540 |
|
try { |
| 541 |
< |
new ConcurrentHashMap(-1); |
| 541 |
> |
new ConcurrentHashMap(-1, .75f, 1); |
| 542 |
|
shouldThrow(); |
| 543 |
< |
} catch (IllegalArgumentException success) {} |
| 543 |
> |
} catch (IllegalArgumentException e) {} |
| 544 |
> |
|
| 545 |
> |
try { |
| 546 |
> |
new ConcurrentHashMap(16, -1, 1); |
| 547 |
> |
shouldThrow(); |
| 548 |
> |
} catch (IllegalArgumentException e) {} |
| 549 |
> |
|
| 550 |
> |
try { |
| 551 |
> |
new ConcurrentHashMap(16, .75f, -1); |
| 552 |
> |
shouldThrow(); |
| 553 |
> |
} catch (IllegalArgumentException e) {} |
| 554 |
> |
} |
| 555 |
> |
|
| 556 |
> |
/** |
| 557 |
> |
* ConcurrentHashMap(map) throws NullPointerException if the given |
| 558 |
> |
* map is null |
| 559 |
> |
*/ |
| 560 |
> |
public void testConstructor4() { |
| 561 |
> |
try { |
| 562 |
> |
new ConcurrentHashMap(null); |
| 563 |
> |
shouldThrow(); |
| 564 |
> |
} catch (NullPointerException e) {} |
| 565 |
> |
} |
| 566 |
> |
|
| 567 |
> |
/** |
| 568 |
> |
* ConcurrentHashMap(map) creates a new map with the same mappings |
| 569 |
> |
* as the given map |
| 570 |
> |
*/ |
| 571 |
> |
public void testConstructor5() { |
| 572 |
> |
ConcurrentHashMap map1 = map5(); |
| 573 |
> |
ConcurrentHashMap map2 = new ConcurrentHashMap(map5()); |
| 574 |
> |
assertTrue(map2.equals(map1)); |
| 575 |
> |
map2.put(one, "F"); |
| 576 |
> |
assertFalse(map2.equals(map1)); |
| 577 |
|
} |
| 578 |
|
|
| 579 |
+ |
|
| 580 |
|
/** |
| 581 |
|
* get(null) throws NPE |
| 582 |
|
*/ |
