Author: bpoussin Date: 2010-10-19 16:51:48 +0200 (Tue, 19 Oct 2010) New Revision: 426 Url: http://nuiton.org/repositories/revision/wikitty/426 Log: refactoring de la notification (event) - utilisation d'un seul thread - ajout de tests unitaires - suppression de 6 methodes redondantes - correction bug http://www.nuiton.org/issues/show/906 Added: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/notification/WikittyServiceNotificationTest.java Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/JGroupsNotifierTransporter.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceEvent.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceListener.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceNotifier.java trunk/wikitty-api/src/main/java/org/nuiton/wikitty/XMPPNotifierTransporter.java Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/JGroupsNotifierTransporter.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/JGroupsNotifierTransporter.java 2010-10-18 08:10:24 UTC (rev 425) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/JGroupsNotifierTransporter.java 2010-10-19 14:51:48 UTC (rev 426) @@ -138,29 +138,7 @@ if (message instanceof WikittyServiceEvent) { WikittyServiceEvent event = (WikittyServiceEvent)message; - - //source is transient, add it here : - event.setSource(ws); - event.setRemote(true); // received event became remote - - switch(event.type) { - case PUT_WIKITTY: - ws.firePutWikitty(event); break; - case REMOVE_WIKITTY: - ws.fireRemoveWikitty(event); break; - case CLEAR_WIKITTY: - ws.fireClearWikitty(event); break; - case PUT_EXTENSION: - ws.firePutExtension(event); break; - case REMOVE_EXTENSION: - ws.fireRemoveExtension(event); break; - case CLEAR_EXTENSION: - ws.fireClearExtension(event); break; - default: - if (log.isDebugEnabled()) { - log.debug("Not managed jgroup message " + event.type); - } - } + ws.processRemoteEvent(event); } } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceEvent.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceEvent.java 2010-10-18 08:10:24 UTC (rev 425) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceEvent.java 2010-10-19 14:51:48 UTC (rev 426) @@ -54,12 +54,18 @@ /** Message type (put, remove, clear...). */ static public enum WikittyEventType { - PUT_WIKITTY, - REMOVE_WIKITTY, - CLEAR_WIKITTY, - PUT_EXTENSION, - REMOVE_EXTENSION, - CLEAR_EXTENSION + PUT_WIKITTY(WikittyServiceListener.PUT_WIKITTY_METHOD), + REMOVE_WIKITTY(WikittyServiceListener.REMOVE_WIKITTY_METHOD), + CLEAR_WIKITTY(WikittyServiceListener.CLEAR_WIKITTY_METHOD), + PUT_EXTENSION(WikittyServiceListener.PUT_EXTENSION_METHOD), + REMOVE_EXTENSION(WikittyServiceListener.REMOVE_EXTENSION_METHOD), + CLEAR_EXTENSION(WikittyServiceListener.CLEAR_EXTENSION_METHOD); + + /** le nom de la methode du listener a appeler pour ce type d'event */ + public String listenerMethodName; + WikittyEventType(String listenerMethodName) { + this.listenerMethodName = listenerMethodName; + } } @@ -69,6 +75,9 @@ /** event type */ protected WikittyEventType type; + /** heure de creation de l'event */ + protected long time; + /** * Id managed by event. * @@ -97,10 +106,19 @@ */ public WikittyServiceEvent(Object source, WikittyEventType type) { super(source); + this.time = System.currentTimeMillis(); this.type = type; } /** + * Return time of event creation + * @return + */ + public long getTime() { + return time; + } + + /** * To allow set transient source after deserialisation. * * @param source source Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceListener.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceListener.java 2010-10-18 08:10:24 UTC (rev 425) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceListener.java 2010-10-19 14:51:48 UTC (rev 426) @@ -26,7 +26,8 @@ package org.nuiton.wikitty; /** - * TODO add comment here. + * Permet d'ajouter des listeners sur les methodes de modification de + * WikittyService. * * @author chatellier * @version $Revision$ @@ -36,6 +37,15 @@ */ public interface WikittyServiceListener { + // this constant must be up to date with real method name + // this is used during fire event + final static public String PUT_WIKITTY_METHOD = "putWikitty"; + final static public String REMOVE_WIKITTY_METHOD = "removeWikitty"; + final static public String CLEAR_WIKITTY_METHOD = "clearWikitty"; + final static public String PUT_EXTENSION_METHOD = "putExtension"; + final static public String REMOVE_EXTENSION_METHOD = "removeExtension"; + final static public String CLEAR_EXTENSION_METHOD = "clearExtension"; + public void putWikitty(WikittyServiceEvent event); public void removeWikitty(WikittyServiceEvent event); public void clearWikitty(WikittyServiceEvent event); @@ -44,4 +54,5 @@ public void putExtension(WikittyServiceEvent event); public void removeExtension(WikittyServiceEvent event); public void clearExtension(WikittyServiceEvent event); + } Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceNotifier.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceNotifier.java 2010-10-18 08:10:24 UTC (rev 425) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/WikittyServiceNotifier.java 2010-10-19 14:51:48 UTC (rev 426) @@ -28,11 +28,16 @@ import java.util.Collection; import java.util.HashMap; import java.util.HashSet; +import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Properties; import java.util.Set; +import java.util.SortedMap; +import java.util.TreeMap; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.TimeUnit; import org.apache.commons.beanutils.ConstructorUtils; import org.apache.commons.logging.Log; @@ -68,10 +73,18 @@ /** Wikitty service listener (only for remote event). */ protected ListenerSet<WikittyServiceListener> remoteWikittyServiceListeners; - /** JGroup notifier. */ + /** notifier */ protected WikittyServiceListener notifier; /** + * Tous les events en attentent d'etre envoyer aux listeners + */ + protected LinkedBlockingQueue<WikittyServiceEvent> eventToSend; + + /** thread utilise pour evoyer les events */ + protected EventThread eventThread; + + /** * Default constructor. * * @param ws delegate service @@ -95,6 +108,12 @@ localWikittyServiceListeners = new ListenerSet<WikittyServiceListener>(); remoteWikittyServiceListeners = new ListenerSet<WikittyServiceListener>(); + eventToSend = new LinkedBlockingQueue<WikittyServiceEvent>(); + + eventThread = new EventThread(eventToSend, + allWikittyServiceListeners, localWikittyServiceListeners, + remoteWikittyServiceListeners); + // can be null according to default constructor if (props != null) { notifier = new RemoteNotifier(this, props); @@ -105,9 +124,21 @@ public void addWikittyServiceListener(WikittyServiceListener listener, ServiceListenerType type) { // not delegated switch (type) { - case ALL : allWikittyServiceListeners.add(listener); break; - case LOCAL : localWikittyServiceListeners.add(listener); break; - case REMOTE : remoteWikittyServiceListeners.add(listener); break; + case ALL : + synchronized(allWikittyServiceListeners) { + allWikittyServiceListeners.add(listener); + } + break; + case LOCAL : + synchronized(localWikittyServiceListeners) { + localWikittyServiceListeners.add(listener); + } + break; + case REMOTE : + synchronized(remoteWikittyServiceListeners) { + remoteWikittyServiceListeners.add(listener); + } + break; } } @@ -115,9 +146,21 @@ public void removeWikittyServiceListener(WikittyServiceListener listener, ServiceListenerType type) { // not delegated switch (type) { - case ALL : allWikittyServiceListeners.remove(listener); break; - case LOCAL : localWikittyServiceListeners.remove(listener); break; - case REMOTE : remoteWikittyServiceListeners.remove(listener); break; + case ALL : + synchronized(allWikittyServiceListeners) { + allWikittyServiceListeners.remove(listener); + } + break; + case LOCAL : + synchronized (localWikittyServiceListeners) { + localWikittyServiceListeners.remove(listener); + } + break; + case REMOTE : + synchronized(remoteWikittyServiceListeners) { + remoteWikittyServiceListeners.remove(listener); + } + break; } } @@ -393,7 +436,7 @@ event.setIds(ids); event.setIdExtensions(idsExtension); event.setIdVersions(idsVersion); - firePutWikitty(event); + fireEvent(event); } /** @@ -412,7 +455,7 @@ } event.setIds(ids); - fireRemoveWikitty(event); + fireEvent(event); } /** @@ -421,7 +464,7 @@ protected void fireClearWikitty() { WikittyServiceEvent event = new WikittyServiceEvent(ws, WikittyServiceEvent.WikittyEventType.CLEAR_WIKITTY); - fireClearWikitty(event); + fireEvent(event); } /** @@ -450,7 +493,7 @@ event.setIds(ids); event.setIdExtensions(idsExtension); - firePutExtension(event); + fireEvent(event); } /** @@ -469,7 +512,7 @@ } event.setIds(ids); - fireRemoveExtension(event); + fireEvent(event); } /** @@ -480,206 +523,224 @@ protected void fireClearExtension() { WikittyServiceEvent event = new WikittyServiceEvent(ws, WikittyServiceEvent.WikittyEventType.CLEAR_EXTENSION); - fireClearExtension(event); + fireEvent(event); } /** * Fire event to all registred listener. - * + * * Take care about {@link WikittyServiceEvent#isRemote()} for fire. * * @param event event to fire */ - protected void firePutWikitty(final WikittyServiceEvent event) { + protected void fireEvent(final WikittyServiceEvent event) { // ajout d'un thread, car si les listener doit // ouvrir une transaction WikittyTransaction // alors que celui qui lance l'event en a une ouverte // cela cause une exception JTA - Thread eventThread = new Thread("wikitty-event-thread") { - @Override - public void run() { - for (WikittyServiceListener l : allWikittyServiceListeners) { - l.putWikitty(event); - } - if (event.isRemote()) { - for (WikittyServiceListener l : remoteWikittyServiceListeners) { - l.putWikitty(event); - } - } - else { - for (WikittyServiceListener l : localWikittyServiceListeners) { - l.putWikitty(event); - } - } + EventThread thread = getEventThread(); + + // si le thread de notification est en cours d'arret on leve une exception + if (thread.stopAsked()) { + throw new WikittyException( + "Event thread dispatcher is stopped, no more event can be send"); + } else { + eventToSend.offer(event); + + if (!thread.isAlive()) { + // on demarre le thread que lorsqu'il y a le premier event d'arrive + thread.start(); } - }; - eventThread.start(); + } } /** - * Fire event to all registred listener. - * - * Take care about {@link WikittyServiceEvent#isRemote()} for fire. - * - * @param event event to fire + * fire event passed in argument. Before fire, change source to current + * WikittyServiceNotifier and set remote event to true. */ - protected void fireRemoveWikitty(final WikittyServiceEvent event) { - // ajout d'un thread, car si les listener doit - // ouvrir une transaction WikittyTransaction - // alors que celui qui lance l'event en a une ouverte - // cela cause une exception JTA - Thread eventThread = new Thread("wikitty-event-thread") { - @Override - public void run() { - for (WikittyServiceListener l : allWikittyServiceListeners) { - l.removeWikitty(event); - } - if (event.isRemote()) { - for (WikittyServiceListener l : remoteWikittyServiceListeners) { - l.removeWikitty(event); - } - } - else { - for (WikittyServiceListener l : localWikittyServiceListeners) { - l.removeWikitty(event); - } - } - } - }; - eventThread.start(); + public void processRemoteEvent(WikittyServiceEvent event) { + //source is transient, add it here : + event.setSource(this); + event.setRemote(true); // received event became remote + fireEvent(event); } /** - * Fire event to all registred listener. - * - * Take care about {@link WikittyServiceEvent#isRemote()} for fire. + * Retourne le dernier thread utiliser pour envoyer les events. * - * @param event event to fire + * @return */ - protected void fireClearWikitty(final WikittyServiceEvent event) { - // ajout d'un thread, car si les listener doit - // ouvrir une transaction WikittyTransaction - // alors que celui qui lance l'event en a une ouverte - // cela cause une exception JTA - Thread eventThread = new Thread("wikitty-event-thread") { - @Override - public void run() { - for (WikittyServiceListener l : allWikittyServiceListeners) { - l.clearWikitty(event); - } - if (event.isRemote()) { - for (WikittyServiceListener l : remoteWikittyServiceListeners) { - l.clearWikitty(event); - } - } - else { - for (WikittyServiceListener l : localWikittyServiceListeners) { - l.clearWikitty(event); - } - } - } - }; - eventThread.start(); + public EventThread getEventThread() { + return eventThread; } + @Override + protected void finalize() throws Throwable { + getEventThread().askStop(); + super.finalize(); + } + /** - * Fire event to all registred listener. - * - * Take care about {@link WikittyServiceEvent#isRemote()} for fire. - * - * @param event event to fire + * Thread utilise pour envoyer les events. On rend accessible ce thread + * pour pouvoir y acceder depuis l'exterieur (pour l'instant pour les tests + * mais peut-etre plus tard du monitoring). Il permet a un thread d'attendre + * qu'un evenement leve a une certaine heure est bien ete dispatchee grace a + * la methode waitfor */ - protected void firePutExtension(final WikittyServiceEvent event) { - // ajout d'un thread, car si les listener doit - // ouvrir une transaction WikittyTransaction - // alors que celui qui lance l'event en a une ouverte - // cela cause une exception JTA - Thread eventThread = new Thread("wikitty-event-thread") { - @Override - public void run() { - for (WikittyServiceListener l : allWikittyServiceListeners) { - l.putExtension(event); + static public class EventThread extends Thread { + + protected boolean mustBeRunning = true; + + protected SortedMap<Long, Object> waiter = new TreeMap<Long, Object>(); + /** + * reference vers la collection qui contient les events a envoyer + */ + protected LinkedBlockingQueue<WikittyServiceEvent> eventToSend; + + /** Wikitty service listener (all event). */ + protected ListenerSet<WikittyServiceListener> allWikittyServiceListeners; + + /** Wikitty service listener (only for local event). */ + protected ListenerSet<WikittyServiceListener> localWikittyServiceListeners; + + /** Wikitty service listener (only for remote event). */ + protected ListenerSet<WikittyServiceListener> remoteWikittyServiceListeners; + + /** heure du dernier event envoye */ + protected long lastEventTime = 0; + + public EventThread(LinkedBlockingQueue<WikittyServiceEvent> eventToSend, + ListenerSet<WikittyServiceListener> allWikittyServiceListeners, + ListenerSet<WikittyServiceListener> localWikittyServiceListeners, + ListenerSet<WikittyServiceListener> remoteWikittyServiceListeners) { + super("wikitty-event-thread"); + this.eventToSend = eventToSend; + this.allWikittyServiceListeners = allWikittyServiceListeners; + this.localWikittyServiceListeners = localWikittyServiceListeners; + this.remoteWikittyServiceListeners = remoteWikittyServiceListeners; + } + + /** + * demande l'arret du thread, ne doit être appeler que par le finalize + * du WikittyServiceNotifier + */ + protected void askStop() { + this.mustBeRunning = false; + } + + /** + * retourne vrai si on a demande l'arret du thread + * @return + */ + public boolean stopAsked() { + return !mustBeRunning; + } + + /** + * thread that want wait for particulare event to be processed, can be + * call this method with event time in argument. + */ + public void waitFor(long eventTime) throws InterruptedException { + if (eventTime <= lastEventTime) { + // le thread demande a attendre un event deja passe + // on le met donc pas en attente + return; + } + Object mutex = null; + synchronized (waiter) { + mutex = waiter.get(eventTime); + if (mutex == null) { + mutex = new Object(); + waiter.put(eventTime, mutex); } - if (event.isRemote()) { - for (WikittyServiceListener l : remoteWikittyServiceListeners) { - l.putExtension(event); - } - } - else { - for (WikittyServiceListener l : localWikittyServiceListeners) { - l.putExtension(event); - } - } } - }; - eventThread.start(); - } + synchronized(mutex) { + mutex.wait(); + } + } - /** - * Fire event to all registred listener. - * - * Take care about {@link WikittyServiceEvent#isRemote()} for fire. - * - * @param event event to fire - */ - protected void fireRemoveExtension(final WikittyServiceEvent event) { - // ajout d'un thread, car si les listener doit - // ouvrir une transaction WikittyTransaction - // alors que celui qui lance l'event en a une ouverte - // cela cause une exception JTA - Thread eventThread = new Thread("wikitty-event-thread") { - @Override - public void run() { - for (WikittyServiceListener l : allWikittyServiceListeners) { - l.removeExtension(event); - } - if (event.isRemote()) { - for (WikittyServiceListener l : remoteWikittyServiceListeners) { - l.removeExtension(event); + @Override + public void run() { + while(mustBeRunning) { + processEventQueue(); + } + // le thread est arrete, force l'envoi de tous les events pour + // liberer correctement tous les threads en attente + // plus aucun event ne doit etre accepte dans la queue (voir method fireEvent) + processEventQueue(); + } + + protected void processEventQueue() { + try { + WikittyServiceEvent event; + // on attend pas indefiniment un event, car il faut verifier + // aussi que personne n'a arrete le thread + while (null != (event = eventToSend.poll(5, TimeUnit.SECONDS))) { + try { + synchronized (allWikittyServiceListeners) { + allWikittyServiceListeners.fire( + event.getType().listenerMethodName, event); + } + } catch (Exception eee) { + log.error("Can't notify listener", eee); } - } - else { - for (WikittyServiceListener l : localWikittyServiceListeners) { - l.removeExtension(event); + try { + if (event.isRemote()) { + synchronized (remoteWikittyServiceListeners) { + remoteWikittyServiceListeners.fire( + event.getType().listenerMethodName, event); + } + } else { + synchronized (localWikittyServiceListeners) { + localWikittyServiceListeners.fire( + event.getType().listenerMethodName, event); + } + } + } catch (Exception eee) { + log.error("Can't notify listener", eee); } - } - } - }; - eventThread.start(); - } + synchronized (waiter) { + // on previent les threads en attente si besoin - /** - * Fire event to all registred listener. - * - * Take care about {@link WikittyServiceEvent#isRemote()} for fire. - * - * @param event event to fire - */ - protected void fireClearExtension(final WikittyServiceEvent event) { - // ajout d'un thread, car si les listener doit - // ouvrir une transaction WikittyTransaction - // alors que celui qui lance l'event en a une ouverte - // cela cause une exception JTA - Thread eventThread = new Thread("wikitty-event-thread") { - @Override - public void run() { - for (WikittyServiceListener l : allWikittyServiceListeners) { - l.clearExtension(event); - } - if (event.isRemote()) { - for (WikittyServiceListener l : remoteWikittyServiceListeners) { - l.clearExtension(event); + // dans un premier temps on ne recupere que ceux + // inferieur a event.getTime() + SortedMap<Long, Object> subwaiter = + waiter.headMap(event.getTime()); + for (Iterator<Map.Entry<Long, Object>> i = subwaiter.entrySet().iterator(); i.hasNext();) { + Object mutex = i.next().getValue(); + i.remove(); + synchronized (mutex) { + mutex.notifyAll(); + } + } + // dans un second temps on verifie si le suivant ne + // serait pas egal a event.getTime() + if (!waiter.isEmpty()) { + Long time = waiter.firstKey(); + // il pourrait y avoir plusieurs event avec la meme heure + // il faut bien tous les liberer + while (time.equals(event.getTime())) { + // il est bien egal on l'enleve aussi + Object mutex = waiter.remove(time); + synchronized (mutex) { + mutex.notifyAll(); + } + + if (!waiter.isEmpty()) { + time = waiter.firstKey(); + } else { + break; + } + } + } } + lastEventTime = event.getTime(); } - else { - for (WikittyServiceListener l : localWikittyServiceListeners) { - l.clearExtension(event); - } - } + } catch (InterruptedException eee) { + log.error("Notification thread error", eee); } - }; - eventThread.start(); - } + } + }; /** * This interface must be implemented to send and received remote message. Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/XMPPNotifierTransporter.java =================================================================== --- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/XMPPNotifierTransporter.java 2010-10-18 08:10:24 UTC (rev 425) +++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/XMPPNotifierTransporter.java 2010-10-19 14:51:48 UTC (rev 426) @@ -167,46 +167,12 @@ } if (event instanceof WikittyServiceEvent) { - processEvent((WikittyServiceEvent)event); + ws.processRemoteEvent((WikittyServiceEvent)event); } } } /** - * Process event - */ - protected void processEvent(WikittyServiceEvent event) { - //source is transient, add it here : - event.setSource(ws); - event.setRemote(true); // received event became remote - - switch (event.getType()) { - case PUT_WIKITTY: - ws.firePutWikitty(event); - break; - case REMOVE_WIKITTY: - ws.fireRemoveWikitty(event); - break; - case CLEAR_WIKITTY: - ws.fireClearWikitty(event); - break; - case PUT_EXTENSION: - ws.firePutExtension(event); - break; - case REMOVE_EXTENSION: - ws.fireRemoveExtension(event); - break; - case CLEAR_EXTENSION: - ws.fireClearExtension(event); - break; - default: - if (log.isDebugEnabled()) { - log.debug("Not managed xmpp message " + event.type); - } - } - } - - /** * Recherche le meilleur nom a utiliser comme pseudo pour cette machine. * Un UUID est toujours ajouter en debut, pour potentiellement lancer * plusieurs application en meme temps sur la meme machine et etre sur que Added: trunk/wikitty-api/src/test/java/org/nuiton/wikitty/notification/WikittyServiceNotificationTest.java =================================================================== --- trunk/wikitty-api/src/test/java/org/nuiton/wikitty/notification/WikittyServiceNotificationTest.java (rev 0) +++ trunk/wikitty-api/src/test/java/org/nuiton/wikitty/notification/WikittyServiceNotificationTest.java 2010-10-19 14:51:48 UTC (rev 426) @@ -0,0 +1,195 @@ +package org.nuiton.wikitty.notification; + + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.junit.Assert; +import org.junit.Test; +import org.nuiton.wikitty.WikittyService.ServiceListenerType; +import org.nuiton.wikitty.WikittyServiceEvent; +import org.nuiton.wikitty.WikittyServiceListener; +import org.nuiton.wikitty.WikittyServiceNotifier; + +/** + * Test si la notification par event fonctionne bien (les bons types d'event + * sont envoyer et recu + * + * @author poussin + * @version $Revision$ + * + * Last update: $Date$ + * by : $Author$ + */ +public class WikittyServiceNotificationTest { + + /** to use log facility, just put in your code: log.info(\"...\"); */ + static private Log log = LogFactory.getLog(WikittyServiceNotificationTest.class); + + protected WikittyServiceEvent.WikittyEventType lastEvent = null; + protected int nbEvent = 0; + + /** + * Test si les events sont bien lever et bien recu + * @throws Exception + */ + @Test + public void testEvent() throws Exception { + WikittyServiceNotifier wsn = new WikittyServiceNotifier(null); + Listener l = new Listener(); + + // test d'envoi et de bonne reception + wsn.addWikittyServiceListener(l, ServiceListenerType.ALL); + sendEvent(wsn, true); + + // si on enleve le listener, plus aucun event ne doit arriver + wsn.removeWikittyServiceListener(l, ServiceListenerType.ALL); + sendEvent(wsn, false); + + // donc au total seulement 6 events on du etre envoye + Assert.assertEquals(6, nbEvent); + + } + + /** + * Envoi tous les events possible. Permet de tester la methode process et + * la method fireEvent de WikittyServiceNotifier vu que la premiere + * appelle la deuxieme + * + * @param wsn + */ + protected void sendEvent(WikittyServiceNotifier wsn, boolean hasListener) throws Exception { + { + WikittyServiceEvent event = new WikittyServiceEvent("test", + WikittyServiceEvent.WikittyEventType.PUT_WIKITTY); + wsn.processRemoteEvent(event); + wsn.getEventThread().waitFor(event.getTime()); + if (hasListener) { + Assert.assertEquals(WikittyServiceEvent.WikittyEventType.PUT_WIKITTY, + lastEvent); + } else { + Assert.assertEquals(null, lastEvent); + } + lastEvent = null; + } + { + WikittyServiceEvent event = new WikittyServiceEvent("test", + WikittyServiceEvent.WikittyEventType.REMOVE_WIKITTY); + wsn.processRemoteEvent(event); + wsn.getEventThread().waitFor(event.getTime()); + if (hasListener) { + Assert.assertEquals(WikittyServiceEvent.WikittyEventType.REMOVE_WIKITTY, + lastEvent); + } else { + Assert.assertEquals(null, lastEvent); + } + lastEvent = null; + } + { + WikittyServiceEvent event = new WikittyServiceEvent("test", + WikittyServiceEvent.WikittyEventType.CLEAR_WIKITTY); + wsn.processRemoteEvent(event); + wsn.getEventThread().waitFor(event.getTime()); + if (hasListener) { + Assert.assertEquals(WikittyServiceEvent.WikittyEventType.CLEAR_WIKITTY, + lastEvent); + } else { + Assert.assertEquals(null, lastEvent); + } + lastEvent = null; + } + { + WikittyServiceEvent event = new WikittyServiceEvent("test", + WikittyServiceEvent.WikittyEventType.PUT_EXTENSION); + wsn.processRemoteEvent(event); + wsn.getEventThread().waitFor(event.getTime()); + if (hasListener) { + Assert.assertEquals(WikittyServiceEvent.WikittyEventType.PUT_EXTENSION, + lastEvent); + } else { + Assert.assertEquals(null, lastEvent); + } + lastEvent = null; + } + { + WikittyServiceEvent event = new WikittyServiceEvent("test", + WikittyServiceEvent.WikittyEventType.REMOVE_EXTENSION); + wsn.processRemoteEvent(event); + wsn.getEventThread().waitFor(event.getTime()); + if (hasListener) { + Assert.assertEquals(WikittyServiceEvent.WikittyEventType.REMOVE_EXTENSION, + lastEvent); + } else { + Assert.assertEquals(null, lastEvent); + } + lastEvent = null; + } + { + WikittyServiceEvent event = new WikittyServiceEvent("test", + WikittyServiceEvent.WikittyEventType.CLEAR_EXTENSION); + wsn.processRemoteEvent(event); + wsn.getEventThread().waitFor(event.getTime()); + if (hasListener) { + Assert.assertEquals(WikittyServiceEvent.WikittyEventType.CLEAR_EXTENSION, + lastEvent); + } else { + Assert.assertEquals(null, lastEvent); + } + lastEvent = null; + } + } + + /** + * Class listener des events, check la bonne reception + */ + class Listener implements WikittyServiceListener { + + @Override + public void putWikitty(WikittyServiceEvent event) { + nbEvent++; + Assert.assertEquals(WikittyServiceEvent.WikittyEventType.PUT_WIKITTY, + event.getType()); + lastEvent = event.getType(); + } + + @Override + public void removeWikitty(WikittyServiceEvent event) { + nbEvent++; + Assert.assertEquals(WikittyServiceEvent.WikittyEventType.REMOVE_WIKITTY, + event.getType()); + lastEvent = event.getType(); + } + + @Override + public void clearWikitty(WikittyServiceEvent event) { + nbEvent++; + Assert.assertEquals(WikittyServiceEvent.WikittyEventType.CLEAR_WIKITTY, + event.getType()); + lastEvent = event.getType(); + } + + @Override + public void putExtension(WikittyServiceEvent event) { + nbEvent++; + Assert.assertEquals(WikittyServiceEvent.WikittyEventType.PUT_EXTENSION, + event.getType()); + lastEvent = event.getType(); + } + + @Override + public void removeExtension(WikittyServiceEvent event) { + nbEvent++; + Assert.assertEquals(WikittyServiceEvent.WikittyEventType.REMOVE_EXTENSION, + event.getType()); + lastEvent = event.getType(); + } + + @Override + public void clearExtension(WikittyServiceEvent event) { + nbEvent++; + Assert.assertEquals(WikittyServiceEvent.WikittyEventType.CLEAR_EXTENSION, + event.getType()); + lastEvent = event.getType(); + } + + } +}
participants (1)
-
bpoussin＠users.nuiton.org