displaySubjectIfChanged(message->getSubject());

}

isInitialJoin_ = false;

chatWindow_->setSubject(message->getSubject());

doneGettingHistory_ = true;

subject_ = message->getSubject();

}

if (!doneGettingHistory_ && !message->getPayload<Delay>()) {

doneGettingHistory_ = true;

}

if (!doneGettingHistory_) {

checkDuplicates(message);

messageEvent->conclude();

}

}

void MUCController::addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time) {

if (from.isBare()) {

chatWindow_->addSystemMessage(message, ChatWindow::DefaultDirection);

}

else {

ChatControllerBase::addMessageHandleIncomingMessage(from, message, senderIsSelf, label, time);

}

}

void MUCController::postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) {

std::shared_ptr<Message> message = messageEvent->getStanza();

if (joined_ && messageEvent->getStanza()->getFrom().getResource() != nick_ && !message->getPayload<Delay>()) {

eventController_->handleIncomingEvent(messageEvent);

}

if (!messageEvent->getConcluded()) {

highlighter_->handleSoundNotifications(chatMessage);

}

}

}

void MUCController::handleOccupantRoleChanged(const std::string& nick, const MUCOccupant& occupant, const MUCOccupant::Role& oldRole) {

clearPresenceQueue();

receivedActivity();

JID jid(nickToJID(nick));

roster_->removeContactFromGroup(jid, roleToGroupName(oldRole));

JID realJID;

if (occupant.getRealJID()) {

realJID = occupant.getRealJID().get();

}

std::string group(roleToGroupName(occupant.getRole()));

roster_->addContact(jid, realJID, nick, group, avatarManager_->getAvatarPath(jid));

roster_->getGroup(group)->setManualSort(roleToSortName(occupant.getRole()));

roster_->applyOnItems(SetMUC(jid, occupant.getRole(), occupant.getAffiliation()));

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "%1% is now a %2%")) % nick % roleToFriendlyName(occupant.getRole()))), ChatWindow::DefaultDirection);

if (nick == nick_) {

setAvailableRoomActions(occupant.getAffiliation(), occupant.getRole());

}

}

void MUCController::handleOccupantAffiliationChanged(const std::string& nick, const MUCOccupant::Affiliation& affiliation, const MUCOccupant::Affiliation& /*oldAffiliation*/)

{

if (nick == nick_) {

#include <Swiften/Client/Client.h>

#include <Swiften/Client/ClientBlockListManager.h>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Client/NickResolver.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Crypto/PlatformCryptoProvider.h>

#include <Swiften/Disco/DummyEntityCapsProvider.h>

#include <Swiften/Elements/CarbonsReceived.h>

#include <Swiften/Elements/CarbonsSent.h>

#include <Swiften/Elements/DeliveryReceipt.h>

#include <Swiften/Elements/DeliveryReceiptRequest.h>

#include <Swiften/Elements/Forwarded.h>

#include <Swiften/Elements/MUCInvitationPayload.h>

#include <Swiften/Elements/MUCUserPayload.h>

#include <Swiften/FileTransfer/UnitTest/DummyFileTransferManager.h>

#include <Swiften/Jingle/JingleSessionManager.h>

#include <Swiften/MUC/MUCManager.h>

#include <Swiften/Presence/DirectedPresenceSender.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/Presence/StanzaChannelPresenceSender.h>

#include <Swiften/Queries/DummyIQChannel.h>

#include <Swiften/Roster/XMPPRosterImpl.h>

#include <Swiften/VCards/VCardManager.h>

#include <Swiften/VCards/VCardMemoryStorage.h>

#include <Swiften/Whiteboard/WhiteboardSessionManager.h>

#include <Swift/Controllers/Chat/ChatController.h>

#include <Swift/Controllers/Chat/ChatsManager.h>

#include <Swift/Controllers/Chat/MUCController.h>

#include <Swift/Controllers/Chat/UnitTest/MockChatListWindow.h>

#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

#include <Swift/Controllers/ProfileSettingsProvider.h>

#include <Swift/Controllers/SettingConstants.h>

#include <Swift/Controllers/Settings/DummySettingsProvider.h>

#include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>

#include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>

#include <Swift/Controllers/UIEvents/UIEventStream.h>

#include <Swift/Controllers/UIInterfaces/ChatListWindowFactory.h>

#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

#include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>

#include <Swift/Controllers/UIInterfaces/JoinMUCWindowFactory.h>

#include <Swift/Controllers/UIInterfaces/MUCSearchWindowFactory.h>

#include <Swift/Controllers/UIInterfaces/WhiteboardWindowFactory.h>

#include <Swift/Controllers/UnitTest/MockChatWindow.h>

#include <Swift/Controllers/WhiteboardManager.h>

#include <Swift/Controllers/XMPPEvents/EventController.h>

using namespace Swift;

class ChatsManagerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(ChatsManagerTest);

CPPUNIT_TEST(testFirstOpenWindowIncoming);

CPPUNIT_TEST(testSecondOpenWindowIncoming);

CPPUNIT_TEST(testFirstOpenWindowOutgoing);

CPPUNIT_TEST(testFirstOpenWindowBareToFull);

CPPUNIT_TEST(testSecondWindow);

CPPUNIT_TEST(testUnbindRebind);

CPPUNIT_TEST(testNoDuplicateUnbind);

CPPUNIT_TEST(testThreeMUCWindows);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnRemoveFromRoster);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnAddToRoster);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToBoth);

