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)); }