12 files changed, 1076 insertions, 844 deletions
diff --git a/Swift/Controllers/UnitTest/ChatMessageSummarizerTest.cpp b/Swift/Controllers/UnitTest/ChatMessageSummarizerTest.cpp
index dd2a8e5..59c57b9 100644
--- a/Swift/Controllers/UnitTest/ChatMessageSummarizerTest.cpp
+++ b/Swift/Controllers/UnitTest/ChatMessageSummarizerTest.cpp
@@ -1,121 +1,121 @@
 /*
- * Copyright (c) 2011 Kevin Smith
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2011-2016 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
-#include "Swift/Controllers/ChatMessageSummarizer.h"
+#include <Swift/Controllers/ChatMessageSummarizer.h>
 
 using namespace Swift;
 using namespace std;
 
 class ChatMessageSummarizerTest : public CppUnit::TestFixture {
-	CPPUNIT_TEST_SUITE(ChatMessageSummarizerTest);
-	CPPUNIT_TEST(testEmpty);
-	CPPUNIT_TEST(testCurrentNone);
-	CPPUNIT_TEST(testCurrentCount);
-	CPPUNIT_TEST(testCurrentCountOthersNone);
-	CPPUNIT_TEST(testCurrentCountOtherCount);
-	CPPUNIT_TEST(testCurrentNoneOtherCount);
-	CPPUNIT_TEST(testCurrentCountOthersCount);
-	CPPUNIT_TEST(testCurrentNoneOthersCount);
-	CPPUNIT_TEST(testCurrentCountSomeOthersCount);
-	CPPUNIT_TEST_SUITE_END();
+    CPPUNIT_TEST_SUITE(ChatMessageSummarizerTest);
+    CPPUNIT_TEST(testEmpty);
+    CPPUNIT_TEST(testCurrentNone);
+    CPPUNIT_TEST(testCurrentCount);
+    CPPUNIT_TEST(testCurrentCountOthersNone);
+    CPPUNIT_TEST(testCurrentCountOtherCount);
+    CPPUNIT_TEST(testCurrentNoneOtherCount);
+    CPPUNIT_TEST(testCurrentCountOthersCount);
+    CPPUNIT_TEST(testCurrentNoneOthersCount);
+    CPPUNIT_TEST(testCurrentCountSomeOthersCount);
+    CPPUNIT_TEST_SUITE_END();
 
 public:
-	ChatMessageSummarizerTest() {}
-
-	void setUp() {
-
-	}
-
-	void testEmpty() {
-		string current("");
-		vector<UnreadPair> unreads;
-		ChatMessageSummarizer summary;
-		CPPUNIT_ASSERT_EQUAL(current, summary.getSummary(current, unreads));
-	}
-
-	void testCurrentNone() {
-		string current("Bob");
-		vector<UnreadPair> unreads;
-		unreads.push_back(UnreadPair("Bob", 0));
-		ChatMessageSummarizer summary;
-		CPPUNIT_ASSERT_EQUAL(current, summary.getSummary(current, unreads));
-	}
-
-	void testCurrentCount() {
-		string current("Bob");
-		vector<UnreadPair> unreads;
-		unreads.push_back(UnreadPair("Bob", 3));
-		ChatMessageSummarizer summary;
-		CPPUNIT_ASSERT_EQUAL(string("Bob (3)"), summary.getSummary(current, unreads));
-	}
-
-	void testCurrentCountOthersNone() {
-		string current("Bob");
-		vector<UnreadPair> unreads;
-		unreads.push_back(UnreadPair("Bert", 0));
-		unreads.push_back(UnreadPair("Bob", 3));
-		unreads.push_back(UnreadPair("Betty", 0));
-		ChatMessageSummarizer summary;
-		CPPUNIT_ASSERT_EQUAL(string("Bob (3)"), summary.getSummary(current, unreads));
-	}
-
-	void testCurrentCountOtherCount() {
-		string current("Bob");
-		vector<UnreadPair> unreads;
-		unreads.push_back(UnreadPair("Bert", 0));
-		unreads.push_back(UnreadPair("Bob", 3));
-		unreads.push_back(UnreadPair("Betty", 7));
-		ChatMessageSummarizer summary;
-		CPPUNIT_ASSERT_EQUAL(string("Bob (3); Betty (7)"), summary.getSummary(current, unreads));
-	}
-
-	void testCurrentNoneOtherCount() {
-		string current("Bob");
-		vector<UnreadPair> unreads;
-		unreads.push_back(UnreadPair("Bert", 0));
-		unreads.push_back(UnreadPair("Bob", 0));
-		unreads.push_back(UnreadPair("Betty", 7));
-		ChatMessageSummarizer summary;
-		CPPUNIT_ASSERT_EQUAL(string("Bob; Betty (7)"), summary.getSummary(current, unreads));
-	}
-
-	void testCurrentNoneOthersCount() {
-		string current("Bob");
-		vector<UnreadPair> unreads;
-		unreads.push_back(UnreadPair("Bert", 2));
-		unreads.push_back(UnreadPair("Bob", 0));
-		unreads.push_back(UnreadPair("Betty", 7));
-		ChatMessageSummarizer summary;
-		CPPUNIT_ASSERT_EQUAL(string("Bob and 2 others (9)"), summary.getSummary(current, unreads));
-	}
-
-	void testCurrentCountOthersCount() {
-		string current("Bob");
-		vector<UnreadPair> unreads;
-		unreads.push_back(UnreadPair("Bert", 2));
-		unreads.push_back(UnreadPair("Bob", 11));
-		unreads.push_back(UnreadPair("Betty", 7));
-		ChatMessageSummarizer summary;
-		CPPUNIT_ASSERT_EQUAL(string("Bob (11) and 2 others (9)"), summary.getSummary(current, unreads));
-	}
-
-	void testCurrentCountSomeOthersCount() {
-		string current("Bob");
-		vector<UnreadPair> unreads;
-		unreads.push_back(UnreadPair("Bert", 2));
-		unreads.push_back(UnreadPair("Beverly", 0));
-		unreads.push_back(UnreadPair("Bob", 11));
-		unreads.push_back(UnreadPair("Beatrice", 0));
-		unreads.push_back(UnreadPair("Betty", 7));
-		ChatMessageSummarizer summary;
-		CPPUNIT_ASSERT_EQUAL(string("Bob (11) and 2 others (9)"), summary.getSummary(current, unreads));
-	}
+    ChatMessageSummarizerTest() {}
+
+    void setUp() {
+
+    }
+
+    void testEmpty() {
+        string current("");
+        vector<UnreadPair> unreads;
+        ChatMessageSummarizer summary;
+        CPPUNIT_ASSERT_EQUAL(current, summary.getSummary(current, unreads));
+    }
+
+    void testCurrentNone() {
+        string current("Bob");
+        vector<UnreadPair> unreads;
+        unreads.push_back(UnreadPair("Bob", 0));
+        ChatMessageSummarizer summary;
+        CPPUNIT_ASSERT_EQUAL(current, summary.getSummary(current, unreads));
+    }
+
+    void testCurrentCount() {
+        string current("Bob");
+        vector<UnreadPair> unreads;
+        unreads.push_back(UnreadPair("Bob", 3));
+        ChatMessageSummarizer summary;
+        CPPUNIT_ASSERT_EQUAL(string("Bob (3)"), summary.getSummary(current, unreads));
+    }
+
+    void testCurrentCountOthersNone() {
+        string current("Bob");
+        vector<UnreadPair> unreads;
+        unreads.push_back(UnreadPair("Bert", 0));
+        unreads.push_back(UnreadPair("Bob", 3));
+        unreads.push_back(UnreadPair("Betty", 0));
+        ChatMessageSummarizer summary;
+        CPPUNIT_ASSERT_EQUAL(string("Bob (3)"), summary.getSummary(current, unreads));
+    }
+
+    void testCurrentCountOtherCount() {
+        string current("Bob");
+        vector<UnreadPair> unreads;
+        unreads.push_back(UnreadPair("Bert", 0));
+        unreads.push_back(UnreadPair("Bob", 3));
+        unreads.push_back(UnreadPair("Betty", 7));
+        ChatMessageSummarizer summary;
+        CPPUNIT_ASSERT_EQUAL(string("Bob (3); Betty (7)"), summary.getSummary(current, unreads));
+    }
+
+    void testCurrentNoneOtherCount() {
+        string current("Bob");
+        vector<UnreadPair> unreads;
+        unreads.push_back(UnreadPair("Bert", 0));
+        unreads.push_back(UnreadPair("Bob", 0));
+        unreads.push_back(UnreadPair("Betty", 7));
+        ChatMessageSummarizer summary;
+        CPPUNIT_ASSERT_EQUAL(string("Bob; Betty (7)"), summary.getSummary(current, unreads));
+    }
+
+    void testCurrentNoneOthersCount() {
+        string current("Bob");
+        vector<UnreadPair> unreads;
+        unreads.push_back(UnreadPair("Bert", 2));
+        unreads.push_back(UnreadPair("Bob", 0));
+        unreads.push_back(UnreadPair("Betty", 7));
+        ChatMessageSummarizer summary;
+        CPPUNIT_ASSERT_EQUAL(string("Bob and 2 others (9)"), summary.getSummary(current, unreads));
+    }
+
+    void testCurrentCountOthersCount() {
+        string current("Bob");
+        vector<UnreadPair> unreads;
+        unreads.push_back(UnreadPair("Bert", 2));
+        unreads.push_back(UnreadPair("Bob", 11));
+        unreads.push_back(UnreadPair("Betty", 7));
+        ChatMessageSummarizer summary;
+        CPPUNIT_ASSERT_EQUAL(string("Bob (11) and 2 others (9)"), summary.getSummary(current, unreads));
+    }
+
+    void testCurrentCountSomeOthersCount() {
+        string current("Bob");
+        vector<UnreadPair> unreads;
+        unreads.push_back(UnreadPair("Bert", 2));
+        unreads.push_back(UnreadPair("Beverly", 0));
+        unreads.push_back(UnreadPair("Bob", 11));
+        unreads.push_back(UnreadPair("Beatrice", 0));
+        unreads.push_back(UnreadPair("Betty", 7));
+        ChatMessageSummarizer summary;
+        CPPUNIT_ASSERT_EQUAL(string("Bob (11) and 2 others (9)"), summary.getSummary(current, unreads));
+    }
 
 };
 
diff --git a/Swift/Controllers/UnitTest/ContactSuggesterTest.cpp b/Swift/Controllers/UnitTest/ContactSuggesterTest.cpp
new file mode 100644
index 0000000..6ac51b2
--- /dev/null
+++ b/Swift/Controllers/UnitTest/ContactSuggesterTest.cpp
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2014-2016 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+
+#include <memory>
+
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+
+#include <cppunit/extensions/HelperMacros.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+
+#include <Swift/Controllers/ContactSuggester.h>
+
+using namespace Swift;
+
+class ContactSuggesterTest : public CppUnit::TestFixture {
+    CPPUNIT_TEST_SUITE(ContactSuggesterTest);
+    CPPUNIT_TEST(equalityTest);
+    CPPUNIT_TEST(lexicographicalSortTest);
+    CPPUNIT_TEST(sortTest);
+    CPPUNIT_TEST_SUITE_END();
+
+public:
+
+    std::vector<std::string> wordList() {
+        const std::string words[] = {
+            "abc",
+            "ab",
+            "bc",
+            "d"
+        };
+
+        return std::vector<std::string>(words, words+sizeof(words)/sizeof(*words));
+    }
+
+    std::vector<StatusShow::Type> statusList() {
+        StatusShow::Type types[] = {
+            StatusShow::Online,
+            StatusShow::Away,
+            StatusShow::FFC,
+            StatusShow::XA,
+            StatusShow::DND,
+            StatusShow::None
+        };
+
+        return std::vector<StatusShow::Type>(types, types+sizeof(types)/sizeof(*types));
+    }
+
+    std::vector<Contact::ref> contactList() {
+        std::vector<Contact::ref> contacts;
+        std::vector<std::string> words = wordList();
+        std::vector<StatusShow::Type> statuses = statusList();
+        for (const auto& name : words) {
+            for (const auto& jid : words) {
+                for (const auto& status : statuses) {
+                    contacts.push_back(std::make_shared<Contact>(name, jid, status, ""));
+                }
+            }
+        }
+        return contacts;
+    }
+
+    /* a = a */
+    bool isReflexive(const boost::function<bool (const Contact::ref&, const Contact::ref&)>& comparitor) {
+        std::vector<Contact::ref> contacts = contactList();
+        for (const auto& a : contacts) {
+            if (!comparitor(a, a)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /* a = b -> b = a */
+    bool isSymmetric(const boost::function<bool (const Contact::ref&, const Contact::ref&)>& comparitor) {
+        std::vector<Contact::ref> contacts = contactList();
+        for (const auto& a : contacts) {
+            for (const auto& b : contacts) {
+                if (comparitor(a, b)) {
+                    if (!comparitor(b, a)) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    /* a = b && b = c -> a = c */
+    bool isTransitive(const boost::function<bool (const Contact::ref&, const Contact::ref&)>& comparitor) {
+        std::vector<Contact::ref> contacts = contactList();
+        for (const auto& a : contacts) {
+            for (const auto& b : contacts) {
+                for (const auto& c : contacts) {
+                    if (comparitor(a, b) && comparitor(b, c)) {
+                        if (!comparitor(a, c)) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    void equalityTest() {
+        CPPUNIT_ASSERT(isReflexive(Contact::equalityPredicate));
+        CPPUNIT_ASSERT(isSymmetric(Contact::equalityPredicate));
+        CPPUNIT_ASSERT(isTransitive(Contact::equalityPredicate));
+    }
+
+    void lexicographicalSortTest() {
+        CPPUNIT_ASSERT(isTransitive(Contact::lexicographicalSortPredicate));
+    }
+
+    void sortTest() {
+        std::vector<std::string> words = wordList();
+        for (const auto& word : words) {
+            CPPUNIT_ASSERT(isTransitive(boost::bind(Contact::sortPredicate, _1, _2, word)));
+        }
+    }
+
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ContactSuggesterTest);
diff --git a/Swift/Controllers/UnitTest/FdpFormSubmitControllerTest.cpp b/Swift/Controllers/UnitTest/FdpFormSubmitControllerTest.cpp
new file mode 100644
index 0000000..8dc3442
--- /dev/null
+++ b/Swift/Controllers/UnitTest/FdpFormSubmitControllerTest.cpp
@@ -0,0 +1,269 @@
+/*
+ * Copyright (c) 2018 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+
+#include <memory>
+#include <string>
+
+#include <gtest/gtest.h>
+
+#include <Swiften/Client/DummyStanzaChannel.h>
+#include <Swiften/Elements/DiscoItems.h>
+#include <Swiften/Elements/Form.h>
+#include <Swiften/Elements/FormField.h>
+#include <Swiften/Elements/IQ.h>
+#include <Swiften/Elements/Payload.h>
+#include <Swiften/Elements/PubSub.h>
+#include <Swiften/Elements/PubSubItems.h>
+#include <Swiften/Elements/PubSubPublish.h>
+#include <Swiften/JID/JID.h>
+#include <Swiften/Queries/IQRouter.h>
+
+#include <Swift/Controllers/FdpFormSubmitController.h>
+#include <Swift/Controllers/UIEvents/FdpFormSubmitWindowOpenUIEvent.h>
+#include <Swift/Controllers/UIEvents/UIEventStream.h>
+#include <Swift/Controllers/UnitTest/MockFdpFormSubmitWindowFactory.h>
+#include <Swift/Controllers/UnitTest/MockFdpFormSubmitWindow.h>
+
+namespace Swift {
+
+class FdpFormSubmitControllerTest : public ::testing::Test {
+
+    protected:
+        void SetUp() {
+            clientJid_ = JID(clientJIDString_);
+            stanzaChannel_ = std::make_unique<DummyStanzaChannel>();
+            iqRouter_ = std::make_unique<IQRouter>(stanzaChannel_.get());
+            uiEventStream_ = std::make_unique<UIEventStream>();
+            fdpWindowFactory_ = std::make_unique<MockFdpFormSubmitWindowFactory>();
+            fdpController_ = std::make_unique<FdpFormSubmitController>(clientJid_, iqRouter_.get(), uiEventStream_.get(), fdpWindowFactory_.get());
+            auto fdpWindowOpenUIEvent = std::make_shared<FdpFormSubmitWindowOpenUIEvent>();
+            uiEventStream_->send(fdpWindowOpenUIEvent);
+            fdpWindow_ = fdpWindowFactory_->getMockFdpFormSubmitWindow();
+        }
+
+        void TearDown() {
+        }
+
+        std::shared_ptr<DiscoItems> createDiscoItemsResult();
+        std::shared_ptr<PubSub> createTemplatePubSubResult(const std::shared_ptr<Form>& form);
+        std::shared_ptr<PubSub> createSubmittedPubSubResult();
+
+        std::string clientJIDString_ = "testjid@test.im/swift";
+        JID clientJid_;
+        std::unique_ptr<DummyStanzaChannel> stanzaChannel_;
+        std::unique_ptr<IQRouter> iqRouter_;
+        std::unique_ptr<UIEventStream> uiEventStream_;
+        std::unique_ptr<MockFdpFormSubmitWindowFactory> fdpWindowFactory_;
+        std::unique_ptr<FdpFormSubmitController> fdpController_;
+        MockFdpFormSubmitWindow* fdpWindow_;
+};
+
+std::shared_ptr<DiscoItems> FdpFormSubmitControllerTest::createDiscoItemsResult() {
+    auto discoItems = std::make_shared<DiscoItems>();
+    discoItems->addItem(DiscoItems::Item("node0", JID(), "fdp/template/testNode0"));
+    discoItems->addItem(DiscoItems::Item("node1", JID(), "fdp/template/testNode1"));
+    discoItems->addItem(DiscoItems::Item("node2", JID(), "fdp/template/testNode2"));
+    return discoItems;
+}
+
+std::shared_ptr<PubSub> FdpFormSubmitControllerTest::createTemplatePubSubResult(const std::shared_ptr<Form>& form) {
+    auto pubSubItem = std::make_shared<PubSubItem>();
+    pubSubItem->addData(form);
+    auto pubSubItems = std::make_shared<PubSubItems>();
+    pubSubItems->addItem(pubSubItem);
+    auto pubSub = std::make_shared<PubSub>();
+    pubSub->setPayload(pubSubItems);
+    return pubSub;
+}
+
+std::shared_ptr<PubSub> FdpFormSubmitControllerTest::createSubmittedPubSubResult() {
+    auto pubSubItem = std::make_shared<PubSubItem>();
+    pubSubItem->setID("testID");
+    auto pubSubPublish = std::make_shared<PubSubPublish>();
+    pubSubPublish->addItem(pubSubItem);
+    pubSubPublish->setNode("fdp/submitted/test");
+    auto pubSub = std::make_shared<PubSub>();
+    pubSub->setPayload(pubSubPublish);
+    return pubSub;
+}
+
+TEST_F(FdpFormSubmitControllerTest, testRequestPubSubNodeData) {
+    std::string domainName = "fdp.example.test";
+    fdpWindow_->onRequestPubSubNodeData(domainName);
+    ASSERT_EQ(1, stanzaChannel_->sentStanzas.size());
+    auto requestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
+    ASSERT_EQ(domainName, requestIq->getTo());
+    auto discoItemsPayloads = requestIq->getPayloads<DiscoItems>();
+    ASSERT_EQ(1, discoItemsPayloads.size());
+
+    auto discoItemsResult = createDiscoItemsResult();
+    auto resultIq = IQ::createResult(clientJid_, domainName, requestIq->getID(), discoItemsResult);
+    stanzaChannel_->onIQReceived(resultIq);
+
+    auto discoItemsList = discoItemsResult->getItems();
+    ASSERT_EQ(discoItemsList.size(), fdpWindow_->nodeData.size());
+    for (unsigned int i = 0; i < fdpWindow_->nodeData.size(); i++) {
+        auto nodeItem = fdpWindow_->nodeData[i];
+        auto discoItem = discoItemsList[i];
+        ASSERT_EQ(discoItem.getNode(), nodeItem.first);
+        ASSERT_EQ(discoItem.getName(), nodeItem.second);
+    }
+    ASSERT_EQ(FdpFormSubmitWindow::NodeError::NoError, fdpWindow_->nodeError_);
+}
+
+TEST_F(FdpFormSubmitControllerTest, testRequestPubSubNodeDataError) {
+    std::string domainName = "fdp.example.test";
+    fdpWindow_->onRequestPubSubNodeData(domainName);
+    ASSERT_EQ(1, stanzaChannel_->sentStanzas.size());
+    auto requestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
+    ASSERT_EQ(domainName, requestIq->getTo());
+
+    auto resultIq = IQ::createError(clientJid_, domainName, requestIq->getID());
+    stanzaChannel_->onIQReceived(resultIq);
+
+    ASSERT_EQ(true, fdpWindow_->nodeData.empty());
+    ASSERT_EQ(FdpFormSubmitWindow::NodeError::DomainNotFound, fdpWindow_->nodeError_);
+}
+
+TEST_F(FdpFormSubmitControllerTest, testRequestTemplateForm) {
+    std::string domainName = "fdp.example.test";
+    fdpWindow_->onRequestPubSubNodeData(domainName);
+    auto nodeDataRequestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
+    auto discoItemsResult = createDiscoItemsResult();
+    auto discoItemsResultIq = IQ::createResult(clientJid_, domainName, nodeDataRequestIq->getID(), discoItemsResult);
+    stanzaChannel_->onIQReceived(discoItemsResultIq);
+
+    std::string templateNodeName = "fdp/template/test";
+    fdpWindow_->onRequestTemplateForm(templateNodeName);
+    ASSERT_EQ(2, stanzaChannel_->sentStanzas.size());
+    auto requestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[1]);
+    ASSERT_EQ(domainName, requestIq->getTo());
+    auto pubSubPayloads = requestIq->getPayloads<PubSub>();
+    ASSERT_EQ(1, pubSubPayloads.size());
+
+    std::string value0("value0");
+    std::string value1("value1@example.test");
+    auto field0 = std::make_shared<FormField>(FormField::TextSingleType, value0);
+    auto field1 = std::make_shared<FormField>(FormField::JIDSingleType, value1);
+    auto form = std::make_shared<Form>();
+    form->addField(field0);
+    form->addField(field1);
+    auto pubSubResult = createTemplatePubSubResult(form);
+    auto resultIq = IQ::createResult(clientJid_, domainName, requestIq->getID(), pubSubResult);
+    stanzaChannel_->onIQReceived(resultIq);
+
+    ASSERT_EQ(form, fdpWindow_->templateForm_);
+    auto fields = fdpWindow_->templateForm_->getFields();
+    ASSERT_EQ(2, fields.size());
+    ASSERT_EQ(field0, fields[0]);
+    ASSERT_EQ(field1, fields[1]);
+    ASSERT_EQ(value0, fields[0]->getTextSingleValue());
+    ASSERT_EQ(value1, fields[1]->getJIDSingleValue());
+    ASSERT_EQ(FdpFormSubmitWindow::TemplateError::NoError, fdpWindow_->templateError_);
+}
+
+TEST_F(FdpFormSubmitControllerTest, testRequestTemplateFormError) {
+    std::string domainName = "fdp.example.test";
+    fdpWindow_->onRequestPubSubNodeData(domainName);
+    auto nodeDataRequestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
+    auto discoItemsResult = createDiscoItemsResult();
+    auto discoItemsResultIq = IQ::createResult(clientJid_, domainName, nodeDataRequestIq->getID(), discoItemsResult);
+    stanzaChannel_->onIQReceived(discoItemsResultIq);
+
+    std::string templateNodeName = "fdp/template/test";
+    fdpWindow_->onRequestTemplateForm(templateNodeName);
+    ASSERT_EQ(2, stanzaChannel_->sentStanzas.size());
+    auto requestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[1]);
+    ASSERT_EQ(domainName, requestIq->getTo());
+
+    auto resultIq = IQ::createError(clientJid_, domainName, requestIq->getID());
+    stanzaChannel_->onIQReceived(resultIq);
+
+    ASSERT_EQ(nullptr, fdpWindow_->templateForm_);
+    ASSERT_EQ(FdpFormSubmitWindow::TemplateError::RequestFailed, fdpWindow_->templateError_);
+}
+
+TEST_F(FdpFormSubmitControllerTest, testSubmitForm) {
+    std::string domainName = "fdp.example.test";
+    std::string templateNodeName = "fdp/template/test";
+    fdpWindow_->onRequestPubSubNodeData(domainName);
+    auto nodeDataRequestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
+    auto discoItemsResult = createDiscoItemsResult();
+    auto discoItemsResultIq = IQ::createResult(clientJid_, domainName, nodeDataRequestIq->getID(), discoItemsResult);
+    stanzaChannel_->onIQReceived(discoItemsResultIq);
+    fdpWindow_->onRequestTemplateForm(templateNodeName);
+    auto templateFormRequestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[1]);
+    auto templateForm = std::make_shared<Form>();
+    auto templatePubSubResult = createTemplatePubSubResult(templateForm);
+    auto templatePubSubResultIq = IQ::createResult(clientJid_, domainName, templateFormRequestIq->getID(), templatePubSubResult);
+    stanzaChannel_->onIQReceived(templatePubSubResultIq);
+
+    std::string value0("value0");
+    std::string value1("value1@example.test");
+    auto field0 = std::make_shared<FormField>(FormField::TextSingleType, value0);
+    auto field1 = std::make_shared<FormField>(FormField::JIDSingleType, value1);
+    auto form = std::make_shared<Form>();
+    form->addField(field0);
+    form->addField(field1);
+    fdpWindow_->onSubmitForm(form);
+
+    ASSERT_EQ(3, stanzaChannel_->sentStanzas.size());
+    auto requestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[2]);
+    ASSERT_EQ(domainName, requestIq->getTo());
+    auto pubSubPayloads = requestIq->getPayloads<PubSub>();
+    ASSERT_EQ(1, pubSubPayloads.size());
+    auto pubSubPayload = pubSubPayloads[0];
+    auto pubSubPublishPayload = std::dynamic_pointer_cast<PubSubPublish>(pubSubPayload->getPayload());
+    ASSERT_TRUE(pubSubPublishPayload);
+    auto pubSubItems = pubSubPublishPayload->getItems();
+    ASSERT_EQ(1, pubSubItems.size());
+    auto dataList = pubSubItems[0]->getData();
+    ASSERT_EQ(1, dataList.size());
+    auto submittedForm = std::dynamic_pointer_cast<Form>(dataList[0]);
+    ASSERT_TRUE(submittedForm);
+    ASSERT_EQ(form, submittedForm);
+    auto fields = submittedForm->getFields();
+    ASSERT_EQ(2, fields.size());
+    ASSERT_EQ(field0, fields[0]);
+    ASSERT_EQ(field1, fields[1]);
+    ASSERT_EQ(value0, fields[0]->getTextSingleValue());
+    ASSERT_EQ(value1, fields[1]->getJIDSingleValue());
+
+    auto pubSubResult = createSubmittedPubSubResult();
+    auto resultIq = IQ::createResult(clientJid_, domainName, requestIq->getID(), pubSubResult);
+    stanzaChannel_->onIQReceived(resultIq);
+
+    ASSERT_EQ(true, fdpWindow_->submissionSuccess_);
+}
+
+TEST_F(FdpFormSubmitControllerTest, testSubmitFormError) {
+    std::string domainName = "fdp.example.test";
+    std::string templateNodeName = "fdp/template/test";
+    fdpWindow_->onRequestPubSubNodeData(domainName);
+    auto nodeDataRequestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
+    auto discoItemsResult = createDiscoItemsResult();
+    auto discoItemsResultIq = IQ::createResult(clientJid_, domainName, nodeDataRequestIq->getID(), discoItemsResult);
+    stanzaChannel_->onIQReceived(discoItemsResultIq);
+    fdpWindow_->onRequestTemplateForm(templateNodeName);
+    auto templateFormRequestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[1]);
+    auto templateForm = std::make_shared<Form>();
+    auto templatePubSubResult = createTemplatePubSubResult(templateForm);
+    auto templatePubSubResultIq = IQ::createResult(clientJid_, domainName, templateFormRequestIq->getID(), templatePubSubResult);
+    stanzaChannel_->onIQReceived(templatePubSubResultIq);
+
+    auto form = std::make_shared<Form>();
+    fdpWindow_->onSubmitForm(form);
+    ASSERT_EQ(3, stanzaChannel_->sentStanzas.size());
+    auto requestIq = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[2]);
+    ASSERT_EQ(domainName, requestIq->getTo());
+
+    auto resultIq = IQ::createError(clientJid_, domainName, requestIq->getID());
+    stanzaChannel_->onIQReceived(resultIq);
+
+    ASSERT_EQ(false, fdpWindow_->submissionSuccess_);
+}
+
+}
diff --git a/Swift/Controllers/UnitTest/HighlightRuleTest.cpp b/Swift/Controllers/UnitTest/HighlightRuleTest.cpp
deleted file mode 100644
index ec81227..0000000
--- a/Swift/Controllers/UnitTest/HighlightRuleTest.cpp
+++ /dev/null
@@ -1,318 +0,0 @@
-/*
- * Copyright (c) 2012 Maciej Niedzielski
- * Licensed under the simplified BSD license.
- * See Documentation/Licenses/BSD-simplified.txt for more information.
- */
-
-#include <vector>
-#include <string>
-
-#include <cppunit/extensions/HelperMacros.h>
-#include <cppunit/extensions/TestFactoryRegistry.h>
-
-#include <Swift/Controllers/HighlightRule.h>
-
-using namespace Swift;
-
-class HighlightRuleTest : public CppUnit::TestFixture {
-		CPPUNIT_TEST_SUITE(HighlightRuleTest);
-		CPPUNIT_TEST(testEmptyRuleNeverMatches);
-		CPPUNIT_TEST(testKeyword);
-		CPPUNIT_TEST(testNickKeyword);
-		CPPUNIT_TEST(testNickWithoutOtherKeywords);
-		CPPUNIT_TEST(testSender);
-		CPPUNIT_TEST(testSenderAndKeyword);
-		CPPUNIT_TEST(testWholeWords);
-		CPPUNIT_TEST(testCase);
-		CPPUNIT_TEST(testWholeWordsAndCase);
-		CPPUNIT_TEST(testMUC);
-		CPPUNIT_TEST_SUITE_END();
-
-	public:
-		void setUp() {
-			std::vector<std::string> keywords;
-			keywords.push_back("keyword1");
-			keywords.push_back("KEYWORD2");
-
-			std::vector<std::string>senders;
-			senders.push_back("sender1");
-			senders.push_back("SENDER2");
-
-			emptyRule = new HighlightRule();
-
-			keywordRule = new HighlightRule();
-			keywordRule->setKeywords(keywords);
-
-			keywordChatRule = new HighlightRule();
-			keywordChatRule->setKeywords(keywords);
-			keywordChatRule->setMatchChat(true);
-
-			keywordNickChatRule = new HighlightRule();
-			keywordNickChatRule->setKeywords(keywords);
-			keywordNickChatRule->setNickIsKeyword(true);
-			keywordNickChatRule->setMatchChat(true);
-
-			nickChatRule = new HighlightRule();
-			nickChatRule->setNickIsKeyword(true);
-			nickChatRule->setMatchChat(true);
-
-			nickRule = new HighlightRule();
-			nickRule->setNickIsKeyword(true);
-
-			senderRule = new HighlightRule();
-			senderRule->setSenders(senders);
-
-			senderChatRule = new HighlightRule();
-			senderChatRule->setSenders(senders);
-			senderChatRule->setMatchChat(true);
-
-			senderKeywordChatRule = new HighlightRule();
-			senderKeywordChatRule->setSenders(senders);
-			senderKeywordChatRule->setKeywords(keywords);
-			senderKeywordChatRule->setMatchChat(true);
-
-			senderKeywordNickChatRule = new HighlightRule();
-			senderKeywordNickChatRule->setSenders(senders);
-			senderKeywordNickChatRule->setKeywords(keywords);
-			senderKeywordNickChatRule->setNickIsKeyword(true);
-			senderKeywordNickChatRule->setMatchChat(true);
-
-			senderKeywordNickWordChatRule = new HighlightRule();
-			senderKeywordNickWordChatRule->setSenders(senders);
-			senderKeywordNickWordChatRule->setKeywords(keywords);
-			senderKeywordNickWordChatRule->setNickIsKeyword(true);
-			senderKeywordNickWordChatRule->setMatchWholeWords(true);
-			senderKeywordNickWordChatRule->setMatchChat(true);
-
-			senderKeywordNickCaseChatRule = new HighlightRule();
-			senderKeywordNickCaseChatRule->setSenders(senders);
-			senderKeywordNickCaseChatRule->setKeywords(keywords);
-			senderKeywordNickCaseChatRule->setNickIsKeyword(true);
-			senderKeywordNickCaseChatRule->setMatchCase(true);
-			senderKeywordNickCaseChatRule->setMatchChat(true);
-
-			senderKeywordNickCaseWordChatRule = new HighlightRule();
-			senderKeywordNickCaseWordChatRule->setSenders(senders);
-			senderKeywordNickCaseWordChatRule->setKeywords(keywords);
-			senderKeywordNickCaseWordChatRule->setNickIsKeyword(true);
-			senderKeywordNickCaseWordChatRule->setMatchCase(true);
-			senderKeywordNickCaseWordChatRule->setMatchWholeWords(true);
-			senderKeywordNickCaseWordChatRule->setMatchChat(true);
-
-			senderKeywordNickMUCRule = new HighlightRule();
-			senderKeywordNickMUCRule->setSenders(senders);
-			senderKeywordNickMUCRule->setKeywords(keywords);
-			senderKeywordNickMUCRule->setNickIsKeyword(true);
-			senderKeywordNickMUCRule->setMatchMUC(true);
-		}
-
-		void tearDown() {
-			delete emptyRule;
-
-			delete keywordRule;
-			delete keywordChatRule;
-			delete keywordNickChatRule;
-			delete nickChatRule;
-			delete nickRule;
-
-			delete senderRule;
-			delete senderChatRule;
-			delete senderKeywordChatRule;
-			delete senderKeywordNickChatRule;
-
-			delete senderKeywordNickWordChatRule;
-			delete senderKeywordNickCaseChatRule;
-			delete senderKeywordNickCaseWordChatRule;
-
-			delete senderKeywordNickMUCRule;
-		}
-
-		void testEmptyRuleNeverMatches() {
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "from", "nick", HighlightRule::MUCMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "from", "", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "from", "", HighlightRule::MUCMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "", "nick", HighlightRule::MUCMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "from", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "from", "nick", HighlightRule::MUCMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "", "", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "", "", HighlightRule::MUCMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "from", "", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "from", "", HighlightRule::MUCMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "", "nick", HighlightRule::MUCMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "", "", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "", "", HighlightRule::MUCMessage), false);
-		}
-
-		void testKeyword() {
-			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("body", "from", "nick", HighlightRule::MUCMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("keyword1", "from", "nick", HighlightRule::MUCMessage), false);
-			CPPUNIT_ASSERT_EQUAL(keywordRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("body", "sender contains keyword1", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("abc keyword1 xyz", "from", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("abckeyword1xyz", "from", "nick", HighlightRule::ChatMessage), true);
-
-			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("KEYword1", "from", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("abc KEYword1 xyz", "from", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("abcKEYword1xyz", "from", "nick", HighlightRule::ChatMessage), true);
-
-			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("keyword2", "from", "nick", HighlightRule::ChatMessage), true);
-		}
-
-		void testNickKeyword() {
-			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::MUCMessage), false);
-			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), true);
-
-			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body", "sender contains nick", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body contains mixed-case NiCk", "sender", "nick", HighlightRule::ChatMessage), true);
-
-			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("nickname", "from", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("NIckNAME", "from", "nick", HighlightRule::ChatMessage), true);
-
-			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body", "from", "", HighlightRule::ChatMessage), false);
-		}
-
-		void testNickWithoutOtherKeywords() {
-			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::MUCMessage), false);
-			CPPUNIT_ASSERT_EQUAL(nickRule->isMatch("body contains nick", "from", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body", "sender contains nick but it does't matter", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body contains mixed-case NiCk", "from", "nick", HighlightRule::ChatMessage), true);
-
-			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("nickname", "from", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("NIckNAME", "from", "nick", HighlightRule::ChatMessage), true);
-
-			// there are no keywords in this rule and empty nick is not treated as a keyword, so we don't check for keywords to get a match
-			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body", "from", "", HighlightRule::ChatMessage), true);
-		}
-
-		void testSender() {
-			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "from", "nick", HighlightRule::MUCMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "sender1", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "sender1", "nick", HighlightRule::MUCMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderRule->isMatch("body", "sender1", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(senderRule->isMatch("body contains sender1", "from", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "abc sender1 xyz", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "abcsender1xyz", "nick", HighlightRule::ChatMessage), true);
-
-			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "SENDer1", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "abc SENDer1 xyz", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "abcSENDer1xyz", "nick", HighlightRule::ChatMessage), true);
-
-			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "sender2", "nick", HighlightRule::ChatMessage), true);
-		}
-
-		void testSenderAndKeyword() {
-			CPPUNIT_ASSERT_EQUAL(senderKeywordChatRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordChatRule->isMatch("body", "sender1", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordChatRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), true);
-		}
-
-		void testWholeWords() {
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("body", "sender1", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("xkeyword1", "sender1", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("keyword1", "xsender1", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("body contains nick", "sender1", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("body contains xnick", "sender1", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("KEYword1", "SENDer1", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("body contains NiCk", "sender1", "nick", HighlightRule::ChatMessage), true);
-		}
-
-		void testCase() {
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("body", "sender1", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("xkeyword1", "xsender1", "nick", HighlightRule::ChatMessage), true);
-
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("body contains nick", "sender1", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("body contains xnick", "sender1", "nick", HighlightRule::ChatMessage), true);
-
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("KEYword1", "SENDer1", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("keyword1", "SENDer1", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("KEYword1", "sender1", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("body contains NiCk", "sender1", "nick", HighlightRule::ChatMessage), false);
-		}
-
-		void testWholeWordsAndCase() {
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("body", "sender1", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("xkeyword1", "sender1", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("keyword1", "xsender1", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("body contains nick", "sender1", "nick", HighlightRule::ChatMessage), true);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("body contains xnick", "sender1", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("KEYword1", "SENDer1", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("keyword1", "SENDer1", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("KEYword1", "sender1", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("body contains NiCk", "sender1", "nick", HighlightRule::ChatMessage), false);
-		}
-
-		void testMUC() {
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickMUCRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
-
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickMUCRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), false);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickMUCRule->isMatch("keyword1", "sender1", "nick", HighlightRule::MUCMessage), true);
-			CPPUNIT_ASSERT_EQUAL(senderKeywordNickMUCRule->isMatch("body contains nick", "sender1", "nick", HighlightRule::MUCMessage), true);
-		}
-
-	private:
-		HighlightRule* emptyRule;
-
-		HighlightRule* keywordRule;
-		HighlightRule* keywordChatRule;
-		HighlightRule* keywordNickChatRule;
-		HighlightRule* nickChatRule;
-		HighlightRule* nickRule;
-
-		HighlightRule* senderRule;
-		HighlightRule* senderChatRule;
-		HighlightRule* senderKeywordChatRule;
-		HighlightRule* senderKeywordNickChatRule;
-
-		HighlightRule* senderKeywordNickWordChatRule;
-		HighlightRule* senderKeywordNickCaseChatRule;
-		HighlightRule* senderKeywordNickCaseWordChatRule;
-
-		HighlightRule* senderKeywordNickMUCRule;
-};
-
-CPPUNIT_TEST_SUITE_REGISTRATION(HighlightRuleTest);
diff --git a/Swift/Controllers/UnitTest/MockChatWindow.cpp b/Swift/Controllers/UnitTest/MockChatWindow.cpp
index 494bc46..f0f666a 100644
--- a/Swift/Controllers/UnitTest/MockChatWindow.cpp
+++ b/Swift/Controllers/UnitTest/MockChatWindow.cpp
@@ -1,10 +1,10 @@
 /*
- * Copyright (c) 2010 Kevin Smith
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2016 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
-#include "Swift/Controllers/UnitTest/MockChatWindow.h"
+#include <Swift/Controllers/UnitTest/MockChatWindow.h>
 
 namespace Swift {
 MockChatWindow::~MockChatWindow() {
diff --git a/Swift/Controllers/UnitTest/MockChatWindow.h b/Swift/Controllers/UnitTest/MockChatWindow.h
index 43779c5..38b3b1f 100644
--- a/Swift/Controllers/UnitTest/MockChatWindow.h
+++ b/Swift/Controllers/UnitTest/MockChatWindow.h
@@ -1,91 +1,172 @@
 /*
- * Copyright (c) 2010 Kevin Smith
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2017 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
 #pragma once
 
-#include <boost/shared_ptr.hpp>
+#include <memory>
+#include <string>
 
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
-#include <Swiften/Base/foreach.h>
-
 
 namespace Swift {
-	class MockChatWindow : public ChatWindow {
-		public:
-			MockChatWindow() : labelsEnabled_(false) {}
-			virtual ~MockChatWindow();
-
-			virtual std::string addMessage(const ChatMessage& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {
-			lastMessageBody_ = bodyFromMessage(message); return "id";}
-
-			virtual std::string addAction(const ChatMessage& /*message*/, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {return "id";}
-
-			virtual void addSystemMessage(const ChatMessage& /*message*/, Direction /*direction*/) {}
-			virtual void addPresenceMessage(const ChatMessage& /*message*/, Direction /*direction*/) {}
-
-			virtual void addErrorMessage(const ChatMessage& /*message*/) {}
-			virtual void replaceMessage(const ChatMessage& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {}
-			virtual void replaceWithAction(const ChatMessage& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {}
-			virtual void replaceLastMessage(const ChatMessage& /*message*/) {}
-
-			// File transfer related stuff
-			virtual std::string addFileTransfer(const std::string& /*senderName*/, bool /*senderIsSelf*/,const std::string& /*filename*/, const boost::uintmax_t /*sizeInBytes*/) { return 0; }
-			virtual void setFileTransferProgress(std::string /*id*/, const int /*alreadyTransferedBytes*/) { }
-			virtual void setFileTransferStatus(std::string /*id*/, const FileTransferState /*state*/, const std::string& /*msg*/) { }
-			
-			virtual void setMessageReceiptState(const std::string &/* id */, ReceiptState /* state */) { }
-
-			virtual void setContactChatState(ChatState::ChatStateType /*state*/) {}
-			virtual void setName(const std::string& name) {name_ = name;}
-			virtual void show() {}
-			virtual void activate() {}
-			virtual void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) {labels_ = labels;}
-			virtual void setSecurityLabelsEnabled(bool enabled) {labelsEnabled_ = enabled;}
-			virtual void setUnreadMessageCount(int /*count*/) {}
-			virtual void convertToMUC(bool /*impromptuMUC*/) {}
-			virtual void setSecurityLabelsError() {}
-			virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() {return label_;}
-			virtual void setInputEnabled(bool /*enabled*/) {}
-			virtual void setRosterModel(Roster* /*roster*/) {}
-			virtual void setTabComplete(TabComplete*) {}
-
-			void setAckState(const std::string& /*id*/, AckState /*state*/) {}
-			virtual void flash() {}
-			virtual void setAlert(const std::string& /*alertText*/, const std::string& /*buttonText*/) {}
-			virtual void cancelAlert() {}
-			virtual void setCorrectionEnabled(Tristate /*enabled*/) {}
-			void setAvailableOccupantActions(const std::vector<OccupantAction>&/* actions*/) {}
-			void setSubject(const std::string& /*subject*/) {}
-			virtual void showRoomConfigurationForm(Form::ref) {}
-			virtual void addMUCInvitation(const std::string& /*senderName*/, const JID& /*jid*/, const std::string& /*reason*/, const std::string& /*password*/, bool = true, bool = false, bool = false) {}
-
-			virtual std::string addWhiteboardRequest(bool) {return "";}
-			virtual void setWhiteboardSessionStatus(std::string, const ChatWindow::WhiteboardSessionState){}
-
-			virtual void setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&) {}
-			virtual void setAvailableRoomActions(const std::vector<RoomAction> &) {}
-
-			virtual void setBlockingState(BlockingState) {}
-			virtual void setCanInitiateImpromptuChats(bool /*supportsImpromptu*/) {}
-
-			std::string bodyFromMessage(const ChatMessage& message) {
-				boost::shared_ptr<ChatTextMessagePart> text;
-				foreach (boost::shared_ptr<ChatMessagePart> part, message.getParts()) {
-					if ((text = boost::dynamic_pointer_cast<ChatTextMessagePart>(part))) {
-						return text->text;
-					}
-				}
-				return "";
-			}
-
-			std::string name_;
-			std::string lastMessageBody_;
-			std::vector<SecurityLabelsCatalog::Item> labels_;
-			bool labelsEnabled_;
-			SecurityLabelsCatalog::Item label_;
-	};
+    class MockChatWindow : public ChatWindow {
+        public:
+            MockChatWindow() {}
+            virtual ~MockChatWindow();
+
+            virtual std::string addMessage(const ChatMessage& message, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/) {
+                lastAddedMessage_ = message;
+                lastAddedMessageSenderName_ = senderName;
+                lastAddedMessageSenderIsSelf_ = senderIsSelf;
+                lastAddedMessageSecurityLabel_ = label;
+                return "id";
+            }
+
+            virtual std::string addAction(const ChatMessage& message, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/) {
+                lastAddedAction_ = message;
+                lastAddedActionSenderName_ = senderName;
+                lastAddedActionSenderIsSelf_ = senderIsSelf;
+                return "id";
+            }
+
+            virtual std::string addSystemMessage(const ChatMessage& message, Direction /*direction*/) {
+                lastAddedSystemMessage_ = message;
+                return "id";
+            }
+
+            virtual void addPresenceMessage(const ChatMessage& message, Direction /*direction*/) {
+                lastAddedPresence_ = message;
+            }
+
+            virtual void addErrorMessage(const ChatMessage& message) {
+                lastAddedErrorMessage_ = message;
+            }
+
+            virtual void replaceMessage(const ChatMessage& message, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/) {
+                lastReplacedMessage_ = message;
+            }
+
+            virtual void replaceWithAction(const ChatMessage& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/) {}
+            virtual void replaceLastMessage(const ChatMessage& message, const TimestampBehaviour /*timestampBehaviour*/) {
+                lastReplacedLastMessage_ = message;
+            }
+            virtual void replaceSystemMessage(const ChatMessage& message, const std::string& /*id*/, const TimestampBehaviour /*timestampBehaviour*/) {
+                lastReplacedSystemMessage_ = message;
+            }
+
+            // File transfer related stuff
+            virtual std::string addFileTransfer(const std::string& /*senderName*/, const std::string& /*avatarPath*/, bool /*senderIsSelf*/,const std::string& /*filename*/, const boost::uintmax_t /*sizeInBytes*/, const std::string& /*description*/) { return nullptr; }
+            virtual void setFileTransferProgress(std::string /*id*/, const int /*alreadyTransferedBytes*/) { }
+            virtual void setFileTransferStatus(std::string /*id*/, const FileTransferState /*state*/, const std::string& /*msg*/) { }
+
+            virtual void setMessageReceiptState(const std::string & id, ReceiptState state) {
+                receiptChanges_.emplace_back(id, state);
+            }
+
+            virtual void setContactChatState(ChatState::ChatStateType /*state*/) {}
+            virtual void setName(const std::string& name) {name_ = name;}
+            virtual void show() {}
+            virtual bool isVisible() const { return true; }
+            virtual void activate() {}
+            virtual void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) {labels_ = labels;}
+            virtual void setSecurityLabelsEnabled(bool enabled) {labelsEnabled_ = enabled;}
+            virtual void setUnreadMessageCount(size_t /*count*/) {}
+
+            virtual void convertToMUC(MUCType mucType) {
+                mucType_ = mucType;
+            }
+
+            virtual void setSecurityLabelsError() {}
+            virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() {return label_;}
+            virtual void setOnline(bool /*online*/) {}
+            virtual void setRosterModel(Roster* roster) { roster_ = roster; }
+            Roster* getRosterModel() { return roster_; }
+            virtual void setTabComplete(TabComplete*) {}
+
+            void setAckState(const std::string& /*id*/, AckState /*state*/) {}
+            virtual void flash() {}
+            virtual AlertID addAlert(const std::string& /*alertText*/) { return 0; }
+            virtual void removeAlert(const AlertID /*id*/) {}
+            virtual void setCorrectionEnabled(Tristate /*enabled*/) {}
+            virtual void setFileTransferEnabled(Tristate /*enabled*/) {}
+            void setAvailableOccupantActions(const std::vector<OccupantAction>&/* actions*/) {}
+            void setSubject(const std::string& /*subject*/) {}
+            virtual void showRoomConfigurationForm(Form::ref) {}
+            virtual void addMUCInvitation(const std::string& /*senderName*/, const JID& jid, const std::string& /*reason*/, const std::string& /*password*/, bool = true, bool = false, bool = false) {
+                lastMUCInvitationJID_ = jid;
+            }
+
+            virtual std::string addWhiteboardRequest(bool) {return "";}
+            virtual void setWhiteboardSessionStatus(std::string, const ChatWindow::WhiteboardSessionState){}
+
+            virtual void setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&) {}
+            virtual void setAvailableRoomActions(const std::vector<RoomAction> &) {}
+
+            virtual void setBlockingState(BlockingState) {}
+            virtual void setCanInitiateImpromptuChats(bool supportsImpromptu) {
+                impromptuMUCSupported_ = supportsImpromptu;
+            }
+
+            virtual void showBookmarkWindow(const MUCBookmark& /*bookmark*/) {}
+            virtual void setBookmarkState(RoomBookmarkState) {}
+
+            static std::string bodyFromMessage(const ChatMessage& message) {
+                std::string body;
+                std::shared_ptr<ChatTextMessagePart> text;
+                std::shared_ptr<ChatHighlightingMessagePart> highlight;
+                for (auto &&part : message.getParts()) {
+                    if ((text = std::dynamic_pointer_cast<ChatTextMessagePart>(part))) {
+                        body += text->text;
+                    }
+                    else if ((highlight = std::dynamic_pointer_cast<ChatHighlightingMessagePart>(part))) {
+                        body += highlight->text;
+                    }
+                }
+                return body;
+            }
+
+            void resetLastMessages() {
+                lastAddedMessage_ = lastAddedAction_ = lastAddedPresence_ = lastReplacedLastMessage_ = lastAddedSystemMessage_ = lastReplacedSystemMessage_ = ChatMessage();
+                lastAddedMessageSenderName_ = lastAddedActionSenderName_ = "";
+                lastAddedMessageSenderIsSelf_ = lastAddedActionSenderIsSelf_ = false;
+            }
+
+            void setChatSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) {
+                markingValue_ = markingValue;
+                markingForegroundColorValue_ = markingForegroundColorValue;
+                markingBackgroundColorValue_ = markingBackgroundColorValue;
+            }
+
+            void removeChatSecurityMarking() {}
+
+            std::string name_;
+            ChatMessage lastAddedMessage_;
+            std::string lastAddedMessageSenderName_;
+            bool lastAddedMessageSenderIsSelf_ = false;
+            std::shared_ptr<SecurityLabel> lastAddedMessageSecurityLabel_ = nullptr;
+            ChatMessage lastAddedAction_;
+            std::string lastAddedActionSenderName_;
+            bool lastAddedActionSenderIsSelf_ = false;
+            ChatMessage lastAddedPresence_;
+            ChatMessage lastReplacedMessage_;
+            ChatMessage lastReplacedLastMessage_;
+            ChatMessage lastAddedSystemMessage_;
+            ChatMessage lastReplacedSystemMessage_;
+            ChatMessage lastAddedErrorMessage_;
+            JID lastMUCInvitationJID_;
+            std::vector<SecurityLabelsCatalog::Item> labels_;
+            bool labelsEnabled_ = false;
+            bool impromptuMUCSupported_ = false;
+            SecurityLabelsCatalog::Item label_;
+            Roster* roster_ = nullptr;
+            std::vector<std::pair<std::string, ReceiptState>> receiptChanges_;
+            boost::optional<MUCType> mucType_;
+            std::string markingValue_;
+            std::string markingForegroundColorValue_;
+            std::string markingBackgroundColorValue_;
+    };
 }
 
diff --git a/Swift/Controllers/UnitTest/MockFdpFormSubmitWindow.h b/Swift/Controllers/UnitTest/MockFdpFormSubmitWindow.h
new file mode 100644
index 0000000..28ef35f
--- /dev/null
+++ b/Swift/Controllers/UnitTest/MockFdpFormSubmitWindow.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2018 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include <Swift/Controllers/UIInterfaces/FdpFormSubmitWindow.h>
+
+namespace Swift {
+
+    class Form;
+
+    class MockFdpFormSubmitWindow : public FdpFormSubmitWindow {
+        public:
+            MockFdpFormSubmitWindow() : FdpFormSubmitWindow() {}
+            virtual void show() override {}
+            virtual void raise() override {}
+            virtual void addNode(const std::string& node, const std::string& nodeName) override { nodeData.push_back(std::pair<std::string, std::string>(node, nodeName)); }
+            virtual void clearNodeData() override { nodeData.clear(); }
+            virtual void setFormData(const std::shared_ptr<Form>& form) override { templateForm_ = form; }
+            virtual void showNodePlaceholder(NodeError nodeError) override { nodeError_ = nodeError; }
+            virtual void showFormPlaceholder(TemplateError templateError) override { templateError_ = templateError; }
+            virtual void handleSubmitServerResponse(bool submissionSuccess) override { submissionSuccess_ = submissionSuccess; }
+
+            std::vector<std::pair<std::string, std::string>> nodeData;
+            std::shared_ptr<Form> templateForm_ = nullptr;
+            NodeError nodeError_ = NodeError::NoError;
+            TemplateError templateError_ = TemplateError::NoError;
+            bool submissionSuccess_ = false;
+    };
+
+}
diff --git a/Swift/Controllers/UnitTest/MockFdpFormSubmitWindowFactory.h b/Swift/Controllers/UnitTest/MockFdpFormSubmitWindowFactory.h
new file mode 100644
index 0000000..8015419
--- /dev/null
+++ b/Swift/Controllers/UnitTest/MockFdpFormSubmitWindowFactory.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2018 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+
+#pragma once
+
+#include <memory>
+
+#include <Swift/Controllers/UIInterfaces/FdpFormSubmitWindowFactory.h>
+#include <Swift/Controllers/UnitTest/MockFdpFormSubmitWindow.h>
+
+namespace Swift {
+
+    class MockFdpFormSubmitWindowFactory : public FdpFormSubmitWindowFactory {
+        public:
+            MockFdpFormSubmitWindowFactory() : FdpFormSubmitWindowFactory() {}
+
+            virtual std::unique_ptr<FdpFormSubmitWindow> createFdpFormSubmitWindow() override {
+                std::unique_ptr<FdpFormSubmitWindow> fdpFormSubmitWindow = std::make_unique<MockFdpFormSubmitWindow>();
+                mockFdpFormSubmitWindow_ = static_cast<MockFdpFormSubmitWindow*>(fdpFormSubmitWindow.get());
+                return fdpFormSubmitWindow;
+            }
+
+            MockFdpFormSubmitWindow* getMockFdpFormSubmitWindow() { return mockFdpFormSubmitWindow_; }
+
+        private:
+            MockFdpFormSubmitWindow* mockFdpFormSubmitWindow_;
+    };
+}
diff --git a/Swift/Controllers/UnitTest/MockMainWindow.h b/Swift/Controllers/UnitTest/MockMainWindow.h
index 69a4e25..9265310 100644
--- a/Swift/Controllers/UnitTest/MockMainWindow.h
+++ b/Swift/Controllers/UnitTest/MockMainWindow.h
@@ -1,31 +1,33 @@
 /*
- * Copyright (c) 2010 Kevin Smith
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2018 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
 #pragma once
 
-#include "Swift/Controllers/UIInterfaces/MainWindow.h"
+#include <Swift/Controllers/UIInterfaces/MainWindow.h>
 
 namespace Swift {
-	class Roster;
-	class MockMainWindow : public MainWindow {
-		public:
-			MockMainWindow() : roster(NULL) {}
-			virtual ~MockMainWindow() {}
-			virtual void setRosterModel(Roster* roster) {this->roster = roster;}
-			virtual void setMyNick(const std::string& /*name*/) {}
-			virtual void setMyJID(const JID& /*jid*/) {}
-			virtual void setMyAvatarPath(const std::string& /*path*/) {}
-			virtual void setMyStatusText(const std::string& /*status*/) {}
-			virtual void setMyStatusType(StatusShow::Type /*type*/) {}
-			virtual void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& /*commands*/) {}
-			virtual void setConnecting() {}
-			virtual void setStreamEncryptionStatus(bool /*tlsInPlaceAndValid*/) {}
-			virtual void openCertificateDialog(const std::vector<Certificate::ref>& /*chain*/) {}
-			virtual void setBlockingCommandAvailable(bool /*isAvailable*/) {}
-			Roster* roster;
+    class Roster;
+    class MockMainWindow : public MainWindow {
+        public:
+            MockMainWindow() : roster(nullptr) {}
+            virtual ~MockMainWindow() {}
+            virtual void setRosterModel(Roster* roster) {this->roster = roster;}
+            virtual void setMyNick(const std::string& /*name*/) {}
+            virtual void setMyJID(const JID& /*jid*/) {}
+            virtual void setMyAvatarPath(const std::string& /*path*/) {}
+            virtual void setMyStatusText(const std::string& /*status*/) {}
+            virtual void setMyStatusType(StatusShow::Type /*type*/) {}
+            virtual void setMyContactRosterItem(std::shared_ptr<ContactRosterItem> /*contact*/) {}
+            virtual void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& /*commands*/) {}
+            virtual void setConnecting() {}
+            virtual void setStreamEncryptionStatus(bool /*tlsInPlaceAndValid*/) {}
+            virtual void openCertificateDialog(const std::vector<Certificate::ref>& /*chain*/) {}
+            virtual void setBlockingCommandAvailable(bool /*isAvailable*/) {}
+            virtual void openFdpFormSubmitDialog(const JID& /*self*/, IQRouter* /*iqRouter*/) {}
+            Roster* roster;
 
-	};
+    };
 }
diff --git a/Swift/Controllers/UnitTest/MockMainWindowFactory.h b/Swift/Controllers/UnitTest/MockMainWindowFactory.h
index 279a6dd..331ca11 100644
--- a/Swift/Controllers/UnitTest/MockMainWindowFactory.h
+++ b/Swift/Controllers/UnitTest/MockMainWindowFactory.h
@@ -1,28 +1,26 @@
 /*
- * Copyright (c) 2010 Kevin Smith
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2016 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
 #pragma once
 
-#include "Swift/Controllers/UIInterfaces/MainWindowFactory.h"
-#include "Swift/Controllers/UnitTest/MockMainWindow.h"
+#include <Swift/Controllers/UIInterfaces/MainWindowFactory.h>
+#include <Swift/Controllers/UnitTest/MockMainWindow.h>
 
 namespace Swift {
 
-	class MockMainWindowFactory : public MainWindowFactory {
-		public:
-			MockMainWindowFactory() : last(NULL) {}
+    class MockMainWindowFactory : public MainWindowFactory {
+        public:
+            MockMainWindowFactory() : last(nullptr) {}
 
-			virtual ~MockMainWindowFactory() {}
+            virtual ~MockMainWindowFactory() {}
 
-			/**
-			 * Transfers ownership of result.
-			 */
-			virtual MainWindow* createMainWindow(UIEventStream*) {last = new MockMainWindow();return last;}
-			MockMainWindow* last;
-	};
+            /**
+             * Transfers ownership of result.
+             */
+            virtual MainWindow* createMainWindow(Chattables&, UIEventStream*) {last = new MockMainWindow();return last;}
+            MockMainWindow* last;
+    };
 }
