5 files changed, 1333 insertions, 559 deletions
diff --git a/Swift/Controllers/Chat/UnitTest/ChatControllerTest.cpp b/Swift/Controllers/Chat/UnitTest/ChatControllerTest.cpp
new file mode 100644
index 0000000..e010656
--- /dev/null
+++ b/Swift/Controllers/Chat/UnitTest/ChatControllerTest.cpp
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2018 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+
+#include <memory>
+#include <string>
+
+#include <gtest/gtest.h>
+#include <hippomocks.h>
+
+#include <Swiften/Avatars/NullAvatarManager.h>
+#include <Swiften/Client/ClientBlockListManager.h>
+#include <Swiften/Client/DummyStanzaChannel.h>
+#include <Swiften/Client/NickResolver.h>
+#include <Swiften/Disco/DummyEntityCapsProvider.h>
+#include <Swiften/Network/DummyTimerFactory.h>
+#include <Swiften/Queries/DummyIQChannel.h>
+#include <Swiften/Roster/XMPPRoster.h>
+#include <Swiften/Roster/XMPPRosterImpl.h>
+#include <Swiften/VCards/VCardManager.h>
+#include <Swiften/VCards/VCardMemoryStorage.h>
+
+#include <Swift/Controllers/Chat/AutoAcceptMUCInviteDecider.h>
+#include <Swift/Controllers/Chat/ChatController.h>
+#include <Swift/Controllers/Chat/ChatMessageParser.h>
+#include <Swift/Controllers/Chat/Chattables.h>
+#include <Swift/Controllers/Settings/DummySettingsProvider.h>
+#include <Swift/Controllers/UIEvents/UIEventStream.h>
+#include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>
+#include <Swift/Controllers/UnitTest/MockChatWindow.h>
+#include <Swift/Controllers/XMPPEvents/EventController.h>
+
+using namespace Swift;
+
+/**
+ * Most of the ChatController tests are in ChatsManagerTest.
+ * New tests related with ChatController should be added here,
+ * and old tests should be migrated when possible.
+ */
+
+class ExtendedChatController : public ChatController {
+public:
+    ExtendedChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables) :
+        ChatController(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, isInMUC, useDelayForLatency, eventStream, timerFactory, eventController, entityCapsProvider, userWantsReceipts, historyController, mucRegistry, highlightManager, clientBlockListManager, chatMessageParser, autoAcceptMUCInviteDecider, settings, chattables) {
+    }
+
+    std::map<std::shared_ptr<Stanza>, std::string> getUnackedStanzas() { return unackedStanzas_; }
+    std::map<std::string, std::shared_ptr<Stanza>> getFailedStanzas() { return failedStanzas_; }
+};
+
+class ChatControllerTest : public ::testing::Test {
+protected:
+    virtual void SetUp() {
+        self_ = JID("alice@wonderland.lit");
+        other_ = JID("whiterabbit@wonderland.lit");
+        stanzaChannel_ = new DummyStanzaChannel();
+        iqChannel_ = new DummyIQChannel();
+        iqRouter_ = new IQRouter(iqChannel_);
+        eventController_ = new EventController();
+        xmppRoster_ = new XMPPRosterImpl();
+        vCardManager_ = new VCardManager(self_, iqRouter_, vCardMemoryStorage_);
+        mucRegistry_ = new MUCRegistry();
+        nickResolver_ = new NickResolver(self_, xmppRoster_, vCardManager_, mucRegistry_);
+        presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);
+        avatarManager_ = new NullAvatarManager();
+        uiEventStream_ = new UIEventStream();
+        timerFactory_ = new DummyTimerFactory();
+        entityCapsProvider_ = new DummyEntityCapsProvider();
+        settings_ = new DummySettingsProvider();
+        highlightManager_ = new HighlightManager(settings_);
+        highlightManager_->resetToDefaultConfiguration();
+        clientBlockListManager_ = new ClientBlockListManager(iqRouter_);
+        autoAcceptMUCInviteDecider_ = new AutoAcceptMUCInviteDecider(self_.getDomain(), xmppRoster_, settings_);
+        chatMessageParser_ = std::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat);
+        mocks_ = new MockRepository();
+        window_ = new MockChatWindow();
+        chatWindowFactory_ = mocks_->InterfaceMock<ChatWindowFactory>();
+        mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(other_, uiEventStream_).Return(window_);
+        chattables_ = std::make_unique<Chattables>();
+
+        controller_ = new  ExtendedChatController(self_, stanzaChannel_, iqRouter_, chatWindowFactory_, other_, nickResolver_, presenceOracle_, avatarManager_, false, false, uiEventStream_, timerFactory_, eventController_, entityCapsProvider_, false, nullptr, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, nullptr, settings_, *chattables_);
+    }
+    virtual void TearDown() {
+        delete controller_;
+        chattables_.reset();
+        chatMessageParser_.reset();
+        delete autoAcceptMUCInviteDecider_;
+        delete clientBlockListManager_;
+        delete highlightManager_;
+        delete settings_;
+        delete entityCapsProvider_;
+        delete timerFactory_;
+        delete uiEventStream_;
+        delete avatarManager_;
+        delete presenceOracle_;
+        delete nickResolver_;
+        delete mucRegistry_;
+        delete vCardManager_;
+        delete xmppRoster_;
+        delete eventController_;
+        delete iqRouter_;
+        delete iqChannel_;
+        delete stanzaChannel_;
+    }
+
+    JID self_, other_;
+    AvatarManager* avatarManager_ = nullptr;
+    ExtendedChatController* controller_ = nullptr;
+    ChatWindowFactory* chatWindowFactory_;
+    ClientBlockListManager* clientBlockListManager_;
+    EventController* eventController_ = nullptr;
+    EntityCapsProvider* entityCapsProvider_ = nullptr;
+    IQChannel* iqChannel_ = nullptr;
+    IQRouter* iqRouter_ = nullptr;
+    MockRepository* mocks_;
+    MockChatWindow* window_;
+    MUCRegistry* mucRegistry_ = nullptr;
+    NickResolver* nickResolver_ = nullptr;
+    PresenceOracle* presenceOracle_ = nullptr;
+    DummyStanzaChannel* stanzaChannel_ = nullptr;
+    TimerFactory* timerFactory_;
+    XMPPRosterImpl* xmppRoster_ = nullptr;
+    UIEventStream* uiEventStream_;
+    VCardManager* vCardManager_ = nullptr;
+    VCardMemoryStorage* vCardMemoryStorage_ = nullptr;
+    DummySettingsProvider* settings_;
+    HighlightManager* highlightManager_;
+    std::shared_ptr<ChatMessageParser> chatMessageParser_;
+    AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;
+    std::unique_ptr<Chattables> chattables_;
+
+};
+
+TEST_F(ChatControllerTest, testResendMessage) {
+    std::string msgBody("TestMsg");
+    stanzaChannel_->setStreamManagementEnabled(true);
+    window_->onSendMessageRequest(msgBody, false);
+    {
+        auto failedStanzas = controller_->getFailedStanzas();
+        auto unackedStanzas = controller_->getUnackedStanzas();
+        ASSERT_EQ(failedStanzas.size(), 0);
+        ASSERT_EQ(unackedStanzas.size(), 1);
+    }
+    //Disconnecting to fail the stanza
+    controller_->setOnline(false);
+    controller_->setOnline(true);
+    {
+        auto failedStanzas = controller_->getFailedStanzas();
+        auto unackedStanzas = controller_->getUnackedStanzas();
+        ASSERT_EQ(failedStanzas.size(), 1);
+        ASSERT_EQ(unackedStanzas.size(), 0);
+    }
+    window_->onResendMessageRequest("id");
+    {
+        auto failedStanzas = controller_->getFailedStanzas();
+        auto unackedStanzas = controller_->getUnackedStanzas();
+        ASSERT_EQ(failedStanzas.size(), 0);
+        ASSERT_EQ(unackedStanzas.size(), 1);
+    }
+}
diff --git a/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp b/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
index ac62942..954dd2f 100644
--- a/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
+++ b/Swift/Controllers/Chat/UnitTest/ChatsManagerTest.cpp
@@ -38,6 +38,7 @@
 #include <Swiften/Jingle/JingleSessionManager.h>
 #include <Swiften/MUC/MUCManager.h>
 #include <Swiften/MUC/UnitTest/MockMUC.h>
+#include <Swiften/MUC/MUCBookmarkManager.h>
 #include <Swiften/Network/DummyTimerFactory.h>
 #include <Swiften/Presence/DirectedPresenceSender.h>
 #include <Swiften/Presence/PresenceOracle.h>
@@ -50,6 +51,7 @@
 
 #include <Swift/Controllers/Chat/ChatController.h>
 #include <Swift/Controllers/Chat/ChatsManager.h>
+#include <Swift/Controllers/Chat/Chattables.h>
 #include <Swift/Controllers/Chat/MUCController.h>
 #include <Swift/Controllers/Chat/UnitTest/MockChatListWindow.h>
 #include <Swift/Controllers/EventNotifier.h>
@@ -57,6 +59,7 @@
 #include <Swift/Controllers/ProfileSettingsProvider.h>
 #include <Swift/Controllers/SettingConstants.h>
 #include <Swift/Controllers/Settings/DummySettingsProvider.h>
+#include <Swift/Controllers/UIEvents/AddMUCBookmarkUIEvent.h>
 #include <Swift/Controllers/UIEvents/CreateImpromptuMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>
@@ -106,6 +109,16 @@ class DummyNotifier : public Notifier {
         std::vector<Notification> notifications;
 };
 
+class ExtendedChatsManager : public ChatsManager {
+public:
+    ExtendedChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, JoinMUCWindowFactory* joinMUCWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency, TimerFactory* timerFactory, MUCRegistry* mucRegistry, EntityCapsProvider* entityCapsProvider, MUCManager* mucManager, MUCSearchWindowFactory* mucSearchWindowFactory, ProfileSettingsProvider* profileSettings, FileTransferOverview* ftOverview, XMPPRoster* roster, bool eagleMode, SettingsProvider* settings, HistoryController* historyController_, WhiteboardManager* whiteboardManager, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, const std::map<std::string, std::string>& emoticons, VCardManager* vcardManager, Chattables& chattables) :
+        ChatsManager(jid, stanzaChannel, iqRouter, eventController, chatWindowFactory, joinMUCWindowFactory, nickResolver, presenceOracle, presenceSender, uiEventStream, chatListWindowFactory, useDelayForLatency, timerFactory, mucRegistry, entityCapsProvider, mucManager, mucSearchWindowFactory, profileSettings, ftOverview, roster, eagleMode, settings, historyController_, whiteboardManager, highlightManager, clientBlockListManager, emoticons, vcardManager, chattables) {
+    }
+    MUCBookmarkManager* getBookmarkManager() {
+        return mucBookmarkManager_;
+    }
+};
+
 
 class ChatsManagerTest : public CppUnit::TestFixture {
     CPPUNIT_TEST_SUITE(ChatsManagerTest);
@@ -161,13 +174,19 @@ class ChatsManagerTest : public CppUnit::TestFixture {
     CPPUNIT_TEST(testReceivingBookmarksWithDomainJID);
     CPPUNIT_TEST(testReceivingBookmarksWithBareJID);
     CPPUNIT_TEST(testReceivingBookmarksWithFullJID);
+    CPPUNIT_TEST(testAutoJoinBookmarksAndChattables);
+    CPPUNIT_TEST(testJoinNoAutojoinBookmark);
+    CPPUNIT_TEST(testJoinAndBookmarkMUC);
+    CPPUNIT_TEST(testReceivingNoBookmarks);
+    CPPUNIT_TEST(testReceivingNullBookmarks);
+    CPPUNIT_TEST(testReceivingBookmarksError);
 
     CPPUNIT_TEST_SUITE_END();
 
 public:
     void setUp() {
         mocks_ = new MockRepository();
-        notifier_ = std::unique_ptr<DummyNotifier>(new DummyNotifier());
+        notifier_ = std::make_unique<DummyNotifier>();
         jid_ = JID("test@test.com/resource");
         stanzaChannel_ = new DummyStanzaChannel();
         iqRouter_ = new IQRouter(stanzaChannel_);
@@ -207,7 +226,8 @@ public:
         mocks_->ExpectCall(chatListWindowFactory_, ChatListWindowFactory::createChatListWindow).With(uiEventStream_).Return(chatListWindow_);
         clientBlockListManager_ = new ClientBlockListManager(iqRouter_);
         timerFactory_ = new DummyTimerFactory();
-        manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, timerFactory_, mucRegistry_, entityCapsProvider_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, nullptr, wbManager_, highlightManager_, clientBlockListManager_, emoticons_, vcardManager_);
+        chattables_ = std::make_unique<Chattables>();
+        manager_ = new ExtendedChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, timerFactory_, mucRegistry_, entityCapsProvider_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, nullptr, wbManager_, highlightManager_, clientBlockListManager_, emoticons_, vcardManager_, *chattables_);
 
         manager_->setAvatarManager(avatarManager_);
     }