CPPUNIT_TEST(testChatControllerPresenceAccessUpdatedOnSubscriptionChangeToFrom);

CPPUNIT_TEST(testChatControllerFullJIDBindingOnMessageAndNotReceipt);

CPPUNIT_TEST(testChatControllerFullJIDBindingOnTypingAndNotActive);

CPPUNIT_TEST(testLocalMUCServiceDiscoveryResetOnDisconnect);

CPPUNIT_TEST(testPresenceChangeDoesNotReplaceMUCInvite);

// MUC PM Tests

CPPUNIT_TEST(testChatControllerPMPresenceHandling);

CPPUNIT_TEST(testChatControllerMucPmUnavailableErrorHandling);

// Highlighting tests

CPPUNIT_TEST(testChatControllerHighlightingNotificationTesting);

CPPUNIT_TEST(testChatControllerHighlightingNotificationDeduplicateSounds);

CPPUNIT_TEST(testChatControllerMeMessageHandling);

CPPUNIT_TEST(testRestartingMUCComponentCrash);

CPPUNIT_TEST(testChatControllerMeMessageHandlingInMUC);

// Carbons tests

CPPUNIT_TEST(testCarbonsForwardedIncomingMessageToSecondResource);

CPPUNIT_TEST(testCarbonsForwardedOutgoingMessageFromSecondResource);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

mocks_ = new MockRepository();

jid_ = JID("test@test.com/resource");

stanzaChannel_ = new DummyStanzaChannel();

iqRouter_ = new IQRouter(stanzaChannel_);

eventController_ = new EventController();

chatWindowFactory_ = mocks_->InterfaceMock<ChatWindowFactory>();

joinMUCWindowFactory_ = mocks_->InterfaceMock<JoinMUCWindowFactory>();

xmppRoster_ = new XMPPRosterImpl();

mucRegistry_ = new MUCRegistry();

nickResolver_ = new NickResolver(jid_.toBare(), xmppRoster_, nullptr, mucRegistry_);

presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

serverDiscoInfo_ = std::make_shared<DiscoInfo>();

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

mucManager_ = new MUCManager(stanzaChannel_, iqRouter_, directedPresenceSender_, mucRegistry_);

uiEventStream_ = new UIEventStream();

entityCapsProvider_ = new DummyEntityCapsProvider();

chatListWindowFactory_ = mocks_->InterfaceMock<ChatListWindowFactory>();

mucSearchWindowFactory_ = mocks_->InterfaceMock<MUCSearchWindowFactory>();

settings_ = new DummySettingsProvider();

profileSettings_ = new ProfileSettingsProvider("a", settings_);

chatListWindow_ = new MockChatListWindow();

ftManager_ = new DummyFileTransferManager();

ftOverview_ = new FileTransferOverview(ftManager_);

avatarManager_ = new NullAvatarManager();

wbSessionManager_ = new WhiteboardSessionManager(iqRouter_, stanzaChannel_, presenceOracle_, entityCapsProvider_);

