@Test
public void testHazelcastInstances() {
assertNotNull(map1);
assertNotNull(map2);
assertNotNull(multiMap);
assertNotNull(replicatedMap);
assertNotNull(queue);
assertNotNull(topic);
assertNotNull(set);
assertNotNull(list);
assertNotNull(executorService);
assertNotNull(idGenerator);
assertNotNull(atomicLong);
assertNotNull(atomicReference);
assertNotNull(countDownLatch);
assertNotNull(semaphore);
assertNotNull(lock);
assertEquals("map1", map1.getName());
assertEquals("map2", map2.getName());
assertEquals("testMultimap", multiMap.getName());
assertEquals("replicatedMap", replicatedMap.getName());
assertEquals("testQ", queue.getName());
assertEquals("testTopic", topic.getName());
assertEquals("set", set.getName());
assertEquals("list", list.getName());
assertEquals("idGenerator", idGenerator.getName());
assertEquals("atomicLong", atomicLong.getName());
assertEquals("atomicReference", atomicReference.getName());
assertEquals("countDownLatch", countDownLatch.getName());
assertEquals("semaphore", semaphore.getName());
}
@Test
public void tryAcquire() throws Exception {
assertTrue(s.tryAcquire());
assertTrue(s.tryAcquire(9));
assertEquals(0, s.availablePermits());
assertFalse(s.tryAcquire(1, TimeUnit.SECONDS));
assertFalse(s.tryAcquire(2, 1, TimeUnit.SECONDS));
final CountDownLatch latch = new CountDownLatch(1);
new Thread() {
public void run() {
try {
if (s.tryAcquire(2, 5, TimeUnit.SECONDS)) {
latch.countDown();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
s.release(2);
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertEquals(0, s.availablePermits());
}
@Test
public void testSemaphoreSplitBrain() throws InterruptedException {
Config config = newConfig();
HazelcastInstance h1 = Hazelcast.newHazelcastInstance(config);
HazelcastInstance h2 = Hazelcast.newHazelcastInstance(config);
final HazelcastInstance h3 = Hazelcast.newHazelcastInstance(config);
final String key = generateKeyOwnedBy(h3);
ISemaphore semaphore = h3.getSemaphore(key);
semaphore.init(5);
semaphore.acquire(3);
assertEquals(2, semaphore.availablePermits());
assertTrueEventually(
new AssertTask() {
@Override
public void run() throws Exception {
assertTrue(h3.getPartitionService().isLocalMemberSafe());
}
});
TestMemberShipListener memberShipListener = new TestMemberShipListener(2);
h3.getCluster().addMembershipListener(memberShipListener);
TestLifeCycleListener lifeCycleListener = new TestLifeCycleListener(1);
h3.getLifecycleService().addLifecycleListener(lifeCycleListener);
closeConnectionBetween(h1, h3);
closeConnectionBetween(h2, h3);
assertOpenEventually(memberShipListener.latch);
assertClusterSizeEventually(2, h1);
assertClusterSizeEventually(2, h2);
assertClusterSizeEventually(1, h3);
final ISemaphore semaphore1 = h1.getSemaphore(key);
// when member is down, permits are released.
// since releasing the permits is async, we use assert eventually
assertTrueEventually(
new AssertTask() {
@Override
public void run() throws Exception {
assertEquals(5, semaphore1.availablePermits());
}
});
semaphore1.acquire(4);
assertOpenEventually(lifeCycleListener.latch);
assertClusterSizeEventually(3, h1);
assertClusterSizeEventually(3, h2);
assertClusterSizeEventually(3, h3);
ISemaphore testSemaphore = h3.getSemaphore(key);
assertEquals(1, testSemaphore.availablePermits());
}
@Test
public void testAcquire() throws Exception {
assertEquals(10, s.drainPermits());
final CountDownLatch latch = new CountDownLatch(1);
new Thread() {
public void run() {
try {
s.acquire();
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
Thread.sleep(1000);
s.release(2);
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertEquals(1, s.availablePermits());
}
@Before
@After
public void clear() throws IOException {
s.reducePermits(100);
s.release(10);
}
