+4.0.3 (2019-01-03)

+------------------

+- Fix handling of empty bookmark responses

+

+4.0.2 (2018-04-05)

+------------------

+- Fix versioning issue in Windows Installer process

+

+4.0.1 (2018-03-28)

+------------------

+- Allow setting vCard on servers that do not return an empty vCard on fresh accounts

+

+4.0 (2018-03-20)

+----------------

+- New chat theme including a new font

+- Support for message carbons (XEP-0280)

+- Enabled trellis mode as a default feature, allowing several tiled chats windows to be shown at once

+- Redesigned keyword highlighting

+- Improve date formatting

+- Fix Last Message Correction in multi client scenarios

+- Fix UI layout issue for translations that require right-to-left (RTL) layout

+- Fix UX issues in trellis mode

+- Improvements to font size handling in the chat theme

+- Fix display of default avatar on Windows

+- Support for automatic software updates on macOS

+- macOS releases are now code-signed

+- Support for unicode emojis on macOS

+- Add AppImage for Linux 64-bit as a supported platform

+- Improved spell checker support on Linux

+- And assorted smaller features and usability enhancements

+

+4.0-rc6 ( 2018-03-07 )

+----------------------

+- Small usability fixes in Carbons ( XEP-0280 ) handling and Windows installer

+- Fix crashes related to room invitations, layout changes, and vCard handling

+- And smaller bug fixes

+

+4.0-rc5 ( 2018-01-09 )

+----------------------

+- Fix crash during sleep on macOS

+

+4.0-rc4 ( 2018-01-04 )

+----------------------

+- Remove conflicting shortcut

+- Debian packaging fixes

+

+4.0-rc3 ( 2017-11-28 )

+----------------------

+- Fix crash in emoticon dialog

+- Fix Windows MSI installer when updating from earlier Swift version

+- Update translations ( Dutch, German )

+- Add AppImage for Linux 64-bit as a supported platform

+- And smaller bug fixes

+

+4.0-rc2 ( 2017-05-22 )

+----------------------

+- Redesigned keyword highlighting

+- Initial release.

+ * Copyright (c) 2010-2019 Isode Limited.

+#include <Swift/Controllers/AccountController.h>

+#include <Swift/Controllers/Chat/Chattables.h>

+#include <Swift/Controllers/FdpFormSubmitController.h>