-
-
diff --git a/Swift/Controllers/UnitTest/PresenceNotifierTest.cpp b/Swift/Controllers/UnitTest/PresenceNotifierTest.cpp
index 3e9be13..1375475 100644
--- a/Swift/Controllers/UnitTest/PresenceNotifierTest.cpp
+++ b/Swift/Controllers/UnitTest/PresenceNotifierTest.cpp
@@ -1,318 +1,322 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2016 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
-#include <cppunit/extensions/HelperMacros.h>
-#include <cppunit/extensions/TestFactoryRegistry.h>
 #include <vector>
+
 #include <boost/bind.hpp>
 
-#include "Swift/Controllers/PresenceNotifier.h"
-#include "Swiften/Client/NickResolver.h"
-#include "SwifTools/Notifier/LoggingNotifier.h"
-#include "Swiften/Client/DummyStanzaChannel.h"
-#include "Swiften/MUC/MUCRegistry.h"
-#include "Swiften/Roster/XMPPRosterImpl.h"
-#include "Swiften/Presence/PresenceOracle.h"
-#include "Swiften/Avatars/DummyAvatarManager.h"
-#include "Swiften/Network/DummyTimerFactory.h"
+#include <cppunit/extensions/HelperMacros.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+
+#include <Swiften/Avatars/DummyAvatarManager.h>
+#include <Swiften/Client/DummyStanzaChannel.h>
+#include <Swiften/Client/NickResolver.h>
+#include <Swiften/MUC/MUCRegistry.h>
+#include <Swiften/Network/DummyTimerFactory.h>
+#include <Swiften/Presence/PresenceOracle.h>
+#include <Swiften/Roster/XMPPRosterImpl.h>
+
+#include <Swift/Controllers/PresenceNotifier.h>
+
+#include <SwifTools/Notifier/LoggingNotifier.h>
 
 using namespace Swift;
 
 class PresenceNotifierTest : public CppUnit::TestFixture {
-		CPPUNIT_TEST_SUITE(PresenceNotifierTest);
-		CPPUNIT_TEST(testReceiveFirstPresenceCreatesAvailableNotification);
-		CPPUNIT_TEST(testReceiveSecondPresenceCreatesStatusChangeNotification);
-		CPPUNIT_TEST(testReceiveUnavailablePresenceAfterAvailablePresenceCreatesUnavailableNotification);
-		CPPUNIT_TEST(testReceiveUnavailablePresenceWithoutAvailableDoesNotCreateNotification);
-		CPPUNIT_TEST(testReceiveAvailablePresenceAfterUnavailableCreatesAvailableNotification);
-		CPPUNIT_TEST(testReceiveAvailablePresenceAfterReconnectCreatesAvailableNotification);
-		CPPUNIT_TEST(testReceiveAvailablePresenceFromMUCDoesNotCreateNotification);
-		CPPUNIT_TEST(testNotificationSubjectContainsNameForJIDInRoster);
-		CPPUNIT_TEST(testNotificationSubjectContainsJIDForJIDNotInRoster);
-		CPPUNIT_TEST(testNotificationSubjectContainsStatus);
-		CPPUNIT_TEST(testNotificationMessageContainsStatusMessage);
-		CPPUNIT_TEST(testNotificationPicture);
-		CPPUNIT_TEST(testNotificationActivationEmitsSignal);
-		CPPUNIT_TEST(testReceiveFirstPresenceWithQuietPeriodDoesNotNotify);
-		CPPUNIT_TEST(testReceiveFirstPresenceWithQuietPeriodDoesNotCountAsQuietPeriod);
-		CPPUNIT_TEST(testReceivePresenceDuringQuietPeriodDoesNotNotify);
-		CPPUNIT_TEST(testReceivePresenceDuringQuietPeriodResetsTimer);
-		CPPUNIT_TEST(testReceivePresenceAfterQuietPeriodNotifies);
-		CPPUNIT_TEST(testReceiveFirstPresenceAfterReconnectWithQuietPeriodDoesNotNotify);
-		CPPUNIT_TEST_SUITE_END();
-
-	public:
-		void setUp() {
-			stanzaChannel = new DummyStanzaChannel();
-			notifier = new LoggingNotifier();
-			mucRegistry = new MUCRegistry();
-			user1 = JID("user1@bar.com/bla");
-			user2 = JID("user2@foo.com/baz");
-			avatarManager = new DummyAvatarManager();
-			roster = new XMPPRosterImpl();
-			nickResolver = new NickResolver(JID("foo@bar.com"), roster, NULL, mucRegistry);
-			presenceOracle = new PresenceOracle(stanzaChannel);
-			timerFactory = new DummyTimerFactory();
-		}
-
-		void tearDown() {
-			delete timerFactory;
-			delete presenceOracle;
-			delete nickResolver;
-			delete roster;
-			delete avatarManager;
-			delete mucRegistry;
-			delete notifier;
-			delete stanzaChannel;
-		}
-
-		void testReceiveFirstPresenceCreatesAvailableNotification() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-
-			sendPresence(user1, StatusShow::Online);
-
-			CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
-			CPPUNIT_ASSERT_EQUAL(Notifier::ContactAvailable, notifier->notifications[0].type);
-		}
-
-		void testReceiveSecondPresenceCreatesStatusChangeNotification() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			sendPresence(user1, StatusShow::Away);
-			notifier->notifications.clear();
-
-			sendPresence(user1, StatusShow::Online);
-
-			CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
-			CPPUNIT_ASSERT_EQUAL(Notifier::ContactStatusChange, notifier->notifications[0].type);
-		}
-
-		void testReceiveUnavailablePresenceAfterAvailablePresenceCreatesUnavailableNotification() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			sendPresence(user1, StatusShow::Away);
-			notifier->notifications.clear();
-
-			sendUnavailablePresence(user1);
-
-			CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
-			CPPUNIT_ASSERT_EQUAL(Notifier::ContactUnavailable, notifier->notifications[0].type);
-		}
-
-		void testReceiveUnavailablePresenceWithoutAvailableDoesNotCreateNotification() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-
-			sendUnavailablePresence(user1);
-
-			CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
-		}
-
-		void testReceiveAvailablePresenceAfterUnavailableCreatesAvailableNotification() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			sendPresence(user1, StatusShow::Away);
-			sendUnavailablePresence(user1);
-			notifier->notifications.clear();
-
-			sendPresence(user1, StatusShow::Away);
-
-			CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
-			CPPUNIT_ASSERT_EQUAL(Notifier::ContactAvailable, notifier->notifications[0].type);
-		}
-
-		void testReceiveAvailablePresenceAfterReconnectCreatesAvailableNotification() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			sendPresence(user1, StatusShow::Away);
-			stanzaChannel->setAvailable(false);
-			stanzaChannel->setAvailable(true);
-			notifier->notifications.clear();
-
-			sendPresence(user1, StatusShow::Away);
-
-			CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
-			CPPUNIT_ASSERT_EQUAL(Notifier::ContactAvailable, notifier->notifications[0].type);
-		}
+        CPPUNIT_TEST_SUITE(PresenceNotifierTest);
+        CPPUNIT_TEST(testReceiveFirstPresenceCreatesAvailableNotification);
+        CPPUNIT_TEST(testReceiveSecondPresenceCreatesStatusChangeNotification);
+        CPPUNIT_TEST(testReceiveUnavailablePresenceAfterAvailablePresenceCreatesUnavailableNotification);
+        CPPUNIT_TEST(testReceiveUnavailablePresenceWithoutAvailableDoesNotCreateNotification);
+        CPPUNIT_TEST(testReceiveAvailablePresenceAfterUnavailableCreatesAvailableNotification);
+        CPPUNIT_TEST(testReceiveAvailablePresenceAfterReconnectCreatesAvailableNotification);
+        CPPUNIT_TEST(testReceiveAvailablePresenceFromMUCDoesNotCreateNotification);
+        CPPUNIT_TEST(testNotificationSubjectContainsNameForJIDInRoster);
+        CPPUNIT_TEST(testNotificationSubjectContainsJIDForJIDNotInRoster);
+        CPPUNIT_TEST(testNotificationSubjectContainsStatus);
+        CPPUNIT_TEST(testNotificationMessageContainsStatusMessage);
+        CPPUNIT_TEST(testNotificationPicture);
+        CPPUNIT_TEST(testNotificationActivationEmitsSignal);
+        CPPUNIT_TEST(testReceiveFirstPresenceWithQuietPeriodDoesNotNotify);
+        CPPUNIT_TEST(testReceiveFirstPresenceWithQuietPeriodDoesNotCountAsQuietPeriod);
+        CPPUNIT_TEST(testReceivePresenceDuringQuietPeriodDoesNotNotify);
+        CPPUNIT_TEST(testReceivePresenceDuringQuietPeriodResetsTimer);
+        CPPUNIT_TEST(testReceivePresenceAfterQuietPeriodNotifies);
+        CPPUNIT_TEST(testReceiveFirstPresenceAfterReconnectWithQuietPeriodDoesNotNotify);
+        CPPUNIT_TEST_SUITE_END();
+
+    public:
+        void setUp() {
+            stanzaChannel = new DummyStanzaChannel();
+            notifier = new LoggingNotifier();
+            mucRegistry = new MUCRegistry();
+            user1 = JID("user1@bar.com/bla");
+            user2 = JID("user2@foo.com/baz");
+            avatarManager = new DummyAvatarManager();
+            roster = new XMPPRosterImpl();
+            nickResolver = new NickResolver(JID("foo@bar.com"), roster, nullptr, mucRegistry);
+            presenceOracle = new PresenceOracle(stanzaChannel, roster);
+            timerFactory = new DummyTimerFactory();
+        }
+
+        void tearDown() {
+            delete timerFactory;
+            delete presenceOracle;
+            delete nickResolver;
+            delete roster;
+            delete avatarManager;
+            delete mucRegistry;
+            delete notifier;
+            delete stanzaChannel;
+        }
+
+        void testReceiveFirstPresenceCreatesAvailableNotification() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+
+            sendPresence(user1, StatusShow::Online);
+
+            CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
+            CPPUNIT_ASSERT_EQUAL(Notifier::ContactAvailable, notifier->notifications[0].type);
+        }
+
+        void testReceiveSecondPresenceCreatesStatusChangeNotification() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+            sendPresence(user1, StatusShow::Away);
+            notifier->notifications.clear();
+
+            sendPresence(user1, StatusShow::Online);
+
+            CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
+            CPPUNIT_ASSERT_EQUAL(Notifier::ContactStatusChange, notifier->notifications[0].type);
+        }
+
+        void testReceiveUnavailablePresenceAfterAvailablePresenceCreatesUnavailableNotification() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+            sendPresence(user1, StatusShow::Away);
+            notifier->notifications.clear();
+
+            sendUnavailablePresence(user1);
+
+            CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
+            CPPUNIT_ASSERT_EQUAL(Notifier::ContactUnavailable, notifier->notifications[0].type);
+        }
+
+        void testReceiveUnavailablePresenceWithoutAvailableDoesNotCreateNotification() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+
+            sendUnavailablePresence(user1);
+
+            CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
+        }
+
+        void testReceiveAvailablePresenceAfterUnavailableCreatesAvailableNotification() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+            sendPresence(user1, StatusShow::Away);
+            sendUnavailablePresence(user1);
+            notifier->notifications.clear();
+
+            sendPresence(user1, StatusShow::Away);
+
+            CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
+            CPPUNIT_ASSERT_EQUAL(Notifier::ContactAvailable, notifier->notifications[0].type);
+        }
+
+        void testReceiveAvailablePresenceAfterReconnectCreatesAvailableNotification() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+            sendPresence(user1, StatusShow::Away);
+            stanzaChannel->setAvailable(false);
+            stanzaChannel->setAvailable(true);
+            notifier->notifications.clear();
+
+            sendPresence(user1, StatusShow::Away);
+
+            CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
+            CPPUNIT_ASSERT_EQUAL(Notifier::ContactAvailable, notifier->notifications[0].type);
+        }
 
