public void testMultipleListenersOnSingleObserver() {
Participant one = new Participant("one");
Participant two = new Participant("two");
final Observer obsA = newObserver(one, InterfaceA.class);
final ObserverListener lisAone = new ObserverListener(one);
final ObserverListener lisAtwo = new ObserverListener(one);
obsA.registerListener(lisAone);
obsA.registerListener(lisAtwo);
lisAone.expectInvocations(2);
lisAtwo.expectInvocations(2);
two.createA(A);
two.createAB(AB);
two.registerObject(A);
two.registerObject(AB);
Lambda ok =
new Lambda() {
@Override
public boolean func() {
return lisAone.getCounter() == 0 && lisAtwo.getCounter() == 0;
}
};
boolean result = waitForLambda(3000, ok);
assertTrue("Count one = " + lisAone.getCounter() + ", two = " + lisAtwo.getCounter(), result);
}
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();
}
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 testGetFirstNext() {
Participant consumer = new Participant("one");
Participant provider = new Participant("two");
final Observer obs = newObserver(consumer, InterfaceA.class);
final ObserverListener listener = new ObserverListener(consumer);
obs.registerListener(listener);
assertNull(obs.getFirst());
assertNull(obs.getNext(null));
ArrayList<ProxyBusObject> objects = null;
String[] names = new String[] {A, AB, B, C};
for (int i = 0; i < names.length; ) {
provider.createA(names[i]);
waitForEvent(listener, provider, names[i]);
objects = checkObjects(++i, obs);
}
assertNotNull(objects);
ProxyBusObject obj = objects.get(1);
unregisterObject(provider, obj, listener);
assertSame(objects.get(2), obs.getNext(obj));
assertSame(objects.get(2), obs.getNext(objects.get(0)));
objects = checkObjects(3, obs);
assertFalse(objects.contains(obj));
obj = objects.get(2);
unregisterObject(provider, obj, listener);
assertNull(obs.getNext(obj));
assertNull(obs.getNext(objects.get(1)));
objects = checkObjects(2, obs);
assertFalse(objects.contains(obj));
obj = objects.get(0);
unregisterObject(provider, obj, listener);
assertSame(objects.get(1), obs.getNext(obj));
assertSame(objects.get(1), obs.getFirst());
objects = checkObjects(1, obs);
assertFalse(objects.contains(obj));
obj = objects.get(0);
unregisterObject(provider, obj, listener);
assertNull(obs.getNext(obj));
assertNull(obs.getFirst());
}
public void testExceptionInListener() {
Participant consumer = new Participant("one");
Participant provider = new Participant("two");
final Observer obs = newObserver(consumer, InterfaceA.class);
final ObserverListener listener = new ObserverListener(consumer);
final ObserverListener lateJoiner = new ObserverListener(consumer);
final Observer.Listener badListener =
new Observer.Listener() {
@Override
public void objectLost(ProxyBusObject object) {
exceptionCount.incrementAndGet();
throw new RuntimeException();
}
@Override
public void objectDiscovered(ProxyBusObject object) {
exceptionCount.incrementAndGet();
throw new RuntimeException();
}
};
obs.registerListener(badListener);
obs.registerListener(listener);
provider.createA(A);
waitForEvent(listener, provider, A);
obs.registerListener(badListener, false);
obs.registerListener(badListener, true);
lateJoiner.expectInvocations(1);
obs.registerListener(lateJoiner, true);
waitForLambda(WAIT_TIMEOUT, new SingleLambda(lateJoiner));
waitForEvent(listener, provider, A, false);
assertTrue(
waitForLambda(
WAIT_TIMEOUT,
new Lambda() {
@Override
public boolean func() {
return 5 == exceptionCount.get();
}
}));
assertEquals(5, exceptionCount.get());
}
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 testClose() throws Exception {
Participant provider = new Participant("prov");
Participant consumer = new Participant("cons");
final Observer obs = newObserver(consumer, InterfaceA.class);
final ObserverListener listener = new ObserverListener(consumer);
obs.registerListener(listener);
provider.createA(A);
waitForEvent(listener, provider, A);
ProxyBusObject pbo = obs.getFirst();
assertNotNull(pbo);
obs.close();
obs.close();
obs.registerListener(listener);
assertNull(obs.getFirst());
assertNull(obs.get(pbo.getBusName(), pbo.getObjPath()));
assertNull(obs.getNext(pbo));
obs.unregisterListener(listener);
obs.unregisterAllListeners();
obs.close();
Thread.sleep(100);
listener.expectInvocations(0);
}
public void testInvalidArgs() throws Exception {
Participant test = new Participant("invArgs");
Observer obs = null;
/* null bus pointer is invalid expect a NullPointerException */
try {
obs = newObserver(null, InterfaceA.class);
fail("bus can't be null");
} catch (NullPointerException rt) {
/* OK */
assertNull(obs);
}
/* must pass in a valid interface Class<?>[] array */
try {
obs = new Observer(test.bus, null);
fail("null array value is not allowed");
} catch (NullPointerException rt) {
/* OK */
assertNull(obs);
}
/* array can not contain a null value. */
try {
obs = newObserver(test, new Class<?>[] {null});
fail("Array with null value is not allowed");
} catch (NullPointerException rt) {
/* OK */
assertNull(obs);
}
/* empty array is not allowed */
try {
obs = newObserver(test);
fail("Empty array is not allowed");
} catch (IllegalArgumentException iae) {
/* OK */
assertNull(obs);
}
/* class must be a BusInterface */
try {
obs = newObserver(test, String.class);
fail("Class is not allowed");
} catch (IllegalArgumentException iae) {
/* OK */
assertNull(obs);
}
/* all classes must be BusInterfaces */
try {
obs =
new Observer(test.bus, new Class<?>[] {InterfaceA.class}, new Class<?>[] {String.class});
fail("Class is not allowed");
} catch (IllegalArgumentException iae) {
/* OK */
assertNull(obs);
}
assertNull(obs);
obs = new Observer(test.bus, new Class<?>[] {InterfaceA.class}, null); // null
// allowed.
try {
obs.registerListener(null);
fail("null not allowed");
} catch (IllegalArgumentException rt) {
/* OK */
assertNotNull(obs);
}
final ObserverListener listener = new ObserverListener(test);
obs.registerListener(listener);
listener.expectInvocations(1);
test.createA(A);
test.registerObject(A);
assertTrue(waitForLambda(3000, new SingleLambda(listener)));
// null values are harmless for the object.
try {
obs.get(null, A);
fail("Expected Observer.get(null, path) to throw a NullPointerException.");
} catch (NullPointerException npe) {
/* OK */
assertNotNull(obs);
}
try {
obs.get(test.bus.getUniqueName(), null);
fail("Expected Observer.get(bus, null) to throw a NullPointerException.");
} catch (NullPointerException npe) {
/* OK */
assertNotNull(obs);
}
assertNull(obs.get(test.bus.getUniqueName(), AB));
assertNull(obs.get(A, A));
assertNotNull(obs.get(test.bus.getUniqueName(), makePath(A)));
Method finalize = obs.getClass().getDeclaredMethod("finalize");
finalize.setAccessible(true);
finalize.invoke(obs);
finalize.invoke(obs);
finalize.invoke(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));
}