+AccountController::AccountController(

+ emoticons_(emoticons),

+ fdpFormSubmitController_(nullptr) {

+ eventController_->onEventQueueLengthChange.connect(boost::bind(&AccountController::handleEventQueueLengthChange, this, _1));

+ loginWindow_->onLoginRequest.connect(boost::bind(&AccountController::handleLoginRequest, this, _1, _2, _3, _4, _5, _6, _7));

+ loginWindow_->onPurgeSavedLoginRequest.connect(boost::bind(&AccountController::handlePurgeSavedLoginRequest, this, _1));

+ loginWindow_->onCancelLoginRequest.connect(boost::bind(&AccountController::handleCancelLoginRequest, this));

+ loginWindow_->onQuitRequest.connect(boost::bind(&AccountController::handleQuitRequest, this));

+ idleDetector_->onIdleChanged.connect(boost::bind(&AccountController::handleInputIdleChanged, this, _1));

+ settings_->onSettingChanged.connect(boost::bind(&AccountController::handleSettingChanged, this, _1));

+AccountController::~AccountController() {

+ idleDetector_->onIdleChanged.disconnect(boost::bind(&AccountController::handleInputIdleChanged, this, _1));

+void AccountController::purgeCachedCredentials() {

+void AccountController::resetClient() {

+ chattables_.reset();

+void AccountController::handleSettingChanged(const std::string& settingPath) {

+void AccountController::resetPendingReconnects() {

+void AccountController::resetCurrentError() {

+void AccountController::handleConnected() {

+ chattables_ = std::make_unique<Chattables>();

+ rosterController_ = new RosterController(boundJID_, client_->getRoster(), client_->getAvatarManager(), uiFactory_, client_->getNickManager(), client_->getNickResolver(), client_->getPresenceOracle(), client_->getSubscriptionManager(), eventController_, uiEventStream_, client_->getIQRouter(), settings_, client_->getEntityCapsProvider(), client_->getClientBlockListManager(), client_->getVCardManager(), *chattables_);

+ rosterController_->onChangeStatusRequest.connect(boost::bind(&AccountController::handleChangeStatusRequest, this, _1, _2));

+ rosterController_->onSignOutRequest.connect(boost::bind(&AccountController::signOut, this));

+ rosterController_->getWindow()->onShowCertificateRequest.connect(boost::bind(&AccountController::handleShowCertificateRequest, this));

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, nullptr, whiteboardManager_, highlightManager_, client_->getClientBlockListManager(), emoticons_, client_->getVCardManager(), *chattables_);

+ discoInfoRequest->onResponse.connect(boost::bind(&AccountController::handleServerDiscoInfoResponse, this, _1, _2));

+void AccountController::handleEventQueueLengthChange(size_t count) {

+void AccountController::reconnectAfterError() {

+void AccountController::handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText) {

+void AccountController::sendPresence(std::shared_ptr<Presence> presence) {

+void AccountController::handleInputIdleChanged(bool idle) {

+void AccountController::handleShowCertificateRequest() {

+void AccountController::handleLoginRequest(const std::string &username, const std::string &password, const std::string& certificatePath, CertificateWithKey::ref certificate, const ClientOptions& options, bool remember, bool loginAutomatically) {

+ profileSettings_->storeInt("enabled", 1);

+void AccountController::handlePurgeSavedLoginRequest(const std::string& username) {

+void AccountController::performLoginFromCachedCredentials() {

+ client_->onDisconnected.connect(boost::bind(&AccountController::handleDisconnected, this, _1));

+ client_->onConnected.connect(boost::bind(&AccountController::handleConnected, this));

+ client_->getVCardManager()->onVCardChanged.connect(boost::bind(&AccountController::handleVCardReceived, this, _1, _2));

+ presenceNotifier_->onNotificationActivated.connect(boost::bind(&AccountController::handleNotificationClicked, this, _1));

+ eventNotifier_->onNotificationActivated.connect(boost::bind(&AccountController::handleNotificationClicked, this, _1));

+ fdpFormSubmitController_ = std::make_unique<FdpFormSubmitController>(jid_, client_->getIQRouter(), uiEventStream_, uiFactory_);

+void AccountController::handleDisconnected(const boost::optional<ClientError>& error) {

+ message = str(format(QT_TRANSLATE_NOOP("", "Reconnect to %1% failed: %2%. Will retry in %3% seconds.")) % jid_.getDomain() % message % std::to_string(timeBeforeNextReconnect_));

+void AccountController::setReconnectTimer() {

+ reconnectTimer_->onTick.connect(boost::bind(&AccountController::reconnectAfterError, this));

+void AccountController::handleCancelLoginRequest() {

+void AccountController::signOut() {

+ profileSettings_->storeInt("enabled", 0);

+void AccountController::logout() {

+void AccountController::setManagersOffline() {

+void AccountController::handleServerDiscoInfoResponse(std::shared_ptr<DiscoInfo> info, ErrorPayload::ref error) {

+void AccountController::enableMessageCarbons() {

+ SWIFT_LOG(warning) << "Failed to enable carbons.";

+ SWIFT_LOG(debug) << "Successfully enabled carbons.";

+void AccountController::handleVCardReceived(const JID& jid, VCard::ref vCard) {

+void AccountController::handleNotificationClicked(const JID& jid) {

+void AccountController::handleQuitRequest() {

+//FIXME: Switch all this to boost::serialise

+

+std::string AccountController::serializeClientOptions(const ClientOptions& options) {

+ SERIALIZE_BOOL(useStreamCompression)

+ SERIALIZE_BOOL(allowPLAINWithoutTLS)

+ SERIALIZE_BOOL(useStreamResumption)

+ SERIALIZE_BOOL(useAcks)

+ SERIALIZE_STRING(manualHostname)

+ SERIALIZE_INT(manualPort)

+ SERIALIZE_STRING(manualProxyHostname)

+ SERIALIZE_INT(manualProxyPort)

+ SERIALIZE_URL(boshURL)

+ SERIALIZE_URL(boshHTTPConnectProxyURL)

+ SERIALIZE_SAFE_STRING(boshHTTPConnectProxyAuthID)

+ SERIALIZE_SAFE_STRING(boshHTTPConnectProxyAuthPassword)

+ SERIALIZE_BOOL(tlsOptions.schannelTLS1_0Workaround)

+ SERIALIZE_BOOL(singleSignOn)

+ * Copyright (c) 2010-2018 Isode Limited.

+ class Chattables;

+ class FdpFormSubmitController;

+ class AccountController {

+ AccountController(

+ ~AccountController();

+ void handleEventQueueLengthChange(size_t count);

+ ProfileSettingsProvider* profileSettings_ = nullptr;

+ std::unique_ptr<Chattables> chattables_;

+ std::unique_ptr<FdpFormSubmitController> fdpFormSubmitController_;

+ * Copyright (c) 2010-2019 Isode Limited.

+ChatController::ChatController(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)

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider, settings, chattables), userWantsReceipts_(userWantsReceipts), clientBlockListManager_(clientBlockListManager) {

+ continuationsBrokenConnection_ = chatWindow_->onContinuationsBroken.connect([this, startMessage]() { chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(startMessage), ChatWindow::DefaultDirection); });

+ SWIFT_LOG(debug) << "received receipt for id: " << receipt->getReceivedID();

+ onActivity(message->getBody().get_value_or(""));

+ failedStanzas_[stanzaIdPair.second] = stanzaIdPair.first;

+ SWIFT_LOG(debug) << "handleFileTransferCancel(" << id << ")";

+ SWIFT_LOG(debug) << "handleFileTransferStart(" << id << ", " << description << ")";

+ SWIFT_LOG(debug) << "handleFileTransferAccept(" << id << ", " << filename << ")";

+ SWIFT_LOG(debug) << "ChatController::handleSendFileRequest(" << filename << ")";

+

+ continuationsBrokenConnection_.disconnect();

+ chatWindow_->onClosed.disconnect(boost::bind(&ChatController::handleWindowClosed, this));

+ chatWindow_->onInviteToChat.disconnect(boost::bind(&ChatController::handleInviteToChat, this, _1));

+ chatWindow_->onUnblockUserRequest.disconnect(boost::bind(&ChatController::handleUnblockUserRequest, this));

+ chatWindow_->onBlockUserRequest.disconnect(boost::bind(&ChatController::handleBlockUserRequest, this));

+ chatWindow_->onWhiteboardWindowShow.disconnect(boost::bind(&ChatController::handleWhiteboardWindowShow, this));

+ chatWindow_->onWhiteboardSessionCancel.disconnect(boost::bind(&ChatController::handleWhiteboardSessionCancel, this));

+ chatWindow_->onWhiteboardSessionAccept.disconnect(boost::bind(&ChatController::handleWhiteboardSessionAccept, this));

+ chatWindow_->onSendFileRequest.disconnect(boost::bind(&ChatController::handleSendFileRequest, this, _1));

+ chatWindow_->onFileTransferCancel.disconnect(boost::bind(&ChatController::handleFileTransferCancel, this, _1));

+ chatWindow_->onFileTransferAccept.disconnect(boost::bind(&ChatController::handleFileTransferAccept, this, _1, _2));

+ chatWindow_->onFileTransferStart.disconnect(boost::bind(&ChatController::handleFileTransferStart, this, _1, _2));

+ chatWindow_->onUserTyping.disconnect(boost::bind(&ChatStateNotifier::setUserIsTyping, chatStateNotifier_));

+ * Copyright (c) 2010-2018 Isode Limited.

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

+ virtual ~ChatController() override;

+ virtual void setToJID(const JID& jid) override;

+ virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) override;

+ virtual void setOnline(bool online) override;

+ virtual void setContactIsReceivingPresence(bool /*isReceivingPresence*/) override;

+ virtual ChatWindow* detachChatWindow() override;

+ virtual void handleIncomingOwnMessage(std::shared_ptr<Message> message) override;

+ virtual void cancelReplaces() override;

+ virtual JID getBaseJID() override;

+ virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) override;

+ virtual bool shouldIgnoreMessage(std::shared_ptr<Message> message) override;

+ virtual JID messageCorrectionJID(const JID& fromJID) override;

+ virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) override;

+ virtual void postSendMessage(const std::string &body, std::shared_ptr<Stanza> sentStanza) override;

+ virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) override;

+ virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) override;

+ virtual void preSendMessageRequest(std::shared_ptr<Message>) override;

+ virtual std::string senderHighlightNameFromMessage(const JID& from) override;

+ virtual std::string senderDisplayNameFromMessage(const JID& from) override;

+ virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message>) const override;

+ virtual void dayTicked() override { lastWasPresence_ = false; }

+ virtual void handleBareJIDCapsChanged(const JID& jid) override;

+ boost::signals2::scoped_connection continuationsBrokenConnection_;

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <Swiften/Elements/DeliveryReceipt.h>

+#include <Swiften/Elements/DeliveryReceiptRequest.h>

+#include <Swift/Controllers/Chat/Chattables.h>

+ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream), roomSecurityMarking_(""), previousMessageSecurityMarking_(""), settings_(settings), chattables_(chattables) {

+ scopedConnectionResendMessage_ = chatWindow_->onResendMessageRequest.connect(boost::bind(&ChatControllerBase::handleResendMessageRequest, this, _1));

+ chatWindow_->onContinuationsBroken.disconnect(boost::bind(&ChatControllerBase::handleContinuationsBroken, this));

+ chatWindow_->onSendMessageRequest.disconnect(boost::bind(&ChatControllerBase::handleSendMessageRequest, this, _1, _2));

+ chatWindow_->onAllMessagesRead.disconnect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));

+ scopedConnectionResendMessage_.disconnect();

+size_t ChatControllerBase::getUnreadCount() {

+ return targetedUnreadMessages_.size();

+ auto baseJID = getBaseJID();

+ auto state = chattables_.getState(baseJID);

+ state.unreadCount = unreadMessages_.size();

+ chatWindow_->setUnreadMessageCount(state.unreadCount);

+ chattables_.setState(baseJID, state);

+#ifndef NOT_YET

+#endif

+ auto displayedLabel = label;

+

+ if (settings_->getSetting(SettingConstants::MUC_MARKING_ELISION)) {

+ if (roomSecurityMarking_ != "") {

+

+ if (label && label->getDisplayMarking() == roomSecurityMarking_) {

+ if (label->getDisplayMarking() == previousMessageSecurityMarking_) {

+ displayedLabel = std::make_shared<SecurityLabel>();

+ }

+ previousMessageSecurityMarking_ = label->getDisplayMarking();

+ }

+ else if (!label || label->getDisplayMarking().empty()) {

+ displayedLabel = std::make_shared<SecurityLabel>();

+ displayedLabel->setDisplayMarking("Unmarked");

+ previousMessageSecurityMarking_ = "Unmarked";

+ }

+ else {

+ previousMessageSecurityMarking_ = displayedLabel->getDisplayMarking();

+ }

+ }

+ }

+

+ return chatWindow_->addAction(chatMessage, senderName, senderIsSelf, displayedLabel, pathToString(avatarPath), time);

+ return chatWindow_->addMessage(chatMessage, senderName, senderIsSelf, displayedLabel, pathToString(avatarPath), time);

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+#endif

+ eventStream_->send(std::make_shared<JoinMUCUIEvent>(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, true));

+void ChatControllerBase::handleResendMessageRequest(const std::string& id) {

+ if (failedStanzas_.find(id) != failedStanzas_.end()) {

+ if (auto resendMsg = std::dynamic_pointer_cast<Message>(failedStanzas_[id])) {

+ stanzaChannel_->sendMessage(resendMsg);

+ if (stanzaChannel_->getStreamManagementEnabled()) {

+ chatWindow_->setAckState(id, ChatWindow::Pending);

+ unackedStanzas_[failedStanzas_[id]] = id;

+ }

+ if (resendMsg->getPayload<DeliveryReceiptRequest>()) {

+ requestedReceipts_[resendMsg->getID()] = id;

+ chatWindow_->setMessageReceiptState(id, ChatWindow::ReceiptRequested);

+ }

+ lastWasPresence_ = false;

+ failedStanzas_.erase(id);

+ }

+ }

+}

+

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+ class Chattables;

+ class HighlightManager;

+ size_t getUnreadCount();

+ ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables);

+ virtual void handleResendMessageRequest(const std::string& id);

+ std::string roomSecurityMarking_;

+ std::string previousMessageSecurityMarking_;

+ SettingsProvider* settings_;

+ boost::signals2::scoped_connection scopedConnectionResendMessage_;

+ std::map<std::string, std::string> requestedReceipts_;

+ std::map<std::shared_ptr<Stanza>, std::string> unackedStanzas_;

+ std::map<std::string, std::shared_ptr<Stanza>> failedStanzas_;

+ Chattables& chattables_;

+/*

+ * Copyright (c) 2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+

+#include <boost/version.hpp>

+#include <boost/algorithm/string.hpp>

+#include <boost/archive/text_iarchive.hpp>

+#include <boost/archive/text_oarchive.hpp>

+#include <boost/bind.hpp>

+#include <boost/serialization/map.hpp>

+#include <boost/serialization/optional.hpp>

+#include <boost/serialization/split_free.hpp>

+#include <boost/serialization/string.hpp>

+#include <boost/serialization/vector.hpp>

+

+#include <Swift/Controllers/UIInterfaces/ChatListWindow.h>

+

+BOOST_CLASS_VERSION(Swift::ChatListWindow::Chat, 3)

+namespace Swift {

+ const boost::archive::library_version_type BoostArchiveSkipVersion(15);

+}

+

+namespace boost {

+ namespace serialization {

+ template<class Archive> void save(Archive& ar, const Swift::JID& jid, const unsigned int /*version*/) {

+ std::string jidStr = jid.toString();

+ ar << jidStr;

+ }

+

+ template<class Archive> void load(Archive& ar, Swift::JID& jid, const unsigned int /*version*/) {

+ std::string stringJID;

+ ar >> stringJID;

+ jid = Swift::JID(stringJID);

+ }

+

+ template<class Archive> inline void serialize(Archive& ar, Swift::JID& t, const unsigned int file_version) {

+ split_free(ar, t, file_version);

+ }

+

+ template<class Archive> void serialize(Archive& ar, Swift::ChatListWindow::Chat& chat, const unsigned int version) {

+ auto archiveLibraryVersion = boost::archive::BOOST_ARCHIVE_VERSION();

+ int archiveVersion = 0;

+ archive::text_oarchive* outputStream = dynamic_cast<archive::text_oarchive*>(&ar);

+ if (outputStream) {

+ archiveVersion = outputStream->get_library_version();

+ }

+ archive::text_iarchive* inputStream = dynamic_cast<archive::text_iarchive*>(&ar);

+ if (inputStream) {

+ archiveVersion = inputStream->get_library_version();

+ //Due to https://svn.boost.org/trac10/ticket/13050 the password field may fail to load and crash the client. Therefore we skip loading the values from previous versions.

+ if (archiveLibraryVersion == Swift::BoostArchiveSkipVersion && archiveLibraryVersion > archiveVersion) {

+ return;

+ }

+ }

+ ar & chat.jid;

+ ar & chat.chatName;

+ ar & chat.activity;

+ ar & chat.isMUC;

+ ar & chat.nick;

+ ar & chat.impromptuJIDs;

+ if (version > 0) {

+ if (outputStream && archiveLibraryVersion == Swift::BoostArchiveSkipVersion) {

+ //The bug does not affect the case boost::optional doesn't have a value. Therefore we store always that value, to avoid problem on future launches of the client.

+ boost::optional<std::string> empty;

+ ar & empty;

+ }

+ else {

+ ar & chat.password;

+ }

+ }

+ if (version > 1) {

+ ar & chat.inviteesNames;

+ }

+ }

+ }

+}

+ catch (const std::runtime_error&) {

+ catch (const std::runtime_error&) {

+ * Copyright (c) 2010-2019 Isode Limited.

+#include <Swift/Controllers/Chat/Chattables.h>

+#include <Swift/Controllers/Chat/ChatListWindowChatBoostSerialize.h>

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ VCardManager* vcardManager,

+ Chattables& chattables) :

+ vcardManager_(vcardManager),

+ chattables_(chattables) {

+#ifndef NOT_YET

+#endif

+ chattables_.onActivated.connect(boost::bind(&ChatsManager::handleChattableActivated, this, _1));

+

+#ifndef NOT_YET

+#endif

+ chattables_.onActivated.disconnect(boost::bind(&ChatsManager::handleChattableActivated, this, _1));

+ SWIFT_LOG(debug) << "Destroying ChatsManager, containing " << chatControllers_.size() << " chats and " << mucControllers_.size() << " MUCs";

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+ SWIFT_LOG(debug) << "Failed to load recents: " << e.what();

+ recentChats.erase(std::remove(recentChats.begin(), recentChats.end(), ChatListWindow::Chat()), recentChats.end());

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ if (bookmark.getRoom().isBare() && !bookmark.getRoom().getNode().empty()) {

+ std::map<JID, MUCController*>::iterator it = mucControllers_.find(bookmark.getRoom());

+ if (it == mucControllers_.end() && bookmark.getAutojoin()) {

+ handleJoinMUCRequest(bookmark.getRoom(), bookmark.getPassword(), bookmark.getNick(), false, false);

+ }

+#ifndef NOT_YET

+ //Only one entry of the bookmark should exist

+ chatListWindow_->removeMUCBookmark(bookmark);

+ chatListWindow_->addMUCBookmark(bookmark);

+#endif

+ chattables_.addJID(bookmark.getRoom(), Chattables::State::Type::Room);

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+ size_t unreadCount = 0;

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+

+ size_t unreadTotal = 0;

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ const auto& jid = it->first;

+ auto state = chattables_.getState(jid);

+ state.status = StatusShow::None;

+ chattables_.setState(jid, state);

+ //If user deletes bookmark from chatListWindow_ and then decides to leave the room, or if the server doesn't support bookmarks, the bookmark will not exist.

+ if (auto bookmarkFound = mucBookmarkManager_->lookupBookmark(jid)) {

+ MUCBookmark newBookmark(bookmarkFound.get());

+ newBookmark.setAutojoin(false);

+ mucBookmarkManager_->replaceBookmark(bookmarkFound.get(), newBookmark);

+ }

+#ifndef NOT_YET

+#endif

+ MUC::ref muc = handleJoinMUCRequest(roomJID, boost::optional<std::string>(), nickResolver_->jidToNick(jid_), true, true);

+ handleJoinMUCRequest(joinEvent->getJID(), joinEvent->getPassword(), joinEvent->getNick(), joinEvent->getCreateAsReservedRoomIfNew(), joinEvent->isImpromptu());

+#ifndef NOT_YET

+#endif

+ MUC::ref muc = handleJoinMUCRequest(roomJID, boost::optional<std::string>(), nickResolver_->jidToNick(jid_), true, true, chatWindow);

+#ifndef NOT_YET

+#endif

+

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ auto controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, timerFactory_, eventController_, entityCapsProvider_, userWantsReceipts_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, autoAcceptMUCInviteDecider_, settings_, chattables_);

+#ifndef NOT_YET

+#endif

+MUC::ref ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::optional<std::string>& password, const boost::optional<std::string>& nickMaybe, bool createAsReservedIfNew, bool isImpromptu, ChatWindow* reuseChatwindow) {

+ controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, reuseChatwindow ? chatWindowFactoryAdapter : chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, isImpromptu, autoAcceptMUCInviteDecider_, vcardManager_, mucBookmarkManager_, settings_, chattables_);

+ chattables_.addJID(muc->getJID(), Chattables::State::Type::Room);

+ auto state = chattables_.getState(muc->getJID());

+ state.status = StatusShow::Online;

+ chattables_.setState(muc->getJID(), state);

+#ifndef NOT_YET

+ controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));

+#endif

+#ifndef NOT_YET

+#endif

+ if (auto existingBookmark = mucBookmarkManager_->lookupBookmark(mucJID)) {

+ if (!existingBookmark->getAutojoin()) {

+ MUCBookmark newbookmark(existingBookmark.get());

+ newbookmark.setAutojoin(true);

+ mucBookmarkManager_->replaceBookmark(*existingBookmark, newbookmark);

+ }

+ }

+ else {

+ MUCBookmark bookmark(mucJID, mucJID.getNode());

+ bookmark.setAutojoin(true);

+ if (nickMaybe) {

+ bookmark.setNick(*nickMaybe);

+ }

+ if (password) {

+ bookmark.setPassword(*password);

+ }

+ mucBookmarkManager_->addBookmark(bookmark);

+ }

+ SWIFT_LOG(debug) << "nickname change in " << mucController->getToJID().toString() << " from " << oldNickname << " to " << newNickname;

+ SWIFT_LOG(error) << "Carbons message ignored.";

+ handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, true, window);

+ handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, true);

+#ifndef NOT_YET

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(chat.jid, boost::optional<std::string>(), chat.nick, false, isImpromptu));

+#endif

+

+void ChatsManager::handleChattableActivated(const JID& jid) {

+ auto state = chattables_.getState(jid);

+ if (state.type == Chattables::State::Type::Person) {

+ uiEventStream_->send(std::make_shared<RequestChatUIEvent>(jid));

+ }

+ else if (state.type == Chattables::State::Type::Room) {

+ if (auto foundBookmark = mucBookmarkManager_->lookupBookmark(jid)) {

+ handleMUCBookmarkActivated(foundBookmark.get());

+ }

+ else {

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(jid, boost::optional<std::string>(), boost::optional<std::string>())); // Just a quick hack to reuse already open MUCs

+ }

+ }

+}

+

+ SWIFT_LOG(debug) << "Use following MUC service for impromptu chats: " << localMUCServiceJID_;

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ * Copyright (c) 2010-2018 Isode Limited.

+ class AutoAcceptMUCInviteDecider;

+ class AvatarManager;

+ class ChatListWindowFactory;

+ class ChatMessageParser;

+ class Chattables;

+ class ClientBlockListManager;

+ class DirectedPresenceSender;

+ class DiscoServiceWalker;

+ class EntityCapsProvider;

+ class EventController;

+ class FileTransferController;

+ class FileTransferOverview;

+ class HighlightManager;

+ class HistoryController;

+ class IQRouter;

+ class MUCBookmarkManager;

+ class MUCController;

+ class MUCManager;

+ class MUCSearchController;

+ class MUCSearchWindowFactory;

+ class StanzaChannel;

+ class TimerFactory;

+ class WhiteboardManager;

+ class XMPPRoster;

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

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ MUC::ref handleJoinMUCRequest(const JID& muc, const boost::optional<std::string>& password, const boost::optional<std::string>& nick, bool createAsReservedIfNew, bool isImpromptu, ChatWindow* reuseChatwindow = nullptr);

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ void handleChattableActivated(const JID& jid);

+#ifndef NOT_YET

+#endif

+

+ protected:

+ MUCBookmarkManager* mucBookmarkManager_;

+

+#ifndef NOT_YET

+#endif

+#ifndef NOT_YET

+#endif

+ Chattables& chattables_;

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/Controllers/Chat/Chattables.h>

+

+namespace Swift {

+

+const std::vector<JID>& Chattables::get() const {

+ return list_;

+}

+

+const Chattables::State& Chattables::getState(const JID& jid) const {

+ auto it = states_.find(jid);

+ return it != states_.end() ? it->second : unknown_;

+}

+

+void Chattables::addJID(const JID& jid, State::Type type) {

+ if (states_.find(jid) != states_.end()) {

+ return;

+ }

+ State state;

+ state.type = type;

+ state.jid = jid;

+ onBeginAdd(static_cast<int>(list_.size()));

+ list_.push_back(jid);

+ states_[jid] = state;

+ onAdded();

+}

+

+void Chattables::setState(const JID& jid, State state) {

+ auto stateIter = states_.find(jid);

+ if (stateIter == states_.end()) {

+ return;

+ }

+ stateIter->second = state;

+ auto listPos = static_cast<int>(std::distance(list_.begin(), std::find(list_.begin(), list_.end(), jid)));

+ onChanged(jid, listPos);

+}

+

+}

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <map>

+#include <vector>

+

+#include <boost/signals2.hpp>

+

+#include <Swiften/Elements/StatusShow.h>

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+class Chattables {

+ public:

+ struct State {

+ enum class Type {Room, Person};

+ JID jid;

+ /// Empty for no name

+ std::string name;

+ size_t unreadCount = 0;

+ Type type;

+ StatusShow::Type status = StatusShow::None;

+ //avatar

+ //status

+ };

+ const std::vector<JID>& get() const;

+ const State& getState(const JID& jid) const;

+

+ void addJID(const JID& jid, State::Type type);

+ void setState(const JID& jid, State state);

+

+ boost::signals2::signal<void (int)> onBeginAdd;

+ boost::signals2::signal<void ()> onAdded;

+ boost::signals2::signal<void (const JID&, int)> onChanged;

+ /// The UI has activated a chattable item (e.g. clicked in the roster)

+ boost::signals2::signal<void (const JID&)> onActivated;

+ private:

+ std::vector<JID> list_;

+ std::map<JID, State> states_;

+ State unknown_;

+};

+}

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <Swiften/Disco/GetDiscoInfoRequest.h>

+#include <Swift/Controllers/Chat/Chattables.h>

+ MUCBookmarkManager* mucBookmarkManager,

+ SettingsProvider* settings,

+ Chattables& chattables) :

+ ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), nickResolver, presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider, settings, chattables), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {

+ roster_ = std::make_unique<Roster>(false, true);

+ updateChatWindowBookmarkStatus(mucBookmarkManager_->lookupBookmark(muc->getJID()));

+

+ requestSecurityMarking();

+

+ actions.push_back(ChatWindow::Leave);

+void MUCController::requestSecurityMarking() {

+ auto discoInfoRequest = GetDiscoInfoRequest::create(muc_->getJID(), iqRouter_);

+ discoInfoRequest->onResponse.connect(

+ [this](std::shared_ptr<DiscoInfo> discoInfoRef, ErrorPayload::ref errorPayloadRef) {

+ if (!discoInfoRef || errorPayloadRef) {

+ return;

+ }

+ const std::vector<Form::ref>& extensionsList = discoInfoRef->getExtensions();

+ if (extensionsList.empty()) {

+ return;

+ }

+ // Get the correct form if it exists

+ Form::ref roomInfoForm;

+ for (const auto& form : extensionsList) {

+ if (form->getFormType() == "http://jabber.org/protocol/muc#roominfo") {

+ roomInfoForm = form;

+ break;

+ }

+ }

+ if (!roomInfoForm) {

+ return;

+ }

+ // It exists, now examine the security marking data

+ auto marking = roomInfoForm->getField("x-isode#roominfo_marking");

+ if (!marking) {

+ return;

+ }

+ // Now we know the marking is valid

+ auto markingValue = marking->getTextSingleValue();

+ if (markingValue == "") {

+ setMUCSecurityMarkingDefault();

+ return;

+ }

+ auto markingForegroundColor = roomInfoForm->getField("x-isode#roominfo_marking_fg_color");

+ auto markingBackgroundColor = roomInfoForm->getField("x-isode#roominfo_marking_bg_color");

+ std::string markingForegroundColorValue = "Black";

+ std::string markingBackgroundColorValue = "White";

+ if (markingForegroundColor && markingForegroundColor->getTextSingleValue() != "") {

+ markingForegroundColorValue = markingForegroundColor->getTextSingleValue();

+ }

+ if (markingBackgroundColor && markingBackgroundColor->getTextSingleValue() != "") {

+ markingBackgroundColorValue = markingBackgroundColor->getTextSingleValue();

+ }

+ setMUCSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);

+ }

+ );

+ discoInfoRequest->send();

+}

+

+void MUCController::setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) {

+ roomSecurityMarking_ = markingValue;

+ chatWindow_->setChatSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);

+}

+

+void MUCController::setMUCSecurityMarkingDefault() {

+ roomSecurityMarking_ = "";

+ chatWindow_->removeChatSecurityMarking();

+}

+

+ * Copyright (c) 2010-2018 Isode Limited.

+ MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* xmppRoster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager, MUCBookmarkManager* mucBookmarkManager, SettingsProvider* settings, Chattables& chattables);

+ virtual ~MUCController() override;

+ virtual void setOnline(bool online) override;

+ virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) override;

+ virtual void preSendMessageRequest(std::shared_ptr<Message> message) override;

+ virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) override;

+ virtual std::string senderHighlightNameFromMessage(const JID& from) override;

+ virtual std::string senderDisplayNameFromMessage(const JID& from) override;

+ virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message> message) const override;

+ virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent>) override;

+ virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time) override;

+ virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent>, const ChatWindow::ChatMessage& chatMessage) override;

