FsMQManager, separate class FsMQIdentities, tests... oh boy

test/java/foundation/pEp/jniadapter/test/utils/transport/fsmqmanager/FsMQIdentities.java

@@ -0,0 +1,175 @@
+package foundation.pEp.jniadapter.test.utils.transport.fsmqmanager;
+
+import foundation.pEp.jniadapter.test.utils.transport.fsmsgqueue.FsMsgQueue;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class FsMQIdentities {
+    public FsMQIdentity self = null;
+    private List<FsMQIdentity> identities = new ArrayList<>();
+    private Map<String, FsMsgQueue> identityAddressQueues = new HashMap<String, FsMsgQueue>();
+
+    public FsMQIdentities(FsMQIdentity self) throws NullPointerException {
+        if (self != null) {
+            this.self = self;
+            addOrUpdate(self);
+        } else {
+            throw new NullPointerException("self cant be null");
+        }
+    }
+
+    // Identity address must be unique
+    // Returns
+    // - true for added
+    // - false for updated or own ident (which cant be updated)
+    public boolean addOrUpdate(FsMQIdentity ident) throws NullPointerException {
+        boolean ret = false;
+        if (ident != null) {
+            if (addIdent(ident)) {
+                // Good, add new ident
+                ret = true;
+            } else {
+                // Ok, update ident
+                update(ident);
+                ret = false;
+            }
+        } else {
+            throw new NullPointerException("ident cant be null");
+        }
+        return ret;
+    }
+
+    // cant update own identity
+    // True - Success
+    // False - ident not existing or own identity
+    public boolean update(FsMQIdentity ident) throws NullPointerException {
+        boolean ret = false;
+        if (ident != null) {
+            if (!isSelf(ident.getAddress()) && exists(ident.getAddress())) {
+                remove(ident.getAddress());
+                addIdent(ident);
+                ret = true;
+            }
+        } else {
+            throw new NullPointerException("ident cant be null");
+        }
+        return ret;
+    }
+
+    // Removes the identity from identities and identityQueues by address
+    public boolean remove(String address) throws NullPointerException {
+        boolean ret = false;
+        if (address != null) {
+            if (exists(address) && !isSelf(address)) {
+                identities.removeIf(i -> i.getAddress().equals(address));
+                identityAddressQueues.entrySet().removeIf(iq -> iq.getKey().equals(address));
+                ret = true;
+            }
+        } else {
+            throw new NullPointerException("address cant be null");
+        }
+        return ret;
+    }
+
+    // cant fail haha
+    public void removeAll() {
+        for (FsMQIdentity i : getAll()) {
+            remove(i.getAddress());
+        }
+    }
+
+    // Returns number of identities added
+    public int addAll(List<FsMQIdentity> idents) throws NullPointerException {
+        int ret = 0;
+        if (idents != null) {
+            for (FsMQIdentity i : idents) {
+                if (addOrUpdate(i)) {
+                    ret++;
+                }
+            }
+        } else {
+            throw new NullPointerException("idents cant be null");
+        }
+        return ret;
+    }
+
+    public boolean isSelf(String address) throws NullPointerException {
+        boolean ret = false;
+        if (address != null) {
+            ret = self.getAddress() == address;
+        } else {
+            throw new NullPointerException("address cant be null");
+        }
+        return ret;
+    }
+
+    // True if existing
+    // False if not
+    // Exception on not unique
+    public boolean exists(String address) throws IllegalStateException, NullPointerException{
+        boolean ret = false;
+        if (address != null) {
+            List<FsMQIdentity> matches = identities.stream().filter(i -> i.getAddress().equals(address)).collect(Collectors.toList());
+            if (matches.size() > 1) {
+                throw new IllegalStateException("Internal Error: Identity address not unique: " + address);
+            }
+            if (matches.size() == 1) {
+                ret = true;
+            }
+        } else {
+            throw new NullPointerException("address cant be null");
+        }
+        return ret;
+    }
+
+    // Returns null if not existing
+    public FsMQIdentity getByAddress(String address) {
+        FsMQIdentity ret = null;
+        if (exists(address)) {
+            ret  = identities.stream().filter(i -> i.getAddress().equals(address)).collect(Collectors.toList()).get(0);
+        }
+        return ret;
+    }
+
+    public List<FsMQIdentity> getAll() {
+        return new ArrayList<FsMQIdentity>(identities);
+    }
+
+    public List<String> getAddresses() {
+        List<String> ret = new ArrayList<>();
+        for (FsMQIdentity i : identities) {
+            ret.add(i.getAddress());
+        }
+        return ret;
+    }
+
+    // True  - success
+    // False - already existing
+    private boolean addIdent(FsMQIdentity ident) {
+        boolean ret = false;
+        if (!exists(ident.getAddress())) {
+            identities.add(ident);
+            createQueueForIdent(ident);
+            ret = true;
+        }
+        return ret;
+    }
+
+    private void createQueueForIdent(FsMQIdentity ident) {
+        FsMsgQueue q = new FsMsgQueue(ident.getqDir());
+        identityAddressQueues.put(ident.getAddress(), q);
+    }
+
+    public FsMsgQueue getQueueForIdentity(String address) throws UnknownIdentityException {
+        FsMsgQueue ret = null;
+        ret = identityAddressQueues.get(address);
+        if (ret == null) {
+            throw new UnknownIdentityException("Unknown identity address: " + address);
+        }
+        return ret;
+    }
+
+}