@@ -783,7 +803,7 @@ public:
         // send message to participantA
         auto messageBody = std::string("message body to send");
         window->onSendMessageRequest(messageBody, false);
-        auto sendMessageStanza = stanzaChannel_->getStanzaAtIndex<Message>(2);
+        auto sendMessageStanza = stanzaChannel_->getStanzaAtIndex<Message>(3);
         CPPUNIT_ASSERT_EQUAL(messageBody, *sendMessageStanza->getBody());
 
         // receive reply with error
@@ -1565,7 +1585,11 @@ public:
         uiEventStream_->send(std::make_shared<CreateImpromptuMUCUIEvent>(jids, mucJID, ""));
         CPPUNIT_ASSERT_EQUAL(std::string("bar@test.com, foo@test.com"), manager_->getRecentChats()[0].getTitle());
 
-        auto mucJoinPresence = std::dynamic_pointer_cast<Presence>(stanzaChannel_->sentStanzas[2]);
+        // Check the MUC security marking request
+        auto mucInfoRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[2]);
+        CPPUNIT_ASSERT(mucInfoRequest);
+
+        auto mucJoinPresence = std::dynamic_pointer_cast<Presence>(stanzaChannel_->sentStanzas[3]);
         CPPUNIT_ASSERT(mucJoinPresence);
 
         // MUC presence reply
@@ -1626,17 +1650,7 @@ public:
         CPPUNIT_ASSERT_EQUAL(std::string("mucroom"), window->name_);
     }
 
-    static std::shared_ptr<Storage> createBookmarkStorageWithJID(const JID& jid) {
-        auto storage = std::make_shared<Storage>();
-        auto room = Storage::Room();
-        room.jid = jid;
-        room.autoJoin = true;
-        storage->addRoom(room);
-        return storage;
-    }
-
-    void testReceivingBookmarksWithDomainJID() {
-        auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
+    std::shared_ptr<Storage> createBookmarkStorageWithJID(std::shared_ptr<IQ> bookmarkRequest, const JID& jid, const bool autojoin) {
         CPPUNIT_ASSERT(bookmarkRequest);
         CPPUNIT_ASSERT_EQUAL(IQ::Get, bookmarkRequest->getType());
 
@@ -1646,56 +1660,179 @@ public:
         auto storage = std::dynamic_pointer_cast<Storage>(privateStorage->getPayload());
         CPPUNIT_ASSERT(storage);
 
+        auto roomsStorage = std::make_shared<Storage>();
+        if (jid.isValid()) {
+            auto room = Storage::Room();
+            room.jid = jid;
+            room.autoJoin = autojoin;
+            roomsStorage->addRoom(room);
+        }
+        return roomsStorage;
+    }
+
+    void testReceivingBookmarksWithDomainJID() {
+        auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
         auto response = IQ::createResult(
             bookmarkRequest->getFrom(),
             bookmarkRequest->getTo(),
             bookmarkRequest->getID(),
-            std::make_shared<PrivateStorage>(createBookmarkStorageWithJID("montague.lit"))
+            std::make_shared<PrivateStorage>(createBookmarkStorageWithJID(bookmarkRequest, "montague.lit", true))
         );
         stanzaChannel_->onIQReceived(response);
     }
 
     void testReceivingBookmarksWithBareJID() {
         auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
-        CPPUNIT_ASSERT(bookmarkRequest);
-        CPPUNIT_ASSERT_EQUAL(IQ::Get, bookmarkRequest->getType());
-
-        auto privateStorage = bookmarkRequest->getPayload<PrivateStorage>();
-        CPPUNIT_ASSERT(privateStorage);
-
-        auto storage = std::dynamic_pointer_cast<Storage>(privateStorage->getPayload());
-        CPPUNIT_ASSERT(storage);
-
         MockChatWindow* window = new MockChatWindow();
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID("example@montague.lit"), uiEventStream_).Return(window);
+        auto response = IQ::createResult(
+            bookmarkRequest->getFrom(),
+            bookmarkRequest->getTo(),
+            bookmarkRequest->getID(),
+            std::make_shared<PrivateStorage>(createBookmarkStorageWithJID(bookmarkRequest, "example@montague.lit", true))
+        );
+        stanzaChannel_->onIQReceived(response);
+    }
 
+    void testReceivingNoBookmarks() {
+        auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
         auto response = IQ::createResult(
             bookmarkRequest->getFrom(),
             bookmarkRequest->getTo(),
             bookmarkRequest->getID(),
-            std::make_shared<PrivateStorage>(createBookmarkStorageWithJID("example@montague.lit"))
+            std::make_shared<PrivateStorage>()
+        );
+        stanzaChannel_->onIQReceived(response);
+    }
+
+    void testReceivingNullBookmarks() {
+        auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
+        auto response = IQ::createResult(
+            bookmarkRequest->getFrom(),
+            bookmarkRequest->getTo(),
+            bookmarkRequest->getID(),
+            nullptr
+        );
+        stanzaChannel_->onIQReceived(response);
+    }
+
+    void testReceivingBookmarksError() {
+        auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
+        auto response = IQ::createError(
+            bookmarkRequest->getFrom(),
+            bookmarkRequest->getTo(),
+            bookmarkRequest->getID(),
+            ErrorPayload::Condition::ServiceUnavailable,
+            ErrorPayload::Type::Cancel,
+            nullptr
         );
         stanzaChannel_->onIQReceived(response);
     }
 
     void testReceivingBookmarksWithFullJID() {
         auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
-        CPPUNIT_ASSERT(bookmarkRequest);
-        CPPUNIT_ASSERT_EQUAL(IQ::Get, bookmarkRequest->getType());
+        auto response = IQ::createResult(
+            bookmarkRequest->getFrom(),
+            bookmarkRequest->getTo(),
+            bookmarkRequest->getID(),
+            std::make_shared<PrivateStorage>(createBookmarkStorageWithJID(bookmarkRequest, "example@montague.lit/someresource", true))
+        );
+        stanzaChannel_->onIQReceived(response);
+    }
 
-        auto privateStorage = bookmarkRequest->getPayload<PrivateStorage>();
-        CPPUNIT_ASSERT(privateStorage);
+    void testAutoJoinBookmarksAndChattables() {
 
-        auto storage = std::dynamic_pointer_cast<Storage>(privateStorage->getPayload());
-        CPPUNIT_ASSERT(storage);
+        auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
+        auto roomsStorage = createBookmarkStorageWithJID(bookmarkRequest, "autojoin@bookmark.lit", true);
+        auto room = Storage::Room();
+        room.jid = "noAutojoin@bookmark.lit";
+        roomsStorage->addRoom(room);
+
+        //Only autojoin@bookmark.lit window should open.
+        MockChatWindow* autojoinBookmarkWindow = new MockChatWindow();
+        mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID("autojoin@bookmark.lit"), uiEventStream_).Return(autojoinBookmarkWindow);
 
         auto response = IQ::createResult(
             bookmarkRequest->getFrom(),
             bookmarkRequest->getTo(),
             bookmarkRequest->getID(),
-            std::make_shared<PrivateStorage>(createBookmarkStorageWithJID("example@montague.lit/someresource"))
+            std::make_shared<PrivateStorage>(roomsStorage)
         );
         stanzaChannel_->onIQReceived(response);
+        //Both bookmarks should be added to the chattables.
+        CPPUNIT_ASSERT_EQUAL(size_t(2), chattables_->get().size());
+        auto autoJoinState = chattables_->getState("autojoin@bookmark.lit");
+        CPPUNIT_ASSERT(autoJoinState.type == Chattables::State::Type::Room);
+        CPPUNIT_ASSERT_EQUAL(autoJoinState.status, StatusShow::Online);
+        auto noAutoJoinState = chattables_->getState("noAutojoin@bookmark.lit");
+        CPPUNIT_ASSERT(noAutoJoinState.type == Chattables::State::Type::Room);
+        CPPUNIT_ASSERT_EQUAL(noAutoJoinState.status, StatusShow::None);
+    }
+
+    void testJoinNoAutojoinBookmark() {
+
+        auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
+        auto roomsStorage = createBookmarkStorageWithJID(bookmarkRequest, "example@montague.lit", false);
+
+        auto response = IQ::createResult(
+            bookmarkRequest->getFrom(),
+            bookmarkRequest->getTo(),
+            bookmarkRequest->getID(),
+            std::make_shared<PrivateStorage>(roomsStorage)
+        );
+        stanzaChannel_->onIQReceived(response);
+
+        //Join previous bookmarked room, expecting no increase in chattables and change of autojoin in bookmark to true
+        MockChatWindow* newExampleChatWindow = new MockChatWindow();
+        mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(JID("example@montague.lit"), uiEventStream_).Return(newExampleChatWindow);
+        uiEventStream_->send(std::make_shared<JoinMUCUIEvent>("example@montague.lit", boost::optional<std::string>(), boost::optional<std::string>()));
+        CPPUNIT_ASSERT_EQUAL(size_t(1), chattables_->get().size());
+        auto state = chattables_->getState("example@montague.lit");
+        CPPUNIT_ASSERT(state.type == Chattables::State::Type::Room);
+        CPPUNIT_ASSERT_EQUAL(state.status, StatusShow::Online);
+
+        auto bookmarks = manager_->getBookmarkManager()->getBookmarks();
+        CPPUNIT_ASSERT_EQUAL(bookmarks.size(), size_t(1));
+        CPPUNIT_ASSERT(bookmarks[0].getRoom() == JID("example@montague.lit"));
+        CPPUNIT_ASSERT(bookmarks[0].getAutojoin());
+    }
+
+    void testJoinAndBookmarkMUC() {
+        auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);
+        auto roomsStorage = createBookmarkStorageWithJID(bookmarkRequest, "", true);
+        auto response = IQ::createResult(
+            bookmarkRequest->getFrom(),
+            bookmarkRequest->getTo(),
+            bookmarkRequest->getID(),
+            std::make_shared<PrivateStorage>(roomsStorage)
+        );
+        stanzaChannel_->onIQReceived(response);
+
+        //Join non-bookmarked room expecting for the room to get bookmarked with autojoin to true
+        MockChatWindow* exampleChatWindow = new MockChatWindow();
+        mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With("example@montague.lit", uiEventStream_).Return(exampleChatWindow);
+        uiEventStream_->send(std::make_shared<JoinMUCUIEvent>("example@montague.lit", boost::optional<std::string>(), boost::optional<std::string>()));
+        {
+            CPPUNIT_ASSERT_EQUAL(size_t(1), chattables_->get().size());
+            auto state = chattables_->getState("example@montague.lit");
+            CPPUNIT_ASSERT(state.type == Chattables::State::Type::Room);
+            CPPUNIT_ASSERT_EQUAL(state.status, StatusShow::Online);
+
+            auto bookmarks = manager_->getBookmarkManager()->getBookmarks();
+            CPPUNIT_ASSERT_EQUAL(bookmarks.size(), size_t(1));
+            CPPUNIT_ASSERT(bookmarks[0].getRoom() == JID("example@montague.lit"));
+            CPPUNIT_ASSERT(bookmarks[0].getAutojoin());
+
+        }
+        //Exiting room that is bookmarked, expecting chattable to stay but bookmark autojoin change to false.
+        exampleChatWindow->onClosed();
+        {
+            CPPUNIT_ASSERT_EQUAL(size_t(1), chattables_->get().size());
+            auto bookmarks = manager_->getBookmarkManager()->getBookmarks();
+            CPPUNIT_ASSERT_EQUAL(bookmarks.size(), size_t(1));
+            CPPUNIT_ASSERT(bookmarks[0].getRoom() == JID("example@montague.lit"));
+            CPPUNIT_ASSERT(!bookmarks[0].getAutojoin());
+        }
     }
 
 private:
