@Test
public void testSubmitToMemberRunnable() throws InterruptedException {
final int k = simpleTestNodeCount;
TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(k);
final HazelcastInstance[] instances = factory.newInstances(new Config());
final AtomicInteger count = new AtomicInteger(0);
final CountDownLatch latch = new CountDownLatch(k);
final ExecutionCallback callback =
new ExecutionCallback() {
public void onResponse(Object response) {
if (response == null) {
count.incrementAndGet();
}
latch.countDown();
}
public void onFailure(Throwable t) {}
};
for (int i = 0; i < k; i++) {
final HazelcastInstance instance = instances[i];
final IExecutorService service = instance.getExecutorService("testSubmitToMemberRunnable");
final String script =
"if(!hazelcast.getCluster().getLocalMember().equals(member)) "
+ "hazelcast.getAtomicLong('testSubmitToMemberRunnable').incrementAndGet();";
final HashMap map = new HashMap();
map.put("member", instance.getCluster().getLocalMember());
service.submitToMember(
new ScriptRunnable(script, map), instance.getCluster().getLocalMember(), callback);
}
latch.await(10, TimeUnit.SECONDS);
assertEquals(0, instances[0].getAtomicLong("testSubmitToMemberRunnable").get());
assertEquals(k, count.get());
}
@Test
public void testSubmitToKeyOwnerCallable() throws Exception {
final int k = simpleTestNodeCount;
TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(k);
final HazelcastInstance[] instances = factory.newInstances(new Config());
final AtomicInteger count = new AtomicInteger(0);
final CountDownLatch latch = new CountDownLatch(k / 2);
final ExecutionCallback callback =
new ExecutionCallback() {
public void onResponse(Object response) {
if ((Boolean) response) count.incrementAndGet();
latch.countDown();
}
public void onFailure(Throwable t) {}
};
for (int i = 0; i < k; i++) {
final HazelcastInstance instance = instances[i];
final IExecutorService service = instance.getExecutorService("testSubmitToKeyOwnerCallable");
final String script = "hazelcast.getCluster().getLocalMember().equals(member)";
final HashMap map = new HashMap();
final Member localMember = instance.getCluster().getLocalMember();
map.put("member", localMember);
int key = 0;
while (!localMember.equals(instance.getPartitionService().getPartition(++key).getOwner())) ;
if (i % 2 == 0) {
final Future f = service.submitToKeyOwner(new ScriptCallable(script, map), key);
assertTrue((Boolean) f.get(5, TimeUnit.SECONDS));
} else {
service.submitToKeyOwner(new ScriptCallable(script, map), key, callback);
}
}
assertTrue(latch.await(30, TimeUnit.SECONDS));
assertEquals(k / 2, count.get());
}
@Test
public void hazelcastInstanceAwareAndLocal() throws Exception {
final Config config = new Config();
config.addExecutorConfig(new ExecutorConfig("test", 1));
final HazelcastInstance instance = createHazelcastInstance(config);
IExecutorService executor = instance.getExecutorService("test");
HazelcastInstanceAwareRunnable task = new HazelcastInstanceAwareRunnable();
executor.submit(task).get();
assertTrue("The setHazelcastInstance should have been called", task.initializeCalled);
}
@Test
public void testListener() throws Exception {
final int maxItems = 10;
final CountDownLatch itemAddedLatch = new CountDownLatch(maxItems);
final CountDownLatch itemRemovedLatch = new CountDownLatch(maxItems);
final IQueue queue = client.getQueue(randomString());
String id =
queue.addItemListener(
new ItemListener() {
public void itemAdded(ItemEvent itemEvent) {
itemAddedLatch.countDown();
}
public void itemRemoved(ItemEvent item) {
itemRemovedLatch.countDown();
}
},
true);
new Thread() {
public void run() {
for (int i = 0; i < maxItems; i++) {
queue.offer(i);
queue.remove(i);
}
}
}.start();
assertTrue(itemAddedLatch.await(5, TimeUnit.SECONDS));
assertTrue(itemRemovedLatch.await(5, TimeUnit.SECONDS));
queue.removeItemListener(id);
}
@Test
public void testOfferPoll() throws IOException, InterruptedException {
final IQueue q = client.getQueue(queueForTestOfferPoll);
for (int i = 0; i < 10; i++) {
boolean result = q.offer("item");
if (i < maxSizeForQueue) {
assertTrue(result);
} else {
assertFalse(result);
}
}
assertEquals(maxSizeForQueue, q.size());
final Thread t1 =
new Thread() {
public void run() {
try {
Thread.sleep(2 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
q.poll();
}
};
t1.start();
boolean result = q.offer("item", 5, TimeUnit.SECONDS);
assertTrue(result);
for (int i = 0; i < 10; i++) {
Object o = q.poll();
if (i < maxSizeForQueue) {
assertNotNull(o);
} else {
assertNull(o);
}
}
assertEquals(0, q.size());
final Thread t2 =
new Thread() {
public void run() {
try {
Thread.sleep(2 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
q.offer("item1");
}
};
t2.start();
Object o = q.poll(5, TimeUnit.SECONDS);
assertEquals("item1", o);
t1.join(10000);
t2.join(10000);
}
@Test
public void testContains() {
final IQueue q = client.getQueue(randomString());
q.offer(1);
assertTrue(q.contains(1));
assertFalse(q.contains(2));
}
@Test
public void testRemove() throws IOException {
final IQueue q = client.getQueue(randomString());
q.offer(1);
assertTrue(q.remove(1));
assertFalse(q.remove(2));
}
@Test
public void testPeak() throws InterruptedException {
final IQueue q = client.getQueue(randomString());
q.offer(1);
assertEquals(1, q.peek());
assertEquals(1, q.peek());
assertEquals(1, q.size());
}
@Test
public void testRemainingCapacity() throws IOException {
final IQueue q = client.getQueue(randomString());
assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
q.offer("one");
assertEquals(Integer.MAX_VALUE - 1, q.remainingCapacity());
}
@Test
public void testDisablingSystemLogs() throws Exception {
Config config = new Config();
config.setProperty(GroupProperties.PROP_SYSTEM_LOG_ENABLED, "true");
config.getGroupConfig().setName("testDisablingSystemLogs");
HazelcastInstance instance = Hazelcast.newHazelcastInstance(config);
HazelcastInstance instance2 = Hazelcast.newHazelcastInstance(config);
instance.getMap("map").put("key", "value");
Node node = TestUtil.getNode(instance);
assertTrue(node.getSystemLogService().getLogBundle().size() > 0);
Hazelcast.shutdownAll();
config.setProperty(GroupProperties.PROP_SYSTEM_LOG_ENABLED, "false");
instance = Hazelcast.newHazelcastInstance(config);
instance2 = Hazelcast.newHazelcastInstance(config);
instance.getMap("map").put("key2", "value2");
assertTrue(node.getSystemLogService().getLogBundle().size() == 0);
}
@Test
public void testQueueWithSizeLimit() {
final IQueue q = client.getQueue(queueForTestQueueWithSizeLimit);
for (int i = 0; i < maxSizeForQueue; i++) {
q.offer(i);
}
assertFalse(q.offer(maxSizeForQueue));
}
@Test
public void testSize() {
final int maxItems = 143;
final IQueue q = client.getQueue(randomString());
for (int i = 0; i < maxItems; i++) {
q.add(i);
}
assertEquals(maxItems, q.size());
}
@Test
public void testRetainEmptyList() throws IOException {
final int maxItems = 131;
final IQueue q = client.getQueue(randomString());
for (int i = 0; i < maxItems; i++) {
q.add(i);
}
List retain = new LinkedList();
assertTrue(q.retainAll(retain));
assertEquals(0, q.size());
}
@Test
public void testIterator() {
final int maxItems = 18;
final IQueue q = client.getQueue(randomString());
for (int i = 0; i < maxItems; i++) {
q.offer(i);
}
int i = 0;
for (Object o : q) {
assertEquals(i++, o);
}
}
@Test
public void testAddAll() throws IOException {
final int maxItems = 13;
final IQueue q = client.getQueue(randomString());
Collection coll = new ArrayList(maxItems);
for (int i = 0; i < maxItems; i++) {
coll.add(i);
}
assertTrue(q.addAll(coll));
assertEquals(coll.size(), q.size());
}
@Test
public void testToArray() {
final int maxItems = 19;
final IQueue q = client.getQueue(randomString());
Object[] offered = new Object[maxItems];
for (int i = 0; i < maxItems; i++) {
q.offer(i);
offered[i] = i;
}
Object[] result = q.toArray();
assertEquals(offered, result);
}
@Test
public void testRemoveList_whereNotFound() throws IOException {
final int maxItems = 131;
final IQueue q = client.getQueue(randomString());
List removeList = new LinkedList();
for (int i = 0; i < maxItems; i++) {
q.add(i);
}
removeList.add(maxItems + 1);
removeList.add(maxItems + 2);
assertFalse(q.removeAll(removeList));
assertEquals(maxItems, q.size());
}
@Test
public void testManagedContextAndLocal() throws Exception {
final Config config = new Config();
config.addExecutorConfig(new ExecutorConfig("test", 1));
config.setManagedContext(
new ManagedContext() {
@Override
public Object initialize(Object obj) {
if (obj instanceof RunnableWithManagedContext) {
RunnableWithManagedContext task = (RunnableWithManagedContext) obj;
task.initializeCalled = true;
}
return obj;
}
});
final HazelcastInstance instance = createHazelcastInstance(config);
IExecutorService executor = instance.getExecutorService("test");
RunnableWithManagedContext task = new RunnableWithManagedContext();
executor.submit(task).get();
assertTrue(
"The task should have been initialized by the ManagedContext", task.initializeCalled);
}
@Test
public void testContainsAll() {
final int maxItems = 11;
final IQueue q = client.getQueue(randomString());
List trueList = new ArrayList();
List falseList = new ArrayList();
for (int i = 0; i < maxItems; i++) {
q.offer(i);
trueList.add(i);
falseList.add(i + 1);
}
assertTrue(q.containsAll(trueList));
assertFalse(q.containsAll(falseList));
}
@Test
public void testDrain() {
final int maxItems = 12;
final IQueue q = client.getQueue(randomString());
List offeredList = new LinkedList();
for (int i = 0; i < maxItems; i++) {
q.offer(i);
offeredList.add(i);
}
List drainedList = new LinkedList();
int totalDrained = q.drainTo(drainedList);
assertEquals(maxItems, totalDrained);
assertEquals(offeredList, drainedList);
}
@Test
public void testPartialDrain() {
final int maxItems = 15;
final int itemsToDrain = maxItems / 2;
final IQueue q = client.getQueue(randomString());
List expectedList = new LinkedList();
for (int i = 0; i < maxItems; i++) {
q.offer(i);
if (i < itemsToDrain) {
expectedList.add(i);
}
}
List drainedList = new LinkedList();
int totalDrained = q.drainTo(drainedList, itemsToDrain);
assertEquals(itemsToDrain, totalDrained);
assertEquals(expectedList, drainedList);
}
@Test
public void testadd() {
final IQueue q = client.getQueue(randomString());
assertTrue(q.add(1));
assertEquals(1, q.size());
}
private IExecutorService createSingleNodeExecutorService(String name, int poolSize) {
final Config config = new Config();
config.addExecutorConfig(new ExecutorConfig(name, poolSize));
final HazelcastInstance instance = createHazelcastInstance(config);
return instance.getExecutorService(name);
}
@Override
public void setHazelcastInstance(HazelcastInstance hazelcastInstance) {
localMember = hazelcastInstance.getCluster().getLocalMember();
}
public String call() throws Exception {
Future future = instance.getExecutorService("NestedExecutorTask").submit(new BasicTestTask());
return (String) future.get();
}
@Test
public void testIsEmpty() {
final IQueue q = client.getQueue(randomString());
assertTrue(q.isEmpty());
}
@Test
public void testEmptyPeak() throws InterruptedException {
final IQueue q = client.getQueue(randomString());
assertNull(q.peek());
}
@Test
public void testTake() throws InterruptedException {
final IQueue q = client.getQueue(randomString());
q.put(1);
assertEquals(1, q.take());
}
@Test
public void testNotIsEmpty() {
final IQueue q = client.getQueue(randomString());
q.offer(1);
assertFalse(q.isEmpty());
}
@Test(expected = UnsupportedOperationException.class)
public void testGetLocalQueueStats() {
final IQueue q = client.getQueue(randomString());
q.getLocalQueueStats();
}