wbManager_ = new WhiteboardManager(whiteboardWindowFactory_, uiEventStream_, nickResolver_, wbSessionManager_);

highlightManager_ = new HighlightManager(settings_);

highlightManager_->resetToDefaultConfiguration();

handledHighlightActions_ = 0;

soundsPlayed_.clear();

highlightManager_->onHighlight.connect(boost::bind(&ChatsManagerTest::handleHighlightAction, this, _1));

crypto_ = PlatformCryptoProvider::create();

vcardStorage_ = new VCardMemoryStorage(crypto_);

vcardManager_ = new VCardManager(jid_, iqRouter_, vcardStorage_);

mocks_->ExpectCall(chatListWindowFactory_, ChatListWindowFactory::createChatListWindow).With(uiEventStream_).Return(chatListWindow_);

clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, nullptr, mucRegistry_, entityCapsProvider_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, nullptr, wbManager_, highlightManager_, clientBlockListManager_, emoticons_, vcardManager_);

manager_->setAvatarManager(avatarManager_);

}

void tearDown() {

delete highlightManager_;

delete profileSettings_;

delete avatarManager_;

delete manager_;

delete clientBlockListManager_;

delete vcardManager_;

delete vcardStorage_;

delete crypto_;

delete ftOverview_;

delete ftManager_;

delete wbSessionManager_;

delete wbManager_;

delete directedPresenceSender_;

delete presenceSender_;

delete presenceOracle_;

delete nickResolver_;

delete mucRegistry_;

delete iqRouter_;

delete stanzaChannel_;

delete eventController_;

delete uiEventStream_;

delete mucManager_;

delete xmppRoster_;

delete entityCapsProvider_;

delete chatListWindow_;

delete mocks_;

delete settings_;

}

void testFirstOpenWindowIncoming() {

JID messageJID("testling@test.com/resource1");

CPPUNIT_ASSERT(stanzaContactOnRoster->getPayload<DeliveryReceipt>() != nullptr);

}

void testChatControllerHighlightingNotificationTesting() {

HighlightConfiguration::KeywordHightlight keywordRuleA;

keywordRuleA.keyword = "Romeo";

keywordRuleA.action.setFrontColor(boost::optional<std::string>("yellow"));

keywordRuleA.action.setSoundFilePath(boost::optional<std::string>(""));

highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleA);

HighlightConfiguration::KeywordHightlight keywordRuleB;

keywordRuleB.keyword = "Juliet";

keywordRuleB.action.setFrontColor(boost::optional<std::string>("green"));

keywordRuleB.action.setSoundFilePath(boost::optional<std::string>("/tmp/someotherfile.wav"));

highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleB);

JID messageJID = JID("testling@test.com");

MockChatWindow* window = new MockChatWindow();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);

std::shared_ptr<Message> message(new Message());

message->setFrom(messageJID);

std::string body("This message should cause two sounds: Juliet and Romeo.");

message->setBody(body);

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT_EQUAL(2, handledHighlightActions_);

CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleA.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());

CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleB.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());

}

void testChatControllerHighlightingNotificationDeduplicateSounds() {

auto keywordRuleA = HighlightConfiguration::KeywordHightlight();

keywordRuleA.keyword = "Romeo";

keywordRuleA.action.setFrontColor(boost::optional<std::string>("yellow"));

keywordRuleA.action.setSoundFilePath(boost::optional<std::string>(""));

highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleA);

auto keywordRuleB = HighlightConfiguration::KeywordHightlight();

keywordRuleB.keyword = "Juliet";

keywordRuleB.action.setFrontColor(boost::optional<std::string>("green"));

keywordRuleB.action.setSoundFilePath(boost::optional<std::string>(""));

highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleB);

JID messageJID = JID("testling@test.com");

MockChatWindow* window = new MockChatWindow();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);

std::shared_ptr<Message> message(new Message());

message->setFrom(messageJID);

std::string body("This message should cause one sound, because both actions have the same sound: Juliet and Romeo.");

message->setBody(body);

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT_EQUAL(1, handledHighlightActions_);

CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleA.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());

CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleB.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());

}

void testChatControllerMeMessageHandling() {

JID messageJID("testling@test.com/resource1");

MockChatWindow* window = new MockChatWindow();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);

