| 17 |
|
import java.util.NoSuchElementException; |
| 18 |
|
import java.util.Set; |
| 19 |
|
import java.util.Spliterator; |
| 20 |
– |
import java.util.Vector; |
| 20 |
|
import java.util.concurrent.ConcurrentHashMap; |
| 21 |
|
import java.util.concurrent.atomic.LongAdder; |
| 22 |
|
import java.util.function.BiFunction; |
| 26 |
|
|
| 27 |
|
public class ConcurrentHashMap8Test extends JSR166TestCase { |
| 28 |
|
public static void main(String[] args) { |
| 29 |
< |
junit.textui.TestRunner.run(suite()); |
| 29 |
> |
main(suite(), args); |
| 30 |
|
} |
| 31 |
|
public static Test suite() { |
| 32 |
|
return new TestSuite(ConcurrentHashMap8Test.class); |
| 163 |
|
Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet(); |
| 164 |
|
assertTrue(a.isEmpty()); |
| 165 |
|
for (int i = 0; i < n; i++) |
| 166 |
< |
a.add(i); |
| 167 |
< |
assertFalse(a.isEmpty()); |
| 166 |
> |
assertTrue(a.add(i)); |
| 167 |
> |
assertEquals(n == 0, a.isEmpty()); |
| 168 |
|
assertEquals(n, a.size()); |
| 169 |
|
return a; |
| 170 |
|
} |
| 173 |
|
Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet(); |
| 174 |
|
assertTrue(a.isEmpty()); |
| 175 |
|
for (int i = 0; i < elements.length; i++) |
| 176 |
< |
a.add(elements[i]); |
| 176 |
> |
assertTrue(a.add(elements[i])); |
| 177 |
|
assertFalse(a.isEmpty()); |
| 178 |
|
assertEquals(elements.length, a.size()); |
| 179 |
|
return a; |
| 227 |
|
*/ |
| 228 |
|
public void testAddAll() { |
| 229 |
|
Set full = populatedSet(3); |
| 230 |
< |
Vector v = new Vector(); |
| 231 |
< |
v.add(three); |
| 232 |
< |
v.add(four); |
| 234 |
< |
v.add(five); |
| 235 |
< |
full.addAll(v); |
| 230 |
> |
assertTrue(full.addAll(Arrays.asList(three, four, five))); |
| 231 |
> |
assertEquals(6, full.size()); |
| 232 |
> |
assertFalse(full.addAll(Arrays.asList(three, four, five))); |
| 233 |
|
assertEquals(6, full.size()); |
| 234 |
|
} |
| 235 |
|
|
| 239 |
|
*/ |
| 240 |
|
public void testAddAll2() { |
| 241 |
|
Set full = populatedSet(3); |
| 242 |
< |
Vector v = new Vector(); |
| 243 |
< |
v.add(three); |
| 244 |
< |
v.add(four); |
| 245 |
< |
v.add(one); // will not add this element |
| 249 |
< |
full.addAll(v); |
| 242 |
> |
// "one" is duplicate and will not be added |
| 243 |
> |
assertTrue(full.addAll(Arrays.asList(three, four, one))); |
| 244 |
> |
assertEquals(5, full.size()); |
| 245 |
> |
assertFalse(full.addAll(Arrays.asList(three, four, one))); |
| 246 |
|
assertEquals(5, full.size()); |
| 247 |
|
} |
| 248 |
|
|
| 251 |
|
*/ |
| 252 |
|
public void testAdd2() { |
| 253 |
|
Set full = populatedSet(3); |
| 254 |
< |
full.add(one); |
| 254 |
> |
assertFalse(full.add(one)); |
| 255 |
|
assertEquals(3, full.size()); |
| 256 |
|
} |
| 257 |
|
|
| 260 |
|
*/ |
| 261 |
|
public void testAdd3() { |
| 262 |
|
Set full = populatedSet(3); |
| 263 |
< |
full.add(three); |
| 263 |
> |
assertTrue(full.add(three)); |
| 264 |
> |
assertTrue(full.contains(three)); |
| 265 |
> |
assertFalse(full.add(three)); |
| 266 |
|
assertTrue(full.contains(three)); |
| 267 |
|
} |
| 268 |
|
|
| 275 |
|
try { |
| 276 |
|
full.add(three); |
| 277 |
|
shouldThrow(); |
| 278 |
< |
} catch (UnsupportedOperationException e){} |
| 278 |
> |
} catch (UnsupportedOperationException success) {} |
| 279 |
|
} |
| 280 |
|
|
| 281 |
|
/** |
| 287 |
|
try { |
| 288 |
|
full.add(null); |
| 289 |
|
shouldThrow(); |
| 290 |
< |
} catch (NullPointerException e){} |
| 290 |
> |
} catch (NullPointerException success) {} |
| 291 |
|
} |
| 292 |
|
|
| 293 |
|
/** |
| 299 |
|
try { |
| 300 |
|
map.keySet(null); |
| 301 |
|
shouldThrow(); |
| 302 |
< |
} catch (NullPointerException e) {} |
| 302 |
> |
} catch (NullPointerException success) {} |
| 303 |
|
ConcurrentHashMap.KeySetView set = map.keySet(one); |
| 304 |
< |
set.add(one); |
| 305 |
< |
set.add(six); |
| 306 |
< |
set.add(seven); |
| 304 |
> |
assertFalse(set.add(one)); |
| 305 |
> |
assertTrue(set.add(six)); |
| 306 |
> |
assertTrue(set.add(seven)); |
| 307 |
|
assertTrue(set.getMappedValue() == one); |
| 308 |
|
assertTrue(map.get(one) != one); |
| 309 |
|
assertTrue(map.get(six) == one); |
| 374 |
|
* KeySet.containsAll returns true for collections with subset of elements |
| 375 |
|
*/ |
| 376 |
|
public void testContainsAll() { |
| 377 |
< |
Set full = populatedSet(3); |
| 378 |
< |
Vector v = new Vector(); |
| 379 |
< |
v.add(one); |
| 380 |
< |
v.add(two); |
| 381 |
< |
assertTrue(full.containsAll(v)); |
| 382 |
< |
v.add(six); |
| 385 |
< |
assertFalse(full.containsAll(v)); |
| 377 |
> |
Collection full = populatedSet(3); |
| 378 |
> |
assertTrue(full.containsAll(Arrays.asList())); |
| 379 |
> |
assertTrue(full.containsAll(Arrays.asList(one))); |
| 380 |
> |
assertTrue(full.containsAll(Arrays.asList(one, two))); |
| 381 |
> |
assertFalse(full.containsAll(Arrays.asList(one, two, six))); |
| 382 |
> |
assertFalse(full.containsAll(Arrays.asList(six))); |
| 383 |
|
} |
| 384 |
|
|
| 385 |
|
/** |
| 386 |
|
* KeySet.isEmpty is true when empty, else false |
| 387 |
|
*/ |
| 388 |
|
public void testIsEmpty() { |
| 389 |
< |
Set empty = ConcurrentHashMap.newKeySet(); |
| 390 |
< |
Set full = populatedSet(3); |
| 394 |
< |
assertTrue(empty.isEmpty()); |
| 395 |
< |
assertFalse(full.isEmpty()); |
| 389 |
> |
assertTrue(populatedSet(0).isEmpty()); |
| 390 |
> |
assertFalse(populatedSet(3).isEmpty()); |
| 391 |
|
} |
| 392 |
|
|
| 393 |
|
/** |
| 458 |
|
*/ |
| 459 |
|
public void testRemoveAll() { |
| 460 |
|
Set full = populatedSet(3); |
| 461 |
< |
Vector v = new Vector(); |
| 462 |
< |
v.add(one); |
| 463 |
< |
v.add(two); |
| 469 |
< |
full.removeAll(v); |
| 461 |
> |
assertTrue(full.removeAll(Arrays.asList(one, two))); |
| 462 |
> |
assertEquals(1, full.size()); |
| 463 |
> |
assertFalse(full.removeAll(Arrays.asList(one, two))); |
| 464 |
|
assertEquals(1, full.size()); |
| 465 |
|
} |
| 466 |
|
|