@@ -1722,7 +1859,7 @@ private:
 private:
     JID jid_;
     std::unique_ptr<DummyNotifier> notifier_;
-    ChatsManager* manager_;
+    ExtendedChatsManager* manager_;
     DummyStanzaChannel* stanzaChannel_;
     IQRouter* iqRouter_;
     EventController* eventController_;
@@ -1760,6 +1897,7 @@ private:
     int handledHighlightActions_;
     std::set<std::string> soundsPlayed_;
     DummyTimerFactory* timerFactory_;
+    std::unique_ptr<Chattables> chattables_;
 
 };
 
diff --git a/Swift/Controllers/Chat/UnitTest/ChattablesTest.cpp b/Swift/Controllers/Chat/UnitTest/ChattablesTest.cpp
new file mode 100644
index 0000000..f30e3fd
--- /dev/null
+++ b/Swift/Controllers/Chat/UnitTest/ChattablesTest.cpp
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2018 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+
+#include <gtest/gtest.h>
+#include <hippomocks.h>
+
+#include <Swift/Controllers/Chat/Chattables.h>
+
+// Clang wrongly things that tests for 0 are using 0 as null.
+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
+
+using namespace Swift;
+
+class ChattablesTest : public ::testing::Test {
+    protected:
+        void SetUp() {
+            beginListSize_ = 0;
+            endListSize_ = 0;
+            callsToBegin_ = 0;
+            callsToEnd_ = 0;
+        }
+
+        void TearDown() {
+        }
+
+        void updateBeginListSize(int listSize);
+        void updateEndListSize();
+
+        Chattables chattables_;
+        int beginListSize_;
+        int endListSize_;
+        int callsToBegin_;
+        int callsToEnd_;
+};
+
+void ChattablesTest::updateBeginListSize(int listSize) {
+    beginListSize_ = listSize;
+    callsToBegin_++;
+}
+
+void ChattablesTest::updateEndListSize() {
+    endListSize_ = chattables_.get().size();
+    callsToEnd_++;
+}
+
+TEST_F(ChattablesTest, testAddJID) {
+    chattables_.onBeginAdd.connect([this](int listSize){ updateBeginListSize(listSize); });
+    chattables_.onAdded.connect([this](){ updateEndListSize(); });
+    JID jid("user@swift.jid");
+
+    chattables_.addJID(jid, Chattables::State::Type::Person);
+    ASSERT_EQ(0, beginListSize_);
+    ASSERT_EQ(1, endListSize_);
+    ASSERT_EQ(1, callsToBegin_);
+    ASSERT_EQ(1, callsToEnd_);
+
+    ASSERT_EQ(jid, chattables_.get()[0]);
+    Chattables::State state = chattables_.getState(jid);
+    ASSERT_EQ(jid, state.jid);
+    ASSERT_EQ(Chattables::State::Type::Person, state.type);
+}
+
+TEST_F(ChattablesTest, testAddMultipleJIDs) {
+    chattables_.onBeginAdd.connect([this](int listSize){ updateBeginListSize(listSize); });
+    chattables_.onAdded.connect([this](){ updateEndListSize(); });
+    JID jid0("user0@swift.jid");
+    JID jid1("user1@swift.jid");
+    JID jid2("user2@swift.jid");
+
+    chattables_.addJID(jid0, Chattables::State::Type::Person);
+    ASSERT_EQ(0, beginListSize_);
+    ASSERT_EQ(1, endListSize_);
+    ASSERT_EQ(1, callsToBegin_);
+    ASSERT_EQ(1, callsToEnd_);
+    chattables_.addJID(jid1, Chattables::State::Type::Person);
+    ASSERT_EQ(1, beginListSize_);
+    ASSERT_EQ(2, endListSize_);
+    ASSERT_EQ(2, callsToBegin_);
+    ASSERT_EQ(2, callsToEnd_);
+    chattables_.addJID(jid2, Chattables::State::Type::Person);
+    ASSERT_EQ(2, beginListSize_);
+    ASSERT_EQ(3, endListSize_);
+    ASSERT_EQ(3, callsToBegin_);
+    ASSERT_EQ(3, callsToEnd_);
+}
+
+TEST_F(ChattablesTest, testAddRoomJID) {
+    chattables_.onBeginAdd.connect([this](int listSize){ updateBeginListSize(listSize); });
+    chattables_.onAdded.connect([this](){ updateEndListSize(); });
+    JID jid("room@swift.jid");
+
+    chattables_.addJID(jid, Chattables::State::Type::Room);
+    ASSERT_EQ(0, beginListSize_);
+    ASSERT_EQ(1, endListSize_);
+    ASSERT_EQ(1, callsToBegin_);
+    ASSERT_EQ(1, callsToEnd_);
+
+    ASSERT_EQ(jid, chattables_.get()[0]);
+    Chattables::State state = chattables_.getState(jid);
+    ASSERT_EQ(jid, state.jid);
+    ASSERT_EQ(Chattables::State::Type::Room, state.type);
+}
+
+TEST_F(ChattablesTest, testSetState) {
+    JID jid("user@swift.jid");
+    chattables_.addJID(jid, Chattables::State::Type::Person);
+    ASSERT_EQ(1, chattables_.get().size());
+    ASSERT_EQ(jid, chattables_.get()[0]);
+    ASSERT_EQ(Chattables::State::Type::Person, chattables_.getState(jid).type);
+    ASSERT_EQ(StatusShow::None, chattables_.getState(jid).status);
+
+    JID returnedJID;
+    int returnedIndex;
+    int callsToChanged = 0;
+    chattables_.onChanged.connect([&returnedJID, &returnedIndex, &callsToChanged](const JID& jid, int index){
+        returnedJID = jid;
+        returnedIndex = index;
+        callsToChanged++;
+    });
+
+    Chattables::State newState;
+    newState.jid = jid;
+    newState.type = Chattables::State::Type::Room;
+    newState.status = StatusShow::Online;
+    chattables_.setState(jid, newState);
+
+    auto storedState = chattables_.getState(jid);
+
+    ASSERT_EQ(1, chattables_.get().size());
+    ASSERT_EQ(jid, chattables_.get()[0]);
+    ASSERT_EQ(jid, returnedJID);
+    ASSERT_EQ(0, returnedIndex);
+    ASSERT_EQ(1, callsToChanged);
+    ASSERT_EQ(jid, storedState.jid);
+    ASSERT_EQ(Chattables::State::Type::Room, storedState.type);
+    ASSERT_EQ(StatusShow::Online, storedState.status);
+}
diff --git a/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp b/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
index 1f69f4f..5339c7b 100644
--- a/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
+++ b/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
@@ -1,13 +1,14 @@
 /*
- * Copyright (c) 2010-2017 Isode Limited.
+ * Copyright (c) 2010-2018 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <boost/algorithm/string.hpp>
 
-#include <cppunit/extensions/HelperMacros.h>
-#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <memory>
+
+#include <gtest/gtest.h>
 #include <hippomocks.h>
 
 #include <Swiften/Avatars/NullAvatarManager.h>
@@ -32,10 +33,12 @@
 #include <Swiften/VCards/VCardMemoryStorage.h>
 
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
+#include <Swift/Controllers/Chat/Chattables.h>
 #include <Swift/Controllers/Chat/MUCController.h>
 #include <Swift/Controllers/Chat/UserSearchController.h>
 #include <Swift/Controllers/Roster/GroupRosterItem.h>
 #include <Swift/Controllers/Roster/Roster.h>
+#include <Swift/Controllers/SettingConstants.h>
 #include <Swift/Controllers/Settings/DummySettingsProvider.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
@@ -44,587 +47,918 @@
 #include <Swift/Controllers/UnitTest/MockChatWindow.h>
 #include <Swift/Controllers/XMPPEvents/EventController.h>
 
+// Clang wrongly things that tests for 0 are using 0 as null.
+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
+
 using namespace Swift;
 
-class MUCControllerTest : public CppUnit::TestFixture {
-    CPPUNIT_TEST_SUITE(MUCControllerTest);
-    CPPUNIT_TEST(testJoinPartStringContructionSimple);
-    CPPUNIT_TEST(testJoinPartStringContructionMixed);
-    CPPUNIT_TEST(testAppendToJoinParts);
-    CPPUNIT_TEST(testAddressedToSelf);
-    CPPUNIT_TEST(testNotAddressedToSelf);
-    CPPUNIT_TEST(testAddressedToSelfBySelf);
-    CPPUNIT_TEST(testMessageWithEmptyLabelItem);
-    CPPUNIT_TEST(testMessageWithLabelItem);
-    CPPUNIT_TEST(testCorrectMessageWithLabelItem);
-    CPPUNIT_TEST(testRoleAffiliationStates);
-    CPPUNIT_TEST(testSubjectChangeCorrect);
-    CPPUNIT_TEST(testSubjectChangeIncorrectA);
-    CPPUNIT_TEST(testSubjectChangeIncorrectB);
-    CPPUNIT_TEST(testSubjectChangeIncorrectC);
-    CPPUNIT_TEST(testHandleOccupantNicknameChanged);
-    CPPUNIT_TEST(testHandleOccupantNicknameChangedRoster);
-    CPPUNIT_TEST(testHandleChangeSubjectRequest);
-
-    CPPUNIT_TEST(testNonImpromptuMUCWindowTitle);
-
-    CPPUNIT_TEST_SUITE_END();
-
-public:
-    void setUp() {
-        crypto_ = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());
-        self_ = JID("girl@wonderland.lit/rabbithole");
-        nick_ = "aLiCe";
-        mucJID_ = JID("teaparty@rooms.wonderland.lit");
-        mocks_ = new MockRepository();
-        stanzaChannel_ = new DummyStanzaChannel();
-        iqChannel_ = new DummyIQChannel();
-        iqRouter_ = new IQRouter(iqChannel_);
-        eventController_ = new EventController();
-        chatWindowFactory_ = mocks_->InterfaceMock<ChatWindowFactory>();
-        userSearchWindowFactory_ = mocks_->InterfaceMock<UserSearchWindowFactory>();
-        xmppRoster_ = new XMPPRosterImpl();
-        presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);
-        presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);
-        directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);
-        uiEventStream_ = new UIEventStream();
-        avatarManager_ = new NullAvatarManager();
-        TimerFactory* timerFactory = nullptr;
-        window_ = new MockChatWindow();
-        mucRegistry_ = new MUCRegistry();
-        entityCapsProvider_ = new DummyEntityCapsProvider();
-        settings_ = new DummySettingsProvider();
-        highlightManager_ = new HighlightManager(settings_);
-        highlightManager_->resetToDefaultConfiguration();
-        muc_ = std::make_shared<MockMUC>(mucJID_);
-        mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(muc_->getJID(), uiEventStream_).Return(window_);
-        chatMessageParser_ = std::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat);
-        vcardStorage_ = new VCardMemoryStorage(crypto_.get());
-        vcardManager_ = new VCardManager(self_, iqRouter_, vcardStorage_);
-        nickResolver_ = new NickResolver(self_, xmppRoster_, vcardManager_, mucRegistry_);
-        clientBlockListManager_ = new ClientBlockListManager(iqRouter_);
-        mucBookmarkManager_ = new MUCBookmarkManager(iqRouter_);
-        controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, nullptr, nullptr, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, false, nullptr, vcardManager_, mucBookmarkManager_);
-    }
+class MUCControllerTest : public ::testing::Test {
+
+    protected:
+        void SetUp() {
+            crypto_ = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());
+            self_ = JID("girl@wonderland.lit/rabbithole");
+            nick_ = "aLiCe";
+            mucJID_ = JID("teaparty@rooms.wonderland.lit");
+            mocks_ = new MockRepository();
+            stanzaChannel_ = new DummyStanzaChannel();
+            iqChannel_ = new DummyIQChannel();
+            iqRouter_ = new IQRouter(iqChannel_);
+            eventController_ = new EventController();
+            chatWindowFactory_ = mocks_->InterfaceMock<ChatWindowFactory>();
+            userSearchWindowFactory_ = mocks_->InterfaceMock<UserSearchWindowFactory>();
+            xmppRoster_ = new XMPPRosterImpl();
+            presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);
+            presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);
+            directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);
+            uiEventStream_ = new UIEventStream();
+            avatarManager_ = new NullAvatarManager();
+            TimerFactory* timerFactory = nullptr;
+            window_ = new MockChatWindow();
+            mucRegistry_ = new MUCRegistry();
+            entityCapsProvider_ = new DummyEntityCapsProvider();
+            settings_ = new DummySettingsProvider();
+            highlightManager_ = new HighlightManager(settings_);
+            highlightManager_->resetToDefaultConfiguration();
+            muc_ = std::make_shared<MockMUC>(mucJID_);
+            mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(muc_->getJID(), uiEventStream_).Return(window_);
+            chatMessageParser_ = std::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat);
+            vcardStorage_ = new VCardMemoryStorage(crypto_.get());
+            vcardManager_ = new VCardManager(self_, iqRouter_, vcardStorage_);
+            nickResolver_ = new NickResolver(self_, xmppRoster_, vcardManager_, mucRegistry_);
+            clientBlockListManager_ = new ClientBlockListManager(iqRouter_);
+            mucBookmarkManager_ = new MUCBookmarkManager(iqRouter_);
+            chattables_ = std::make_unique<Chattables>();
+            controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, nullptr, nullptr, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, false, nullptr, vcardManager_, mucBookmarkManager_, settings_, *chattables_);
+        }
 
-    void tearDown() {
-        delete controller_;
-        delete mucBookmarkManager_;
-        delete clientBlockListManager_;
-        delete nickResolver_;
-        delete vcardManager_;
-        delete vcardStorage_;
-        delete highlightManager_;
-        delete settings_;
-        delete entityCapsProvider_;
-        delete eventController_;
-        delete presenceOracle_;
-        delete xmppRoster_;
-        delete mocks_;
-        delete uiEventStream_;
-        delete stanzaChannel_;
-        delete presenceSender_;
-        delete directedPresenceSender_;
-        delete iqRouter_;
-        delete iqChannel_;
-        delete mucRegistry_;
-        delete avatarManager_;
-    }
+        void TearDown() {
+            delete controller_;
+            delete mucBookmarkManager_;
+            delete clientBlockListManager_;
+            delete nickResolver_;
+            delete vcardManager_;
+            delete vcardStorage_;
+            delete highlightManager_;
+            delete settings_;
+            delete entityCapsProvider_;
+            delete eventController_;
+            delete presenceOracle_;
+            delete xmppRoster_;
+            delete mocks_;
+            delete uiEventStream_;
+            delete stanzaChannel_;
+            delete presenceSender_;
+            delete directedPresenceSender_;
+            delete iqRouter_;
+            delete iqChannel_;
+            delete mucRegistry_;
+            delete avatarManager_;
+        }
 
-    void finishJoin() {
-        Presence::ref presence(new Presence());
-        presence->setFrom(JID(muc_->getJID().toString() + "/" + nick_));
-        MUCUserPayload::ref status(new MUCUserPayload());
-        MUCUserPayload::StatusCode code;
-        code.code = 110;
-        status->addStatusCode(code);
-        presence->addPayload(status);
-        stanzaChannel_->onPresenceReceived(presence);
-    }
+        void finishJoin() {
+            Presence::ref presence(new Presence());
+            presence->setFrom(JID(muc_->getJID().toString() + "/" + nick_));
+            MUCUserPayload::ref status(new MUCUserPayload());
+            MUCUserPayload::StatusCode code;
+            code.code = 110;
+            status->addStatusCode(code);
+            presence->addPayload(status);
+            stanzaChannel_->onPresenceReceived(presence);
+        }
 
-    void joinCompleted() {
-        std::string messageBody("test message");
-        window_->onSendMessageRequest(messageBody, false);
-        std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];
-        Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);
-        CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
-        CPPUNIT_ASSERT(message);
-        CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get_value_or(""));
-
-        {
-            Message::ref message = std::make_shared<Message>();
-            message->setType(Message::Groupchat);
-            message->setTo(self_);
-            message->setFrom(mucJID_.withResource("SomeNickname"));
-            message->setID(iqChannel_->getNewIQID());
-            message->setSubject("Initial");
+        void joinCompleted() {
+            std::string messageBody("test message");
+            window_->onSendMessageRequest(messageBody, false);
+            std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];
+            Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);
+            ASSERT_TRUE(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
+            ASSERT_TRUE(message);
+            ASSERT_EQ(messageBody, message->getBody().get_value_or(""));
+
+            {
+                Message::ref message = std::make_shared<Message>();
+                message->setType(Message::Groupchat);
+                message->setTo(self_);
+                message->setFrom(mucJID_.withResource("SomeNickname"));
+                message->setID(iqChannel_->getNewIQID());
+                message->setSubject("Initial");
+
+                controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));
+            }
+        }
 
-            controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));
+        void checkEqual(const std::vector<NickJoinPart>& expected, const std::vector<NickJoinPart>& actual) {
+            ASSERT_EQ(expected.size(), actual.size());
+            for (size_t i = 0; i < expected.size(); i++) {
+                ASSERT_EQ(expected[i].nick, actual[i].nick);
+                ASSERT_EQ(expected[i].type, actual[i].type);
+            }
+        }
+
+        JID jidFromOccupant(const MUCOccupant& occupant) {
+            return JID(mucJID_.toString()+"/"+occupant.getNick());
         }
-    }
 
-    void testAddressedToSelf() {
-        finishJoin();
-        Message::ref message(new Message());
+        void testRoleAffiliationStatesVerify(const std::map<std::string, MUCOccupant> &occupants) {
+            /* verify that the roster is in sync */
+            GroupRosterItem* group = window_->getRosterModel()->getRoot();
+            for (auto rosterItem : group->getChildren()) {
+                GroupRosterItem* child = dynamic_cast<GroupRosterItem*>(rosterItem);
+                ASSERT_TRUE(child);
+                for (auto childItem : child->getChildren()) {
+                    ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(childItem);
+                    ASSERT_TRUE(item);
+                    std::map<std::string, MUCOccupant>::const_iterator occupant = occupants.find(item->getJID().getResource());
+                    ASSERT_TRUE(occupant != occupants.end());
+                    ASSERT_TRUE(item->getMUCRole() == occupant->second.getRole());
+                    ASSERT_TRUE(item->getMUCAffiliation() == occupant->second.getAffiliation());
+                }
+            }
+        }
 