-		void testReceiveAvailablePresenceFromMUCDoesNotCreateNotification() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			mucRegistry->addMUC(JID("teaparty@wonderland.lit"));
+        void testReceiveAvailablePresenceFromMUCDoesNotCreateNotification() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+            mucRegistry->addMUC(JID("teaparty@wonderland.lit"));
 
-			sendPresence(JID("teaparty@wonderland.lit/Alice"), StatusShow::Away);
+            sendPresence(JID("teaparty@wonderland.lit/Alice"), StatusShow::Away);
 
-			CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
-		}
+            CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
+        }
 
-		void testNotificationPicture() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			avatarManager->avatars[user1] = createByteArray("abcdef");
+        void testNotificationPicture() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+            avatarManager->avatars[user1] = createByteArray("abcdef");
 
-			sendPresence(user1, StatusShow::Online);
+            sendPresence(user1, StatusShow::Online);
 
-			CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
-			CPPUNIT_ASSERT_EQUAL(boost::filesystem::path("/avatars/user1@bar.com/bla"), notifier->notifications[0].picture);
-		}
+            CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
+            CPPUNIT_ASSERT_EQUAL(boost::filesystem::path("/avatars/user1@bar.com/bla"), notifier->notifications[0].picture);
+        }
 
-		void testNotificationActivationEmitsSignal() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
+        void testNotificationActivationEmitsSignal() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
 