test/java/foundation/pEp/jniadapter/test/utils/transport/fsmqmanager/FsMQIdentity.java

@@ -1,5 +1,7 @@
 package foundation.pEp.jniadapter.test.utils.transport.fsmqmanager;
 
+import java.util.Objects;
+
 public class FsMQIdentity implements java.io.Serializable {
     private String address = null;
     private String qDir = null;
@@ -34,4 +36,17 @@ public class FsMQIdentity implements java.io.Serializable {
         ret += "qDir   : '" + qDir + "'";
         return  ret;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        FsMQIdentity that = (FsMQIdentity) o;
+        return address.equals(that.address);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(address);
+    }
 }

test/java/foundation/pEp/jniadapter/test/utils/transport/fsmqmanager/FsMQManager.java

@@ -6,185 +6,26 @@ import foundation.pEp.jniadapter.test.utils.transport.fsmsgqueue.FsMsgQueue;
 import java.io.*;
 import java.util.*;
 import java.util.concurrent.TimeoutException;
-import java.util.stream.Collectors;
 
 import static foundation.pEp.jniadapter.test.framework.TestLogger.log;
 
 public class FsMQManager {
-    private FsMQIdentity self = null;
+    public FsMQIdentities identities = null;
-    private List<FsMQIdentity> identities = new ArrayList<>();
-    private Map<String, FsMsgQueue> identityAddressQueues = new HashMap<String, FsMsgQueue>();
 
-    public FsMQManager(FsMQIdentity self) throws NullPointerException {
+    public FsMQManager(FsMQIdentity self) {
-        if (self != null) {
+        identities = new FsMQIdentities(self);
-            this.self = self;
-            addOrUpdateIdentity(self);
-        } else {
-            throw new NullPointerException("self cant be null");
-        }
-    }
-
-    // Identity address must be unique
-    // Returns
-    // - true for added
-    // - false for updated or own ident (which cant be updated)
-    public boolean addOrUpdateIdentity(FsMQIdentity ident) throws NullPointerException {
-        boolean ret = false;
-        if (ident != null) {
-            if (addIdent(ident)) {
-                // Good, add new ident
-                ret = true;
-            } else {
-                // Ok, update ident
-                updateIdentity(ident);
-                ret = false;
-            }
-        } else {
-            throw new NullPointerException("ident cant be null");
-        }
-        return ret;
-    }
-
-    // cant update own identity
-    // True - Success
-    // False - ident not existing or own identity
-    public boolean updateIdentity(FsMQIdentity ident) throws NullPointerException {
-        boolean ret = false;
-        if (ident != null) {
-            if (!isOwnIdentity(ident.getAddress()) && identityExists(ident.getAddress())) {
-                removeIdentity(ident.getAddress());
-                addIdent(ident);
-                ret = true;
-            }
-        } else {
-            throw new NullPointerException("ident cant be null");
-        }
-        return ret;
-    }
-
-    // Removes the identity from identities and identityQueues by address
-    public boolean removeIdentity(String address) throws NullPointerException {
-        boolean ret = false;
-        if (address != null) {
-            if (identityExists(address) && !isOwnIdentity(address)) {
-                identities.removeIf(i -> i.getAddress().equals(address));
-                identityAddressQueues.entrySet().removeIf(iq -> iq.getKey().equals(address));
-                ret = true;
-            }
-        } else {
-            throw new NullPointerException("address cant be null");
-        }
-        return ret;
-    }
-
-    // cant fail haha
-    public void removeAllIdentities() {
-        for (FsMQIdentity i : getIdentities()) {
-            removeIdentity(i.getAddress());
-        }
-    }
-
-    // Returns number of identities added
-    public int addIdentities(List<FsMQIdentity> idents) throws NullPointerException {
-        int ret = 0;
-        if (idents != null) {
-            for (FsMQIdentity i : idents) {
-                if (addOrUpdateIdentity(i)) {
-                    ret++;
-                }
-            }
-        } else {
-            throw new NullPointerException("idents cant be null");
-        }
-        return ret;
-    }
-
-    public boolean isOwnIdentity(String address) throws NullPointerException {
-        boolean ret = false;
-        if (address != null) {
-            ret = self.getAddress() == address;
-        } else {
-            throw new NullPointerException("address cant be null");
-        }
-        return ret;
-    }
-
-    // True if existing
-    // False if not
-    // Exception on not unique
-    public boolean identityExists(String address) throws IllegalStateException, NullPointerException{
-        boolean ret = false;
-        if (address != null) {
-            List<FsMQIdentity> matches = identities.stream().filter(i -> i.getAddress().equals(address)).collect(Collectors.toList());
-            if (matches.size() > 1) {
-                throw new IllegalStateException("Internal Error: Identity address not unique: " + address);
-            }
-            if (matches.size() == 1) {
-                ret = true;
-            }
-        } else {
-            throw new NullPointerException("address cant be null");
-        }
-        return ret;
-    }
-
-    // Returns null if not existing
-    public FsMQIdentity getIdentityForAddress(String address) {
-        FsMQIdentity ret = null;
-        if (identityExists(address)) {
-            ret  = identities.stream().filter(i -> i.getAddress().equals(address)).collect(Collectors.toList()).get(0);
-        }
-        return ret;
-    }
-
-    public List<FsMQIdentity> getIdentities() {
-        return new ArrayList<FsMQIdentity>(identities);
-    }
-
-    public List<String> getIdentityAddresses() {
-        List<String> ret = new ArrayList<>();
-        for (FsMQIdentity i : identities) {
-            ret.add(i.getAddress());
-        }
-        return ret;
-    }
-
-    // True  - success
-    // False - already existing
-    private boolean addIdent(FsMQIdentity ident) {
-        boolean ret = false;
-        if (!identityExists(ident.getAddress())) {
-            identities.add(ident);
-            createQueueForIdent(ident);
-            ret = true;
-        }
-        return ret;
-    }
-
-    private void createQueueForIdent(FsMQIdentity ident) {
-        FsMsgQueue q = new FsMsgQueue(ident.getqDir());
-        identityAddressQueues.put(ident.getAddress(), q);
-    }
-
-    private FsMsgQueue getQueueForIdentity(String address) throws UnknownIdentityException {
-        FsMsgQueue ret = null;
-        ret = identityAddressQueues.get(address);
-        if (ret == null) {
-            throw new UnknownIdentityException("Unknown identity address: " + address);
-        }
-        return ret;
     }
 
     public void clearOwnQueue() {
-        getQueueForIdentity(self.getAddress()).clear();
+        identities.getQueueForIdentity(identities.self.getAddress()).clear();
     }
 
     public void sendMessage(String address, String msg) throws UnknownIdentityException, IOException, NullPointerException {
         if (address != null) {
             if (msg != null) {
-                FsMQMessageInternal mqMsg = new FsMQMessageInternal(self, msg);
+                FsMQMessageInternal mqMsg = new FsMQMessageInternal(identities.self, msg);
                 String serializedStr = mqMsg.serialize();
-                getQueueForIdentity(address).add(serializedStr);
+                identities.getQueueForIdentity(address).add(serializedStr);
             } else {
                 throw new NullPointerException("msg cant be null");
             }
@@ -195,15 +36,15 @@ public class FsMQManager {
 
     // Non blocking read
     // Returns null if no messages available
-    public FsMQMessage receiveMessage() throws IOException, ClassNotFoundException, TimeoutException {
+    public FsMQMessage receiveMessage() throws IOException, ClassNotFoundException {
         return receiveMessage(0);
     }
 
     // Blocking read
     // Returns null if no messages available
-    public FsMQMessage receiveMessage(int timeoutSec) throws IOException, ClassNotFoundException, TimeoutException {
+    public FsMQMessage receiveMessage(int timeoutSec) throws IOException, ClassNotFoundException {
         FsMQMessage ret = null;
-        FsMsgQueue onwQueue = getQueueForIdentity(self.getAddress());
+        FsMsgQueue onwQueue = identities.getQueueForIdentity(identities.self.getAddress());
         FsMQMessageInternal mqMsg = null;
         int pollInterval = 100;
         int pollRepeats = timeoutSec * 1000 / pollInterval;

test/java/foundation/pEp/jniadapter/test/utils/transport/fsmqmanager/test/Makefile.conf

@@ -5,6 +5,7 @@ JAVA=java -enableassertions
 
 JAVA_CLASSES_FSMSGQUEUE= \
  	../../FsMQManager.class \
+ 	../../FsMQIdentities.class \
  	../../FsMQIdentity.class \
  	../../FsMQMessage.class \
  	../../UnknownIdentityException.class \

test/java/foundation/pEp/jniadapter/test/utils/transport/fsmqmanager/test/ctx/FsMQManagerBaseTestContext.java

@@ -4,23 +4,20 @@ import foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.*;
 import foundation.pEp.jniadapter.test.framework.*;
 import foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.test.utils.FsMQManagerTestUtils;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
 
 public class FsMQManagerBaseTestContext extends AbstractTestContext {
     private String qDirBase = "../resources/fsmsgqueue-test/";
     public String address = null;
     public FsMQIdentity self = null;
     private List<String> peerNames = null;
-    public Map<String, FsMQIdentity> peerMap = null;
+    protected Map<String, FsMQIdentity> peerMap = null;
-    public List<FsMQIdentity> peerList = null;
+    protected List<FsMQIdentity> peerList = null;
 
     private int MSG_COUNT = 10;
     private List<String> messages;
 
+
     public FsMQManagerBaseTestContext(String selfAddress) {
         address = selfAddress;
     }
@@ -32,6 +29,7 @@ public class FsMQManagerBaseTestContext extends AbstractTestContext {
         peerNames.add("Bob");
         peerNames.add("Carol");
         createPeerMapAndPeerList();
+        defineSelfAndUpdatePeers();
         messages = FsMQManagerTestUtils.createTestMessages(self.getAddress(), MSG_COUNT);
     }
 
@@ -39,7 +37,7 @@ public class FsMQManagerBaseTestContext extends AbstractTestContext {
         peerMap = new HashMap<>();
         peerList = new ArrayList<>();
         for (String addr : peerNames) {
-            FsMQIdentity ident = new FsMQIdentity(addr, getOwnQDir());
+            FsMQIdentity ident = new FsMQIdentity(addr, getQDirForAddress(addr));
             peerMap.put(addr, ident);
             peerList.add(ident);
         }
@@ -54,11 +52,10 @@ public class FsMQManagerBaseTestContext extends AbstractTestContext {
         peerList.removeIf(p -> p.getAddress().equals(self.getAddress()));
     }
 
-    private String getOwnQDir() {
+    private String getQDirForAddress(String addr) {
-        return qDirBase + "/" + address;
+        return qDirBase + "/" + addr;
     }
 
-
     public List<String> getMessages() {
         return messages;
     }

test/java/foundation/pEp/jniadapter/test/utils/transport/fsmqmanager/test/ctx/FsMQManagerTestContext.java

@@ -0,0 +1,19 @@
+package foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.test.ctx;
+
+import foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.FsMQManager;
+
+public class FsMQManagerTestContext extends FsMQManagerBaseTestContext {
+    public FsMQManager qm;
+
+    public FsMQManagerTestContext(String selfAddress) {
+        super(selfAddress);
+    }
+
+    @Override
+    public void init() throws Throwable {
+        super.init();
+        qm = new FsMQManager(self);
+        qm.identities.addAll(peerList);
+    }
+
+}

test/java/foundation/pEp/jniadapter/test/utils/transport/fsmqmanager/test/identities/TestMain.java

@@ -54,7 +54,7 @@ class TestMain {
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("getIdentities", testCtx, ctx -> {
-            List<FsMQIdentity> idents = ctx.qm.getIdentities();
+            List<FsMQIdentity> idents = ctx.qm.identities.getAll();
             for (FsMQIdentity i : idents) {
                 log(i.toString());
             }
@@ -62,7 +62,7 @@ class TestMain {
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("Ident known: " + testCtx.ownAddress, testCtx, ctx -> {
-            assert ctx.qm.identityExists(ctx.self.getAddress()) : "Own identity unknown";
+            assert ctx.qm.identities.exists(ctx.self.getAddress()) : "Own identity unknown";
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("Create ident " + testCtx.bobAddress, testCtx, ctx -> {
@@ -73,15 +73,15 @@ class TestMain {
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("Ident unknown: " + testCtx.bobAddress, testCtx, ctx -> {
-            assert !ctx.qm.identityExists(ctx.bobAddress) : "Ident is known but shouldnt";
+            assert !ctx.qm.identities.exists(ctx.bobAddress) : "Ident is known but shouldnt";
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("Add ident " + testCtx.bobAddress, testCtx, ctx -> {
-            assert ctx.qm.addOrUpdateIdentity(ctx.bob) : "Identity updated but should have been added";
+            assert ctx.qm.identities.addOrUpdate(ctx.bob) : "Identity updated but should have been added";
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("Ident known: " + testCtx.bobAddress, testCtx, ctx -> {
-            assert ctx.qm.identityExists(ctx.bobAddress) : "Ident is not known";
+            assert ctx.qm.identities.exists(ctx.bobAddress) : "Ident is not known";
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("Create/Add Ident " + testCtx.carolAddress, testCtx, ctx -> {
@@ -89,12 +89,12 @@ class TestMain {
             assert ctx.carol != null : "null";
             assert ctx.carol.getAddress().equals(ctx.carolAddress) : "Address mismatch";
             assert ctx.carol.getqDir().equals(ctx.carolQDirWrong) : "qDir mismatch";
-            assert ctx.qm.addOrUpdateIdentity(ctx.carol) : "Ident got updated but should have been added";
+            assert ctx.qm.identities.addOrUpdate(ctx.carol) : "Ident got updated but should have been added";
         });
 
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("getIdentities", testCtx, ctx -> {
-            List<FsMQIdentity> idents = ctx.qm.getIdentities();
+            List<FsMQIdentity> idents = ctx.qm.identities.getAll();
             for (FsMQIdentity i : idents) {
                 log(i.toString());
             }
@@ -102,30 +102,30 @@ class TestMain {
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("getIdents is copy", testCtx, ctx -> {
-            List<FsMQIdentity> idents = ctx.qm.getIdentities();
+            List<FsMQIdentity> idents = ctx.qm.identities.getAll();
             int identSize = idents.size();
             idents.add(new FsMQIdentity("Eve", "EvilEveDir"));
-            assert identSize == ctx.qm.getIdentities().size() : "ident count wrong";
+            assert identSize == ctx.qm.identities.getAll().size() : "ident count wrong";
-            assert !ctx.qm.identityExists("Eve") : "Identity Eve should not be known";
+            assert !ctx.qm.identities.exists("Eve") : "Identity Eve should not be known";
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("AddOrUpdate ident " + testCtx.bobAddress, testCtx, ctx -> {
             ctx.bob.setqDir(ctx.bobQDir);
             assert ctx.bob.getqDir().equals(ctx.bobQDir);
-            assert !ctx.qm.addOrUpdateIdentity(ctx.bob) : "Ident got added but should have been updated";
+            assert !ctx.qm.identities.addOrUpdate(ctx.bob) : "Ident got added but should have been updated";
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("Update ident " + testCtx.carolAddress, testCtx, ctx -> {
             ctx.carol.setqDir(ctx.carolQDir);
-            assert ctx.qm.updateIdentity(ctx.carol) : "Error updating ident";
+            assert ctx.qm.identities.update(ctx.carol) : "Error updating ident";
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("Update ownIdent Fails " + testCtx.carolAddress, testCtx, ctx -> {
-            assert !ctx.qm.updateIdentity(ctx.self) : "upadted own ident";
+            assert !ctx.qm.identities.update(ctx.self) : "upadted own ident";
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("getIdentities", testCtx, ctx -> {
-            List<FsMQIdentity> idents = ctx.qm.getIdentities();
+            List<FsMQIdentity> idents = ctx.qm.identities.getAll();
             for (FsMQIdentity i : idents) {
                 log(i.toString());
             }
@@ -133,11 +133,11 @@ class TestMain {
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("removeAllIdents", testCtx, ctx -> {
-            ctx.qm.removeAllIdentities();
+            ctx.qm.identities.removeAll();
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("getIdentities", testCtx, ctx -> {
-            List<FsMQIdentity> idents = ctx.qm.getIdentities();
+            List<FsMQIdentity> idents = ctx.qm.identities.getAll();
             for (FsMQIdentity i : idents) {
                 log(i.toString());
             }
@@ -149,11 +149,11 @@ class TestMain {
             ctx.identList.add(ctx.self);
             ctx.identList.add(ctx.bob);
             ctx.identList.add(ctx.carol);
-            assert ctx.qm.addIdentities(ctx.identList) == 2 : "indents added count wrong";
+            assert ctx.qm.identities.addAll(ctx.identList) == 2 : "indents added count wrong";
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("getIdentities", testCtx, ctx -> {
-            List<FsMQIdentity> idents = ctx.qm.getIdentities();
+            List<FsMQIdentity> idents = ctx.qm.identities.getAll();
             for (FsMQIdentity i : idents) {
                 log(i.toString());
             }
@@ -162,8 +162,8 @@ class TestMain {
 
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("isOwnIdent", testCtx, ctx -> {
-            for (FsMQIdentity i : ctx.qm.getIdentities()) {
+            for (FsMQIdentity i : ctx.qm.identities.getAll()) {
-                if (ctx.qm.isOwnIdentity(i.getAddress())) {
+                if (ctx.qm.identities.isSelf(i.getAddress())) {
                     log("isOwnIdent: " + i.getAddress() + "... YES");
                     assert i.getAddress().equals(ctx.self.getAddress()) : "should be own ident";
                 } else {
@@ -174,13 +174,13 @@ class TestMain {
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("removeIdent" + testCtx.carolAddress, testCtx, ctx -> {
-            ctx.qm.removeIdentity(ctx.carol.getAddress());
+            ctx.qm.identities.remove(ctx.carol.getAddress());
-            assert ctx.qm.getIdentities().size() == 2 : "identity count wrong";
+            assert ctx.qm.identities.getAll().size() == 2 : "identity count wrong";
-            assert !ctx.qm.identityExists(ctx.carol.getAddress()) : "Remove failed";
+            assert !ctx.qm.identities.exists(ctx.carol.getAddress()) : "Remove failed";
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("getIdentities", testCtx, ctx -> {
-            List<FsMQIdentity> idents = ctx.qm.getIdentities();
+            List<FsMQIdentity> idents = ctx.qm.identities.getAll();
             for (FsMQIdentity i : idents) {
                 log(i.toString());
             }
@@ -188,25 +188,25 @@ class TestMain {
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("cant remove own ident", testCtx, ctx -> {
-            ctx.qm.removeIdentity(ctx.self.getAddress());
+            ctx.qm.identities.remove(ctx.self.getAddress());
-            assert ctx.qm.getIdentities().size() == 2 : "identity count wrong";
+            assert ctx.qm.identities.getAll().size() == 2 : "identity count wrong";
-            assert ctx.qm.identityExists(ctx.self.getAddress()) : "removed own identity";
+            assert ctx.qm.identities.exists(ctx.self.getAddress()) : "removed own identity";
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("getIdentForAddr" + testCtx.bobAddress, testCtx, ctx -> {
-            FsMQIdentity found = ctx.qm.getIdentityForAddress(ctx.bob.getAddress());
+            FsMQIdentity found = ctx.qm.identities.getByAddress(ctx.bob.getAddress());
             assert found != null :"failed to find known address";
             assert found.getAddress().equals(ctx.bob.getAddress()) :"found wrong ident";
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("getIdentForAdd" + testCtx.ownAddress, testCtx, ctx -> {
-            FsMQIdentity found = ctx.qm.getIdentityForAddress(ctx.self.getAddress());
+            FsMQIdentity found = ctx.qm.identities.getByAddress(ctx.self.getAddress());
             assert found != null :"failed to find known address";
             assert found.getAddress().equals(ctx.self.getAddress()) :"found wrong ident";
         });
 
         new TestUnit<FsMQManagerIdentitiesTestContext>("getIdentityForAddress not existing", testCtx, ctx -> {
-            assert ctx.qm.getIdentityForAddress("UNKNOWN") == null : "Found an unknown address";
+            assert ctx.qm.identities.getByAddress("UNKNOWN") == null : "Found an unknown address";
         });
 
         TestSuite.getDefault().run();

test/java/foundation/pEp/jniadapter/test/utils/transport/fsmqmanager/test/stateless_rxtx/Makefile

@@ -6,6 +6,8 @@ JAVA_CLASSES = \
  	TestMain.class \
 
 JAVA_CLASSES += $(JAVA_CLASSES_FSMSGQUEUE)
+JAVA_CLASSES += $(JAVA_CLASSES_TESTSCOMMON)
+
 
 .PHONY: compile run test clean
 

test/java/foundation/pEp/jniadapter/test/utils/transport/fsmqmanager/test/stateless_rxtx/TestMain.java

@@ -5,11 +5,10 @@ import static foundation.pEp.jniadapter.test.framework.TestLogger.*;
 import foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.*;
 import foundation.pEp.jniadapter.test.framework.*;
 
-import java.io.IOException;
 import java.util.ArrayList;
 
 
-class FsMQManagerTestContext extends AbstractTestContext {
+class FsMQManagerBaseTestContext extends AbstractTestContext {
     Entity alice;
     Entity bob;
     Entity carol;
@@ -43,7 +42,7 @@ class FsMQManagerTestContext extends AbstractTestContext {
         }
 
         public void add(Entity ent) {
-            qm.addOrUpdateIdentity(ent.ident);
+            qm.identities.addOrUpdate(ent.ident);
         }
 
         public java.util.ArrayList<String> createTestMessages(int count) {
@@ -63,15 +62,15 @@ class FsMQManagerTestContext extends AbstractTestContext {
 class TestMain {
     public static void main(String[] args) throws Exception {
         TestSuite.getDefault().setVerbose(true);
-        FsMQManagerTestContext testCtx = new FsMQManagerTestContext();
+        FsMQManagerBaseTestContext testCtx = new FsMQManagerBaseTestContext();
 
-        new TestUnit<FsMQManagerTestContext>("a/b/c ClearOwnQueue: ", testCtx, ctx -> {
+        new TestUnit<FsMQManagerBaseTestContext>("a/b/c ClearOwnQueue: ", testCtx, ctx -> {
             ctx.alice.qm.clearOwnQueue();
             ctx.bob.qm.clearOwnQueue();
             ctx.carol.qm.clearOwnQueue();
         });
 
-        new TestUnit<FsMQManagerTestContext>("alice rx with timeout", testCtx, ctx -> {
+        new TestUnit<FsMQManagerBaseTestContext>("alice rx with timeout", testCtx, ctx -> {
             log("waitForMessage with timeout...");
             FsMQMessage msg = null;
             try {
@@ -83,7 +82,7 @@ class TestMain {
             }
         });
 
-        new TestUnit<FsMQManagerTestContext>("tx to null fails", testCtx, ctx -> {
+        new TestUnit<FsMQManagerBaseTestContext>("tx to null fails", testCtx, ctx -> {
             try {
                 ctx.alice.qm.sendMessage(null, "");
             } catch (Exception e) {
@@ -92,7 +91,7 @@ class TestMain {
             assert false : "receiver cant be null";
         });
 
-        new TestUnit<FsMQManagerTestContext>("tx null msg fails", testCtx, ctx -> {
+        new TestUnit<FsMQManagerBaseTestContext>("tx null msg fails", testCtx, ctx -> {
             try {
                 ctx.alice.qm.sendMessage(ctx.bob.name, null);
             } catch (Exception e) {
@@ -101,7 +100,7 @@ class TestMain {
             assert false : "msg cant be null";
         });
 
-        new TestUnit<FsMQManagerTestContext>("a2a rx==tx seq", testCtx, ctx -> {
+        new TestUnit<FsMQManagerBaseTestContext>("a2a rx==tx seq", testCtx, ctx -> {
             for (int i = 0; i < ctx.alice.msgCount; i++) {
                 String msg = ctx.alice.messages.get(i);
                 log("TX MSG: " + msg);
@@ -130,7 +129,7 @@ class TestMain {
 
         });
 
-        new TestUnit<FsMQManagerTestContext>("a2b rx==tx seq", testCtx, ctx -> {
+        new TestUnit<FsMQManagerBaseTestContext>("a2b rx==tx seq", testCtx, ctx -> {
             for (int i = 0; i < ctx.alice.msgCount; i++) {
                 String msg = ctx.alice.messages.get(i);
                 log("TX MSG: " + msg);
@@ -160,7 +159,7 @@ class TestMain {
 
         });
 
-        new TestUnit<FsMQManagerTestContext>("b2a not known", testCtx, ctx -> {
+        new TestUnit<FsMQManagerBaseTestContext>("b2a not known", testCtx, ctx -> {
             try {
                 ctx.bob.qm.sendMessage(ctx.alice.name, "WONT ARRIVE");
             } catch (UnknownIdentityException e) {
@@ -170,7 +169,7 @@ class TestMain {
             assert false : "identity should not be known";
         });
 
-        new TestUnit<FsMQManagerTestContext>("b add a, tx again", testCtx, ctx -> {
+        new TestUnit<FsMQManagerBaseTestContext>("b add a, tx again", testCtx, ctx -> {
             ctx.bob.add(ctx.alice);
             try {
                 ctx.bob.qm.sendMessage(ctx.alice.name, ctx.bob.messages.get(0));

test/java/foundation/pEp/jniadapter/test/utils/transport/fsmqmanager/test/stateless_rxtx_mp/Makefile

@@ -4,8 +4,7 @@ TEST_UNIT_NAME=stateless_rxtx_mp
 
 JAVA_CLASSES = \
  	TestAlice.class \
- 	../utils/FsMQManagerTestUtils.class
+ 	TestBob.class
-# 	TestBob.class
 
 JAVA_CLASSES += $(JAVA_CLASSES_FSMSGQUEUE)
 JAVA_CLASSES += $(JAVA_CLASSES_TESTSCOMMON)

test/java/foundation/pEp/jniadapter/test/utils/transport/fsmqmanager/test/stateless_rxtx_mp/TestAlice.java

@@ -5,31 +5,13 @@ import static foundation.pEp.jniadapter.test.framework.TestLogger.*;
 import foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.*;
 import foundation.pEp.jniadapter.test.framework.*;
 import foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.test.ctx.*;
-import foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.test.utils.*;
 
-import java.util.ArrayList;
+import java.io.IOException;
-import java.util.List;
-
-
-class FsMQManagerTestContext extends FsMQManagerBaseTestContext {
-    public FsMQManager qm;
-
-    public FsMQManagerTestContext(String selfAddress) {
-        super(selfAddress);
-    }
-
-    @Override
-    public void init() throws Throwable {
-        super.init();
-        qm = new FsMQManager(self);
-        qm.addIdentities(peerList);
-    }
-
-}
 
 class TestAlice {
     public static void main(String[] args) throws Exception {
         TestSuite.getDefault().setVerbose(true);
+        TestSuite.getDefault().setTestColor(TestUtils.TermColor.GREEN);
         String myself = "Alice";
         FsMQManagerTestContext testCtx = new FsMQManagerTestContext(myself);
 
@@ -41,20 +23,49 @@ class TestAlice {
         new TestUnit<FsMQManagerTestContext>("I know Bob and Carol", testCtx, ctx -> {
             log("I know:");
             log("QM");
-            for (FsMQIdentity ident : ctx.qm.getIdentities()) {
+            for (FsMQIdentity ident : ctx.qm.identities.getAll()) {
                 log(ident.toString());
             }
-            log("PeerMap:");
+        });
-            for (String addr : ctx.peerMap.keySet()) {
+
-                log(addr);
+        new TestUnit<FsMQManagerTestContext>("Clear own queue", testCtx, ctx -> {
+            ctx.qm.clearOwnQueue();
+        });
+
+        new TestUnit<FsMQManagerTestContext>("Initiate PingPong", testCtx, ctx -> {
+            try {
+                String toStr = ctx.qm.identities.getByAddress("Bob").getAddress();
+                String msgStr = "Ping";
+                log("TX to: " + toStr);
+                log(msgStr);
+                ctx.qm.sendMessage(toStr, msgStr);
+            } catch (IOException e) {
+                assert false :e.toString();
+            }
+        });
+
+        new TestUnit<FsMQManagerTestContext>("PingPong", testCtx, ctx -> {
+            try {
+                FsMQMessage msg;
+                while((msg = ctx.qm.receiveMessage(5)) != null) {
+                    // RX
+                    String fromStr =  msg.getFrom().getAddress();
+                    String msgRx =  msg.getMsg();
+                    log("RX From: " + fromStr);
+                    log(msgRx);
+
+                    // TX
+                    String toStr = fromStr;
+                    String msgTx = ctx.getMessages().get(0) + msgRx;
+                    log("TX to:" + toStr);
+                    log(msgTx);
+                    ctx.qm.sendMessage(fromStr,msgTx);
                 }
-            log("PeerList:");
+            } catch (IOException e) {
-            for (FsMQIdentity ident : ctx.peerList) {
+                assert false :e.toString();
-                log(ident.getAddress());
+            } catch (ClassNotFoundException e) {
+                assert false : e.toString();
             }
-            assert !ctx.peerMap.containsKey(myself) : "peers should not contain" + myself;
-            assert ctx.peerMap.containsKey("Bob") : "peers must contain Bob";
-            assert ctx.peerMap.containsKey("Carol") : "peers must contain Carol";
         });
 
         TestSuite.getDefault().run();

test/java/foundation/pEp/jniadapter/test/utils/transport/fsmqmanager/test/stateless_rxtx_mp/TestBob.java

@@ -0,0 +1,61 @@
+package foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.test.stateless_rxtx_mp;
+
+import static foundation.pEp.jniadapter.test.framework.TestLogger.*;
+
+import foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.*;
+import foundation.pEp.jniadapter.test.framework.*;
+import foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.test.ctx.*;
+
+import java.io.IOException;
+
+class TestBob {
+    public static void main(String[] args) throws Exception {
+        TestSuite.getDefault().setVerbose(true);
+        TestSuite.getDefault().setTestColor(TestUtils.TermColor.YELLOW);
+        String myself = "Bob";
+        FsMQManagerTestContext testCtx = new FsMQManagerTestContext(myself);
+
+        new TestUnit<FsMQManagerTestContext>("I am: " + myself, testCtx, ctx -> {
+            log("I am: " + ctx.self.getAddress());
+            assert ctx.self.getAddress().equals(myself);
+        });
+
+        new TestUnit<FsMQManagerTestContext>("I know Alice and Carol", testCtx, ctx -> {
+            log("I know:");
+            log("QM");
+            for (FsMQIdentity ident : ctx.qm.identities.getAll()) {
+                log(ident.toString());
+            }
+        });
+
+        new TestUnit<FsMQManagerTestContext>("Clear own queue", testCtx, ctx -> {
+            ctx.qm.clearOwnQueue();
+        });
+
+        new TestUnit<FsMQManagerTestContext>("PingPong", testCtx, ctx -> {
+            try {
+                FsMQMessage msg;
+                while((msg = ctx.qm.receiveMessage(5)) != null) {
+                    // RX
+                    String fromStr =  msg.getFrom().getAddress();
+                    String msgRx =  msg.getMsg();
+                    log("RX From: " + fromStr);
+                    log(msgRx);
+
+                    // TX
+                    String toStr = fromStr;
+                    String msgTx = ctx.getMessages().get(0) + msgRx;
+                    log("TX to:" + toStr);
+                    log(msgTx);
+                    ctx.qm.sendMessage(fromStr,msgTx);
+                }
+            } catch (IOException e) {
+                assert false :e.toString();
+            } catch (ClassNotFoundException e) {
+                assert false : e.toString();
+            }
+        });
+
+        TestSuite.getDefault().run();
+    }
+}