-        message = Message::ref(new Message());
-        message->setFrom(JID(muc_->getJID().toString() + "/otherperson"));
-        message->setBody("basic " + nick_ + " test.");
-        message->setType(Message::Groupchat);
-        controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
-        CPPUNIT_ASSERT_EQUAL((size_t)1, eventController_->getEvents().size());
+        void setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue, const bool includeFormTypeField = true) {
+            auto form = std::make_shared<Form>(Form::Type::ResultType);
 
-        message = Message::ref(new Message());
-        message->setFrom(JID(muc_->getJID().toString() + "/otherperson"));
-        message->setBody(nick_ + ": hi there");
-        message->setType(Message::Groupchat);
-        controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
-        CPPUNIT_ASSERT_EQUAL((size_t)2, eventController_->getEvents().size());
+            if (includeFormTypeField) {
+                std::shared_ptr<FormField> formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");
+                formTypeField->setName("FORM_TYPE");
+                form->addField(formTypeField);
+            }
 
-        message->setFrom(JID(muc_->getJID().toString() + "/other"));
-        message->setBody("Hi there " + nick_);
-        message->setType(Message::Groupchat);
-        controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
-        CPPUNIT_ASSERT_EQUAL((size_t)3, eventController_->getEvents().size());
+            auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingValue);
+            auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingForegroundColorValue);
+            auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingBackgroundColorValue);
 
-        message = Message::ref(new Message());
-        message->setFrom(JID(muc_->getJID().toString() + "/other2"));
-        message->setBody("Hi " + boost::to_lower_copy(nick_) + ".");
-        message->setType(Message::Groupchat);
-        controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
+            markingField->setName("x-isode#roominfo_marking");
+            markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");
+            markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");
 
-        // The last message is ignored because self-mention highlights are matched case
-        // sensitive against the nickname.
-        CPPUNIT_ASSERT_EQUAL((size_t)3, eventController_->getEvents().size());
+            form->addField(markingField);
+            form->addField(markingForegroundColorField);
+            form->addField(markingBackgroundColorField);
 
-        message = Message::ref(new Message());
-        message->setFrom(JID(muc_->getJID().toString() + "/other3"));
-        message->setBody("Hi bert.");
-        message->setType(Message::Groupchat);
-        controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
-        CPPUNIT_ASSERT_EQUAL((size_t)3, eventController_->getEvents().size());
+            auto discoInfoRef = std::make_shared<DiscoInfo>();
+            discoInfoRef->addExtension(form);
 