+ virtual void cancelReplaces() override;

+ virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) override;

+ virtual JID messageCorrectionJID(const JID& fromJID) override;

+ virtual void dayTicked() override { clearPresenceQueue(); }

+ virtual void handleBareJIDCapsChanged(const JID& jid) override;

+ void requestSecurityMarking();

+ void setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue);

+ void setMUCSecurityMarkingDefault();

+

+ * Copyright (c) 2010-2019 Isode Limited.

+ SWIFT_LOG(debug) << "Starting walking MUC services";

+ SWIFT_LOG(debug) << "MUC Service found: " << jid;

+ SWIFT_LOG(debug) << "Requesting items of " << jid << " (" << itemsInProgress_ << " item requests in progress)";

+ SWIFT_LOG(debug) << "MUC Walk finished";

+ SWIFT_LOG(debug) << "Items received for " << jid << " (" << itemsInProgress_ << " item requests in progress)";

+/*

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

+ }

+}

+/*

+ * Copyright (c) 2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <memory>

+#include <string>

+#include <vector>

+

+#include <boost/algorithm/string.hpp>

+#include <boost/version.hpp>

+

+#include <gtest/gtest.h>

+

+#include <Swiften/Base/ByteArray.h>

+#include <Swiften/StringCodecs/Base64.h>

+

+#include <Swift/Controllers/Chat/ChatListWindowChatBoostSerialize.h>

+#include <Swift/Controllers/UIInterfaces/ChatListWindow.h>

+

+using namespace Swift;

+

+class ChatListWindowChatTest : public ::testing::Test {

+protected:

+ virtual void SetUp() {}

+ virtual void TearDown() {}

+

+ void testOptionalPasswordValue(const boost::optional<std::string>& value1, const std::string& value2) {

+ auto archiveLibraryVersion = boost::archive::BOOST_ARCHIVE_VERSION();

+ if (archiveLibraryVersion != Swift::BoostArchiveSkipVersion) {

+ EXPECT_EQ(value1.get_value_or(""), value2);

+ }

+ else {

+ EXPECT_EQ(value1.get_value_or(""), "");

+ }

+ }

+

+ std::string chatsSerialise(const std::vector<ChatListWindow::Chat>& chats) {

+ std::stringstream serializeStream;

+ boost::archive::text_oarchive oa(serializeStream);

+ oa & chats;

+ std::string serializedStr = Base64::encode(createByteArray(serializeStream.str()));

+ return serializedStr;

+ }

+

+ std::vector<ChatListWindow::Chat> chatsDeserialise(const std::string& b64chats) {

+ ByteArray debase64 = Base64::decode(b64chats);

+ std::vector<ChatListWindow::Chat> recentChats;

+ std::stringstream deserializeStream(std::string(reinterpret_cast<const char*>(vecptr(debase64)), debase64.size()));

+ try {

+ boost::archive::text_iarchive ia(deserializeStream);

+ ia >> recentChats;

+ }

+ catch (const boost::archive::archive_exception& e) {

+ EXPECT_TRUE(false) << "Archive Version:" << boost::archive::BOOST_ARCHIVE_VERSION() << " " << e.what() << std::endl;

+ recentChats.clear();

+ return recentChats;

+ }

+ recentChats.erase(std::remove(recentChats.begin(), recentChats.end(), ChatListWindow::Chat()), recentChats.end());

+ return recentChats;

+ }

+};

+

+TEST_F(ChatListWindowChatTest, testNormalSerialization) {

+ ChatListWindow::Chat chat1("swift@rooms.swift.im", "swift@rooms.swift.im", "Some text 0", 0, StatusShow::None, "", false, false, "Nick Name");

+ ChatListWindow::Chat chat2("testuser1@domain.com", "swift@rooms2.swift.im", "Some text 1", 0, StatusShow::None, "", false, false, "Nick Name", std::string("pass"));

+ ChatListWindow::Chat chat3("testuser2@domain.com", "room 2", "Some text 2", 0, StatusShow::None, "", true, false, "Nick Name");

+ ChatListWindow::Chat chat4("testuser3@domain.com", "room 3", "Some text 2", 0, StatusShow::None, "", true, false, "Nick Name", std::string("pass"));

+

+ std::map<std::string, JID> impromptuJIDs;

+ impromptuJIDs["testuser1@domain.com"] = "testuser1@domain.com";

+ impromptuJIDs["testuser2@domain.com"] = "testuser2@domain.com";

+ std::map<JID, std::string> inviteesNames;

+ inviteesNames["user1@domain.com"] = "user1@domain.com";

+

+ chat3.impromptuJIDs = impromptuJIDs;

+ chat3.inviteesNames = inviteesNames;

+ chat4.impromptuJIDs = impromptuJIDs;

+ chat4.inviteesNames = inviteesNames;

+

+ std::vector<ChatListWindow::Chat> chats;

+ chats.push_back(chat1);

+ chats.push_back(chat2);

+ chats.push_back(chat3);

+ chats.push_back(chat4);

+

+ auto base64 = chatsSerialise(chats);

+ ASSERT_TRUE(base64.size() > 0);

+ auto restoredChats = chatsDeserialise(base64);

+ ASSERT_EQ(restoredChats.size(), 4);

+

+ EXPECT_FALSE(restoredChats[0].isMUC);

+ EXPECT_EQ(restoredChats[0].jid, "swift@rooms.swift.im");

+ EXPECT_EQ(restoredChats[0].chatName, "swift@rooms.swift.im");

+ EXPECT_EQ(restoredChats[0].activity, "Some text 0");

+ EXPECT_EQ(restoredChats[0].nick, "Nick Name");

+ EXPECT_EQ(restoredChats[0].impromptuJIDs.size(), 0);

+ testOptionalPasswordValue(restoredChats[0].password, "");

+ EXPECT_EQ(restoredChats[0].inviteesNames.size(), 0);

+

+ EXPECT_FALSE(restoredChats[1].isMUC);

+ EXPECT_EQ(restoredChats[1].jid, "testuser1@domain.com");

+ EXPECT_EQ(restoredChats[1].chatName, "swift@rooms2.swift.im");

+ EXPECT_EQ(restoredChats[1].activity, "Some text 1");

+ EXPECT_EQ(restoredChats[1].nick, "Nick Name");

+ EXPECT_EQ(restoredChats[1].impromptuJIDs.size(), 0);

+ testOptionalPasswordValue(restoredChats[1].password, "pass");

+ EXPECT_EQ(restoredChats[1].inviteesNames.size(), 0);

+

+ EXPECT_TRUE(restoredChats[2].isMUC);

+ EXPECT_EQ(restoredChats[2].jid, "testuser2@domain.com");

+ EXPECT_EQ(restoredChats[2].chatName, "room 2");

+ EXPECT_EQ(restoredChats[2].activity, "Some text 2");

+ EXPECT_EQ(restoredChats[2].nick, "Nick Name");

+ ASSERT_EQ(restoredChats[2].impromptuJIDs.size(), 2);

+ EXPECT_EQ(restoredChats[2].impromptuJIDs["testuser1@domain.com"], "testuser1@domain.com");

+ EXPECT_EQ(restoredChats[2].impromptuJIDs["testuser2@domain.com"], "testuser2@domain.com");

+ testOptionalPasswordValue(restoredChats[2].password, "");

+ ASSERT_EQ(restoredChats[2].inviteesNames.size(), 1);

+ EXPECT_EQ(restoredChats[2].inviteesNames["user1@domain.com"], "user1@domain.com");

+

+ EXPECT_TRUE(restoredChats[3].isMUC);

+ EXPECT_EQ(restoredChats[3].jid, "testuser3@domain.com");

+ EXPECT_EQ(restoredChats[3].chatName, "room 3");

+ EXPECT_EQ(restoredChats[3].activity, "Some text 2");

+ EXPECT_EQ(restoredChats[3].nick, "Nick Name");

+ ASSERT_EQ(restoredChats[3].impromptuJIDs.size(), 2);

+ EXPECT_EQ(restoredChats[3].impromptuJIDs["testuser1@domain.com"], "testuser1@domain.com");

+ EXPECT_EQ(restoredChats[3].impromptuJIDs["testuser2@domain.com"], "testuser2@domain.com");

+ testOptionalPasswordValue(restoredChats[3].password, "pass");

+ ASSERT_EQ(restoredChats[3].inviteesNames.size(), 1);

+ EXPECT_EQ(restoredChats[3].inviteesNames["user1@domain.com"], "user1@domain.com");

+}

+

+TEST_F(ChatListWindowChatTest, testVersionsSerialization) {

+ auto archiveLibraryVersion = boost::archive::BOOST_ARCHIVE_VERSION();

+ /*

+ The following strings are base64 serialised vectors with these Swift::ChatListWindow::Chat elements:

+

+ Chat1: Jid = "swift@rooms.swift.im", ChatName = "swift@rooms.swift.im", Activity = "Some text 0", isMUC = false, nick="Nick Name"

+ Chat2: Jid = "testuser1@domain.com", ChatName = "swift@rooms2.swift.im", Activity = "Some text 1", isMUC = false, nick="Nick Name", password = "pass"

+ Chat3: Jid = "testuser2@domain.com", ChatName = "room2", Activity = "Some text 2", isMUC = true, nick="Nick Name", impromptuJIDs, inviteesNames

+ Chat4: Jid = "testuser3@domain.com", ChatName = "room3", Activity = "Some text 2", isMUC = true, nick="Nick Name", impromptuJIDs, password = "pass", inviteesNames

+

+ impromptuJIDs = {("testuser1@domain.com","testuser1@domain.com"), ("testuser2@domain.com", "testuser2@domain.com")}

+ inviteesNames = {("user1@domain.com","user1@domain.com")}

+ */

