subscription manager tests

src/main/java/net/engio/mbassy/common/ReflectionUtils.java

@@ -1,9 +1,7 @@
 package net.engio.mbassy.common;
 
 import java.lang.reflect.Method;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
+import java.util.*;
 
 /**
  * @author bennidi
@@ -50,27 +48,18 @@ public class ReflectionUtils {
         return null;
     }
 
-    public static List<Method> withoutOverridenSuperclassMethods(final List<Method> allMethods) {
-        List<Method> filtered = new LinkedList<Method>();
-        for (Method method : allMethods) {
-            if (!containsOverridingMethod(allMethods, method)) {
-                filtered.add(method);
-            }
-        }
-        return filtered;
-    }
-
-    public static Collection<Class> getSuperclasses(Class from) {
-        Collection<Class> superclasses = new LinkedList<Class>();
+    public static Set<Class> getSuperclasses(Class from) {
+        Set<Class> superclasses = new HashSet<Class>();
+        collectInterfaces(from, superclasses);
         while (!from.equals(Object.class) && !from.isInterface()) {
             superclasses.add(from.getSuperclass());
-            collectInterfaces(from, superclasses);
+
             from = from.getSuperclass();
         }
         return superclasses;
     }
 
-    public static void collectInterfaces(Class from, Collection<Class> accumulator){
+    public static void collectInterfaces(Class from, Set<Class> accumulator){
         for(Class intface : from.getInterfaces()){
             accumulator.add(intface);
             collectInterfaces(intface, accumulator);

src/main/java/net/engio/mbassy/listener/MessageHandlerMetadata.java

@@ -63,7 +63,7 @@ public class MessageHandlerMetadata {
         return listenerConfig.useStrongReferences();
     }
 
-    public boolean isFromListener(Object listener){
+    public boolean isFromListener(Class listener){
         return listenerConfig.isFromListener(listener);
     }
 

src/main/java/net/engio/mbassy/listener/MessageListenerMetadata.java

@@ -38,8 +38,8 @@ public class MessageListenerMetadata<T> {
     }
 
 
-    public boolean isFromListener(Object listener){
-        return listenerDefinition.equals(listener.getClass());
+    public boolean isFromListener(Class listener){
+        return listenerDefinition.equals(listener);
     }
 
     public boolean useStrongReferences(){

src/main/java/net/engio/mbassy/subscription/Subscription.java

@@ -27,7 +27,7 @@ public class Subscription {
         this.listeners = listeners;
     }
 
-    public boolean isFromListener(Object listener){
+    public boolean isFromListener(Class listener){
         return context.getHandlerMetadata().isFromListener(listener);
     }
 

src/test/java/net/engio/mbassy/SubscriptionManagerTest.java

@@ -1,6 +1,7 @@
 package net.engio.mbassy;
 
 import net.engio.mbassy.common.ConcurrentExecutor;
+import net.engio.mbassy.common.IPredicate;
 import net.engio.mbassy.common.UnitTest;
 import net.engio.mbassy.listener.Handler;
 import net.engio.mbassy.listener.MetadataReader;
@@ -11,10 +12,7 @@ import net.engio.mbassy.subscription.SubscriptionFactory;
 import net.engio.mbassy.subscription.SubscriptionManager;
 import org.junit.Test;
 
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
@@ -25,6 +23,7 @@ import java.util.concurrent.ConcurrentHashMap;
  */
 public class SubscriptionManagerTest extends UnitTest{
 
+
     @Test
     public void testSimpleSynchronousHandler(){
         final SubscriptionManager subMan = new SubscriptionManager(new MetadataReader(), new SubscriptionFactory());
@@ -72,6 +71,86 @@ public class SubscriptionManagerTest extends UnitTest{
     }
 
 
+    class SubscriptionValidator{
+
+
+        private List<Entry> validations = new LinkedList<Entry>();
+        private Set<Class> messageTypes = new HashSet<Class>();
+        private Set<Class> subsribers = new HashSet<Class>();
+
+
+        public SubscriptionValidator expect(int numberOfSubscriber, Class subscriber, Class messageType){
+            validations.add(new Entry(messageType, numberOfSubscriber, subscriber));
+            messageTypes.add(messageType);
+            subsribers.add(subscriber);
+            return this;
+        }
+
+        public void validate(SubscriptionManager manager){
+            for(Class messageType : messageTypes){
+                Collection<Subscription> subscriptions = manager.getSubscriptionsByMessageType(messageType);
+                Collection<Entry> validationEntries = getEntries(EntriesByMessageType(messageType));
+                assertEquals(subscriptions.size(), validationEntries.size());
+                for(Entry validationEntry : validationEntries){
+                    Subscription matchingSub = null;
+                    for(Subscription sub : subscriptions){
+                        if(sub.isFromListener(validationEntry.subscriber));
+                    }
+                }
+            }
+
+
+        }
+
+
+        private Collection<Entry> getEntries(IPredicate<Entry> filter){
+            Collection<Entry> matching = new LinkedList<Entry>();
+            for (Entry validationEntry : validations){
+                if(filter.apply(validationEntry))matching.add(validationEntry);
+            }
+            return matching;
+        }
+
+        private IPredicate<Entry> EntriesByMessageType(final Class messageType){
+            return new IPredicate<Entry>() {
+                @Override
+                public boolean apply(Entry target) {
+                    return target.messageType.equals(messageType);
+                }
+            };
+        }
+
+        private IPredicate<Entry> EntriesBySubscriberType(final Class subscriberType){
+            return new IPredicate<Entry>() {
+                @Override
+                public boolean apply(Entry target) {
+                    return target.subscriber.equals(subscriberType);
+                }
+            };
+        }
+
+
+
+        private class Entry{
+
+            private int numberOfSubscribers;
+
+            private Class subscriber;
+
+            private Class messageType;
+
+            private Entry(Class messageType, int numberOfSubscribers, Class subscriber) {
+                this.messageType = messageType;
+                this.numberOfSubscribers = numberOfSubscribers;
+                this.subscriber = subscriber;
+            }
+
+
+        }
+
+    }
+
+
     static class SimpleSynchronousMessageHandler{
 
         @Handler