-        message = Message::ref(new Message());
-        message->setFrom(JID(muc_->getJID().toString() + "/other2"));
-        message->setBody("Hi " + boost::to_lower_copy(nick_) + "ie.");
-        message->setType(Message::Groupchat);
-        controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
-        CPPUNIT_ASSERT_EQUAL((size_t)3, eventController_->getEvents().size());
+            auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);
+            iqChannel_->onIQReceived(infoResponse);
+        }
+
+        Message::ref createTestMessageWithoutSecurityLabel() {
+            auto message = std::make_shared<Message>();
+            message->setType(Message::Type::Groupchat);
+            message->setID("test-id");
+            message->setTo(self_);
+            message->setFrom(mucJID_.withResource("TestNickname"));
+            message->setBody("Do Not Read This Message");
+            return message;
+        }
+
+        JID self_;
+        JID mucJID_;
+        MockMUC::ref muc_;
+        std::string nick_;
+        DummyStanzaChannel* stanzaChannel_;
+        DummyIQChannel* iqChannel_;
+        IQRouter* iqRouter_;
+        EventController* eventController_;
+        ChatWindowFactory* chatWindowFactory_;
+        UserSearchWindowFactory* userSearchWindowFactory_;
+        MUCController* controller_;
+        NickResolver* nickResolver_;
+        PresenceOracle* presenceOracle_;
+        AvatarManager* avatarManager_;
+        StanzaChannelPresenceSender* presenceSender_;
+        DirectedPresenceSender* directedPresenceSender_;
+        MockRepository* mocks_;
+        UIEventStream* uiEventStream_;
+        MockChatWindow* window_;
+        MUCRegistry* mucRegistry_;
+        DummyEntityCapsProvider* entityCapsProvider_;
+        DummySettingsProvider* settings_;
+        HighlightManager* highlightManager_;
+        std::shared_ptr<ChatMessageParser> chatMessageParser_;
+        std::shared_ptr<CryptoProvider> crypto_;
+        VCardManager* vcardManager_;
+        VCardMemoryStorage* vcardStorage_;
+        ClientBlockListManager* clientBlockListManager_;
+        MUCBookmarkManager* mucBookmarkManager_;
+        XMPPRoster* xmppRoster_;
+        std::unique_ptr<Chattables> chattables_;
+};
+
+TEST_F(MUCControllerTest, testAddressedToSelf) {
+    finishJoin();
+    Message::ref message(new Message());
+
+    message = Message::ref(new Message());
+    message->setFrom(JID(muc_->getJID().toString() + "/otherperson"));
+    message->setBody("basic " + nick_ + " test.");
+    message->setType(Message::Groupchat);
+    controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
+    ASSERT_EQ(1, eventController_->getEvents().size());
+
+    message = Message::ref(new Message());
+    message->setFrom(JID(muc_->getJID().toString() + "/otherperson"));
+    message->setBody(nick_ + ": hi there");
+    message->setType(Message::Groupchat);
+    controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
+    ASSERT_EQ(2, eventController_->getEvents().size());
+
+    message->setFrom(JID(muc_->getJID().toString() + "/other"));
+    message->setBody("Hi there " + nick_);
+    message->setType(Message::Groupchat);
+    controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
+    ASSERT_EQ(3, eventController_->getEvents().size());
+
+    message = Message::ref(new Message());
+    message->setFrom(JID(muc_->getJID().toString() + "/other2"));
+    message->setBody("Hi " + boost::to_lower_copy(nick_) + ".");
+    message->setType(Message::Groupchat);
+    controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
+
+    // The last message is ignored because self-mention highlights are matched case
+    // sensitive against the nickname.
+    ASSERT_EQ(3, eventController_->getEvents().size());
+
+    message = Message::ref(new Message());
+    message->setFrom(JID(muc_->getJID().toString() + "/other3"));
+    message->setBody("Hi bert.");
+    message->setType(Message::Groupchat);
+    controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
+    ASSERT_EQ(3, eventController_->getEvents().size());
+
+    message = Message::ref(new Message());
+    message->setFrom(JID(muc_->getJID().toString() + "/other2"));
+    message->setBody("Hi " + boost::to_lower_copy(nick_) + "ie.");
+    message->setType(Message::Groupchat);
+    controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
+    ASSERT_EQ(3, eventController_->getEvents().size());
+}
+
+TEST_F(MUCControllerTest, testNotAddressedToSelf) {
+    finishJoin();
+    Message::ref message(new Message());
+    message->setFrom(JID(muc_->getJID().toString() + "/other3"));
+    message->setBody("Hi there Hatter");
+    message->setType(Message::Groupchat);
+    controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
+    ASSERT_EQ(0, eventController_->getEvents().size());
+}
+
+TEST_F(MUCControllerTest, testAddressedToSelfBySelf) {
+    finishJoin();
+    Message::ref message(new Message());
+    message->setFrom(JID(muc_->getJID().toString() + "/" + nick_));
+    message->setBody("Hi there " + nick_);
+    message->setType(Message::Groupchat);
+    controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
+    ASSERT_EQ(0, eventController_->getEvents().size());
+}
+
+TEST_F(MUCControllerTest, testMessageWithEmptyLabelItem) {
+    SecurityLabelsCatalog::Item label;
+    label.setSelector("Bob");
+    window_->label_ = label;
+    std::shared_ptr<DiscoInfo> features = std::make_shared<DiscoInfo>();
+    features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);
+    controller_->setAvailableServerFeatures(features);
+    IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];
+    SecurityLabelsCatalog::ref labelPayload = std::make_shared<SecurityLabelsCatalog>();
+    labelPayload->addItem(label);
+    IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);
+    iqChannel_->onIQReceived(result);
+    std::string messageBody("agamemnon");
+    window_->onSendMessageRequest(messageBody, false);
+    std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];
+    Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);
+    ASSERT_EQ(iq->getTo(), result->getFrom());
+    ASSERT_TRUE(window_->labelsEnabled_);
+    ASSERT_TRUE(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
+    ASSERT_TRUE(message);
+    ASSERT_EQ(messageBody, message->getBody().get());
+    ASSERT_FALSE(message->getPayload<SecurityLabel>());
+}
+
+TEST_F(MUCControllerTest, testMessageWithLabelItem) {
+    std::shared_ptr<SecurityLabel> label = std::make_shared<SecurityLabel>();
+    label->setLabel("a");
+    SecurityLabelsCatalog::Item labelItem;
+    labelItem.setSelector("Bob");
+    labelItem.setLabel(label);
+    window_->label_ = labelItem;
+    std::shared_ptr<DiscoInfo> features = std::make_shared<DiscoInfo>();
+    features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);
+    controller_->setAvailableServerFeatures(features);
+    IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];
+    SecurityLabelsCatalog::ref labelPayload = std::make_shared<SecurityLabelsCatalog>();
+    labelPayload->addItem(labelItem);
+    IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);
+    iqChannel_->onIQReceived(result);
+    std::string messageBody("agamemnon");
+    window_->onSendMessageRequest(messageBody, false);
+    std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];
+    Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);
+    ASSERT_EQ(iq->getTo(), result->getFrom());
+    ASSERT_TRUE(window_->labelsEnabled_);
+    ASSERT_TRUE(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
+    ASSERT_TRUE(message);
+    ASSERT_EQ(messageBody, message->getBody().get());
+    ASSERT_EQ(label, message->getPayload<SecurityLabel>());
+}
+
+TEST_F(MUCControllerTest, testCorrectMessageWithLabelItem) {
+    std::shared_ptr<SecurityLabel> label = std::make_shared<SecurityLabel>();
+    label->setLabel("a");
+    SecurityLabelsCatalog::Item labelItem;
+    labelItem.setSelector("Bob");
+    labelItem.setLabel(label);
+    std::shared_ptr<SecurityLabel> label2 = std::make_shared<SecurityLabel>();
+    label->setLabel("b");
+    SecurityLabelsCatalog::Item labelItem2;
+    labelItem2.setSelector("Charlie");
+    labelItem2.setLabel(label2);
+    window_->label_ = labelItem;
+    std::shared_ptr<DiscoInfo> features = std::make_shared<DiscoInfo>();
+    features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);
+    controller_->setAvailableServerFeatures(features);
+    IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];
+    SecurityLabelsCatalog::ref labelPayload = std::make_shared<SecurityLabelsCatalog>();
+    labelPayload->addItem(labelItem);
+    IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);
+    iqChannel_->onIQReceived(result);
+    std::string messageBody("agamemnon");
+    window_->onSendMessageRequest(messageBody, false);
+    std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];
+    Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);
+    ASSERT_EQ(iq->getTo(), result->getFrom());
+    ASSERT_TRUE(window_->labelsEnabled_);
+    ASSERT_TRUE(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
+    ASSERT_TRUE(message);
+    ASSERT_EQ(messageBody, message->getBody().get());
+    ASSERT_EQ(label, message->getPayload<SecurityLabel>());
+    window_->label_ = labelItem2;
+    window_->onSendMessageRequest(messageBody, true);
+    rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];
+    message = std::dynamic_pointer_cast<Message>(rawStanza);
+    ASSERT_EQ(messageBody, message->getBody().get());
+    ASSERT_EQ(label, message->getPayload<SecurityLabel>());
+}
+
+TEST_F(MUCControllerTest, testAppendToJoinParts) {
+    std::vector<NickJoinPart> list;
+    std::vector<NickJoinPart> gold;
+    MUCController::appendToJoinParts(list, NickJoinPart("Kev", Join));
+    gold.push_back(NickJoinPart("Kev", Join));
+    checkEqual(gold, list);
+    MUCController::appendToJoinParts(list, NickJoinPart("Remko", Join));
+    gold.push_back(NickJoinPart("Remko", Join));
+    checkEqual(gold, list);
+    MUCController::appendToJoinParts(list, NickJoinPart("Bert", Join));
+    gold.push_back(NickJoinPart("Bert", Join));
+    checkEqual(gold, list);
+    MUCController::appendToJoinParts(list, NickJoinPart("Bert", Part));
+    gold[2].type = JoinThenPart;
+    checkEqual(gold, list);
+    MUCController::appendToJoinParts(list, NickJoinPart("Kev", Part));
+    gold[0].type = JoinThenPart;
+    checkEqual(gold, list);
+    MUCController::appendToJoinParts(list, NickJoinPart("Remko", Part));
+    gold[1].type = JoinThenPart;
+    checkEqual(gold, list);
+    MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Part));
+    gold.push_back(NickJoinPart("Ernie", Part));
+    checkEqual(gold, list);
+    MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Join));
+    gold[3].type = PartThenJoin;
+    checkEqual(gold, list);
+    MUCController::appendToJoinParts(list, NickJoinPart("Kev", Join));
+    gold[0].type = Join;
+    checkEqual(gold, list);
+    MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Part));
+    gold[3].type = Part;
+    checkEqual(gold, list);
+
+}
+
+TEST_F(MUCControllerTest, testJoinPartStringContructionSimple) {
+    std::vector<NickJoinPart> list;
+    list.push_back(NickJoinPart("Kev", Join));
+    ASSERT_EQ(std::string("Kev has entered the room"), MUCController::generateJoinPartString(list, false));
+    list.push_back(NickJoinPart("Remko", Part));
+    ASSERT_EQ(std::string("Kev has entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));
+    list.push_back(NickJoinPart("Bert", Join));
+    ASSERT_EQ(std::string("Kev and Bert have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));
+    list.push_back(NickJoinPart("Ernie", Join));
+    ASSERT_EQ(std::string("Kev, Bert and Ernie have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));
+}
+
+TEST_F(MUCControllerTest, testJoinPartStringContructionMixed) {
+    std::vector<NickJoinPart> list;
+    list.push_back(NickJoinPart("Kev", JoinThenPart));
+    ASSERT_EQ(std::string("Kev has entered then left the room"), MUCController::generateJoinPartString(list, false));
+    list.push_back(NickJoinPart("Remko", Part));
+    ASSERT_EQ(std::string("Remko has left the room and Kev has entered then left the room"), MUCController::generateJoinPartString(list, false));
+    list.push_back(NickJoinPart("Bert", PartThenJoin));
+    ASSERT_EQ(std::string("Remko has left the room, Kev has entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list, false));
+    list.push_back(NickJoinPart("Ernie", JoinThenPart));
+    ASSERT_EQ(std::string("Remko has left the room, Kev and Ernie have entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list, false));
+}
+
+TEST_F(MUCControllerTest, testRoleAffiliationStates) {
+
+    typedef std::map<std::string, MUCOccupant> occupant_map;
+    occupant_map occupants;
+    occupants.insert(occupant_map::value_type("Kev", MUCOccupant("Kev", MUCOccupant::Participant, MUCOccupant::Owner)));
+    occupants.insert(occupant_map::value_type("Remko", MUCOccupant("Remko", MUCOccupant::Participant, MUCOccupant::Owner)));
+    occupants.insert(occupant_map::value_type("Bert", MUCOccupant("Bert", MUCOccupant::Participant, MUCOccupant::Owner)));
+    occupants.insert(occupant_map::value_type("Ernie", MUCOccupant("Ernie", MUCOccupant::Participant, MUCOccupant::Owner)));
+
+    /* populate the MUC with fake users */
+    for (auto&& occupant : occupants) {
+        muc_->insertOccupant(occupant.second);
     }
 
-    void testNotAddressedToSelf() {
-        finishJoin();
-        Message::ref message(new Message());
-        message->setFrom(JID(muc_->getJID().toString() + "/other3"));
-        message->setBody("Hi there Hatter");
-        message->setType(Message::Groupchat);
-        controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
-        CPPUNIT_ASSERT_EQUAL((size_t)0, eventController_->getEvents().size());
+    std::vector<MUCOccupant> alterations;
+    alterations.push_back(MUCOccupant("Kev", MUCOccupant::Visitor, MUCOccupant::Admin));
+    alterations.push_back(MUCOccupant("Remko", MUCOccupant::Moderator, MUCOccupant::Member));
+    alterations.push_back(MUCOccupant("Bert", MUCOccupant::Visitor, MUCOccupant::Outcast));
+    alterations.push_back(MUCOccupant("Ernie", MUCOccupant::NoRole, MUCOccupant::Member));
+    alterations.push_back(MUCOccupant("Bert", MUCOccupant::Moderator, MUCOccupant::Owner));
+    alterations.push_back(MUCOccupant("Kev", MUCOccupant::Participant, MUCOccupant::Outcast));
+    alterations.push_back(MUCOccupant("Bert", MUCOccupant::Visitor, MUCOccupant::NoAffiliation));
+    alterations.push_back(MUCOccupant("Remko", MUCOccupant::NoRole, MUCOccupant::NoAffiliation));
+    alterations.push_back(MUCOccupant("Ernie", MUCOccupant::Visitor, MUCOccupant::Outcast));
+
+    for (const auto& alteration : alterations) {
+        /* perform an alteration to a user's role and affiliation */
+        occupant_map::iterator occupant = occupants.find(alteration.getNick());
+        ASSERT_TRUE(occupant != occupants.end());
+        const JID jid = jidFromOccupant(occupant->second);
+        /* change the affiliation, leave the role in place */
+        muc_->changeAffiliation(jid, alteration.getAffiliation());
+        occupant->second = MUCOccupant(occupant->first, occupant->second.getRole(), alteration.getAffiliation());
+        testRoleAffiliationStatesVerify(occupants);
+        /* change the role, leave the affiliation in place */
+        muc_->changeOccupantRole(jid, alteration.getRole());
+        occupant->second = MUCOccupant(occupant->first, alteration.getRole(), occupant->second.getAffiliation());
+        testRoleAffiliationStatesVerify(occupants);
     }
+}
+
+TEST_F(MUCControllerTest, testSubjectChangeCorrect) {
+    joinCompleted();
 
-    void testAddressedToSelfBySelf() {
-        finishJoin();
-        Message::ref message(new Message());
-        message->setFrom(JID(muc_->getJID().toString() + "/" + nick_));
-        message->setBody("Hi there " + nick_);
+    {
+        Message::ref message = std::make_shared<Message>();
         message->setType(Message::Groupchat);
-        controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
-        CPPUNIT_ASSERT_EQUAL((size_t)0, eventController_->getEvents().size());
-    }
+        message->setTo(self_);
+        message->setFrom(mucJID_.withResource("SomeNickname"));
+        message->setID("3FB99C56-7C92-4755-91B0-9C0098BC7AE0");
+        message->setSubject("New Room Subject");
 
-    void testMessageWithEmptyLabelItem() {
-        SecurityLabelsCatalog::Item label;
-        label.setSelector("Bob");
-        window_->label_ = label;
-        std::shared_ptr<DiscoInfo> features = std::make_shared<DiscoInfo>();
-        features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);
-        controller_->setAvailableServerFeatures(features);
-        IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];
-        SecurityLabelsCatalog::ref labelPayload = std::make_shared<SecurityLabelsCatalog>();
-        labelPayload->addItem(label);
-        IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);
-        iqChannel_->onIQReceived(result);
-        std::string messageBody("agamemnon");
-        window_->onSendMessageRequest(messageBody, false);
-        std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];
-        Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);
-        CPPUNIT_ASSERT_EQUAL(iq->getTo(), result->getFrom());
-        CPPUNIT_ASSERT(window_->labelsEnabled_);
-        CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
-        CPPUNIT_ASSERT(message);
-        CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get());
-        CPPUNIT_ASSERT(!message->getPayload<SecurityLabel>());
+        controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));
+        ASSERT_EQ(std::string("The room subject is now: New Room Subject"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);
     }
+}
 
-    void testMessageWithLabelItem() {
-        std::shared_ptr<SecurityLabel> label = std::make_shared<SecurityLabel>();
-        label->setLabel("a");
-        SecurityLabelsCatalog::Item labelItem;
-        labelItem.setSelector("Bob");
-        labelItem.setLabel(label);
-        window_->label_ = labelItem;
-        std::shared_ptr<DiscoInfo> features = std::make_shared<DiscoInfo>();
-        features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);
-        controller_->setAvailableServerFeatures(features);
-        IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];
-        SecurityLabelsCatalog::ref labelPayload = std::make_shared<SecurityLabelsCatalog>();
-        labelPayload->addItem(labelItem);
-        IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);
-        iqChannel_->onIQReceived(result);
-        std::string messageBody("agamemnon");
-        window_->onSendMessageRequest(messageBody, false);
-        std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];
-        Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);
-        CPPUNIT_ASSERT_EQUAL(iq->getTo(), result->getFrom());
-        CPPUNIT_ASSERT(window_->labelsEnabled_);
-        CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
-        CPPUNIT_ASSERT(message);
-        CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get());
-        CPPUNIT_ASSERT_EQUAL(label, message->getPayload<SecurityLabel>());
-    }
+/*
+    * Test that message stanzas with subject element and non-empty body element do not cause a subject change.
+    */
+TEST_F(MUCControllerTest, testSubjectChangeIncorrectA) {
+    joinCompleted();
 
-    void testCorrectMessageWithLabelItem() {
-        std::shared_ptr<SecurityLabel> label = std::make_shared<SecurityLabel>();
-        label->setLabel("a");
-        SecurityLabelsCatalog::Item labelItem;
-        labelItem.setSelector("Bob");
-        labelItem.setLabel(label);
-        std::shared_ptr<SecurityLabel> label2 = std::make_shared<SecurityLabel>();
-        label->setLabel("b");
-        SecurityLabelsCatalog::Item labelItem2;
-        labelItem2.setSelector("Charlie");
-        labelItem2.setLabel(label2);
-        window_->label_ = labelItem;
-        std::shared_ptr<DiscoInfo> features = std::make_shared<DiscoInfo>();
-        features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);
-        controller_->setAvailableServerFeatures(features);
-        IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];
-        SecurityLabelsCatalog::ref labelPayload = std::make_shared<SecurityLabelsCatalog>();
-        labelPayload->addItem(labelItem);
-        IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);
-        iqChannel_->onIQReceived(result);
-        std::string messageBody("agamemnon");
-        window_->onSendMessageRequest(messageBody, false);
-        std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];
-        Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);
-        CPPUNIT_ASSERT_EQUAL(iq->getTo(), result->getFrom());
-        CPPUNIT_ASSERT(window_->labelsEnabled_);
-        CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
-        CPPUNIT_ASSERT(message);
-        CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get());
-        CPPUNIT_ASSERT_EQUAL(label, message->getPayload<SecurityLabel>());
-        window_->label_ = labelItem2;
-        window_->onSendMessageRequest(messageBody, true);
-        rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];
-        message = std::dynamic_pointer_cast<Message>(rawStanza);
-        CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get());
-        CPPUNIT_ASSERT_EQUAL(label, message->getPayload<SecurityLabel>());
+    {
+        Message::ref message = std::make_shared<Message>();
+        message->setType(Message::Groupchat);
+        message->setTo(self_);
+        message->setFrom(mucJID_.withResource("SomeNickname"));
+        message->setID(iqChannel_->getNewIQID());
+        message->setSubject("New Room Subject");
+        message->setBody("Some body text that prevents this stanza from being a subject change.");
+
+        controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));
+        ASSERT_EQ(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);
     }