+ std::string serializedChats_BoostArchiveV10_ClassVersion_0 = "MjIgc2VyaWFsaXphdGlvbjo6YXJjaGl2ZSAxMCAwIDAgNCAwIDAgMCAwIDAgMjAgc3dpZnRAcm9vbXMuc3dpZnQuaW0gMjAgc3dpZnRAcm9vbXMuc3dpZnQuaW0gMTEgU29tZSB0ZXh0IDAgMCA5IE5pY2sgTmFtZSAwIDAgMCAwIDIwIHRlc3R1c2VyMUBkb21haW4uY29tIDIxIHN3aWZ0QHJvb21zMi5zd2lmdC5pbSAxMSBTb21lIHRleHQgMSAwIDkgTmljayBOYW1lIDAgMCAyMCB0ZXN0dXNlcjJAZG9tYWluLmNvbSA2IHJvb20gMiAxMSBTb21lIHRleHQgMiAxIDkgTmljayBOYW1lIDIgMCAwIDAgMjAgdGVzdHVzZXIxQGRvbWFpbi5jb20gMjAgdGVzdHVzZXIxQGRvbWFpbi5jb20gMjAgdGVzdHVzZXIyQGRvbWFpbi5jb20gMjAgdGVzdHVzZXIyQGRvbWFpbi5jb20gMjAgdGVzdHVzZXIzQGRvbWFpbi5jb20gNiByb29tIDMgMTEgU29tZSB0ZXh0IDIgMSA5IE5pY2sgTmFtZSAyIDAgMjAgdGVzdHVzZXIxQGRvbWFpbi5jb20gMjAgdGVzdHVzZXIxQGRvbWFpbi5jb20gMjAgdGVzdHVzZXIyQGRvbWFpbi5jb20gMjAgdGVzdHVzZXIyQGRvbWFpbi5jb20=";