std::shared_ptr<Message> message(new Message());

message->setFrom(messageJID);

std::string body("/me is feeling delighted.");

message->setBody(body);

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT_EQUAL(std::string("is feeling delighted."), window->bodyFromMessage(window->lastAddedAction_));

}

void testRestartingMUCComponentCrash() {

JID mucJID = JID("teaparty@rooms.wonderland.lit");

JID self = JID("girl@wonderland.lit/rabbithole");

std::string nick = "aLiCe";

MockChatWindow* window;

auto genRemoteMUCPresence = [=]() {

auto presence = Presence::create();

presence->setFrom(mucJID.withResource(nick));

presence->setTo(self);

return presence;

};

stanzaChannel_->onPresenceReceived(firstPresence);

}

CPPUNIT_ASSERT_EQUAL(std::string("Couldn't enter room: Unable to enter this room."), MockChatWindow::bodyFromMessage(window->lastAddedErrorMessage_));

{

auto presence = genRemoteMUCPresence();

presence->setType(Presence::Unavailable);

auto userPayload = std::make_shared<MUCUserPayload>();

userPayload->addStatusCode(303);

auto item = MUCItem(MUCOccupant::Owner, self, MUCOccupant::Moderator);

item.nick = nick;

userPayload->addItem(item);

userPayload->addStatusCode(110);

presence->addPayload(userPayload);

stanzaChannel_->onPresenceReceived(presence);

}

}

void testChatControllerMeMessageHandlingInMUC() {

JID mucJID("mucroom@rooms.test.com");

std::string nickname = "toodles";

//highlightManager_->resetToDefaultConfiguration();

// add highlight rule for 'foo'

HighlightConfiguration::KeywordHightlight keywordHighlight;

keywordHighlight.keyword = "foo";

keywordHighlight.action.setBackColor(boost::optional<std::string>("green"));

highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordHighlight);

MockChatWindow* window = new MockChatWindow();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(mucJID, uiEventStream_).Return(window);

uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(mucJID, boost::optional<std::string>(), nickname));

auto genRemoteMUCPresence = [=]() {

auto presence = Presence::create();

presence->setFrom(mucJID.withResource(nickname));

presence->setTo(jid_);

return presence;

};

{

auto presence = genRemoteMUCPresence();

auto userPayload = std::make_shared<MUCUserPayload>();

userPayload->addStatusCode(110);

userPayload->addItem(MUCItem(MUCOccupant::Owner, jid_, MUCOccupant::Moderator));

presence->addPayload(userPayload);

stanzaChannel_->onPresenceReceived(presence);

}

{

auto presence = genRemoteMUCPresence();

presence->setFrom(mucJID.withResource("someDifferentNickname"));

auto userPayload = std::make_shared<MUCUserPayload>();

userPayload->addItem(MUCItem(MUCOccupant::Member, JID("foo@bar.com"), MUCOccupant::Moderator));

presence->addPayload(userPayload);

stanzaChannel_->onPresenceReceived(presence);

}

window->onSendMessageRequest("/me sends a test message with foo", false);

window->resetLastMessages();

{

Message::ref mucMirrored = std::make_shared<Message>();

mucMirrored->setFrom(mucJID.withResource(nickname));

mucMirrored->setTo(jid_);

mucMirrored->setType(Message::Groupchat);

mucMirrored->setBody("/me sends a test message with foo");

manager_->handleIncomingMessage(mucMirrored);

}

CPPUNIT_ASSERT_EQUAL(std::string("sends a test message with foo"), window->bodyFromMessage(window->lastAddedAction_));

window->resetLastMessages();

{

Message::ref mucMirrored = std::make_shared<Message>();

mucMirrored->setFrom(mucJID.withResource("someDifferentNickname"));

mucMirrored->setTo(jid_);

mucMirrored->setType(Message::Groupchat);

mucMirrored->setBody("/me says hello with a test message with foo and foo");

manager_->handleIncomingMessage(mucMirrored);

}

CPPUNIT_ASSERT_EQUAL(std::string("says hello with a test message with foo and foo"), window->bodyFromMessage(window->lastAddedAction_));

}

