| 391 |
|
/** |
| 392 |
|
* take blocks interruptibly when empty |
| 393 |
|
*/ |
| 394 |
< |
public void testTakeFromEmpty() throws InterruptedException { |
| 395 |
< |
final DelayQueue q = new DelayQueue(); |
| 396 |
< |
Thread t = new ThreadShouldThrow(InterruptedException.class) { |
| 397 |
< |
public void realRun() throws InterruptedException { |
| 398 |
< |
q.take(); |
| 399 |
< |
}}; |
| 400 |
< |
|
| 401 |
< |
t.start(); |
| 394 |
> |
public void testTakeFromEmptyBlocksInterruptibly() |
| 395 |
> |
throws InterruptedException { |
| 396 |
> |
final BlockingQueue q = new DelayQueue(); |
| 397 |
> |
final CountDownLatch threadStarted = new CountDownLatch(1); |
| 398 |
> |
Thread t = newStartedThread(new CheckedRunnable() { |
| 399 |
> |
public void realRun() { |
| 400 |
> |
long t0 = System.nanoTime(); |
| 401 |
> |
threadStarted.countDown(); |
| 402 |
> |
try { |
| 403 |
> |
q.take(); |
| 404 |
> |
shouldThrow(); |
| 405 |
> |
} catch (InterruptedException expected) {} |
| 406 |
> |
assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS); |
| 407 |
> |
}}); |
| 408 |
> |
threadStarted.await(); |
| 409 |
|
Thread.sleep(SHORT_DELAY_MS); |
| 410 |
+ |
assertTrue(t.isAlive()); |
| 411 |
|
t.interrupt(); |
| 412 |
< |
t.join(); |
| 412 |
> |
awaitTermination(t, MEDIUM_DELAY_MS); |
| 413 |
> |
assertFalse(t.isAlive()); |
| 414 |
|
} |
| 415 |
|
|
| 416 |
|
/** |
| 448 |
|
} |
| 449 |
|
|
| 450 |
|
/** |
| 451 |
< |
* timed pool with zero timeout succeeds when non-empty, else times out |
| 451 |
> |
* timed poll with zero timeout succeeds when non-empty, else times out |
| 452 |
|
*/ |
| 453 |
|
public void testTimedPoll0() throws InterruptedException { |
| 454 |
|
DelayQueue q = populatedQueue(SIZE); |
| 459 |
|
} |
| 460 |
|
|
| 461 |
|
/** |
| 462 |
< |
* timed pool with nonzero timeout succeeds when non-empty, else times out |
| 462 |
> |
* timed poll with nonzero timeout succeeds when non-empty, else times out |
| 463 |
|
*/ |
| 464 |
|
public void testTimedPoll() throws InterruptedException { |
| 465 |
|
DelayQueue q = populatedQueue(SIZE); |
| 784 |
|
* Delayed actions do not occur until their delay elapses |
| 785 |
|
*/ |
| 786 |
|
public void testDelay() throws InterruptedException { |
| 787 |
< |
DelayQueue q = new DelayQueue(); |
| 788 |
< |
NanoDelay[] elements = new NanoDelay[SIZE]; |
| 789 |
< |
for (int i = 0; i < SIZE; ++i) { |
| 781 |
< |
elements[i] = new NanoDelay(1000000000L + 1000000L * (SIZE - i)); |
| 782 |
< |
} |
| 783 |
< |
for (int i = 0; i < SIZE; ++i) { |
| 784 |
< |
q.add(elements[i]); |
| 785 |
< |
} |
| 787 |
> |
DelayQueue<NanoDelay> q = new DelayQueue<NanoDelay>(); |
| 788 |
> |
for (int i = 0; i < SIZE; ++i) |
| 789 |
> |
q.add(new NanoDelay(1000000L * (SIZE - i))); |
| 790 |
|
|
| 791 |
|
long last = 0; |
| 792 |
|
for (int i = 0; i < SIZE; ++i) { |
| 793 |
< |
NanoDelay e = (NanoDelay)(q.take()); |
| 793 |
> |
NanoDelay e = q.take(); |
| 794 |
|
long tt = e.getTriggerTime(); |
| 795 |
< |
assertTrue(tt <= System.nanoTime()); |
| 795 |
> |
assertTrue(System.nanoTime() - tt >= 0); |
| 796 |
|
if (i != 0) |
| 797 |
|
assertTrue(tt >= last); |
| 798 |
|
last = tt; |
| 799 |
|
} |
| 800 |
+ |
assertTrue(q.isEmpty()); |
| 801 |
|
} |
| 802 |
|
|
| 803 |
|
/** |
| 919 |
|
} |
| 920 |
|
|
| 921 |
|
/** |
| 922 |
< |
* drainTo(c, n) empties first max {n, size} elements of queue into c |
| 922 |
> |
* drainTo(c, n) empties first min(n, size) elements of queue into c |
| 923 |
|
*/ |
| 924 |
|
public void testDrainToN() { |
| 925 |
|
for (int i = 0; i < SIZE + 2; ++i) { |
| 926 |
|
DelayQueue q = populatedQueue(SIZE); |
| 927 |
|
ArrayList l = new ArrayList(); |
| 928 |
|
q.drainTo(l, i); |
| 929 |
< |
int k = (i < SIZE)? i : SIZE; |
| 929 |
> |
int k = (i < SIZE) ? i : SIZE; |
| 930 |
|
assertEquals(q.size(), SIZE-k); |
| 931 |
|
assertEquals(l.size(), k); |
| 932 |
|
} |