+ {

+ auto restoredChats = chatsDeserialise(serializedChats_BoostArchiveV10_ClassVersion_0);

+ if (archiveLibraryVersion == Swift::BoostArchiveSkipVersion) {

+ ASSERT_EQ(restoredChats.size(), 0);

+ }

+ else {

+ ASSERT_EQ(restoredChats.size(), 4);

+

+ EXPECT_FALSE(restoredChats[0].isMUC);

+ EXPECT_EQ(restoredChats[0].jid, "swift@rooms.swift.im");

+ EXPECT_EQ(restoredChats[0].chatName, "swift@rooms.swift.im");

+ EXPECT_EQ(restoredChats[0].activity, "Some text 0");

+ EXPECT_EQ(restoredChats[0].nick, "Nick Name");

+ EXPECT_EQ(restoredChats[0].impromptuJIDs.size(), 0);

+

+ EXPECT_FALSE(restoredChats[1].isMUC);

+ EXPECT_EQ(restoredChats[1].jid, "testuser1@domain.com");

+ EXPECT_EQ(restoredChats[1].chatName, "swift@rooms2.swift.im");

+ EXPECT_EQ(restoredChats[1].activity, "Some text 1");

+ EXPECT_EQ(restoredChats[1].nick, "Nick Name");

+ EXPECT_EQ(restoredChats[1].impromptuJIDs.size(), 0);

+

+ EXPECT_TRUE(restoredChats[2].isMUC);

+ EXPECT_EQ(restoredChats[2].jid, "testuser2@domain.com");

+ EXPECT_EQ(restoredChats[2].chatName, "room 2");

+ EXPECT_EQ(restoredChats[2].activity, "Some text 2");

+ EXPECT_EQ(restoredChats[2].nick, "Nick Name");

+ ASSERT_EQ(restoredChats[2].impromptuJIDs.size(), 2);

+ EXPECT_EQ(restoredChats[2].impromptuJIDs["testuser1@domain.com"], "testuser1@domain.com");

+ EXPECT_EQ(restoredChats[2].impromptuJIDs["testuser2@domain.com"], "testuser2@domain.com");

+

+ EXPECT_TRUE(restoredChats[3].isMUC);

+ EXPECT_EQ(restoredChats[3].jid, "testuser3@domain.com");

+ EXPECT_EQ(restoredChats[3].chatName, "room 3");

+ EXPECT_EQ(restoredChats[3].activity, "Some text 2");

+ EXPECT_EQ(restoredChats[3].nick, "Nick Name");

+ ASSERT_EQ(restoredChats[3].impromptuJIDs.size(), 2);

+ EXPECT_EQ(restoredChats[3].impromptuJIDs["testuser1@domain.com"], "testuser1@domain.com");

+ EXPECT_EQ(restoredChats[3].impromptuJIDs["testuser2@domain.com"], "testuser2@domain.com");

+ }

+ }

+

