1 files changed, 839 insertions, 0 deletions
diff --git a/test/com/isode/stroke/pubsub/TestMain.java b/test/com/isode/stroke/pubsub/TestMain.java
new file mode 100644
index 0000000..2088898
--- /dev/null
+++ b/test/com/isode/stroke/pubsub/TestMain.java
@@ -0,0 +1,839 @@
+/*
+* Copyright (c) 2014, Isode Limited, London, England.
+* All rights reserved.
+*/
+/*
+* Copyright (c) 2014, Remko Tronçon.
+* All rights reserved.
+*/
+
+package com.isode.stroke.pubsub;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.isode.stroke.elements.DiscoInfo;
+import com.isode.stroke.elements.DiscoItems;
+import com.isode.stroke.elements.DiscoItems.Item;
+import com.isode.stroke.elements.ErrorPayload;
+import com.isode.stroke.elements.Form;
+import com.isode.stroke.elements.Payload;
+import com.isode.stroke.elements.PubSub;
+import com.isode.stroke.elements.PubSubEventItem;
+import com.isode.stroke.elements.PubSubEventItems;
+import com.isode.stroke.elements.PubSubEventPayload;
+import com.isode.stroke.elements.PubSubEventRetract;
+import com.isode.stroke.elements.PubSubItem;
+import com.isode.stroke.elements.PubSubItems;
+import com.isode.stroke.elements.PubSubOwnerAffiliation;
+import com.isode.stroke.elements.PubSubOwnerAffiliations;
+import com.isode.stroke.elements.PubSubOwnerPubSub;
+import com.isode.stroke.elements.PubSubOwnerSubscription;
+import com.isode.stroke.elements.PubSubOwnerSubscriptions;
+import com.isode.stroke.elements.PubSubPublish;
+import com.isode.stroke.elements.PubSubSubscriptions;
+import com.isode.stroke.elements.RawXMLPayload;
+import com.isode.stroke.elements.SoftwareVersion;
+import com.isode.stroke.eventloop.DummyEventLoop;
+import com.isode.stroke.eventloop.Event;
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.network.JavaNetworkFactories;
+import com.isode.stroke.signals.Slot;
+import com.isode.stroke.signals.Slot2;
+
+public class TestMain {
+    
+    /* begin test parameters */
+    static String _server = "stan.isode.net";
+    static String _pubJID = "test1@stan.isode.net";
+    static String _pubPass = "password";
+    static String _subJID = "test2@stan.isode.net";
+    static String _subPass = "password";
+    static String _pubSubDomain = "pubsub.stan.isode.net";
+    static String _pubSubNode = "testnode";
+    /* end test parameters */
+    
+    static DummyEventLoop eventLoop_ = new DummyEventLoop();
+    static ArrayList<TestCase> testRoutines_ = new ArrayList<TestCase>();
+    static int testRoutinesIndex_;
+    static Client clientPub_;
+    static Client clientSub_;
+    static boolean shutdown_;
+    
+    static class ShutdownEvent implements Event.Callback {
+        public void run() {
+            shutdown_ = true;
+            beginNextTest();
+        }
+    };
+    
+    static class NodeCreate implements Event.Callback {
+        public void run() {
+            /* create a temporary pubsub node */
+            PubSubTools.create(clientPub_, _pubSubDomain, _pubSubNode, new Slot2<PubSub, ErrorPayload>() {
+                public void call(PubSub pubSub, ErrorPayload error) {
+                    /* we do not assert here, since failing tests can leave old nodes hanging */
+                    /* change the access mode to 'open' */
+                    PubSubTools.ownerConfigure(clientPub_, _pubSubDomain, _pubSubNode, "pubsub#access_model", "open", new Slot2<PubSubOwnerPubSub, ErrorPayload>() {
+                        public void call(PubSubOwnerPubSub pubSub, ErrorPayload error) {
+                            if (!assertTest(error==null, "Failed to change node access mode to 'open'.")) {
+                                return;
+                            }
+                            /* change the number of items to return to '10' */
+                            PubSubTools.ownerConfigure(clientPub_,  _pubSubDomain,  _pubSubNode,  "pubsub#max_items", "10", new Slot2<PubSubOwnerPubSub, ErrorPayload>() {
+                                public void call(PubSubOwnerPubSub pubSub, ErrorPayload error) {
+                                    if (!assertTest(error==null, "Failed to change node 'max_items'.")) {
+                                        return;
+                                    }
+                                    /* enable retract notifications */
+                                    PubSubTools.ownerConfigure(clientPub_,  _pubSubDomain,  _pubSubNode,  "pubsub#notify_retract", "1", new Slot2<PubSubOwnerPubSub, ErrorPayload>() {
+                                        public void call(PubSubOwnerPubSub pubSub, ErrorPayload error) {
+                                            if (!assertTest(error==null, "Failed to change node 'notify_retract'.")) {
+                                                return;
+                                            }
+                                            beginNextTest();
+                                        }
+                                    });
+                                }
+                            });
+                        }
+                    });
+                }
+            });
+        }
+    };
+    
+    static class NodeDelete implements Event.Callback {
+        public void run() {
+            PubSubTools.delete(clientPub_, _pubSubDomain, _pubSubNode, "", new Slot2<PubSubOwnerPubSub, ErrorPayload>() {
+                public void call(PubSubOwnerPubSub pubSub, ErrorPayload error) {
+                    beginNextTest();
+                }
+            });
+        }
+    };
+    
+    static boolean assertTest(boolean cond, String reason) {
+        if (!cond) {
+            System.out.println("\n-----BEGIN TEST FAILURE REPORT-----\n");
+            System.out.println("Name: " + testRoutines_.get(testRoutinesIndex_-1).getName() + "\n");
+            System.out.println("Reason: " + reason + "\n");
+            System.out.println("-----END TEST FAILURE REPORT-----\n");
+            eventLoop_.postEvent(new ShutdownEvent());
+        }
+        return cond;
+    }
+    
+    static void beginNextTest() {
+        /* return to the main loop and kick off the next test */
+        
+        String testName = testRoutines_.get(testRoutinesIndex_).getName();
+        if (!testName.isEmpty()) {
+            System.out.println("Test complete: " + testName);
+        }
+        
+        if (testRoutinesIndex_ < testRoutines_.size()) {
+            TestCase nextTest = testRoutines_.get(testRoutinesIndex_);
+            eventLoop_.postEvent(nextTest.getRoutine());
+            testRoutinesIndex_++;
+        }
+    }
+    
+    static void addTest(String name, final Event.Callback routine) {
+        /* create a temporary pubsub node and configure it, run the test case, then delete the item afterwards */
+        
+        testRoutines_.add(new TestCase("", new NodeCreate()));
+        testRoutines_.add(new TestCase(name, routine));
+        testRoutines_.add(new TestCase("", new NodeDelete()));
+    }
+    
+    static boolean compareItems(Payload ax, String ay, Payload bx, String by) {
+        /* compare two item payload's and id's for equality */
+        
+        if (!(ax instanceof SoftwareVersion) || !(bx instanceof SoftwareVersion)) {
+            return false;
+        }
+        SoftwareVersion az = (SoftwareVersion)ax;
+        SoftwareVersion bz = (SoftwareVersion)bx;
+        if (!az.getName().equals(bz.getName())) {
+            return false;
+        }
+        if (!az.getVersion().equals(bz.getVersion())) {
+            return false;
+        }
+        if (!az.getOS().equals(bz.getOS())) {
+            return false;
+        }
+        if (!ay.equals(by)) {
+            return false;
+        }
+        return true;
+    }
+    
+    static boolean compareJID(JID a, JID b) {
+        return a.compare(b, JID.CompareType.WithoutResource) == 0;
+    }
+    
+    static void testEntityUseCases() {
+        //--------------------------------------------------------------------------------
+        //-- 5. Entity use cases
+        //--------------------------------------------------------------------------------
+        
+        addTest("5.2 List nodes", new Event.Callback() {
+            public void run() {
+                PubSubTools.itemList(clientSub_, _server, new Slot2<DiscoItems, ErrorPayload>() {
+                    public void call(DiscoItems items, ErrorPayload error) {
+                        if (!assertTest(items!=null, "Service discovery failed.")) {
+                            return;
+                        }
+                        if (!assertTest(items.getItems().size()>0, "There are no services on this domain.")) {
+                            return;
+                        }
+                        System.out.println("Services at " + _server + ":");
+                        boolean foundTestService = false;
+                        for (Item item : items.getItems()) {
+                            String jid = item.getJID().toString();
+                            if (!item.getName().isEmpty()) {
+                                System.out.println("\t" + jid + " (" + item.getName() + ")");
+                            } else {
+                                System.out.println("\t" + jid);
+                            }
+                            if (jid.equals(_pubSubDomain)) {
+                                foundTestService = true;
+                            }
+                        }
+                        System.out.println("");
+                        if (!assertTest(foundTestService, "The service could not be found.")) {
+                            return;
+                        }
+                        beginNextTest();
+                    }
+                });
+            }
+        });
+        
+        addTest("5.5 Discover items of node", new Event.Callback() {
+            public void run() {
+                PubSubTools.itemList(clientPub_, _pubSubDomain, new Slot2<DiscoItems, ErrorPayload>() {
+                    public void call(DiscoItems items, ErrorPayload error) {
+                        if (!assertTest(error==null, "Failed to retreieve pubsub node items.")) {
+                            return;
+                        }
+                        if (!assertTest(items.getItems().size()>0, "There are no nodes on this domain.")) {
+                            return;
+                        }
+                        System.out.println("Services at " + _pubSubDomain + ":");
+                        boolean foundTestService = false;
+                        for (Item item : items.getItems()) {
+                            System.out.println("\t" + item.getNode());
+                            if (item.getNode().equals(_pubSubNode)) {
+                                foundTestService = true;
+                            }
+                        }
+                        System.out.println("");
+                        if (!assertTest(foundTestService, "The service could not be found.")) {
+                            return;
+                        }
+                        beginNextTest();
+                    }
+                });
+            }
+        });
+        
+        addTest("5.6 Subscriptions", new Event.Callback() {
+            public void run() {
+                PubSubTools.subscribe(clientSub_, _pubSubDomain, _pubSubNode, new Slot2<PubSub, ErrorPayload>() {
+                    public void call(PubSub pubSub, ErrorPayload error) {
+                        if (!assertTest(error==null, "Failed to subscribe to a node.")) {
+                            return;
+                        }
+                        PubSubTools.subscriptionList(clientSub_, _pubSubDomain, _pubSubNode, new Slot2<PubSub, ErrorPayload>() {
+                            public void call(PubSub pubSub, ErrorPayload error) {
+                                if (!assertTest(error==null && pubSub!=null, "Failed to list subscriptions on a node.")) {
+                                    return;
+                                }
+                                PubSubSubscriptions results = (PubSubSubscriptions)pubSub.getPayload();
+                                if (!assertTest(results.getSubscriptions().size() == 1, "Unexpected subscription count.")) {
+                                    return;
+                                }
+                                beginNextTest();
+                            }
+                        });
+                    }
+                });
+            }
+        });
+    }
+    
+    static void testSubscriberUseCases() {
+        //--------------------------------------------------------------------------------
+        //-- 6. Subscriber use cases
+        //--------------------------------------------------------------------------------
+        
+        addTest("6.1 Subscribe to a node", new Event.Callback() {
+            public void run() {
+                PubSubTools.subscribe(clientSub_, _pubSubDomain, _pubSubNode, new Slot2<PubSub, ErrorPayload>() {
+                    public void call(PubSub pubSub, ErrorPayload error) {
+                        if (!assertTest(error==null && pubSub!=null, "Failed to subscribe to a node.")) {
+                            return;
+                        }
+                        beginNextTest();
+                    }
+                });
+            }
+        });
+        
+        addTest("6.2 Unsubscribe from a node", new Event.Callback() {
+            public void run() {
+                PubSubTools.subscribe(clientSub_, _pubSubDomain, _pubSubNode, new Slot2<PubSub, ErrorPayload>() {
+                    public void call(PubSub pubSub, ErrorPayload error) {
+                        if (!assertTest(error==null && pubSub!=null, "Failed to subscribe to a node.")) {
+                            return;
+                        }
+                        PubSubTools.unsubscribe(clientSub_, _pubSubDomain, _pubSubNode, new Slot2<PubSub, ErrorPayload>() {
+                            public void call(PubSub pubSub, ErrorPayload error) {
+                                if (!assertTest(error==null, "Failed to unsubscribe from a node.")) {
+                                    return;
+                                }
+                                beginNextTest();
+                            }
+                        });
+                    }
+                });
+            }
+        });
+        
+        addTest("6.5 Retrieve items of a node", new Event.Callback() {
+            public void run() { /* publish 2 items, then retrieve them, making sure that we get back what we sent */
+                final String publishItem1Id = "item_id";
+                final SoftwareVersion publishItem1Payload = new SoftwareVersion("MyTest1", "1.0", "Java");
+                PubSubTools.publish(clientPub_, _pubSubDomain, _pubSubNode, publishItem1Id, publishItem1Payload, new Slot2<PubSubPublish, ErrorPayload>() {
+                    public void call(PubSubPublish publish, ErrorPayload error) {
+                        if (!assertTest(error==null, "Failed to publish item.")) {
+                            return;
+                        }
+                        final String publishItem2Id = "item_id2";
+                        final SoftwareVersion publishItem2Payload = new SoftwareVersion("MyTest2", "2.0", "Java");
+                        PubSubTools.publish(clientPub_, _pubSubDomain, _pubSubNode, publishItem2Id, publishItem2Payload, new Slot2<PubSubPublish, ErrorPayload>() {
+                            public void call(PubSubPublish publish, ErrorPayload error) {
+                                if (!assertTest(error==null, "Failed to publish item.")) {
+                                    return;
+                                }
+                                PubSubTools.getItems(clientSub_, _pubSubDomain, _pubSubNode, 2, new Slot2<PubSub, ErrorPayload>() {
+                                    public void call(PubSub pubSub, ErrorPayload error) {
+                                        if (!assertTest(error==null, "Failed to retrieve items.")) {
+                                            return;
+                                        }
+                                        PubSubItems itemsPayload = (PubSubItems)pubSub.getPayload();
+                                        List<PubSubItem> items = itemsPayload.getItems();
+                                        if (!assertTest(items.size()==2, "Incorrect number of items.")) {
+                                            return;
+                                        }
+                                        Payload payload1 = items.get(0).getData().get(0);
+                                        if (!assertTest(compareItems(payload1, items.get(0).getID(), publishItem1Payload, publishItem1Id), "Invalid item received.")) {
+                                            return;
+                                        }
+                                        Payload payload2 = items.get(1).getData().get(0);
+                                        if (!assertTest(compareItems(payload2, items.get(1).getID(), publishItem2Payload, publishItem2Id), "Invalid item received.")) {
+                                            return;
+                                        }
+                                        beginNextTest();
+                                    }
+                                });
+                            };
+                        });
+                    }
+                });
+            }
+        });
+        
+        addTest("6.5.7 Requesting most recent items", new Event.Callback() {
+            public void run() { /* publish 3 items, then retrieve 2 of them, making sure that we receive the 2 most recent items published */
+                final String publishItem1Id = "item_id";
+                final SoftwareVersion publishItem1Payload = new SoftwareVersion("MyTest1", "1.0", "Java");
+                PubSubTools.publish(clientPub_, _pubSubDomain, _pubSubNode, publishItem1Id, publishItem1Payload, new Slot2<PubSubPublish, ErrorPayload>() {
+                    public void call(PubSubPublish publish, ErrorPayload error) {
+                        if (!assertTest(error==null, "Failed to publish item.")) {
+                            return;
+                        }
+                        final String publishItem2Id = "item_id2";
+                        final SoftwareVersion publishItem2Payload = new SoftwareVersion("MyTest2", "2.0", "Java");
+                        PubSubTools.publish(clientPub_, _pubSubDomain, _pubSubNode, publishItem2Id, publishItem2Payload, new Slot2<PubSubPublish, ErrorPayload>() {
+                            public void call(PubSubPublish publish, ErrorPayload error) {
+                                if (!assertTest(error==null, "Failed to publish item.")) {
+                                    return;
+                                }
+                                final String publishItem3Id = "item_id3";
+                                final SoftwareVersion publishItem3Payload = new SoftwareVersion("MyTest3", "3.0", "Java");
+                                PubSubTools.publish(clientPub_, _pubSubDomain, _pubSubNode, publishItem3Id, publishItem3Payload, new Slot2<PubSubPublish, ErrorPayload>() {
+                                    public void call(PubSubPublish publish, ErrorPayload error) {
+                                        if (!assertTest(error==null, "Failed to publish item.")) {
+                                            return;
+                                        }
+                                        PubSubTools.getItems(clientSub_, _pubSubDomain, _pubSubNode, 2, new Slot2<PubSub, ErrorPayload>() {
+                                            public void call(PubSub pubSub, ErrorPayload error) {
+                                                if (!assertTest(error==null, "Failed to retrieve items.")) {
+                                                    return;
+                                                }
+                                                PubSubItems itemsPayload = (PubSubItems)pubSub.getPayload();
+                                                List<PubSubItem> items = itemsPayload.getItems();
+                                                if (!assertTest(items.size()==2, "Incorrect number of items.")) {
+                                                    return;
+                                                }
+                                                Payload payload1 = items.get(0).getData().get(0);
+                                                if (!assertTest(compareItems(payload1, items.get(0).getID(), publishItem2Payload, publishItem2Id), "Invalid item received.")) {
+                                                    return;
+                                                }
+                                                Payload payload2 = items.get(1).getData().get(0);
+                                                if (!assertTest(compareItems(payload2, items.get(1).getID(), publishItem3Payload, publishItem3Id), "Invalid item received.")) {
+                                                    return;
+                                                }
+                                                beginNextTest();
+                                            }
+                                        });
+                                    }
+                                });
+                            };
+                        });
+                    }
+                });
+            }
+        });
+        
+        addTest("6.5.8 requesting specific item", new Event.Callback() {
+            public void run() { /* publish 2 items, then ask for a specific item, making sure that we get back what we sent */
+                final String publishItem1Id = "item_id";
+                final SoftwareVersion publishItem1Payload = new SoftwareVersion("MyTest1", "1.0", "Java");
+                PubSubTools.publish(clientPub_, _pubSubDomain, _pubSubNode, publishItem1Id, publishItem1Payload, new Slot2<PubSubPublish, ErrorPayload>() {
+                    public void call(PubSubPublish publish, ErrorPayload error) {
+                        if (!assertTest(error==null, "Failed to publish item.")) {
+                            return;
+                        }
+                        final String publishItem2Id = "item_id2";
+                        final SoftwareVersion publishItem2Payload = new SoftwareVersion("MyTest2", "2.0", "Java");
+                        PubSubTools.publish(clientPub_, _pubSubDomain, _pubSubNode, publishItem2Id, publishItem2Payload, new Slot2<PubSubPublish, ErrorPayload>() {
+                            public void call(PubSubPublish publish, ErrorPayload error) {
+                                if (!assertTest(error==null, "Failed to publish item.")) {
+                                    return;
+                                }
+                                PubSubTools.getItem(clientSub_, _pubSubDomain, _pubSubNode, publishItem2Id, new Slot2<PubSub, ErrorPayload>() {
+                                    public void call(PubSub pubSub, ErrorPayload error) {
+                                        if (!assertTest(error==null, "Failed to retrieve items.")) {
+                                            return;
+                                        }
+                                        PubSubItems itemsPayload = (PubSubItems)pubSub.getPayload();
+                                        List<PubSubItem> items = itemsPayload.getItems();
+                                        if (!assertTest(items.size()==1, "Incorrect number of items.")) {
+                                            return;
+                                        }
+                                        Payload payload2 = items.get(0).getData().get(0);
+                                        if (!assertTest(compareItems(payload2, items.get(0).getID(), publishItem2Payload, publishItem2Id), "Invalid item received.")) {
+                                            return;
+                                        }
+                                        beginNextTest();
+                                    }
+                                });
+                            };
+                        });
+                    }
+                });
+            }
+        });
+    }
+    
+    static void testPublisherUseCases() {
+        //--------------------------------------------------------------------------------
+        //-- 7. Publisher use cases
+        //--------------------------------------------------------------------------------
+        
+        addTest("7.1 Publish item to a node", new Event.Callback() {
+            public void run() { /* register a pubsub event handler callback and publish an item to the node, making sure we get back the same data */
+                final String publishItemId = "item_id";
+                final SoftwareVersion publishItemPayload = new SoftwareVersion("MyTest", "1.0", "Java");
+                final PubSubManager clientPubManager = clientSub_.getPubSubManager();
+                clientPubManager.onEvent.connect(new Slot2<JID, PubSubEventPayload>() {
+                    public void call(JID jid, PubSubEventPayload payload) {	
+                        if (payload instanceof PubSubEventItems) {
+                            PubSubEventItems items = (PubSubEventItems)payload;
+                            if (items.getNode().equals(_pubSubNode) && items.getItems().size()>0) {
+                                PubSubEventItem item = items.getItems().get(0);
+                                Payload itemPayload = item.getData().get(0);
+                                if (itemPayload instanceof SoftwareVersion) {
+                                    SoftwareVersion version = (SoftwareVersion)itemPayload;
+                                    if (!assertTest(compareItems(version, item.getID(), publishItemPayload, publishItemId), "Item data mismatch.")) {
+                                        return;
+                                    }
+                                    System.out.println("\tGot publish notification.\n");
+                                    clientPubManager.onEvent.disconnectAll();
+                                    beginNextTest();
+                                }
+                            }
+                        }
+                    }
+                });
+                PubSubTools.subscribe(clientSub_, _pubSubDomain, _pubSubNode, new Slot2<PubSub, ErrorPayload>() {
+                    public void call(PubSub pubSub, ErrorPayload error) {
+                        if (!assertTest(error==null, "Failed to subscribe to a node.")) {
+                            return;
+                        }
+                        PubSubTools.publish(clientPub_, _pubSubDomain, _pubSubNode, publishItemId, publishItemPayload, new Slot2<PubSubPublish, ErrorPayload>() {
+                            public void call(PubSubPublish pubSub, ErrorPayload error) {
+                                if (!assertTest(error==null, "Failed to publish item to a node.")) {
+                                    return;
+                                }
+                                System.out.println("\tWaiting for publish notification...");
+                            }
+                        });
+                    }
+                });
+            }
+        });
+        
+        addTest("7.2 Delete item from a node", new Event.Callback() {
+            public void run() { /* subscribe to a node, publish an item, then 'retract' (delete) it */
+                PubSubTools.subscribe(clientSub_, _pubSubDomain, _pubSubNode, new Slot2<PubSub, ErrorPayload>() {
+                    public void call(PubSub pubSub, ErrorPayload error) {
+                        if (!assertTest(error==null, "Failed to subscribe to a node.")) {
+                            return;
+                        }
+                        final String publishItemId = "item_id";
+                        SoftwareVersion publishItemPayload = new SoftwareVersion("MyTest", "1.0", "Java");
+                        PubSubTools.publish(clientPub_, _pubSubDomain, _pubSubNode, publishItemId, publishItemPayload, new Slot2<PubSubPublish, ErrorPayload>() {
+                            public void call(PubSubPublish pubSub, ErrorPayload error) {
+                                if (!assertTest(error==null, "Failed to publish item to a node.")) {
+                                    return;
+                                }
+                                PubSubTools.retract(clientPub_, _pubSubDomain, _pubSubNode, publishItemId, true, new Slot2<PubSub, ErrorPayload>() {
+                                    public void call(PubSub pubSub, ErrorPayload error) {
+                                        if (!assertTest(error==null, "Failed to retract item from a node.")) {
+                                            return;
+                                        }
+                                        beginNextTest();
+                                    }
+                                });
+                            }
+                        });
+                    }
+                });
+            }
+        });
+        
+        addTest("7.2.2.1 Delete and notify", new Event.Callback() {
+            public void run() { /* register a pubsub event handler callback and retract an item to the node, check that we are notified */
+                final String publishItemId = "item_id";
+                final SoftwareVersion publishItemPayload = new SoftwareVersion("MyTest", "1.0", "Java");
+                final PubSubManager clientPubManager = clientSub_.getPubSubManager();
+                clientPubManager.onEvent.connect(new Slot2<JID, PubSubEventPayload>() {
+                    public void call(JID jid, PubSubEventPayload payload) {
+                        if (payload instanceof PubSubEventItems) {
+                            PubSubEventItems items = (PubSubEventItems)payload;
+                            List<PubSubEventRetract> retracts = items.getRetracts();
+                            if (items.getNode().equals(_pubSubNode) && retracts.size()==1) {
+                                if (!assertTest(retracts.get(0).getID().equals(publishItemId), "Unexpected retract item.")) {
+                                    return;
+                                }
+                                System.out.println("\tGot retract notification.\n");
+                                clientPubManager.onEvent.disconnectAll();
+                                beginNextTest();
+                            }
+                        }
+                    }
+                });
+                PubSubTools.subscribe(clientSub_, _pubSubDomain, _pubSubNode, new Slot2<PubSub, ErrorPayload>() {
+                    public void call(PubSub pubSub, ErrorPayload error) {
+                        if (!assertTest(error==null, "Failed to subscribe to a node.")) {
+                            return;
+                        }
+                        PubSubTools.publish(clientPub_, _pubSubDomain, _pubSubNode, publishItemId, publishItemPayload, new Slot2<PubSubPublish, ErrorPayload>() {
+                            public void call(PubSubPublish pubSub, ErrorPayload error) {
+                                if (!assertTest(error==null, "Failed to publish item to a node.")) {
+                                    return;
+                                }
+                                PubSubTools.retract(clientPub_, _pubSubDomain, _pubSubNode, publishItemId, true, new Slot2<PubSub, ErrorPayload>() {
+                                    public void call(PubSub pubSub, ErrorPayload error) {
+                                        if (!assertTest(error==null, "Failed to retract item from a node.")) {
+                                            return;
+                                        }
+                                        System.out.println("Waiting for retract notification...");
+                                    }
+                                });
+                            }
+                        });
+                    }
+                });
+            }
+        });
+        
+        addTest("Publish an unknown element type", new Event.Callback() {
+            public void run() { /* subscribe to a node and publish raw xml, making sure we get back the data in the handler */
+                final String publishItemId = "item_id";
+                final RawXMLPayload publishItemPayload = new RawXMLPayload();
+                publishItemPayload.setRawXML(
+                        "<entry xmlns='http://www.w3.org/2005/Atom'>"
+                                + "<title>Down the Rabbit Hole</title>"
+                                + "<summary>"
+                                + "Alice was beginning to get very tired of sitting by her sister on the"
+                                + "bank and of having nothing to do: once or twice she had peeped into the"
+                                + "book her sister was reading, but it had no pictures or conversations in"
+                                + "it, \"and what is the use of a book,\" thought Alice, \"without pictures"
+                                + "or conversations?\'"
+                                + "</summary>"
+                                + "<link rel='alternate' type='text/html' href='http://www.gutenberg.org/files/11/11-h/11-h.htm#link2HCH0001'/>"
+                                + "<id>tag:gutenberg.org,2008:entry-1234</id>"
+                                + "<published>2008-06-25T18:30:02Z</published>"
+                                + "<updated>2008-06-25T18:30:02Z</updated>"
+                                + "</entry>"
+                        );
+                final PubSubManager clientPubManager = clientSub_.getPubSubManager();
+                clientPubManager.onEvent.connect(new Slot2<JID, PubSubEventPayload>() {
+                    public void call(JID jid, PubSubEventPayload payload) {	
+                        if (payload instanceof PubSubEventItems) {
+                            PubSubEventItems items = (PubSubEventItems)payload;
+                            List<PubSubEventItem> itemList = items.getItems();
+                            if (itemList.size() > 0) {
+                                List<Payload> payloads = itemList.get(0).getData();
+                                if (payloads.size() > 0) {
+                                    if (payloads.get(0) instanceof RawXMLPayload) {
+                                        System.out.println("\tGot publish notification.\n");
+                                        clientPubManager.onEvent.disconnectAll();
+                                        beginNextTest();
+                                    }
+                                }
+                            }
+                        }
+                    }
+                });
+                PubSubTools.subscribe(clientSub_, _pubSubDomain, _pubSubNode, new Slot2<PubSub, ErrorPayload>() {
+                    public void call(PubSub pubSub, ErrorPayload error) {
+                        if (!assertTest(error==null, "Failed to subscribe to a node.")) {
+                            return;
+                        }
+                        PubSubTools.publish(clientPub_, _pubSubDomain, _pubSubNode, publishItemId, publishItemPayload, new Slot2<PubSubPublish, ErrorPayload>() {
+                            public void call(PubSubPublish pubSub, ErrorPayload error) {
+                                if (!assertTest(error==null, "Failed to publish item to a node.")) {
+                                    return;
+                                }
+                                System.out.println("Waiting for publish notification...");
+                            }
+                        });
+                    }
+                });
+            }
+        });
+    }
+    
+    static void testOwnerUseCases() {
+        //--------------------------------------------------------------------------------
+        //-- 8 Owner Use Cases
+        //--------------------------------------------------------------------------------
+        
+        //-- 8.1 Create a node
+        //--   Create node with default config
+        //--   Create node with custom config
+        //-- 8.2 Configure node
+        // ^ not applicable ^ exist as separate tests in Sluift, but already used as part of the other tests
+        
+        addTest("8.3 Request Default Node Configuration Options", new Event.Callback() {
+            public void run() {
+                PubSubTools.ownerDefaultConfiguration(clientPub_, _pubSubDomain, new Slot2<Form, ErrorPayload>() {
+                    public void call(Form config, ErrorPayload error) {
+                        if (!assertTest(error==null && config!=null, "Failed to retrieve default configuration.")) {
+                            return;
+                        }
+                        beginNextTest();
+                    }
+                });
+            }
+        });
+        
+        addTest("8.4 Delete node - with redirection", new Event.Callback() {
+            public void run() {
+                PubSubTools.subscribe(clientSub_, _pubSubDomain, _pubSubNode, new Slot2<PubSub, ErrorPayload>() {
+                    public void call(PubSub pubSub, ErrorPayload error) {
+                        if (!assertTest(error==null, "Failed to subscribe to a node.")) {
+                            return;
+                        }
+                        PubSubTools.delete(clientPub_, _pubSubDomain, _pubSubNode, "foo@bar.com", new Slot2<PubSubOwnerPubSub, ErrorPayload>() {
+                            public void call(PubSubOwnerPubSub pubSub, ErrorPayload error) {
+                                if (!assertTest(error==null, "Failed to delete a node.")) {
+                                    return;
+                                }
+                                beginNextTest();
+                            }
+                        });
+                    }
+                });
+            }
+        });
+        
+        // NOT IMPLEMENTED
+        //	addTest("8.5 Purge node items", new Event.Callback() {
+        //		public void run() { /* publish 2 items, then purge the node */
+        //			PubSubTools.subscribe(clientSub_, _pubSubDomain, _pubSubNode, new Slot2<PubSub, ErrorPayload>() {
+        //				public void call(PubSub pubSub, ErrorPayload error) {
+        //					if (!assertTest(error==null, "Failed to subscribe to a node.")) {
+        //						return;
+        //					}
+        //					final String publishItem1Id = "item_id";
+        //					final SoftwareVersion publishItem1Payload = new SoftwareVersion("MyTest1", "1.0", "Java");
+        //					PubSubTools.publish(clientPub_, _pubSubDomain, _pubSubNode, publishItem1Id, publishItem1Payload, new Slot2<PubSubPublish, ErrorPayload>() {
+        //						public void call(PubSubPublish publish, ErrorPayload error) {
+        //							if (!assertTest(error==null, "Failed to publish item.")) {
+        //								return;
+        //							}
+        //							final String publishItem2Id = "item_id2";
+        //							final SoftwareVersion publishItem2Payload = new SoftwareVersion("MyTest2", "2.0", "Java");
+        //							PubSubTools.publish(clientPub_, _pubSubDomain, _pubSubNode, publishItem2Id, publishItem2Payload, new Slot2<PubSubPublish, ErrorPayload>() {
+        //								public void call(PubSubPublish publish, ErrorPayload error) {
+        //									if (!assertTest(error==null, "Failed to publish item.")) {
+        //										return;
+        //									}
+        //									PubSubTools.purge(clientPub_, _pubSubDomain, _pubSubNode, new Slot2<PubSubOwnerPubSub, ErrorPayload>() {
+        //										public void call(PubSubOwnerPubSub pubSub, ErrorPayload error) {
+        //											if (!assertTest(error==null, "Failed to purge node items.")) {
+        //												return;
+        //											}
+        //											beginNextTest();
+        //										}
+        //									});
+        //								}
+        //							});
+        //						}
+        //					});
+        //				}
+        //			});
+        //		}
+        //	});
+        
+        addTest("8.8 Manage Subscriptions", new Event.Callback() {
+            public void run() {
+                PubSubTools.subscribe(clientSub_, _pubSubDomain, _pubSubNode, new Slot2<PubSub, ErrorPayload>() {
+                    public void call(PubSub pubSub, ErrorPayload error) {
+                        if (!assertTest(error==null, "Failed to subscribe to a node.")) {
+                            return;
+                        }
+                        PubSubTools.ownerSubscriptionlist(clientPub_, _pubSubDomain, _pubSubNode, new Slot2<PubSubOwnerPubSub, ErrorPayload>() {
+                            public void call(PubSubOwnerPubSub pubSub, ErrorPayload error) {
+                                if (!assertTest(error==null, "Failed to retrieve subscription list.")) {
+                                    return;
+                                }
+                                System.out.println("Subscriptions to " + _pubSubNode + " on " + _pubSubDomain + ":");
+                                PubSubOwnerSubscriptions subscriptionPayload = (PubSubOwnerSubscriptions)pubSub.getPayload();
+                                ArrayList<PubSubOwnerSubscription> subscriptionList = subscriptionPayload.getSubscriptions();
+                                for (PubSubOwnerSubscription subscription : subscriptionList) {
+                                    System.out.println("\t" + subscription.getJID() + " (" + subscription.getSubscription().toString() + ")");
+                                }
+                                System.out.println("");
+                                beginNextTest();
+                            }
+                        });
+                    }
+                });
+            }
+        });
+        
+        addTest("8.9 Manage Affiliations", new Event.Callback() {
+            public void run() {
+                PubSubTools.ownerSetAffiliations(clientPub_, _pubSubDomain, _pubSubNode, clientSub_.getJID(), PubSubOwnerAffiliation.Type.Publisher, new Slot2<PubSubOwnerPubSub, ErrorPayload>() {
+                    public void call(PubSubOwnerPubSub pubSub, ErrorPayload error) {
+                        if (!assertTest(error==null, "Failed to set affiliation.")) {
+                            return;
+                        }
+                        PubSubTools.ownerGetAffiliations(clientPub_, _pubSubDomain, _pubSubNode, new Slot2<PubSubOwnerPubSub, ErrorPayload>() {
+                            public void call(PubSubOwnerPubSub pubSub, ErrorPayload error) {
+                                if (!assertTest(error==null, "Failed to retrieve affiliations.")) {
+                                    return;
+                                }
+                                PubSubOwnerAffiliations affiliationsPayload = (PubSubOwnerAffiliations)pubSub.getPayload();
+                                ArrayList<PubSubOwnerAffiliation> affiliations = affiliationsPayload.getAffiliations();
+                                if (!assertTest(affiliations.size()==2, "Unexpected affiliation count.")) {
+                                    return;
+                                }
+                                PubSubOwnerAffiliation affiliationPub = affiliations.get(0);
+                                if (!assertTest(compareJID(affiliationPub.getJID(),clientPub_.getJID()), "Unexpected affiliation JID.")) {
+                                    return;
+                                }
+                                if (!assertTest(affiliationPub.getType() == PubSubOwnerAffiliation.Type.Owner, "Unexpected affiliation type.")) {
+                                    return;
+                                }
+                                PubSubOwnerAffiliation affiliationSub = affiliations.get(1);
+                                if (!assertTest(compareJID(affiliationSub.getJID(),clientSub_.getJID()), "Unexpected affiliation JID.")) {
+                                    return;
+                                }
+                                if (!assertTest(affiliationSub.getType() == PubSubOwnerAffiliation.Type.Publisher, "Unexpected affiliation type.")) {
+                                    return;
+                                }
+                                beginNextTest();
+                            }
+                        });
+                    }
+                });
+            }
+        });
+    }
+    
+    public static void main(String[] args) {
+        /* print server supported features */
+        
+        addTest("Query Domain Features", new Event.Callback() {
+            public void run() {
+                PubSubTools.featureList(clientSub_, _pubSubDomain, new Slot2<DiscoInfo, ErrorPayload>() {
+                    public void call(DiscoInfo info, ErrorPayload error) {
+                        if (!assertTest(error==null, "Failed to retrieve server feature list.")) {
+                            return;
+                        }
+                        System.out.println("List of features at " + _pubSubDomain + ":");
+                        for (String feature : info.getFeatures()) {
+                            System.out.println("\t" + feature);
+                        }
+                        System.out.println("");
+                        beginNextTest();
+                    };
+                });
+            }
+        });
+        
+        /* set up test cases */
+        
+        testEntityUseCases();
+        testSubscriberUseCases();
+        testPublisherUseCases();
+        testOwnerUseCases();
+        
+        /* the final "test" disconnects the clients */
+        
+        addTest("ShutdownEvent", new ShutdownEvent());
+        
+        /* connect the client and begin the tests */
+        
+        JavaNetworkFactories networkFactories = new JavaNetworkFactories(eventLoop_);
+        
+        Slot connectCallback = new Slot() {
+            public void call() {
+                if (clientPub_!=null && clientPub_.isConnected() && clientSub_!=null && clientSub_.isConnected()) {
+                    beginNextTest(); /* kick off the tests once both clients are connected */
+                }
+            }
+        };
+        
+        clientPub_ = new Client("PUBLISHER", new JID(_pubJID), _pubPass, networkFactories, connectCallback);
+        clientSub_ = new Client("SUBSCRIBER", new JID(_subJID), _subPass, networkFactories, connectCallback);
+        
+        while (!shutdown_) {
+            eventLoop_.processEvents();
+        }
+        
+        clientSub_.disconnect();
+        clientPub_.disconnect();
+        
+        /* the tests are over */
+        
+        if (testRoutinesIndex_ == testRoutines_.size()) {
+            System.out.println("\n-----BEGIN TEST REPORT-----\n");
+            System.out.println("Success: The tests completed.\n");
+            System.out.println("-----END TEST REPORT-----\n");
+        }
+        
+        System.out.println("Finished.");
+    }
+}