-			sendPresence(user1, StatusShow::Online);
-			CPPUNIT_ASSERT(notifier->notifications[0].callback);
-			notifier->notifications[0].callback();
+            sendPresence(user1, StatusShow::Online);
+            CPPUNIT_ASSERT(notifier->notifications[0].callback);
+            notifier->notifications[0].callback();
 
-			CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(activatedNotifications.size()));
-			CPPUNIT_ASSERT_EQUAL(user1, activatedNotifications[0]);
-		}
+            CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(activatedNotifications.size()));
+            CPPUNIT_ASSERT_EQUAL(user1, activatedNotifications[0]);
+        }
 
-		void testNotificationSubjectContainsNameForJIDInRoster() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			roster->addContact(user1.toBare(), "User 1", std::vector<std::string>(), RosterItemPayload::Both);
+        void testNotificationSubjectContainsNameForJIDInRoster() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+            roster->addContact(user1.toBare(), "User 1", std::vector<std::string>(), RosterItemPayload::Both);
 
-			sendPresence(user1, StatusShow::Online);
+            sendPresence(user1, StatusShow::Online);
 
-			CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
-			std::string subject = notifier->notifications[0].subject;
-			CPPUNIT_ASSERT(subject.find("User 1") != std::string::npos);
-		}
+            CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
+            std::string subject = notifier->notifications[0].subject;
+            CPPUNIT_ASSERT(subject.find("User 1") != std::string::npos);
+        }
 
