corda/test/LinkedBlockingQueueTest.java

362 lines
9.6 KiB
Java

import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
public class LinkedBlockingQueueTest {
private static final int DELAY_TILL_ACTION = 10;
public static void main(String[] args) throws InterruptedException {
remainingCapacityTest();
sizeTest();
isEmptyTest();
addTest();
addCapacityFail();
offerTest();
offerWithTimeoutTest();
offerTimeoutTest();
putTest();
addAllTest();
addAllFail();
elementTest();
elementFail();
pollEmptyTest();
pollTest();
pollTimeoutTest();
takeTest();
removeEmptyTest();
removeTest();
drainToTest();
drainToLimitTest();
containsTest();
containsAllTest();
removeObjectTest();
removeAllTest();
clearTest();
toArrayTest();
}
private static void verify(boolean val) {
if (! val) {
throw new RuntimeException();
}
}
private static void remainingCapacityTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>(2);
verify(lbq.remainingCapacity() == 2);
lbq.add(new Object());
verify(lbq.remainingCapacity() == 1);
}
private static void sizeTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
verify(lbq.size() == 0);
lbq.add(new Object());
verify(lbq.size() == 1);
}
private static void isEmptyTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
verify(lbq.isEmpty());
lbq.add(new Object());
verify(! lbq.isEmpty());
}
private static void addTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
Object testObject = new Object();
lbq.add(testObject);
verify(lbq.size() == 1);
verify(lbq.peek() == testObject);
}
private static void addCapacityFail() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>(1);
Object testObject = new Object();
lbq.add(testObject);
try {
lbq.add(new Object());
throw new RuntimeException("Exception should have thrown");
} catch (IllegalStateException e) {
// expected
}
verify(lbq.size() == 1);
verify(lbq.peek() == testObject);
}
private static void offerTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>(1);
Object testObject = new Object();
verify(lbq.offer(testObject));
verify(! lbq.offer(new Object()));
verify(lbq.size() == 1);
verify(lbq.peek() == testObject);
}
private static void offerWithTimeoutTest() throws InterruptedException {
final LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>(1);
lbq.add(new Object());
new Thread(new Runnable() {
@Override
public void run() {
try {
// sleep to make sure offer call starts first
Thread.sleep(DELAY_TILL_ACTION);
lbq.take();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}).start();
// should accept once thread starts
verify(lbq.offer(new Object(), 10, TimeUnit.SECONDS));
}
private static void offerTimeoutTest() throws InterruptedException {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>(1);
lbq.add(new Object());
verify(! lbq.offer(new Object(), 10, TimeUnit.MILLISECONDS));
}
private static void putTest() throws InterruptedException {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
Object testObject = new Object();
lbq.put(testObject);
verify(lbq.size() == 1);
verify(lbq.peek() == testObject);
}
private static void addAllTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
LinkedList<Object> toAdd = new LinkedList<Object>();
toAdd.add(new Object());
toAdd.add(new Object());
lbq.addAll(toAdd);
verify(lbq.size() == toAdd.size());
while (! lbq.isEmpty()) {
verify(lbq.remove() == toAdd.remove());
}
}
private static void addAllFail() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>(1);
LinkedList<Object> toAdd = new LinkedList<Object>();
toAdd.add(new Object());
toAdd.add(new Object());
try {
lbq.addAll(toAdd);
throw new RuntimeException("Exception should have thrown");
} catch (IllegalStateException e) {
// expected
}
}
private static void elementTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
Object testObject = new Object();
lbq.add(testObject);
verify(lbq.element() == testObject);
}
private static void elementFail() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
try {
lbq.element();
throw new RuntimeException("Exception should have thrown");
} catch (NoSuchElementException e) {
// expected
}
}
private static void pollEmptyTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
verify(lbq.poll() == null);
}
private static void pollTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
Object testObject = new Object();
lbq.add(testObject);
verify(lbq.poll() == testObject);
}
private static void pollTimeoutTest() throws InterruptedException {
final LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
final Object testObject = new Object();
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(DELAY_TILL_ACTION);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
lbq.add(testObject);
}
}).start();
verify(lbq.poll(DELAY_TILL_ACTION * 2, TimeUnit.MILLISECONDS) == testObject);
}
private static void takeTest() throws InterruptedException {
final LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
final Object testObject = new Object();
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(DELAY_TILL_ACTION);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
lbq.add(testObject);
}
}).start();
verify(lbq.take() == testObject);
}
private static void removeEmptyTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
try {
lbq.remove();
throw new RuntimeException("Exception should have thrown");
} catch (NoSuchElementException e) {
// expected
}
}
private static void removeTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
Object testObject = new Object();
lbq.add(testObject);
verify(lbq.remove() == testObject);
}
private static void drainToTest() {
int objQty = 2;
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
for (int i = 0; i < objQty; i++) {
lbq.add(new Object());
}
LinkedList<Object> drainToResult = new LinkedList<Object>();
verify(lbq.drainTo(drainToResult) == objQty);
verify(drainToResult.size() == objQty);
}
private static void drainToLimitTest() {
int objQty = 4;
int limit = 2;
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
for (int i = 0; i < objQty; i++) {
lbq.add(new Object());
}
LinkedList<Object> drainToResult = new LinkedList<Object>();
verify(lbq.drainTo(drainToResult, limit) == limit);
verify(drainToResult.size() == limit);
verify(lbq.size() == objQty - limit);
}
private static void containsTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
Object testObject = new Object();
verify(! lbq.contains(testObject));
lbq.add(testObject);
verify(lbq.contains(testObject));
}
private static void containsAllTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
Object testObject = new Object();
lbq.add(testObject);
LinkedList<Object> testList = new LinkedList<Object>();
testList.add(testObject);
testList.add(new Object());
verify(! lbq.containsAll(testList));
lbq.addAll(testList);
verify(lbq.containsAll(testList));
}
private static void removeObjectTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
Object testObject = new Object();
verify(! lbq.remove(testObject));
lbq.add(testObject);
verify(lbq.remove(testObject));
}
private static void removeAllTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
Object testObject = new Object();
lbq.add(testObject);
LinkedList<Object> testList = new LinkedList<Object>();
testList.add(testObject);
testList.add(new Object());
verify(lbq.removeAll(testList));
lbq.addAll(testList);
verify(lbq.removeAll(testList));
}
private static void clearTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
lbq.add(new Object());
lbq.clear();
verify(lbq.isEmpty());
}
private static void toArrayTest() {
LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>();
if (lbq.toArray().length != 0) {
throw new RuntimeException();
}
Object testObject = new Object();
lbq.add(testObject);
Object[] result = lbq.toArray();
verify(result.length == 1);
verify(result[0] == testObject);
}
}