+}
 
-    void checkEqual(const std::vector<NickJoinPart>& expected, const std::vector<NickJoinPart>& actual) {
-        CPPUNIT_ASSERT_EQUAL(expected.size(), actual.size());
-        for (size_t i = 0; i < expected.size(); i++) {
-            CPPUNIT_ASSERT_EQUAL(expected[i].nick, actual[i].nick);
-            CPPUNIT_ASSERT_EQUAL(expected[i].type, actual[i].type);
-        }
+/*
+    * Test that message stanzas with subject element and thread element do not cause a subject change.
+    */
+TEST_F(MUCControllerTest, testSubjectChangeIncorrectB) {
+    joinCompleted();
+
+    {
+        Message::ref message = std::make_shared<Message>();
+        message->setType(Message::Groupchat);
+        message->setTo(self_);
+        message->setFrom(mucJID_.withResource("SomeNickname"));
+        message->setID(iqChannel_->getNewIQID());
+        message->setSubject("New Room Subject");
+        message->addPayload(std::make_shared<Thread>("Thread that prevents the subject change."));
+
+        controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));
+        ASSERT_EQ(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);
     }
+}
 
-    void testAppendToJoinParts() {
-        std::vector<NickJoinPart> list;
-        std::vector<NickJoinPart> gold;
-        MUCController::appendToJoinParts(list, NickJoinPart("Kev", Join));
-        gold.push_back(NickJoinPart("Kev", Join));
-        checkEqual(gold, list);
-        MUCController::appendToJoinParts(list, NickJoinPart("Remko", Join));
-        gold.push_back(NickJoinPart("Remko", Join));
-        checkEqual(gold, list);
-        MUCController::appendToJoinParts(list, NickJoinPart("Bert", Join));
-        gold.push_back(NickJoinPart("Bert", Join));
-        checkEqual(gold, list);
-        MUCController::appendToJoinParts(list, NickJoinPart("Bert", Part));
-        gold[2].type = JoinThenPart;
-        checkEqual(gold, list);
-        MUCController::appendToJoinParts(list, NickJoinPart("Kev", Part));
-        gold[0].type = JoinThenPart;
-        checkEqual(gold, list);
-        MUCController::appendToJoinParts(list, NickJoinPart("Remko", Part));
-        gold[1].type = JoinThenPart;
-        checkEqual(gold, list);
-        MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Part));
-        gold.push_back(NickJoinPart("Ernie", Part));
-        checkEqual(gold, list);
-        MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Join));
-        gold[3].type = PartThenJoin;
-        checkEqual(gold, list);
-        MUCController::appendToJoinParts(list, NickJoinPart("Kev", Join));
-        gold[0].type = Join;
-        checkEqual(gold, list);
-        MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Part));
-        gold[3].type = Part;
-        checkEqual(gold, list);
+/*
+    * Test that message stanzas with subject element and empty body element do not cause a subject change.
+    */
+TEST_F(MUCControllerTest, testSubjectChangeIncorrectC) {
+    joinCompleted();
 
+    {
+        Message::ref message = std::make_shared<Message>();
+        message->setType(Message::Groupchat);
+        message->setTo(self_);
+        message->setFrom(mucJID_.withResource("SomeNickname"));
+        message->setID(iqChannel_->getNewIQID());
+        message->setSubject("New Room Subject");
+        message->setBody("");
+
+        controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));
+        ASSERT_EQ(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);
     }
+}
+
+TEST_F(MUCControllerTest, testHandleOccupantNicknameChanged) {
+    const auto occupantCount = [&](const std::string & nick) {
+        auto roster = window_->getRosterModel();
+        const auto currentOccupantsJIDs = roster->getJIDs();
+        int count = 0;
+        for (auto & p : currentOccupantsJIDs) {
+            if (p.getResource() == nick) {
+                ++count;
+            }
+        }
+        return count;
+    };
+
+    muc_->insertOccupant(MUCOccupant("TestUserOne", MUCOccupant::Participant, MUCOccupant::Owner));
+    muc_->insertOccupant(MUCOccupant("TestUserTwo", MUCOccupant::Participant, MUCOccupant::Owner));
+    muc_->insertOccupant(MUCOccupant("TestUserThree", MUCOccupant::Participant, MUCOccupant::Owner));
+
+    muc_->onOccupantNicknameChanged("TestUserOne", "TestUserTwo");
+
+    ASSERT_EQ(0, occupantCount("TestUserOne"));
+    ASSERT_EQ(1, occupantCount("TestUserTwo"));
+    ASSERT_EQ(1, occupantCount("TestUserThree"));
+}
+
+TEST_F(MUCControllerTest, testHandleOccupantNicknameChangedRoster) {
+    const auto occupantCount = [&](const std::string & nick) {
+        auto roster = window_->getRosterModel();
+        const auto participants = roster->getGroup("Participants");
+        const auto displayedParticipants = participants->getDisplayedChildren();
+        int count = 0;
+        for (auto & p : displayedParticipants) {
+            if (p->getDisplayName() == nick) {
+                ++count;
+            }
+        }
+        return count;
+    };
+
+    muc_->insertOccupant(MUCOccupant("TestUserOne", MUCOccupant::Participant, MUCOccupant::Owner));
+    muc_->insertOccupant(MUCOccupant("TestUserTwo", MUCOccupant::Participant, MUCOccupant::Owner));
+    muc_->insertOccupant(MUCOccupant("TestUserThree", MUCOccupant::Participant, MUCOccupant::Owner));
+    ASSERT_EQ(1, occupantCount("TestUserOne"));
+    ASSERT_EQ(1, occupantCount("TestUserTwo"));
+    ASSERT_EQ(1, occupantCount("TestUserThree"));
+
+    muc_->onOccupantNicknameChanged("TestUserOne", "TestUserTwo");
+
+    ASSERT_EQ(0, occupantCount("TestUserOne"));
+    ASSERT_EQ(1, occupantCount("TestUserTwo"));
+    ASSERT_EQ(1, occupantCount("TestUserThree"));
+}
+
+TEST_F(MUCControllerTest, testHandleChangeSubjectRequest) {
+    std::string testStr("New Subject");
+    ASSERT_EQ(std::string(""), muc_->newSubjectSet_);
+    window_->onChangeSubjectRequest(testStr);
+    ASSERT_EQ(testStr, muc_->newSubjectSet_);
+}
+
+TEST_F(MUCControllerTest, testNonImpromptuMUCWindowTitle) {
+    ASSERT_EQ(muc_->getJID().getNode(), window_->name_);
+}
+
+TEST_F(MUCControllerTest, testSecurityMarkingRequestCompleteMarking) {
+    setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red", true);
+
+    ASSERT_EQ(std::string("Test|Highest Possible Security"), window_->markingValue_);
+    ASSERT_EQ(std::string("Black"), window_->markingForegroundColorValue_);
+    ASSERT_EQ(std::string("Red"), window_->markingBackgroundColorValue_);
+}
+
+TEST_F(MUCControllerTest, testSecurityMarkingRequestCompleteMarkingWithExtraForm) {
+    auto formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");
+    auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test|Highest Possible Security");
+    auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Black");
+    auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Red");
+    formTypeField->setName("FORM_TYPE");
+    markingField->setName("x-isode#roominfo_marking");
+    markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");
+    markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");
+
+    auto extraForm = std::make_shared<Form>(Form::Type::ResultType);
+    auto form = std::make_shared<Form>(Form::Type::ResultType);
+    form->addField(formTypeField);
+    form->addField(markingField);
+    form->addField(markingForegroundColorField);
+    form->addField(markingBackgroundColorField);
+
+    auto discoInfoRef = std::make_shared<DiscoInfo>();
+    discoInfoRef->addExtension(extraForm);
+    discoInfoRef->addExtension(form);
+
+    auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);
+    iqChannel_->onIQReceived(infoResponse);
+    ASSERT_EQ(std::string("Test|Highest Possible Security"), window_->markingValue_);
+    ASSERT_EQ(std::string("Black"), window_->markingForegroundColorValue_);
+    ASSERT_EQ(std::string("Red"), window_->markingBackgroundColorValue_);
+}
+
+TEST_F(MUCControllerTest, testSecurityMarkingRequestNoColorsInMarking) {
+    auto formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");
+    auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test|Highest Possible Security");
+    auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");
+    auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");
+    formTypeField->setName("FORM_TYPE");
+    markingField->setName("x-isode#roominfo_marking");
+    markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");
+    markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");
+
+    auto form = std::make_shared<Form>(Form::Type::ResultType);
+    form->addField(formTypeField);
+    form->addField(markingField);
+    form->addField(markingForegroundColorField);
+    form->addField(markingBackgroundColorField);
+
+    auto discoInfoRef = std::make_shared<DiscoInfo>();
+    discoInfoRef->addExtension(form);
+
+    auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);
+    iqChannel_->onIQReceived(infoResponse);
+    ASSERT_EQ(std::string("Test|Highest Possible Security"), window_->markingValue_);
+    ASSERT_EQ(std::string("Black"), window_->markingForegroundColorValue_);
+    ASSERT_EQ(std::string("White"), window_->markingBackgroundColorValue_);
+}
+
+TEST_F(MUCControllerTest, testSecurityMarkingRequestEmptyMarking) {
+    setMUCSecurityMarking("", "", "", true);
+
+    ASSERT_EQ(std::string(""), window_->markingValue_);
+    ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);
+    ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);
+}
+
+TEST_F(MUCControllerTest, testSecurityMarkingRequestWithMarkingNoFormType) {
+    setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red", false);
+
+    ASSERT_EQ(std::string(""), window_->markingValue_);
+    ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);
+    ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);
+}
+
+TEST_F(MUCControllerTest, testSecurityMarkingRequestNoMarking) {
+    auto form = std::make_shared<Form>(Form::Type::ResultType);
+
+    auto discoInfoRef = std::make_shared<DiscoInfo>();
+    discoInfoRef->addExtension(form);
+
+    auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);
+    iqChannel_->onIQReceived(infoResponse);
+    ASSERT_EQ(std::string(""), window_->markingValue_);
+    ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);
+    ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);
+}
+
+TEST_F(MUCControllerTest, testSecurityMarkingRequestNoForm) {
+    auto discoInfoRef = std::make_shared<DiscoInfo>();
+
+    auto infoResponse = IQ::createResult( self_, mucJID_, "test-id", discoInfoRef);
+    iqChannel_->onIQReceived(infoResponse);
+    ASSERT_EQ(std::string(""), window_->markingValue_);
+    ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);
+    ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);
+}
+
+TEST_F(MUCControllerTest, testSecurityMarkingRequestError) {
+    auto errorPayload = std::make_shared<ErrorPayload>(ErrorPayload::Condition::NotAuthorized, ErrorPayload::Type::Auth);
+
+    auto infoResponse = IQ::createResult( self_, mucJID_, "test-id", errorPayload);
+    iqChannel_->onIQReceived(infoResponse);
+    ASSERT_EQ(std::string(""), window_->markingValue_);
+    ASSERT_EQ(std::string(""), window_->markingForegroundColorValue_);
+    ASSERT_EQ(std::string(""), window_->markingBackgroundColorValue_);
+}
 