-		void testNotificationSubjectContainsJIDForJIDNotInRoster() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
+        void testNotificationSubjectContainsJIDForJIDNotInRoster() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
 
-			sendPresence(user1, StatusShow::Online);
+            sendPresence(user1, StatusShow::Online);
 
-			CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
-			std::string subject = notifier->notifications[0].subject;
-			CPPUNIT_ASSERT(subject.find(user1.toBare().toString()) != std::string::npos);
-		}
+            CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
+            std::string subject = notifier->notifications[0].subject;
+            CPPUNIT_ASSERT(subject.find(user1.toBare().toString()) != std::string::npos);
+        }
 
-		void testNotificationSubjectContainsStatus() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
+        void testNotificationSubjectContainsStatus() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
 
-			sendPresence(user1, StatusShow::Away);
+            sendPresence(user1, StatusShow::Away);
 
-			CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
-			std::string subject = notifier->notifications[0].subject;
-			CPPUNIT_ASSERT(subject.find("Away") != std::string::npos);
-		}
+            CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
+            std::string subject = notifier->notifications[0].subject;
+            CPPUNIT_ASSERT(subject.find("Away") != std::string::npos);
+        }
 
-		void testNotificationMessageContainsStatusMessage() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
+        void testNotificationMessageContainsStatusMessage() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
 