+ std::string serializedChats_BoostArchiveV10_ClassVersion_1 = "MjIgc2VyaWFsaXphdGlvbjo6YXJjaGl2ZSAxMCAwIDAgNCAxIDAgMSAwIDAgMjAgc3dpZnRAcm9vbXMuc3dpZnQuaW0gMjAgc3dpZnRAcm9vbXMuc3dpZnQuaW0gMTEgU29tZSB0ZXh0IDAgMCA5IE5pY2sgTmFtZSAwIDAgMCAwIDAgMCAwIDIwIHRlc3R1c2VyMUBkb21haW4uY29tIDIxIHN3aWZ0QHJvb21zMi5zd2lmdC5pbSAxMSBTb21lIHRleHQgMSAwIDkgTmljayBOYW1lIDAgMCAxIDAgNCBwYXNzIDIwIHRlc3R1c2VyMkBkb21haW4uY29tIDYgcm9vbSAyIDExIFNvbWUgdGV4dCAyIDEgOSBOaWNrIE5hbWUgMiAwIDAgMCAyMCB0ZXN0dXNlcjFAZG9tYWluLmNvbSAyMCB0ZXN0dXNlcjFAZG9tYWluLmNvbSAyMCB0ZXN0dXNlcjJAZG9tYWluLmNvbSAyMCB0ZXN0dXNlcjJAZG9tYWluLmNvbSAwIDIwIHRlc3R1c2VyM0Bkb21haW4uY29tIDYgcm9vbSAzIDExIFNvbWUgdGV4dCAyIDEgOSBOaWNrIE5hbWUgMiAwIDIwIHRlc3R1c2VyMUBkb21haW4uY29tIDIwIHRlc3R1c2VyMUBkb21haW4uY29tIDIwIHRlc3R1c2VyMkBkb21haW4uY29tIDIwIHRlc3R1c2VyMkBkb21haW4uY29tIDEgMCA0IHBhc3M=";

+ {

+ auto restoredChats = chatsDeserialise(serializedChats_BoostArchiveV10_ClassVersion_1);

+ if (archiveLibraryVersion == Swift::BoostArchiveSkipVersion) {

+ ASSERT_EQ(restoredChats.size(), 0);

+ }

+ else {

+ ASSERT_EQ(restoredChats.size(), 4);

+

+ EXPECT_FALSE(restoredChats[0].isMUC);

+ EXPECT_EQ(restoredChats[0].jid, "swift@rooms.swift.im");

+ EXPECT_EQ(restoredChats[0].chatName, "swift@rooms.swift.im");

+ EXPECT_EQ(restoredChats[0].activity, "Some text 0");

+ EXPECT_EQ(restoredChats[0].nick, "Nick Name");

+ EXPECT_EQ(restoredChats[0].impromptuJIDs.size(), 0);

+ EXPECT_EQ(restoredChats[0].password.get_value_or(""), "");

+

+ EXPECT_FALSE(restoredChats[1].isMUC);

+ EXPECT_EQ(restoredChats[1].jid, "testuser1@domain.com");

+ EXPECT_EQ(restoredChats[1].chatName, "swift@rooms2.swift.im");

+ EXPECT_EQ(restoredChats[1].activity, "Some text 1");

+ EXPECT_EQ(restoredChats[1].nick, "Nick Name");

+ EXPECT_EQ(restoredChats[1].impromptuJIDs.size(), 0);

+ EXPECT_EQ(restoredChats[1].password.get_value_or(""), "pass");

+

+ EXPECT_TRUE(restoredChats[2].isMUC);

+ EXPECT_EQ(restoredChats[2].jid, "testuser2@domain.com");

+ EXPECT_EQ(restoredChats[2].chatName, "room 2");

+ EXPECT_EQ(restoredChats[2].activity, "Some text 2");

+ EXPECT_EQ(restoredChats[2].nick, "Nick Name");

+ ASSERT_EQ(restoredChats[2].impromptuJIDs.size(), 2);

+ EXPECT_EQ(restoredChats[2].impromptuJIDs["testuser1@domain.com"], "testuser1@domain.com");

+ EXPECT_EQ(restoredChats[2].impromptuJIDs["testuser2@domain.com"], "testuser2@domain.com");

+ EXPECT_EQ(restoredChats[2].password.get_value_or(""), "");

+

+ EXPECT_TRUE(restoredChats[3].isMUC);

+ EXPECT_EQ(restoredChats[3].jid, "testuser3@domain.com");

+ EXPECT_EQ(restoredChats[3].chatName, "room 3");

+ EXPECT_EQ(restoredChats[3].activity, "Some text 2");

+ EXPECT_EQ(restoredChats[3].nick, "Nick Name");

+ ASSERT_EQ(restoredChats[3].impromptuJIDs.size(), 2);

+ EXPECT_EQ(restoredChats[3].impromptuJIDs["testuser1@domain.com"], "testuser1@domain.com");

+ EXPECT_EQ(restoredChats[3].impromptuJIDs["testuser2@domain.com"], "testuser2@domain.com");

+ EXPECT_EQ(restoredChats[3].password.get_value_or(""), "pass");

+ }

+ }

+

+ std::string serializedChats_BoostArchiveV10_ClassVersion_2 = "MjIgc2VyaWFsaXphdGlvbjo6YXJjaGl2ZSAxMCAwIDAgNCAyIDAgMiAwIDAgMjAgc3dpZnRAcm9vbXMuc3dpZnQuaW0gMjAgc3dpZnRAcm9vbXMuc3dpZnQuaW0gMTEgU29tZSB0ZXh0IDAgMCA5IE5pY2sgTmFtZSAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMjAgdGVzdHVzZXIxQGRvbWFpbi5jb20gMjEgc3dpZnRAcm9vbXMyLnN3aWZ0LmltIDExIFNvbWUgdGV4dCAxIDAgOSBOaWNrIE5hbWUgMCAwIDEgMCA0IHBhc3MgMCAwIDIwIHRlc3R1c2VyMkBkb21haW4uY29tIDYgcm9vbSAyIDExIFNvbWUgdGV4dCAyIDEgOSBOaWNrIE5hbWUgMiAwIDAgMCAyMCB0ZXN0dXNlcjFAZG9tYWluLmNvbSAyMCB0ZXN0dXNlcjFAZG9tYWluLmNvbSAyMCB0ZXN0dXNlcjJAZG9tYWluLmNvbSAyMCB0ZXN0dXNlcjJAZG9tYWluLmNvbSAwIDEgMCAwIDAgMTYgdXNlcjFAZG9tYWluLmNvbSAxNiB1c2VyMUBkb21haW4uY29tIDIwIHRlc3R1c2VyM0Bkb21haW4uY29tIDYgcm9vbSAzIDExIFNvbWUgdGV4dCAyIDEgOSBOaWNrIE5hbWUgMiAwIDIwIHRlc3R1c2VyMUBkb21haW4uY29tIDIwIHRlc3R1c2VyMUBkb21haW4uY29tIDIwIHRlc3R1c2VyMkBkb21haW4uY29tIDIwIHRlc3R1c2VyMkBkb21haW4uY29tIDEgMCA0IHBhc3MgMSAwIDE2IHVzZXIxQGRvbWFpbi5jb20gMTYgdXNlcjFAZG9tYWluLmNvbQ==";

+ {

+ auto restoredChats = chatsDeserialise(serializedChats_BoostArchiveV10_ClassVersion_2);

+ if (archiveLibraryVersion == Swift::BoostArchiveSkipVersion) {

+ ASSERT_EQ(restoredChats.size(), 0);

+ }

+ else {

+ ASSERT_EQ(restoredChats.size(), 4);

+

+ EXPECT_FALSE(restoredChats[0].isMUC);

+ EXPECT_EQ(restoredChats[0].jid, "swift@rooms.swift.im");

+ EXPECT_EQ(restoredChats[0].chatName, "swift@rooms.swift.im");

+ EXPECT_EQ(restoredChats[0].activity, "Some text 0");

+ EXPECT_EQ(restoredChats[0].nick, "Nick Name");

+ EXPECT_EQ(restoredChats[0].impromptuJIDs.size(), 0);

+ EXPECT_EQ(restoredChats[0].password.get_value_or(""), "");

+ EXPECT_EQ(restoredChats[0].inviteesNames.size(), 0);

+

+ EXPECT_FALSE(restoredChats[1].isMUC);

+ EXPECT_EQ(restoredChats[1].jid, "testuser1@domain.com");

+ EXPECT_EQ(restoredChats[1].chatName, "swift@rooms2.swift.im");

+ EXPECT_EQ(restoredChats[1].activity, "Some text 1");

+ EXPECT_EQ(restoredChats[1].nick, "Nick Name");

+ EXPECT_EQ(restoredChats[1].impromptuJIDs.size(), 0);

+ EXPECT_EQ(restoredChats[1].password.get_value_or(""), "pass");

+ EXPECT_EQ(restoredChats[1].inviteesNames.size(), 0);

+

+ EXPECT_TRUE(restoredChats[2].isMUC);

+ EXPECT_EQ(restoredChats[2].jid, "testuser2@domain.com");

+ EXPECT_EQ(restoredChats[2].chatName, "room 2");

+ EXPECT_EQ(restoredChats[2].activity, "Some text 2");

+ EXPECT_EQ(restoredChats[2].nick, "Nick Name");

+ ASSERT_EQ(restoredChats[2].impromptuJIDs.size(), 2);

+ EXPECT_EQ(restoredChats[2].impromptuJIDs["testuser1@domain.com"], "testuser1@domain.com");

+ EXPECT_EQ(restoredChats[2].impromptuJIDs["testuser2@domain.com"], "testuser2@domain.com");

+ EXPECT_EQ(restoredChats[2].password.get_value_or(""), "");

+ ASSERT_EQ(restoredChats[2].inviteesNames.size(), 1);

+ EXPECT_EQ(restoredChats[2].inviteesNames["user1@domain.com"], "user1@domain.com");

+

+ EXPECT_TRUE(restoredChats[3].isMUC);

+ EXPECT_EQ(restoredChats[3].jid, "testuser3@domain.com");

+ EXPECT_EQ(restoredChats[3].chatName, "room 3");

+ EXPECT_EQ(restoredChats[3].activity, "Some text 2");

+ EXPECT_EQ(restoredChats[3].nick, "Nick Name");

+ ASSERT_EQ(restoredChats[3].impromptuJIDs.size(), 2);

+ EXPECT_EQ(restoredChats[3].impromptuJIDs["testuser1@domain.com"], "testuser1@domain.com");

+ EXPECT_EQ(restoredChats[3].impromptuJIDs["testuser2@domain.com"], "testuser2@domain.com");

+ EXPECT_EQ(restoredChats[3].password.get_value_or(""), "pass");

+ ASSERT_EQ(restoredChats[3].inviteesNames.size(), 1);

+ EXPECT_EQ(restoredChats[3].inviteesNames["user1@domain.com"], "user1@domain.com");

+ }

+ }