-    void testJoinPartStringContructionSimple() {
-        std::vector<NickJoinPart> list;
-        list.push_back(NickJoinPart("Kev", Join));
-        CPPUNIT_ASSERT_EQUAL(std::string("Kev has entered the room"), MUCController::generateJoinPartString(list, false));
-        list.push_back(NickJoinPart("Remko", Part));
-        CPPUNIT_ASSERT_EQUAL(std::string("Kev has entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));
-        list.push_back(NickJoinPart("Bert", Join));
-        CPPUNIT_ASSERT_EQUAL(std::string("Kev and Bert have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));
-        list.push_back(NickJoinPart("Ernie", Join));
-        CPPUNIT_ASSERT_EQUAL(std::string("Kev, Bert and Ernie have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));
-    }
+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingA) {
+    settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);
+    setMUCSecurityMarking("", "Black", "Red");
 
-    void testJoinPartStringContructionMixed() {
-        std::vector<NickJoinPart> list;
-        list.push_back(NickJoinPart("Kev", JoinThenPart));
-        CPPUNIT_ASSERT_EQUAL(std::string("Kev has entered then left the room"), MUCController::generateJoinPartString(list, false));
-        list.push_back(NickJoinPart("Remko", Part));
-        CPPUNIT_ASSERT_EQUAL(std::string("Remko has left the room and Kev has entered then left the room"), MUCController::generateJoinPartString(list, false));
-        list.push_back(NickJoinPart("Bert", PartThenJoin));
-        CPPUNIT_ASSERT_EQUAL(std::string("Remko has left the room, Kev has entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list, false));
-        list.push_back(NickJoinPart("Ernie", JoinThenPart));
-        CPPUNIT_ASSERT_EQUAL(std::string("Remko has left the room, Kev and Ernie have entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list, false));
-    }
+    auto messageLabel = std::make_shared<SecurityLabel>();
+    messageLabel->setDisplayMarking("Test|Highest Possible Security");
 
-    JID jidFromOccupant(const MUCOccupant& occupant) {
-        return JID(mucJID_.toString()+"/"+occupant.getNick());
-    }
+    auto sentMessage = createTestMessageWithoutSecurityLabel();
+    sentMessage->addPayload(messageLabel);
 
-    void testRoleAffiliationStates() {
+    auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+    controller_->handleIncomingMessage(sentMessageEvent);
 
-        typedef std::map<std::string, MUCOccupant> occupant_map;
-        occupant_map occupants;
-        occupants.insert(occupant_map::value_type("Kev", MUCOccupant("Kev", MUCOccupant::Participant, MUCOccupant::Owner)));
-        occupants.insert(occupant_map::value_type("Remko", MUCOccupant("Remko", MUCOccupant::Participant, MUCOccupant::Owner)));
-        occupants.insert(occupant_map::value_type("Bert", MUCOccupant("Bert", MUCOccupant::Participant, MUCOccupant::Owner)));
-        occupants.insert(occupant_map::value_type("Ernie", MUCOccupant("Ernie", MUCOccupant::Participant, MUCOccupant::Owner)));
+    auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
 
-        /* populate the MUC with fake users */
-        for (auto&& occupant : occupants) {
-            muc_->insertOccupant(occupant.second);
-        }
+    ASSERT_EQ(false, storedSecurityLabel == nullptr);
+    // This is the potentially altered security label that is displayed on the screen
+    ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());
+}
 
-        std::vector<MUCOccupant> alterations;
-        alterations.push_back(MUCOccupant("Kev", MUCOccupant::Visitor, MUCOccupant::Admin));
-        alterations.push_back(MUCOccupant("Remko", MUCOccupant::Moderator, MUCOccupant::Member));
-        alterations.push_back(MUCOccupant("Bert", MUCOccupant::Visitor, MUCOccupant::Outcast));
-        alterations.push_back(MUCOccupant("Ernie", MUCOccupant::NoRole, MUCOccupant::Member));
-        alterations.push_back(MUCOccupant("Bert", MUCOccupant::Moderator, MUCOccupant::Owner));
-        alterations.push_back(MUCOccupant("Kev", MUCOccupant::Participant, MUCOccupant::Outcast));
-        alterations.push_back(MUCOccupant("Bert", MUCOccupant::Visitor, MUCOccupant::NoAffiliation));
-        alterations.push_back(MUCOccupant("Remko", MUCOccupant::NoRole, MUCOccupant::NoAffiliation));
-        alterations.push_back(MUCOccupant("Ernie", MUCOccupant::Visitor, MUCOccupant::Outcast));
-
-        for (const auto& alteration : alterations) {
-            /* perform an alteration to a user's role and affiliation */
-            occupant_map::iterator occupant = occupants.find(alteration.getNick());
-            CPPUNIT_ASSERT(occupant != occupants.end());
-            const JID jid = jidFromOccupant(occupant->second);
-            /* change the affiliation, leave the role in place */
-            muc_->changeAffiliation(jid, alteration.getAffiliation());
-            occupant->second = MUCOccupant(occupant->first, occupant->second.getRole(), alteration.getAffiliation());
-            testRoleAffiliationStatesVerify(occupants);
-            /* change the role, leave the affiliation in place */
-            muc_->changeOccupantRole(jid, alteration.getRole());
-            occupant->second = MUCOccupant(occupant->first, alteration.getRole(), occupant->second.getAffiliation());
-            testRoleAffiliationStatesVerify(occupants);
-        }
-    }
+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingB) {
+    settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);
+    setMUCSecurityMarking("", "Black", "Red");
 
-    void testSubjectChangeCorrect() {
-        joinCompleted();
+    auto messageLabel = std::make_shared<SecurityLabel>();
+    messageLabel->setDisplayMarking("");
 
-        {
-            Message::ref message = std::make_shared<Message>();
-            message->setType(Message::Groupchat);
-            message->setTo(self_);
-            message->setFrom(mucJID_.withResource("SomeNickname"));
-            message->setID("3FB99C56-7C92-4755-91B0-9C0098BC7AE0");
-            message->setSubject("New Room Subject");
+    auto sentMessage = createTestMessageWithoutSecurityLabel();
+    sentMessage->addPayload(messageLabel);
 
-            controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));
-            CPPUNIT_ASSERT_EQUAL(std::string("The room subject is now: New Room Subject"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);
-        }
-    }
+    auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+    controller_->handleIncomingMessage(sentMessageEvent);
 
-    /*
-     * Test that message stanzas with subject element and non-empty body element do not cause a subject change.
-     */
-    void testSubjectChangeIncorrectA() {
-        joinCompleted();
+    auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
 
-        {
-            Message::ref message = std::make_shared<Message>();
-            message->setType(Message::Groupchat);
-            message->setTo(self_);
-            message->setFrom(mucJID_.withResource("SomeNickname"));
-            message->setID(iqChannel_->getNewIQID());
-            message->setSubject("New Room Subject");
-            message->setBody("Some body text that prevents this stanza from being a subject change.");
+    ASSERT_EQ(false, storedSecurityLabel == nullptr);
+    // This is the potentially altered security label that is displayed on the screen
+    ASSERT_EQ(std::string(""), storedSecurityLabel->getDisplayMarking());
+}
 
-            controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));
-            CPPUNIT_ASSERT_EQUAL(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);
-        }
-    }
+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingA) {
+    settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);
+    setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");
 
-    /*
-     * Test that message stanzas with subject element and thread element do not cause a subject change.
-     */
-    void testSubjectChangeIncorrectB() {
-        joinCompleted();
+    auto messageLabel = std::make_shared<SecurityLabel>();
+    messageLabel->setDisplayMarking("Test|Highest Possible Security");
 
-        {
-            Message::ref message = std::make_shared<Message>();
-            message->setType(Message::Groupchat);
-            message->setTo(self_);
-            message->setFrom(mucJID_.withResource("SomeNickname"));
-            message->setID(iqChannel_->getNewIQID());
-            message->setSubject("New Room Subject");
-            message->addPayload(std::make_shared<Thread>("Thread that prevents the subject change."));
+    auto sentMessage = createTestMessageWithoutSecurityLabel();
+    sentMessage->addPayload(messageLabel);
 
-            controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));
-            CPPUNIT_ASSERT_EQUAL(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);
-        }
-    }
+    // Test the first message matching MUC marking. This message SHOULD have a marking
 