-			sendPresence(user1, StatusShow::Away);
+            sendPresence(user1, StatusShow::Away);
 
-			CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
-			CPPUNIT_ASSERT(notifier->notifications[0].description.find("Status Message") != std::string::npos);
-		}
+            CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
+            CPPUNIT_ASSERT(notifier->notifications[0].description.find("Status Message") != std::string::npos);
+        }
 
-		void testReceiveFirstPresenceWithQuietPeriodDoesNotNotify() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			testling->setInitialQuietPeriodMS(10);
+        void testReceiveFirstPresenceWithQuietPeriodDoesNotNotify() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+            testling->setInitialQuietPeriodMS(10);
 
-			sendPresence(user1, StatusShow::Online);
+            sendPresence(user1, StatusShow::Online);
 
-			CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
-		}
+            CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
+        }
 
-		void testReceivePresenceDuringQuietPeriodDoesNotNotify() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			testling->setInitialQuietPeriodMS(10);
+        void testReceivePresenceDuringQuietPeriodDoesNotNotify() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+            testling->setInitialQuietPeriodMS(10);
 
-			sendPresence(user1, StatusShow::Online);
-			timerFactory->setTime(1);
-			sendPresence(user2, StatusShow::Away);
+            sendPresence(user1, StatusShow::Online);
+            timerFactory->setTime(1);
+            sendPresence(user2, StatusShow::Away);
 