+}

+

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <Swiften/Elements/PrivateStorage.h>

+#include <Swiften/Elements/Storage.h>

+#include <Swiften/MUC/UnitTest/MockMUC.h>

+#include <Swiften/MUC/MUCBookmarkManager.h>

+#include <Swift/Controllers/Chat/Chattables.h>

+#include <Swift/Controllers/UIEvents/AddMUCBookmarkUIEvent.h>

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

+ }

+};

+

+ // Bookmark tests

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

+

+ notifier_ = std::make_unique<DummyNotifier>();

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

+ auto sendMessageStanza = stanzaChannel_->getStanzaAtIndex<Message>(3);

+

+ auto recentChats = manager_->getRecentChats();

+ CPPUNIT_ASSERT_EQUAL(recentChats.size(), size_t(1));

+ CPPUNIT_ASSERT_EQUAL(recentChats[0].jid, originalMessage->getFrom().toBare());

+ CPPUNIT_ASSERT_EQUAL(recentChats[0].activity, std::string("Some further text."));

+

+ auto recentChats = manager_->getRecentChats();

+ CPPUNIT_ASSERT_EQUAL(recentChats.size(), size_t(1));

+ CPPUNIT_ASSERT_EQUAL(recentChats[0].jid, originalMessage->getTo().toBare());

+ CPPUNIT_ASSERT_EQUAL(recentChats[0].activity, std::string("Some text my other resource sent."));

+

+ //Delivery receipt should not change the latest recent entry. Checking for the original message.

+ auto recentChats = manager_->getRecentChats();

+ CPPUNIT_ASSERT_EQUAL(recentChats.size(), size_t(1));

+ CPPUNIT_ASSERT_EQUAL(recentChats[0].jid, messageJID.toBare());

+ CPPUNIT_ASSERT_EQUAL(recentChats[0].activity, std::string("Some text my other resource sent."));

+

+

+

+

+

+

+

+

+

+ auto recentChats = manager_->getRecentChats();

+ CPPUNIT_ASSERT_EQUAL(recentChats.size(), size_t(1));

+ CPPUNIT_ASSERT_EQUAL(recentChats[0].jid, originalMessage->getFrom().toBare());

+ CPPUNIT_ASSERT_EQUAL(recentChats[0].activity, std::string("Some further text."));

+ // 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]);

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

+

+ auto privateStorage = bookmarkRequest->getPayload<PrivateStorage>();

+ CPPUNIT_ASSERT(privateStorage);

+

+ 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(bookmarkRequest, "montague.lit", true))

+ );

+ stanzaChannel_->onIQReceived(response);

+ }

+

+ void testReceivingBookmarksWithBareJID() {

+ auto bookmarkRequest = std::dynamic_pointer_cast<IQ>(stanzaChannel_->sentStanzas[0]);

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

+ );

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

+ auto response = IQ::createResult(

+ bookmarkRequest->getFrom(),

+ bookmarkRequest->getTo(),

+ bookmarkRequest->getID(),

+ std::make_shared<PrivateStorage>(createBookmarkStorageWithJID(bookmarkRequest, "example@montague.lit/someresource", true))

+ );

+ stanzaChannel_->onIQReceived(response);

+ }

+

+ void testAutoJoinBookmarksAndChattables() {

+

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

+ }

+ }

+

+ ExtendedChatsManager* manager_;

+ std::unique_ptr<Chattables> chattables_;

+/*

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

+}

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <memory>

+

+#include <gtest/gtest.h>

+#include <Swift/Controllers/Chat/Chattables.h>

+#include <Swift/Controllers/SettingConstants.h>

+// Clang wrongly things that tests for 0 are using 0 as null.

+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"

+

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

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

+ }

+ }

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

+ }

+ }

+ }

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

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

+ }

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

+ markingField->setName("x-isode#roominfo_marking");

+ markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");

+ markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");

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

+ }

+

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

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

+ {

+ Message::ref message = std::make_shared<Message>();

+ message->setTo(self_);

+ message->setFrom(mucJID_.withResource("SomeNickname"));

+ message->setID("3FB99C56-7C92-4755-91B0-9C0098BC7AE0");

+ message->setSubject("New Room Subject");

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

+}

+/*

+ * Test that message stanzas with subject element and non-empty body element do not cause a subject change.

+ */

+TEST_F(MUCControllerTest, testSubjectChangeIncorrectA) {

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

+}

+/*

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

+}

+/*

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

+}

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingA) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ 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_Elision_NoRoomMarkingB) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ 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_Elision_WithRoomMarkingA) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ 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 NOT 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(""), storedSecurityLabel2->getDisplayMarking());

+}

+TEST_F(MUCControllerTest, testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingB) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("Test|Lower Security Marking", "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_Elision_WithRoomMarkingC) {

+ settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);

+ setMUCSecurityMarking("Test|Highest Possible Security", "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("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);

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

+}

+ void setUnreadCount(size_t /*unread*/) {}

+ * Copyright (c) 2014-2018 Isode Limited.

+ results.erase(std::remove_if(results.begin(), results.end(), [&](const Contact::ref contact) {

+ return !matchContact(search, contact);

+ }), results.end());

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/Controllers/FdpFormSubmitController.h>

+

+#include <Swiften/Disco/GetDiscoItemsRequest.h>

+#include <Swiften/Elements/DiscoItems.h>

+#include <Swiften/Queries/IQRouter.h>

+#include <Swiften/Queries/PubSubRequest.h>

+

+#include <Swift/Controllers/UIEvents/FdpFormSubmitWindowOpenUIEvent.h>

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

+#include <Swift/Controllers/UIInterfaces/FdpFormSubmitWindow.h>

+#include <Swift/Controllers/UIInterfaces/FdpFormSubmitWindowFactory.h>

+

+namespace Swift {

+

+FdpFormSubmitController::FdpFormSubmitController(const JID& self, IQRouter* iqRouter, UIEventStream* uiEventStream, FdpFormSubmitWindowFactory* factory) : selfJID_(self), iqRouter_(iqRouter), uiEventStream_(uiEventStream), factory_(factory), formSubmitWindow_(nullptr) {

+ fdpFormSubmitWindowOpenUIEventConnection_= uiEventStream_->onUIEvent.connect( [this](const std::shared_ptr<UIEvent>& uiEvent){ handleUIEvent(uiEvent); });

+}

+

+FdpFormSubmitController::~FdpFormSubmitController() {

+}

+

+void FdpFormSubmitController::handleUIEvent(const std::shared_ptr<UIEvent>& uiEvent) {

+ if (auto openEvent = std::dynamic_pointer_cast<FdpFormSubmitWindowOpenUIEvent>(uiEvent)) {

+ if (formSubmitWindow_) {

+ formSubmitWindow_->raise();

+ }

+ else {

+ createFormSubmitWindow();

+ }

+ }

+}

+

+void FdpFormSubmitController::createFormSubmitWindow() {

+ formSubmitWindow_ = factory_->createFdpFormSubmitWindow();

+ formSubmitWindow_->onCloseEvent.connect([this](){ closeFormSubmitWindow(); });

+ formSubmitWindow_->onRequestPubSubNodeData.connect([this](const std::string& string){ requestPubSubNodeData(string); });

+ formSubmitWindow_->onRequestTemplateForm.connect([this](const std::string& fdpTemplateNodeName){ requestTemplateForm(fdpTemplateNodeName); });

+ formSubmitWindow_->onSubmitForm.connect([this](const std::shared_ptr<Form>& form){ submitForm(form); });

+ formSubmitWindow_->show();

+}

+

+void FdpFormSubmitController::closeFormSubmitWindow() {

+ formSubmitWindow_.reset();

+}

+

+void FdpFormSubmitController::requestPubSubNodeData(const std::string& domainName) {

+ JID domainJID(domainName);

+ auto discoItemsRequest = GetDiscoItemsRequest::create(domainJID, iqRouter_);

+ discoItemsRequest->onResponse.connect(

+ [this, domainName](std::shared_ptr<DiscoItems> discoItems, ErrorPayload::ref errorPayloadRef) {

+ if (!discoItems || errorPayloadRef) {

+ formSubmitWindow_->showNodePlaceholder(FdpFormSubmitWindow::NodeError::DomainNotFound);

+ return;

+ }

+ currentDomain_ = domainName;

+

+ bool templateNodeAdded = false;

+ formSubmitWindow_->clearNodeData();

+ auto discoItemList = discoItems->getItems();

+ for (auto discoItem : discoItemList) {

+ auto node = discoItem.getNode();

+ if (node.substr(0, 13) != "fdp/template/") {

+ continue;

+ }

+

+ std::string nodeName = discoItem.getName().empty() ? node : discoItem.getName();

+

+ formSubmitWindow_->addNode(node, nodeName);

+ templateNodeAdded = true;

+ }

+ if (!templateNodeAdded) {

+ formSubmitWindow_->showNodePlaceholder(FdpFormSubmitWindow::NodeError::NoFdpNodesInDomain);

+ }

+ }

+ );

+ discoItemsRequest->send();

+}

+

+void FdpFormSubmitController::requestTemplateForm(const std::string& nodeName) {

+ auto pubSubItems = std::make_shared<PubSubItems>(nodeName);

+ pubSubItems->setMaximumItems(1);

+ auto formRequest = std::make_shared<PubSubRequest<PubSubItems>>(IQ::Type::Get, selfJID_, currentDomain_, pubSubItems, iqRouter_);

+

+ formRequest->onResponse.connect(

+ [this, nodeName](std::shared_ptr<PubSubItems> response, ErrorPayload::ref errorPayload) {

+ if (!response || errorPayload) {

+ formSubmitWindow_->showFormPlaceholder(FdpFormSubmitWindow::TemplateError::RequestFailed);

+ return;

+ }

+ auto pubSubItemList = response->getItems();

+ if (pubSubItemList.empty()) {

+ formSubmitWindow_->showFormPlaceholder(FdpFormSubmitWindow::TemplateError::CannotLocateForm);

+ return;

+ }

+ auto payloadList = pubSubItemList[0]->getData();

+ if (payloadList.empty()) {

+ formSubmitWindow_->showFormPlaceholder(FdpFormSubmitWindow::TemplateError::CannotLocateForm);

+ return;

+ }

+ if (auto form = std::dynamic_pointer_cast<Form>(payloadList[0])) {

+ currentTemplateNode_ = nodeName;

+ formSubmitWindow_->setFormData(form);

+ }

+ else {

+ formSubmitWindow_->showFormPlaceholder(FdpFormSubmitWindow::TemplateError::InvalidPayload);

+ return;

+ }

+ }

+ );

+

+ formRequest->send();

+}

+

+void FdpFormSubmitController::submitForm(const std::shared_ptr<Form>& form) {

+ std::string submittedNode = currentTemplateNode_;

+ submittedNode.replace(submittedNode.find("/template/", 0), 10, "/submitted/");

+ auto pubSubItem = std::make_shared<PubSubItem>();

+ auto pubSubItems = std::make_shared<PubSubItems>(submittedNode);

+ auto pubSubPublish = std::make_shared<PubSubPublish>();

+ pubSubPublish->setNode(submittedNode);

+ pubSubPublish->addItem(pubSubItem);

+ pubSubItem->addData(form);

+ pubSubItems->addItem(pubSubItem);

+ auto formRequest = std::make_shared<PubSubRequest<PubSubPublish>>(IQ::Type::Set, selfJID_, currentDomain_, pubSubPublish, iqRouter_);

+

+ formRequest->onResponse.connect(

+ [this](std::shared_ptr<PubSubPublish> response, ErrorPayload::ref errorPayload) {

+ if (!response || errorPayload) {

+ formSubmitWindow_->handleSubmitServerResponse(false);

+ return;

+ }

+ formSubmitWindow_->handleSubmitServerResponse(true);

+ }

+ );

+

+ formRequest->send();

+}

+

+}

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+#include <string>

