public void testListenTwiceOnSameObserver() throws Exception {
/* reuse the same listener for two observers */
Participant provider = new Participant("prov");
Participant consumer = new Participant("cons");
provider.createA(A);
final ObserverListener listener = new ObserverListener(consumer);
final Observer obs = newObserver(consumer, InterfaceA.class);
obs.registerListener(listener);
Lambda ok = new SingleLambda(listener);
/*
* use listener twice on observer, so we expect to see all events twice
*/
listener.expectInvocations(1);
provider.registerObject(A);
assertTrue(waitForLambda(3000, ok));
/*
* one observer is gone, so we expect to see every event just once.
*/
listener.allowDuplicates = true;
listener.expectInvocations(1);
obs.registerListener(listener, true);
boolean result = waitForLambda(3000, ok);
assertTrue("Counter value = " + listener.getCounter(), result);
listener.expectInvocations(2);
provider.createAB(AB);
provider.registerObject(AB);
result = waitForLambda(3000, ok);
assertTrue("Counter value = " + listener.getCounter(), result);
obs.unregisterListener(listener);
listener.expectInvocations(1);
provider.unregisterObject(AB);
assertTrue(waitForLambda(3000, ok));
obs.unregisterListener(listener);
provider.unregisterObject(A);
Thread.sleep(100);
listener.expectInvocations(0);
obs.unregisterListener(listener); // the listener is not registered
// anymore, but this should work.
obs.unregisterListener(null); // Does nothing sensible, but should not
// trigger an exception.
obs.registerListener(listener);
obs.registerListener(new ObserverListener(consumer));
// We should be able to unregisterAll multiple times
obs.unregisterAllListeners();
obs.unregisterAllListeners();
obs.unregisterAllListeners();
obs.unregisterAllListeners();
obs.unregisterAllListeners();
}
private void waitForEvent(
ObserverListener listener, Participant provider, String name, boolean register) {
listener.expectInvocations(1);
if (register) {
provider.registerObject(name);
} else {
provider.unregisterObject(name);
}
Lambda ok = new SingleLambda(listener);
assertTrue(waitForLambda(WAIT_TIMEOUT, ok));
}
public void testListenTwice() {
/* reuse the same listener for two observers */
Participant provider = new Participant("prov");
Participant consumer = new Participant("cons");
provider.createA(A);
provider.createAB(AB);
provider.createAB("ab2");
final ObserverListener listener = new ObserverListener(consumer);
final Observer obs = newObserver(consumer, InterfaceA.class);
obs.registerListener(listener);
final Observer obs2 = newObserver(consumer, InterfaceA.class);
obs2.registerListener(listener);
Lambda ok = new SingleLambda(listener);
/* use listener for 2 observers, so we expect to
* see all events twice */
listener.expectInvocations(6);
provider.registerObject(A);
provider.registerObject(AB);
provider.registerObject("ab2");
assertTrue(waitForLambda(3000, ok));
obs2.unregisterListener(listener);
/* one observer is gone, so we expect to see
* every event just once. */
listener.expectInvocations(3);
provider.unregisterObject(A);
provider.unregisterObject(AB);
provider.unregisterObject("ab2");
assertTrue(waitForLambda(3000, ok));
}
public void testRejection() throws Exception {
Participant willing = new Participant("willing");
Participant doubtful = new Participant("doubtful");
Participant unwilling = new Participant("unwilling");
Participant consumer = new Participant("consumer");
willing.createA(A);
doubtful.createAB(A);
unwilling.createAB(A);
unwilling.accepter.accept = false;
final ObserverListener listener = new ObserverListener(consumer);
final Observer obs = newObserver(consumer, InterfaceA.class);
obs.registerListener(listener);
listener.expectInvocations(2);
willing.registerObject(A);
doubtful.registerObject(A);
unwilling.registerObject(A);
Lambda ok = new SingleLambda(listener);
assertTrue(waitForLambda(3000, ok));
/* now let doubtful kill the connection */
Thread.sleep(100); // This sleep is necessary to make sure the provider knows it has a session.
listener.expectInvocations(1);
Integer sessionid = doubtful.accepter.sessions.get(consumer.bus.getUniqueName());
assertNotNull(sessionid);
doubtful.bus.leaveHostedSession(sessionid);
assertTrue(waitForLambda(3000, ok));
/* there should only be one object left */
assertEquals(1, countProxies(obs));
/* unannounce and reannounce, connection should be restored */
listener.expectInvocations(1);
doubtful.unregisterObject(A);
doubtful.registerObject(A);
assertTrue(waitForLambda(3000, ok));
/* now there should only be two objects */
assertEquals(2, countProxies(obs));
}
public void simpleScenario(Participant provider, Participant consumer) {
provider.createA("justA");
provider.createB("justB");
provider.createAB("both");
final Observer obsA = newObserver(consumer, InterfaceA.class);
final ObserverListener listenerA = new ObserverListener(consumer);
obsA.registerListener(listenerA);
final Observer obsB = newObserver(consumer, InterfaceB.class);
final ObserverListener listenerB = new ObserverListener(consumer);
obsB.registerListener(listenerB);
final Observer obsAB = newObserver(consumer, InterfaceA.class, InterfaceB.class);
final ObserverListener listenerAB = new ObserverListener(consumer);
obsAB.registerListener(listenerAB);
Lambda allDone =
new Lambda() {
@Override
public boolean func() {
return listenerA.getCounter() == 0
&& listenerB.getCounter() == 0
&& listenerAB.getCounter() == 0;
}
};
/* let provider publish objects on the bus */
listenerA.expectInvocations(2);
listenerB.expectInvocations(2);
listenerAB.expectInvocations(1);
provider.registerObject("justA");
provider.registerObject("justB");
provider.registerObject("both");
assertTrue(waitForLambda(3000, allDone));
/* remove justA from the bus */
listenerA.expectInvocations(1);
listenerB.expectInvocations(0);
listenerAB.expectInvocations(0);
provider.unregisterObject("justA");
assertTrue(waitForLambda(3000, allDone));
/* remove "both" from the bus */
listenerA.expectInvocations(1);
listenerB.expectInvocations(1);
listenerAB.expectInvocations(1);
provider.unregisterObject("both");
assertTrue(waitForLambda(3000, allDone));
/* count the number of proxies left in the Observers.
* There should be 0 in A, 1 in B, 0 in AB */
assertEquals(0, countProxies(obsA));
assertEquals(1, countProxies(obsB));
assertEquals(0, countProxies(obsAB));
/* remove all listeners */
obsA.unregisterAllListeners();
obsB.unregisterAllListeners();
obsAB.unregisterListener(listenerAB);
/* remove "justB" and reinstate the other objects */
listenerA.expectInvocations(0);
listenerB.expectInvocations(0);
listenerAB.expectInvocations(0);
provider.unregisterObject("justB");
provider.registerObject("justA");
provider.registerObject("both");
/* busy-wait for a second at most */
assertTrue(
waitForLambda(
1000,
new Lambda() {
@Override
public boolean func() {
return 2 == countProxies(obsA)
&& 1 == countProxies(obsB)
&& 1 == countProxies(obsAB);
}
}));
/* reinstate listeners & test triggerOnExisting functionality */
listenerA.expectInvocations(2);
listenerB.expectInvocations(1);
listenerAB.expectInvocations(1);
obsA.registerListener(listenerA);
obsB.registerListener(listenerB);
obsAB.registerListener(listenerAB);
assertTrue(waitForLambda(3000, allDone));
/* test multiple listeners for same observer */
final ObserverListener listenerB2 = new ObserverListener(consumer);
listenerB2.expectInvocations(0);
obsB.registerListener(listenerB2, false);
Lambda allDone2 =
new Lambda() {
@Override
public boolean func() {
return listenerA.getCounter() == 0
&& listenerB.getCounter() == 0
&& listenerB2.getCounter() == 0
&& listenerAB.getCounter() == 0;
}
};
listenerA.expectInvocations(0);
listenerB.expectInvocations(1);
listenerB2.expectInvocations(1);
listenerAB.expectInvocations(0);
provider.registerObject("justB");
assertTrue(waitForLambda(1000, allDone2));
/* are all objects back where they belong? */
assertEquals(2, countProxies(obsA));
assertEquals(2, countProxies(obsB));
assertEquals(1, countProxies(obsAB));
/* test multiple observers for the same set of interfaces */
final Observer obsB2 = newObserver(consumer, InterfaceB.class);
obsB.unregisterListener(
listenerB2); /* unregister listenerB2 from obsB so we can reuse it here */
listenerA.expectInvocations(0);
listenerB.expectInvocations(0);
listenerB2.expectInvocations(2);
listenerAB.expectInvocations(0);
obsB2.registerListener(listenerB2);
assertTrue(waitForLambda(1000, allDone2));
/* test Observer::Get() and the proxy creation functionality */
ProxyBusObject proxy;
proxy = obsA.get(provider.bus.getUniqueName(), makePath("justA"));
assertTrue(null != proxy);
proxy = obsA.get(provider.bus.getUniqueName(), makePath("both"));
assertTrue(null != proxy);
/* verify that we can indeed perform method calls */
InterfaceA intfA = proxy.getInterface(InterfaceA.class);
try {
String id = intfA.methodA();
assertEquals(provider.bus.getUniqueName() + "@" + makePath("both"), id);
} catch (BusException e) {
fail("method call failed: " + e);
}
}
public void testMulti() {
/* multiple providers, multiple consumers */
Participant one = new Participant("one");
Participant two = new Participant("two");
one.createA(A);
one.createB(B);
one.createAB(AB);
two.createA(A);
two.createB(B);
two.createAB(AB);
final Observer obsAone = newObserver(one, InterfaceA.class);
final ObserverListener lisAone = new ObserverListener(one);
obsAone.registerListener(lisAone);
final Observer obsBone = newObserver(one, InterfaceB.class);
final ObserverListener lisBone = new ObserverListener(one);
obsBone.registerListener(lisBone);
final Observer obsABone = newObserver(one, InterfaceA.class, InterfaceB.class);
final ObserverListener lisABone = new ObserverListener(one);
obsABone.registerListener(lisABone);
final Observer obsAtwo = newObserver(two, InterfaceA.class);
final ObserverListener lisAtwo = new ObserverListener(two);
obsAtwo.registerListener(lisAtwo);
final Observer obsBtwo = newObserver(two, InterfaceB.class);
final ObserverListener lisBtwo = new ObserverListener(two);
obsBtwo.registerListener(lisBtwo);
final Observer obsABtwo = newObserver(two, InterfaceA.class, InterfaceB.class);
final ObserverListener lisABtwo = new ObserverListener(two);
obsABtwo.registerListener(lisABtwo);
Lambda ok =
new Lambda() {
@Override
public boolean func() {
return lisAone.getCounter() == 0
&& lisBone.getCounter() == 0
&& lisABone.getCounter() == 0
&& lisAtwo.getCounter() == 0
&& lisBtwo.getCounter() == 0
&& lisABtwo.getCounter() == 0;
}
};
/* put objects on the bus */
lisAone.expectInvocations(4);
lisBone.expectInvocations(4);
lisABone.expectInvocations(2);
lisAtwo.expectInvocations(4);
lisBtwo.expectInvocations(4);
lisABtwo.expectInvocations(2);
one.registerObject(A);
one.registerObject(B);
one.registerObject(AB);
two.registerObject(A);
two.registerObject(B);
two.registerObject(AB);
assertTrue(waitForLambda(3000, ok));
assertEquals(4, countProxies(obsAone));
assertEquals(4, countProxies(obsBone));
assertEquals(2, countProxies(obsABone));
assertEquals(4, countProxies(obsAtwo));
assertEquals(4, countProxies(obsBtwo));
assertEquals(2, countProxies(obsABtwo));
/* now drop all objects */
lisAone.expectInvocations(4);
lisBone.expectInvocations(4);
lisABone.expectInvocations(2);
lisAtwo.expectInvocations(4);
lisBtwo.expectInvocations(4);
lisABtwo.expectInvocations(2);
one.unregisterObject(A);
one.unregisterObject(B);
one.unregisterObject(AB);
two.unregisterObject(A);
two.unregisterObject(B);
two.unregisterObject(AB);
assertTrue(waitForLambda(3000, ok));
assertEquals(0, countProxies(obsAone));
assertEquals(0, countProxies(obsBone));
assertEquals(0, countProxies(obsABone));
assertEquals(0, countProxies(obsAtwo));
assertEquals(0, countProxies(obsBtwo));
assertEquals(0, countProxies(obsABtwo));
}