-			CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
-		}
+            CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
+        }
 
-		void testReceivePresenceDuringQuietPeriodResetsTimer() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			testling->setInitialQuietPeriodMS(10);
+        void testReceivePresenceDuringQuietPeriodResetsTimer() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+            testling->setInitialQuietPeriodMS(10);
 
-			sendPresence(user1, StatusShow::Online);
-			timerFactory->setTime(9);
-			sendPresence(user2, StatusShow::Away);
-			timerFactory->setTime(18);
-			sendPresence(user1, StatusShow::Away);
+            sendPresence(user1, StatusShow::Online);
+            timerFactory->setTime(9);
+            sendPresence(user2, StatusShow::Away);
+            timerFactory->setTime(18);
+            sendPresence(user1, StatusShow::Away);
 
-			CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
-		}
+            CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
+        }
 
-		void testReceivePresenceAfterQuietPeriodNotifies() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			testling->setInitialQuietPeriodMS(10);
-
-			sendPresence(user1, StatusShow::Online);
-			timerFactory->setTime(11);
-			sendPresence(user2, StatusShow::Away);
-
-			CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
-		}
-
-		void testReceiveFirstPresenceWithQuietPeriodDoesNotCountAsQuietPeriod() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			testling->setInitialQuietPeriodMS(10);
-
-			timerFactory->setTime(11);
-			sendPresence(user1, StatusShow::Away);
-
-			CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
-		}
-
-		void testReceiveFirstPresenceAfterReconnectWithQuietPeriodDoesNotNotify() {
-			boost::shared_ptr<PresenceNotifier> testling = createNotifier();
-			testling->setInitialQuietPeriodMS(10);
-			sendPresence(user1, StatusShow::Online);
-			timerFactory->setTime(15);
-			notifier->notifications.clear();
-
-			stanzaChannel->setAvailable(false);
-			stanzaChannel->setAvailable(true);
-			sendPresence(user1, StatusShow::Online);
-			timerFactory->setTime(21);
-			sendPresence(user2, StatusShow::Online);
-
-			CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
-		}
-
-
-	private:
-		boost::shared_ptr<PresenceNotifier> createNotifier() {
-			boost::shared_ptr<PresenceNotifier> result(new PresenceNotifier(stanzaChannel, notifier, mucRegistry, avatarManager, nickResolver, presenceOracle, timerFactory));
-			result->onNotificationActivated.connect(boost::bind(&PresenceNotifierTest::handleNotificationActivated, this, _1));
-			result->setInitialQuietPeriodMS(0);
-			return result;
-		}
-
-		void sendPresence(const JID& jid, StatusShow::Type type) {
-			boost::shared_ptr<Presence> presence(new Presence());
-			presence->setFrom(jid);
-			presence->setShow(type);
-			presence->setStatus("Status Message");
-			stanzaChannel->onPresenceReceived(presence);
-		}
-
-		void sendUnavailablePresence(const JID& jid) {
-			boost::shared_ptr<Presence> presence(new Presence());
-			presence->setType(Presence::Unavailable);
-			presence->setFrom(jid);
-			stanzaChannel->onPresenceReceived(presence);
-		}
-
-		void handleNotificationActivated(const JID& j) {
-			activatedNotifications.push_back(j);
-		}
-
-	private:
-		DummyStanzaChannel* stanzaChannel;
-		LoggingNotifier* notifier;
-		MUCRegistry* mucRegistry;
-		DummyAvatarManager* avatarManager;
-		XMPPRosterImpl* roster;
-		NickResolver* nickResolver;
-		PresenceOracle* presenceOracle;
-		DummyTimerFactory* timerFactory;
-		JID user1;
-		JID user2;
-		std::vector<JID> activatedNotifications;
+        void testReceivePresenceAfterQuietPeriodNotifies() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+            testling->setInitialQuietPeriodMS(10);
+
+            sendPresence(user1, StatusShow::Online);
+            timerFactory->setTime(11);
+            sendPresence(user2, StatusShow::Away);
+
+            CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(notifier->notifications.size()));
+        }
+
+        void testReceiveFirstPresenceWithQuietPeriodDoesNotCountAsQuietPeriod() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+            testling->setInitialQuietPeriodMS(10);
+
+            timerFactory->setTime(11);
+            sendPresence(user1, StatusShow::Away);
+
+            CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
+        }
+
+        void testReceiveFirstPresenceAfterReconnectWithQuietPeriodDoesNotNotify() {
+            std::shared_ptr<PresenceNotifier> testling = createNotifier();
+            testling->setInitialQuietPeriodMS(10);
+            sendPresence(user1, StatusShow::Online);
+            timerFactory->setTime(15);
+            notifier->notifications.clear();
+
+            stanzaChannel->setAvailable(false);
+            stanzaChannel->setAvailable(true);
+            sendPresence(user1, StatusShow::Online);
+            timerFactory->setTime(21);
+            sendPresence(user2, StatusShow::Online);
+
+            CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(notifier->notifications.size()));
+        }
+
+
+    private:
+        std::shared_ptr<PresenceNotifier> createNotifier() {
+            std::shared_ptr<PresenceNotifier> result(new PresenceNotifier(stanzaChannel, notifier, mucRegistry, avatarManager, nickResolver, presenceOracle, timerFactory));
+            result->onNotificationActivated.connect(boost::bind(&PresenceNotifierTest::handleNotificationActivated, this, _1));
+            result->setInitialQuietPeriodMS(0);
+            return result;
+        }
+
+        void sendPresence(const JID& jid, StatusShow::Type type) {
+            std::shared_ptr<Presence> presence(new Presence());
+            presence->setFrom(jid);
+            presence->setShow(type);
+            presence->setStatus("Status Message");
+            stanzaChannel->onPresenceReceived(presence);
+        }
+
+        void sendUnavailablePresence(const JID& jid) {
+            std::shared_ptr<Presence> presence(new Presence());
+            presence->setType(Presence::Unavailable);
+            presence->setFrom(jid);
+            stanzaChannel->onPresenceReceived(presence);
+        }
+
+        void handleNotificationActivated(const JID& j) {
+            activatedNotifications.push_back(j);
+        }
+
+    private:
+        DummyStanzaChannel* stanzaChannel;
+        LoggingNotifier* notifier;
+        MUCRegistry* mucRegistry;
+        DummyAvatarManager* avatarManager;
+        XMPPRosterImpl* roster;
+        NickResolver* nickResolver;
+        PresenceOracle* presenceOracle;
+        DummyTimerFactory* timerFactory;
+        JID user1;
+        JID user2;
+        std::vector<JID> activatedNotifications;
 };
 
 CPPUNIT_TEST_SUITE_REGISTRATION(PresenceNotifierTest);