-    /*
-     * Test that message stanzas with subject element and empty body element do not cause a subject change.
-     */
-    void testSubjectChangeIncorrectC() {
-        joinCompleted();
+    auto sentMessageEvent1 = std::make_shared<MessageEvent>(sentMessage);
+    controller_->handleIncomingMessage(sentMessageEvent1);
 
-        {
-            Message::ref message = std::make_shared<Message>();
-            message->setType(Message::Groupchat);
-            message->setTo(self_);
-            message->setFrom(mucJID_.withResource("SomeNickname"));
-            message->setID(iqChannel_->getNewIQID());
-            message->setSubject("New Room Subject");
-            message->setBody("");
+    auto storedSecurityLabel1 = window_->lastAddedMessageSecurityLabel_;
 
-            controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));
-            CPPUNIT_ASSERT_EQUAL(std::string("Trying to enter room teaparty@rooms.wonderland.lit"), std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(window_->lastAddedSystemMessage_.getParts()[0])->text);
-        }
-    }
+    ASSERT_EQ(false, storedSecurityLabel1 == nullptr);
+    // This is the potentially altered security label that is displayed on the screen
+    ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel1->getDisplayMarking());
 
-    void testHandleOccupantNicknameChanged() {
-        const auto occupantCount = [&](const std::string & nick) {
-            auto roster = window_->getRosterModel();
-            CPPUNIT_ASSERT(roster != nullptr);
-            const auto currentOccupantsJIDs = roster->getJIDs();
-            int count = 0;
-            for (auto & p : currentOccupantsJIDs) {
-                if (p.getResource() == nick) {
-                    ++count;
-                }
-            }
-            return count;
-        };
+    // Test a consecutive message matching MUC marking. This message SHOULD NOT have a marking
 
-        muc_->insertOccupant(MUCOccupant("TestUserOne", MUCOccupant::Participant, MUCOccupant::Owner));
-        muc_->insertOccupant(MUCOccupant("TestUserTwo", MUCOccupant::Participant, MUCOccupant::Owner));
-        muc_->insertOccupant(MUCOccupant("TestUserThree", MUCOccupant::Participant, MUCOccupant::Owner));
+    auto sentMessageEvent2 = std::make_shared<MessageEvent>(sentMessage);
+    controller_->handleIncomingMessage(sentMessageEvent2);
 
-        muc_->onOccupantNicknameChanged("TestUserOne", "TestUserTwo");
+    auto storedSecurityLabel2 = window_->lastAddedMessageSecurityLabel_;
 
-        CPPUNIT_ASSERT_EQUAL(0, occupantCount("TestUserOne"));
-        CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserTwo"));
-        CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserThree"));
-    }
+    ASSERT_EQ(false, storedSecurityLabel2 == nullptr);
+    // This is the potentially altered security label that is displayed on the screen
+    ASSERT_EQ(std::string(""), storedSecurityLabel2->getDisplayMarking());
+}
 
-    void testHandleOccupantNicknameChangedRoster() {
-        const auto occupantCount = [&](const std::string & nick) {
-            auto roster = window_->getRosterModel();
-            CPPUNIT_ASSERT(roster != nullptr);
-            const auto participants = roster->getGroup("Participants");
-            CPPUNIT_ASSERT(participants != nullptr);
-            const auto displayedParticipants = participants->getDisplayedChildren();
-            int count = 0;
-            for (auto & p : displayedParticipants) {
-                if (p->getDisplayName() == nick) {
-                    ++count;
-                }
-            }
-            return count;
-        };
+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingB) {
+    settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);
+    setMUCSecurityMarking("Test|Lower Security Marking", "Black", "Red");
 
-        muc_->insertOccupant(MUCOccupant("TestUserOne", MUCOccupant::Participant, MUCOccupant::Owner));
-        muc_->insertOccupant(MUCOccupant("TestUserTwo", MUCOccupant::Participant, MUCOccupant::Owner));
-        muc_->insertOccupant(MUCOccupant("TestUserThree", MUCOccupant::Participant, MUCOccupant::Owner));
-        CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserOne"));
-        CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserTwo"));
-        CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserThree"));
+    auto messageLabel = std::make_shared<SecurityLabel>();
+    messageLabel->setDisplayMarking("Test|Highest Possible Security");
 
-        muc_->onOccupantNicknameChanged("TestUserOne", "TestUserTwo");
+    auto sentMessage = createTestMessageWithoutSecurityLabel();
+    sentMessage->addPayload(messageLabel);
 
-        CPPUNIT_ASSERT_EQUAL(0, occupantCount("TestUserOne"));
-        CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserTwo"));
-        CPPUNIT_ASSERT_EQUAL(1, occupantCount("TestUserThree"));
-    }
+    auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+    controller_->handleIncomingMessage(sentMessageEvent);
 
-    void testRoleAffiliationStatesVerify(const std::map<std::string, MUCOccupant> &occupants) {
-        /* verify that the roster is in sync */
-        GroupRosterItem* group = window_->getRosterModel()->getRoot();
-        for (auto rosterItem : group->getChildren()) {
-            GroupRosterItem* child = dynamic_cast<GroupRosterItem*>(rosterItem);
-            CPPUNIT_ASSERT(child);
-            for (auto childItem : child->getChildren()) {
-                ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(childItem);
-                CPPUNIT_ASSERT(item);
-                std::map<std::string, MUCOccupant>::const_iterator occupant = occupants.find(item->getJID().getResource());
-                CPPUNIT_ASSERT(occupant != occupants.end());
-                CPPUNIT_ASSERT(item->getMUCRole() == occupant->second.getRole());
-                CPPUNIT_ASSERT(item->getMUCAffiliation() == occupant->second.getAffiliation());
-            }
-        }
-    }
+    auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
 
-    void testHandleChangeSubjectRequest() {
-        std::string testStr("New Subject");
-        CPPUNIT_ASSERT_EQUAL(std::string(""), muc_->newSubjectSet_);
-        window_->onChangeSubjectRequest(testStr);
-        CPPUNIT_ASSERT_EQUAL(testStr, muc_->newSubjectSet_);
-    }
+    ASSERT_EQ(false, storedSecurityLabel == nullptr);
+    // This is the potentially altered security label that is displayed on the screen
+    ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());
+}
 
-    void testNonImpromptuMUCWindowTitle() {
-        CPPUNIT_ASSERT_EQUAL(muc_->getJID().getNode(), window_->name_);
-    }
+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingC) {
+    settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);
+    setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");
 
-private:
-    JID self_;
-    JID mucJID_;
-    MockMUC::ref muc_;
-    std::string nick_;
-    DummyStanzaChannel* stanzaChannel_;
-    DummyIQChannel* iqChannel_;
-    IQRouter* iqRouter_;
-    EventController* eventController_;
-    ChatWindowFactory* chatWindowFactory_;
-    UserSearchWindowFactory* userSearchWindowFactory_;
-    MUCController* controller_;
-    NickResolver* nickResolver_;
-    PresenceOracle* presenceOracle_;
-    AvatarManager* avatarManager_;
-    StanzaChannelPresenceSender* presenceSender_;
-    DirectedPresenceSender* directedPresenceSender_;
-    MockRepository* mocks_;
-    UIEventStream* uiEventStream_;
-    MockChatWindow* window_;
-    MUCRegistry* mucRegistry_;
-    DummyEntityCapsProvider* entityCapsProvider_;
-    DummySettingsProvider* settings_;
-    HighlightManager* highlightManager_;
-    std::shared_ptr<ChatMessageParser> chatMessageParser_;
-    std::shared_ptr<CryptoProvider> crypto_;
-    VCardManager* vcardManager_;
-    VCardMemoryStorage* vcardStorage_;
-    ClientBlockListManager* clientBlockListManager_;
-    MUCBookmarkManager* mucBookmarkManager_;
-    XMPPRoster* xmppRoster_;
-};
+    auto messageLabel = std::make_shared<SecurityLabel>();
+    messageLabel->setDisplayMarking("");
+
+    auto sentMessage = createTestMessageWithoutSecurityLabel();
+    sentMessage->addPayload(messageLabel);
+
+    auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+    controller_->handleIncomingMessage(sentMessageEvent);
+
+    auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
+
+    ASSERT_EQ(false, storedSecurityLabel == nullptr);
+    // This is the potentially altered security label that is displayed on the screen
+    ASSERT_EQ(std::string("Unmarked"), storedSecurityLabel->getDisplayMarking());
+}
+
+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingA) {
+    settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);
+    setMUCSecurityMarking("", "Black", "Red");
+
+    auto messageLabel = std::make_shared<SecurityLabel>();
+    messageLabel->setDisplayMarking("Test|Highest Possible Security");
+
+    auto sentMessage = createTestMessageWithoutSecurityLabel();
+    sentMessage->addPayload(messageLabel);
+
+    auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+    controller_->handleIncomingMessage(sentMessageEvent);
+
+    auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
+
+    ASSERT_EQ(false, storedSecurityLabel == nullptr);
+    // This is the potentially altered security label that is displayed on the screen
+    ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());
+}
+
+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingB) {
+    settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);
+    setMUCSecurityMarking("", "Black", "Red");
+
+    auto messageLabel = std::make_shared<SecurityLabel>();
+    messageLabel->setDisplayMarking("");
+
+    auto sentMessage = createTestMessageWithoutSecurityLabel();
+    sentMessage->addPayload(messageLabel);
+
+    auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+    controller_->handleIncomingMessage(sentMessageEvent);
+
+    auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
+
+    ASSERT_EQ(false, storedSecurityLabel == nullptr);
+    // This is the potentially altered security label that is displayed on the screen
+    ASSERT_EQ(std::string(""), storedSecurityLabel->getDisplayMarking());
+}
+
+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingA) {
+    settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);
+    setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");
+
+    auto messageLabel = std::make_shared<SecurityLabel>();
+    messageLabel->setDisplayMarking("Test|Highest Possible Security");
+
+    auto sentMessage = createTestMessageWithoutSecurityLabel();
+    sentMessage->addPayload(messageLabel);
+
+    // Test the first message matching MUC marking. This message SHOULD have a marking
+
+    auto sentMessageEvent1 = std::make_shared<MessageEvent>(sentMessage);
+    controller_->handleIncomingMessage(sentMessageEvent1);
+
+    auto storedSecurityLabel1 = window_->lastAddedMessageSecurityLabel_;
+
+    ASSERT_EQ(false, storedSecurityLabel1 == nullptr);
+    // This is the potentially altered security label that is displayed on the screen
+    ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel1->getDisplayMarking());
+
+    // Test a consecutive message matching MUC marking. This message SHOULD ALSO have a marking
+
+    auto sentMessageEvent2 = std::make_shared<MessageEvent>(sentMessage);
+    controller_->handleIncomingMessage(sentMessageEvent2);
+
+    auto storedSecurityLabel2 = window_->lastAddedMessageSecurityLabel_;
+
+    ASSERT_EQ(false, storedSecurityLabel2 == nullptr);
+    // This is the potentially altered security label that is displayed on the screen
+    ASSERT_EQ(std::string("Test|Highest Possible Security"), storedSecurityLabel2->getDisplayMarking());
+}
+
+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingB) {
+    settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);
+    setMUCSecurityMarking("", "Black", "Red");
+
+    auto messageLabel = std::make_shared<SecurityLabel>();
+    messageLabel->setDisplayMarking("");
+
+    auto sentMessage = createTestMessageWithoutSecurityLabel();
+    sentMessage->addPayload(messageLabel);
+
+    auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+    controller_->handleIncomingMessage(sentMessageEvent);
 
-CPPUNIT_TEST_SUITE_REGISTRATION(MUCControllerTest);
+    auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
 
+    ASSERT_EQ(false, storedSecurityLabel == nullptr);
+    // This is the potentially altered security label that is displayed on the screen
+    ASSERT_EQ(std::string(""), storedSecurityLabel->getDisplayMarking());
+}
diff --git a/Swift/Controllers/Chat/UnitTest/MockChatListWindow.h b/Swift/Controllers/Chat/UnitTest/MockChatListWindow.h
index 395b050..1d980d3 100644
--- a/Swift/Controllers/Chat/UnitTest/MockChatListWindow.h
+++ b/Swift/Controllers/Chat/UnitTest/MockChatListWindow.h
@@ -20,7 +20,7 @@ namespace Swift {
             void removeWhiteboardSession(const JID& /*jid*/) {}
             void setBookmarksEnabled(bool /*enabled*/) {}
             void setRecents(const std::list<ChatListWindow::Chat>& /*recents*/) {}
-            void setUnreadCount(int /*unread*/) {}
+            void setUnreadCount(size_t /*unread*/) {}
             void clearBookmarks() {}
             void setOnline(bool /*isOnline*/) {}
     };