+

+#include <boost/signals2.hpp>

+

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+ class FdpFormSubmitWindow;

+ class FdpFormSubmitWindowFactory;

+ class Form;

+ class IQRouter;

+ class UIEvent;

+ class UIEventStream;

+

+ class FdpFormSubmitController {

+ public:

+ FdpFormSubmitController(const JID& self, IQRouter* iqRouter, UIEventStream* uiEventStream, FdpFormSubmitWindowFactory* factory);

+ ~FdpFormSubmitController();

+

+ private:

+ void handleUIEvent(const std::shared_ptr<UIEvent>& uiEvent);

+ void createFormSubmitWindow();

+ void closeFormSubmitWindow();

+ void requestPubSubNodeData(const std::string& domainName);

+ void requestTemplateForm(const std::string& nodeName);

+ void submitForm(const std::shared_ptr<Form>& form);

+

+ JID selfJID_;

+ IQRouter* iqRouter_;

+ UIEventStream* uiEventStream_;

+ FdpFormSubmitWindowFactory* factory_;

+ std::unique_ptr<FdpFormSubmitWindow> formSubmitWindow_;

+ std::string currentDomain_;

+ std::string currentTemplateNode_;

+

+ boost::signals2::scoped_connection fdpFormSubmitWindowOpenUIEventConnection_;

+ };

+}

+ * Copyright (c) 2015-2019 Isode Limited.

+ SWIFT_LOG(debug) << "FileTransferController::start";

+ SWIFT_LOG(debug) << "FileTransferController::accept";

+ * Copyright (c) 2016-2018 Isode Limited.

+FileTransferProgressInfo::FileTransferProgressInfo(size_t completeBytes) : completeBytes(completeBytes), completedBytes(0), percentage(0) {

+void FileTransferProgressInfo::setBytesProcessed(size_t processedBytes) {

+ completedBytes += processedBytes;

+ * Copyright (c) 2016-2018 Isode Limited.

+#include <cstddef>

+

+ FileTransferProgressInfo(size_t completeBytes);

+ void setBytesProcessed(size_t processedBytes);

+ size_t completeBytes;

+ size_t completedBytes;

+BOOST_CLASS_VERSION(Swift::HighlightAction, 1)

+

+#include <map>

+#include <memory>

+#include <boost/serialization/map.hpp>

+

+ void HighlightAction::serialize(Archive& ar, const unsigned int version) {

+ auto inputStream = dynamic_cast<boost::archive::text_iarchive*>(&ar);

+ auto outputStream = dynamic_cast<boost::archive::text_oarchive*>(&ar);

+

+ if (version == 0) {

+ if (inputStream) {

+ const boost::archive::library_version_type BoostArchiveSkipVersion(15);

+ auto archiveLibraryVersion = boost::archive::BOOST_ARCHIVE_VERSION();

+ //Due to https://svn.boost.org/trac10/ticket/13050 the boost::optional fields may fail to load and crash the client. Therefore we skip loading the values from previous versions.

+ if (archiveLibraryVersion == BoostArchiveSkipVersion && archiveLibraryVersion > inputStream->get_library_version()) {

+ return;

+ }

+ }

+ ar & frontColor_;

+ ar & backColor_;

+ ar & soundFilePath_;

+ ar & systemNotificaitonEnabled_;

+ }

+ else if (version == 1) {

+ //Using a map instead of optional values that may cause a problems when serialised with boost::archive 15 version

+ std::map<std::string, std::string> properties;

+ if (outputStream) {

+ if (frontColor_.is_initialized()) {

+ properties["frontColor"] = frontColor_.get();

+ }

+ if (backColor_.is_initialized()) {

+ properties["backColor"] = backColor_.get();

+ }

+ if (soundFilePath_.is_initialized()) {

+ properties["soundFilePath"] = soundFilePath_.get();

+ }

+ }

+ ar & properties;

+ ar & systemNotificaitonEnabled_;

+ if (inputStream) {

+ if (properties.find("frontColor") != properties.end()) {

+ frontColor_ = properties["frontColor"];

+ }

+ if (properties.find("backColor") != properties.end()) {

+ backColor_ = properties["backColor"];

+ }

+ if (properties.find("soundFilePath") != properties.end()) {

+ soundFilePath_ = properties["soundFilePath"];

+ }

+ }

+ }

+ * Copyright (c) 2014-2019 Isode Limited.

+ SWIFT_LOG(warning) << "Failed to load highlight configuration. Will use default configuration instead.";

+ * @param displayJID An alternate JID that is used instead of the JID this item represents. If not available,

+ * Copyright (c) 2011-2018 Isode Limited.

+ result[i + j*width] = predicate(*(xBegin + static_cast<long long>(i)-1), *(yBegin + static_cast<long long>(j)-1)) ? result[(i-1) + (j-1)*width] + 1 : std::max(result[i + (j-1)*width], result[i-1 + (j*width)]);

+Roster::Roster(bool sortByStatus, bool fullJIDMapping) : fullJIDMapping_(fullJIDMapping), sortByStatus_(sortByStatus), root_(std::make_unique<GroupRosterItem>("Dummy-Root", nullptr, sortByStatus_)) {

+ * Copyright (c) 2010-2018 Isode Limited.

+#include <Swift/Controllers/Chat/Chattables.h>

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

+RosterController::RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter, SettingsProvider* settings, EntityCapsProvider* entityCapsManager, ClientBlockListManager* clientBlockListManager, VCardManager* vcardManager, Chattables& chattables)

+ : myJID_(jid), xmppRoster_(xmppRoster), mainWindowFactory_(mainWindowFactory), mainWindow_(mainWindowFactory_->createMainWindow(chattables, uiEventStream)), roster_(new Roster()), offlineFilter_(new OfflineRosterFilter()), vcardManager_(vcardManager), avatarManager_(avatarManager), nickManager_(nickManager), nickResolver_(nickResolver), presenceOracle_(presenceOracle), uiEventStream_(uiEventStream), entityCapsManager_(entityCapsManager), clientBlockListManager_(clientBlockListManager), chattables_(chattables) {

+#ifndef NOT_YET

+#endif

+ featureOracle_ = std::make_unique<FeatureOracle>(entityCapsManager_, presenceOracle_);

+

+ chattables_.addJID(jid, Chattables::State::Type::Person);

+ auto state = chattables_.getState(jid);

+ state.name = name;

+ chattables_.setState(jid, state);

+ auto bareFrom = newPresence->getFrom().toBare();

+ Presence::ref accountPresence = presenceOracle_->getAccountPresence(bareFrom);

+ auto state = chattables_.getState(bareFrom);

+ state.status = accountPresence->getShow();

+ chattables_.setState(bareFrom, state);

+ * Copyright (c) 2010-2018 Isode Limited.

+ class Chattables;

+ RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter, SettingsProvider* settings, EntityCapsProvider* entityCapsProvider, ClientBlockListManager* clientBlockListManager, VCardManager* vcardManager, Chattables& chattables);

+ Chattables& chattables_;

+ * Copyright (c) 2011-2018 Isode Limited.