diff --git a/Swift/Controllers/UnitTest/PreviousStatusStoreTest.cpp b/Swift/Controllers/UnitTest/PreviousStatusStoreTest.cpp
index 9489e5b..be35468 100644
--- a/Swift/Controllers/UnitTest/PreviousStatusStoreTest.cpp
+++ b/Swift/Controllers/UnitTest/PreviousStatusStoreTest.cpp
@@ -1,44 +1,44 @@
 /*
- * Copyright (c) 2010 Kevin Smith
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2016 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 
-#include "Swift/Controllers/PreviousStatusStore.h"
+#include <Swift/Controllers/PreviousStatusStore.h>
 
 using namespace Swift;
 
 class PreviousStatusStoreTest : public CppUnit::TestFixture {
-	CPPUNIT_TEST_SUITE(PreviousStatusStoreTest);
-	CPPUNIT_TEST(testGetAll);
-	//CPPUNIT_TEST(testGetAllLimited);
-	//CPPUNIT_TEST(testGetSuggestionsInexact);
-	//CPPUNIT_TEST(testGetSuggestionsExact);
-	CPPUNIT_TEST_SUITE_END();
+    CPPUNIT_TEST_SUITE(PreviousStatusStoreTest);
+    CPPUNIT_TEST(testGetAll);
+    //CPPUNIT_TEST(testGetAllLimited);
+    //CPPUNIT_TEST(testGetSuggestionsInexact);
+    //CPPUNIT_TEST(testGetSuggestionsExact);
+    CPPUNIT_TEST_SUITE_END();
 
 public:
-	void setUp() {
-		store_ = new PreviousStatusStore();
-		store_->addStatus(StatusShow::Online, "At home in the study");
-		store_->addStatus(StatusShow::DND, "In a meeting");
-		store_->addStatus(StatusShow::DND, "With a client");
-		store_->addStatus(StatusShow::Away, "Walking the elephant");
-		store_->addStatus(StatusShow::Online, "In the office, at my desk");
-	}
+    void setUp() {
+        store_ = new PreviousStatusStore();
+        store_->addStatus(StatusShow::Online, "At home in the study");
+        store_->addStatus(StatusShow::DND, "In a meeting");
+        store_->addStatus(StatusShow::DND, "With a client");
+        store_->addStatus(StatusShow::Away, "Walking the elephant");
+        store_->addStatus(StatusShow::Online, "In the office, at my desk");
+    }
 
-	void tearDown() {
-		
-	}
+    void tearDown() {
+        delete store_;
+    }
 
-	void testGetAll() {
+    void testGetAll() {
 
-	}
+    }
 
 private:
-	PreviousStatusStore* store_;
+    PreviousStatusStore* store_;
 };
 
 CPPUNIT_TEST_SUITE_REGISTRATION(PreviousStatusStoreTest);