void testPresenceChangeDoesNotReplaceMUCInvite() {

JID messageJID("testling@test.com/resource1");

auto generateIncomingPresence = [=](Presence::Type type) {

auto presence = std::make_shared<Presence>();

presence->setType(type);

presence->setFrom(messageJID);

presence->setTo(jid_);

return presence;

};

stanzaChannel_->onPresenceReceived(generateIncomingPresence(Presence::Available));

MockChatWindow* window = new MockChatWindow();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(messageJID, uiEventStream_).Return(window);

std::shared_ptr<Message> message(new Message());

message->setFrom(messageJID);

std::string body("This is a legible message. >HEH@)oeueu");

message->setBody(body);

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT_EQUAL(body, MockChatWindow::bodyFromMessage(window->lastAddedMessage_));

auto incomingMUCInvite = std::make_shared<Message>();

incomingMUCInvite->setFrom(messageJID);

auto invitePayload = std::make_shared<MUCInvitationPayload>();

invitePayload->setJID("room@muc.service.com");

manager_->handleIncomingMessage(messageWrapper);

CPPUNIT_ASSERT_EQUAL(size_t(2), window->receiptChanges_.size());

CPPUNIT_ASSERT_EQUAL(ChatWindow::ReceiptReceived, window->receiptChanges_[1].second);

}

}

private:

std::shared_ptr<Message> makeDeliveryReceiptTestMessage(const JID& from, const std::string& id) {

std::shared_ptr<Message> message = std::make_shared<Message>();

message->setFrom(from);

message->setID(id);

message->setBody("This will cause the window to open");

message->addPayload(std::make_shared<DeliveryReceiptRequest>());

return message;

}

size_t st(int i) {

return static_cast<size_t>(i);

}

void handleHighlightAction(const HighlightAction& action) {

handledHighlightActions_++;

if (action.getSoundFilePath()) {

soundsPlayed_.insert(action.getSoundFilePath().get_value_or(""));

}

}

private:

JID jid_;

ChatsManager* manager_;

DummyStanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;

EventController* eventController_;

ChatWindowFactory* chatWindowFactory_;

JoinMUCWindowFactory* joinMUCWindowFactory_;

NickResolver* nickResolver_;

PresenceOracle* presenceOracle_;

AvatarManager* avatarManager_;

std::shared_ptr<DiscoInfo> serverDiscoInfo_;

XMPPRosterImpl* xmppRoster_;

PresenceSender* presenceSender_;

MockRepository* mocks_;

UIEventStream* uiEventStream_;

ChatListWindowFactory* chatListWindowFactory_;

WhiteboardWindowFactory* whiteboardWindowFactory_;

MUCSearchWindowFactory* mucSearchWindowFactory_;

MUCRegistry* mucRegistry_;

DirectedPresenceSender* directedPresenceSender_;

DummyEntityCapsProvider* entityCapsProvider_;

MUCManager* mucManager_;

DummySettingsProvider* settings_;

ProfileSettingsProvider* profileSettings_;

ChatListWindow* chatListWindow_;

FileTransferOverview* ftOverview_;

FileTransferManager* ftManager_;

WhiteboardSessionManager* wbSessionManager_;

WhiteboardManager* wbManager_;

HighlightManager* highlightManager_;

ClientBlockListManager* clientBlockListManager_;

VCardManager* vcardManager_;

CryptoProvider* crypto_;

VCardStorage* vcardStorage_;

std::map<std::string, std::string> emoticons_;

int handledHighlightActions_;

std::set<std::string> soundsPlayed_;

};

CPPUNIT_TEST_SUITE_REGISTRATION(ChatsManagerTest);

CPPUNIT_TEST(testHandleOccupantNicknameChanged);

CPPUNIT_TEST(testHandleOccupantNicknameChangedRoster);

CPPUNIT_TEST(testHandleChangeSubjectRequest);

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_);

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_);

}

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_;

void 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)));

CPPUNIT_ASSERT_EQUAL((size_t)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)));

CPPUNIT_ASSERT_EQUAL((size_t)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)));

CPPUNIT_ASSERT_EQUAL((size_t)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)));

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)));

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)));

}

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());

}

void 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)));

CPPUNIT_ASSERT_EQUAL((size_t)0, eventController_->getEvents().size());

}

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];