for key, value in os.environ.items() :

if key.startswith("CCC_") or key.startswith("CLANG") :

env["ENV"][key] = value

env["CC"] = os.environ["CC"]

env["CXX"] = os.environ["CXX"]

# Override the compiler with custom variables set at config time

if "cc" in env :

env["CC"] = env["cc"]

if "cxx" in env :

env["CXX"] = env["cxx"]

if "ar" in env :

env["AR"] = env["ar"]

if "link" in env :

env["SHLINK"] = env["link"]

env["LINK"] = env["link"]

# Process user-defined external flags

for flags_type in ["ccflags", "cxxflags", "linkflags"] :

if flags_type in env :

if isinstance(env[flags_type], str) :

# FIXME: Make the splitting more robust

env[flags_type.upper()] = env[flags_type].split(" ")

else :

env[flags_type.upper()] = env[flags_type]

# This isn't a real flag (yet) AFAIK. Be sure to append it to the CXXFLAGS

# where you need it

env["OBJCCFLAGS"] = []

# Compile code as C++11

if env["PLATFORM"] != "win32" :

env.Append(CXXFLAGS = ["-std=c++11"])

if env["optimize"] :

if env["PLATFORM"] == "win32" :

env.Append(CCFLAGS = ["/O2"])

else :

env.Append(CCFLAGS = ["-O2"])

if env["target"] == "xcode" and os.environ["CONFIGURATION"] == "Release" :

env.Append(CCFLAGS = ["-Os"])

if env["debug"] :

if env["PLATFORM"] == "win32" :

env.Append(CCFLAGS = ["/Zi"])

env.Append(LINKFLAGS = ["/DEBUG"])

if GetOption("num_jobs") > 1 :

env["CCPDBFLAGS"] = '/Fd${TARGET}.pdb'

env["PDB"] = '${TARGET.base}.pdb'

if env["set_iterator_debug_level"] :

env.Append(CPPDEFINES = ["_ITERATOR_DEBUG_LEVEL=0"])

env.Append(LINKFLAGS = ["/OPT:NOREF"])

env.Append(CCFLAGS = ["/MD"])

else :

env.Append(CCFLAGS = ["-g"])

elif env["PLATFORM"] == "win32" :

env.Append(CCFLAGS = ["/MD"])

if env.get("universal", 0) :

PresenceOracle* presenceOracle,

AvatarManager* avatarManager,

UIEventStream* uiEventStream,

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

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

assert(avatarManager_);

parting_ = true;

joined_ = false;

lastWasPresence_ = false;

shouldJoinOnReconnect_ = true;

doneGettingHistory_ = false;

xmppRoster_ = xmppRoster;

subject_ = "";

isInitialJoin_ = true;

chatWindowTitle_ = "";

rosterVCardProvider_ = new RosterVCardProvider(roster_.get(), vcardManager, JID::WithResource);

completer_ = new TabComplete();

chatWindow_->setRosterModel(roster_.get());

chatWindow_->setTabComplete(completer_);

chatWindow_->onClosed.connect(boost::bind(&MUCController::handleWindowClosed, this));

chatWindow_->onOccupantSelectionChanged.connect(boost::bind(&MUCController::handleWindowOccupantSelectionChanged, this, _1));

chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));

chatWindow_->onChangeSubjectRequest.connect(boost::bind(&MUCController::handleChangeSubjectRequest, this, _1));

chatWindow_->onBookmarkRequest.connect(boost::bind(&MUCController::handleBookmarkRequest, this));

chatWindow_->onConfigureRequest.connect(boost::bind(&MUCController::handleConfigureRequest, this, _1));

chatWindow_->onConfigurationFormCancelled.connect(boost::bind(&MUCController::handleConfigurationCancelled, this));

chatWindow_->onDestroyRequest.connect(boost::bind(&MUCController::handleDestroyRoomRequest, this));

chatWindow_->onInviteToChat.connect(boost::bind(&MUCController::handleInvitePersonToThisMUCRequest, this, _1));

chatWindow_->onGetAffiliationsRequest.connect(boost::bind(&MUCController::handleGetAffiliationsRequest, this));

chatWindow_->onChangeAffiliationsRequest.connect(boost::bind(&MUCController::handleChangeAffiliationsRequest, this, _1));

chatWindow_->onUnblockUserRequest.connect(boost::bind(&MUCController::handleUnblockUserRequest, this));

chatWindow_->onContinuationsBroken.connect(boost::bind(&MUCController::addChatSystemMessage, this));

muc_->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));

muc_->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));

muc_->onOccupantJoined.connect(boost::bind(&MUCController::handleOccupantJoined, this, _1));

muc_->onOccupantNicknameChanged.connect(boost::bind(&MUCController::handleOccupantNicknameChanged, this, _1, _2));

muc_->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));

muc_->onOccupantLeft.connect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));

muc_->onRoleChangeFailed.connect(boost::bind(&MUCController::handleOccupantRoleChangeFailed, this, _1, _2, _3));

muc_->onAffiliationListReceived.connect(boost::bind(&MUCController::handleAffiliationListReceived, this, _1, _2));

muc_->onConfigurationFailed.connect(boost::bind(&MUCController::handleConfigurationFailed, this, _1));

muc_->onConfigurationFormReceived.connect(boost::bind(&MUCController::handleConfigurationFormReceived, this, _1));

chatMessageParser_->setNick(nick_);

if (timerFactory && stanzaChannel_->isAvailable()) {

loginCheckTimer_ = std::shared_ptr<Timer>(timerFactory->createTimer(MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS));

CPPUNIT_TEST(testChatControllerHighlightingNotificationTesting);

CPPUNIT_TEST(testChatControllerHighlightingNotificationDeduplicateSounds);

CPPUNIT_TEST(testChatControllerHighlightingNotificationKeyword);

CPPUNIT_TEST(testChatControllerMeMessageHandling);

CPPUNIT_TEST(testRestartingMUCComponentCrash);

CPPUNIT_TEST(testChatControllerMeMessageHandlingInMUC);

// Carbons tests

CPPUNIT_TEST(testCarbonsForwardedIncomingMessageToSecondResource);

CPPUNIT_TEST(testCarbonsForwardedOutgoingMessageFromSecondResource);

CPPUNIT_TEST(testCarbonsForwardedIncomingDuplicates);

// Message correction tests

CPPUNIT_TEST(testChatControllerMessageCorrectionCorrectReplaceID);

CPPUNIT_TEST(testChatControllerMessageCorrectionIncorrectReplaceID);

CPPUNIT_TEST(testChatControllerMessageCorrectionReplaceBySameResource);

CPPUNIT_TEST(testChatControllerMessageCorrectionReplaceByOtherResource);

CPPUNIT_TEST(testMUCControllerMessageCorrectionNoIDMatchRequired);

// Chat window title tests

CPPUNIT_TEST(testImpromptuChatTitle);

CPPUNIT_TEST(testImpromptuChatWindowTitle);

CPPUNIT_TEST(testStandardMUCChatWindowTitle);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

mocks_ = new MockRepository();

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

stanzaChannel_ = new DummyStanzaChannel();

iqRouter_ = new IQRouter(stanzaChannel_);

eventController_ = new EventController();

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

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

xmppRoster_ = new XMPPRosterImpl();

mucRegistry_ = new MUCRegistry();

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

presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

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

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

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

uiEventStream_ = new UIEventStream();

entityCapsProvider_ = new DummyEntityCapsProvider();

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

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

settings_ = new DummySettingsProvider();

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

chatListWindow_ = new MockChatListWindow();

ftManager_ = new DummyFileTransferManager();

ftOverview_ = new FileTransferOverview(ftManager_);

avatarManager_ = new NullAvatarManager();

eventNotifier_ = new EventNotifier(eventController_, notifier_.get(), avatarManager_, nickResolver_);

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

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

highlightManager_ = new HighlightManager(settings_);

highlightManager_->resetToDefaultConfiguration();

handledHighlightActions_ = 0;

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swift/Controllers/Roster/Roster.h>

#include <algorithm>

#include <deque>

#include <memory>

#include <set>

#include <string>

#include <boost/bind.hpp>

#include <Swiften/JID/JID.h>

#include <Swift/Controllers/Roster/ContactRosterItem.h>

#include <Swift/Controllers/Roster/GroupRosterItem.h>

#include <Swift/Controllers/Roster/ItemOperations/RosterItemOperation.h>

#include <Swift/Controllers/Roster/RosterItem.h>

namespace Swift {

root_->onChildrenChanged.connect(boost::bind(&Roster::handleChildrenChanged, this, root_.get()));

}

Roster::~Roster() {

std::deque<RosterItem*> queue;

while (!queue.empty()) {

RosterItem* item = *queue.begin();

queue.pop_front();

GroupRosterItem* group = dynamic_cast<GroupRosterItem*>(item);

if (group) {

queue.insert(queue.begin(), group->getChildren().begin(), group->getChildren().end());

}

ContactRosterItem* contact = dynamic_cast<ContactRosterItem*>(item);

if (contact) {

contact->onVCardRequested.disconnect(boost::bind(boost::ref(onVCardUpdateRequested), contact->getJID()));

}

delete item;

}

}

GroupRosterItem* Roster::getRoot() const {

return root_.get();

}

std::set<JID> Roster::getJIDs() const {

std::set<JID> jids;

std::deque<RosterItem*> queue;

queue.push_back(root_.get());

while (!queue.empty()) {

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

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

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

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

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

namespace Swift {

/**

* The controller does not gain ownership of these parameters.

*/

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)

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

iqRouter_ = iqRouter;

subscriptionManager_ = subscriptionManager;

eventController_ = eventController;

settings_ = settings;

expandiness_ = new RosterGroupExpandinessPersister(roster_, settings);

mainWindow_->setRosterModel(roster_);

rosterVCardProvider_ = new RosterVCardProvider(roster_, vcardManager, JID::WithoutResource);

changeStatusConnection_ = mainWindow_->onChangeStatusRequest.connect(boost::bind(&RosterController::handleChangeStatusRequest, this, _1, _2));

signOutConnection_ = mainWindow_->onSignOutRequest.connect(boost::bind(boost::ref(onSignOutRequest)));

xmppRoster_->onJIDAdded.connect(boost::bind(&RosterController::handleOnJIDAdded, this, _1));

xmppRoster_->onJIDUpdated.connect(boost::bind(&RosterController::handleOnJIDUpdated, this, _1, _2, _3));

xmppRoster_->onJIDRemoved.connect(boost::bind(&RosterController::handleOnJIDRemoved, this, _1));

xmppRoster_->onRosterCleared.connect(boost::bind(&RosterController::handleRosterCleared, this));

subscriptionManager_->onPresenceSubscriptionRequest.connect(boost::bind(&RosterController::handleSubscriptionRequest, this, _1, _2));

uiEventConnection_ = uiEventStream->onUIEvent.connect(boost::bind(&RosterController::handleUIEvent, this, _1));

vcardManager_->onOwnVCardChanged.connect(boost::bind(&RosterController::handleOwnVCardChanged, this, _1));

avatarManager_->onAvatarChanged.connect(boost::bind(&RosterController::handleAvatarChanged, this, _1));

presenceOracle_->onPresenceChange.connect(boost::bind(&RosterController::handlePresenceChanged, this, _1));

mainWindow_->setMyAvatarPath(pathToString(avatarManager_->getAvatarPath(myJID_.toBare())));

nickManager_->onOwnNickChanged.connect(boost::bind(&MainWindow::setMyNick, mainWindow_, _1));

mainWindow_->setMyJID(jid);

mainWindow_->setMyNick(nickManager_->getOwnNick());

entityCapsManager_->onCapsChanged.connect(boost::bind(&RosterController::handleOnCapsChanged, this, _1));

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

handleShowOfflineToggled(settings_->getSetting(SettingConstants::SHOW_OFFLINE));

ownContact_ = std::make_shared<ContactRosterItem>(myJID_.toBare(), myJID_.toBare(), nickManager_->getOwnNick(), static_cast<GroupRosterItem*>(nullptr));

ownContact_->setVCard(vcardManager_->getVCard(myJID_.toBare()));

ownContact_->setAvatarPath(pathToString(avatarManager_->getAvatarPath(myJID_.toBare())));

mainWindow_->setMyContactRosterItem(ownContact_);

}

RosterController::~RosterController() {

settings_->onSettingChanged.disconnect(boost::bind(&RosterController::handleSettingChanged, this, _1));

nickManager_->onOwnNickChanged.disconnect(boost::bind(&MainWindow::setMyNick, mainWindow_, _1));

delete offlineFilter_;

delete expandiness_;

using namespace Swift;

class DummyCapsProvider : public CapsProvider {

DiscoInfo::ref getCaps(const std::string&) const {return DiscoInfo::ref(new DiscoInfo());}

};

class RosterControllerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(RosterControllerTest);

CPPUNIT_TEST(testAdd);

CPPUNIT_TEST(testAddSubscription);

CPPUNIT_TEST(testReceiveRename);

CPPUNIT_TEST(testReceiveRegroup);

CPPUNIT_TEST(testSendRename);

CPPUNIT_TEST(testPresence);

CPPUNIT_TEST(testHighestPresence);

CPPUNIT_TEST(testNotHighestPresence);

CPPUNIT_TEST(testUnavailablePresence);

CPPUNIT_TEST(testRemoveResultsInUnavailablePresence);

CPPUNIT_TEST(testOwnContactInRosterPresence);

CPPUNIT_TEST(testMultiResourceFileTransferFeature);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

jid_ = JID("testjid@swift.im/swift");

xmppRoster_ = new XMPPRosterImpl();

avatarManager_ = new NullAvatarManager();

mainWindowFactory_ = new MockMainWindowFactory();

mucRegistry_ = new MUCRegistry();

crypto_ = PlatformCryptoProvider::create();

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

channel_ = new DummyIQChannel();

router_ = new IQRouter(channel_);

stanzaChannel_ = new DummyStanzaChannel();

presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);

subscriptionManager_ = new SubscriptionManager(stanzaChannel_);

eventController_ = new EventController();

uiEventStream_ = new UIEventStream();

settings_ = new DummySettingsProvider();

nickManager_ = new DummyNickManager();

entityCapsManager_ = new EntityCapsManager(capsManager_.get(), stanzaChannel_);

jingleSessionManager_ = new JingleSessionManager(router_);

clientBlockListManager_ = new ClientBlockListManager(router_);

vcardStorage_ = new VCardMemoryStorage(crypto_);

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

rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, nickManager_, nickResolver_, presenceOracle_, subscriptionManager_, eventController_, uiEventStream_, router_, settings_, entityCapsManager_, clientBlockListManager_, vcardManager_);

mainWindow_ = mainWindowFactory_->last;

}

void tearDown() {

delete rosterController_;

delete vcardManager_;

delete vcardStorage_;

delete crypto_;

delete clientBlockListManager_;

delete jingleSessionManager_;

delete entityCapsManager_;

delete nickManager_;

delete nickResolver_;

delete mucRegistry_;

delete mainWindowFactory_;

delete avatarManager_;

delete router_;

delete channel_;

delete eventController_;

delete subscriptionManager_;

delete presenceOracle_;

delete stanzaChannel_;

delete uiEventStream_;

delete settings_;

delete xmppRoster_;

}

GroupRosterItem* groupChild(size_t i) {

return dynamic_cast<GroupRosterItem*>(getUIRosterChildren()[i]);

}

* All rights reserved.

* See the COPYING file for more information.

*/

#include <memory>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swift/Controllers/Roster/GroupRosterItem.h>

#include <Swift/Controllers/Roster/ItemOperations/SetPresence.h>

#include <Swift/Controllers/Roster/Roster.h>

using namespace Swift;

class RosterTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(RosterTest);

CPPUNIT_TEST(testGetGroup);

CPPUNIT_TEST(testRemoveContact);

CPPUNIT_TEST(testRemoveSecondContact);

CPPUNIT_TEST(testRemoveSecondContactSameBare);

CPPUNIT_TEST(testApplyPresenceLikeMUC);

CPPUNIT_TEST(testReSortLikeMUC);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

jid1_ = JID("a@b.c");

jid2_ = JID("b@c.d");

jid3_ = JID("c@d.e");

}

void testGetGroup() {

roster_->addContact(jid1_, JID(), "Bert", "group1", "");

roster_->addContact(jid2_, JID(), "Ernie", "group2", "");

roster_->addContact(jid3_, JID(), "Cookie", "group1", "");

CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(roster_->getRoot()->getChildren().size()));

CPPUNIT_ASSERT_EQUAL(std::string("group1"), roster_->getRoot()->getChildren()[0]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("group2"), roster_->getRoot()->getChildren()[1]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("Bert"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[0]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("Cookie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[1]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("Ernie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[1])->getChildren()[0]->getDisplayName());

}

void testRemoveContact() {

roster_->addContact(jid1_, jid1_, "Bert", "group1", "");

CPPUNIT_ASSERT_EQUAL(std::string("Bert"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[0]->getDisplayName());

roster_->removeContact(jid1_);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren().size()));

}

void testRemoveSecondContact() {

roster_->addContact(jid1_, jid1_, "Bert", "group1", "");

roster_->addContact(jid2_, jid2_, "Cookie", "group1", "");

CPPUNIT_ASSERT_EQUAL(std::string("Cookie"), static_cast<GroupRosterItem*>(roster_->getRoot()->getChildren()[0])->getChildren()[1]->getDisplayName());

roster_->removeContact(jid2_);

#include <Swift/Controllers/Roster/TableRoster.h>

std::ostream& operator<<(std::ostream& os, const Swift::TableRoster::Index& i);

std::ostream& operator<<(std::ostream& os, const Swift::TableRoster::Index& i) {

os << "(" << i.section << ", " << i.row << ")";

return os;

}

#include <memory>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <boost/variant.hpp>

#include <Swiften/Network/DummyTimerFactory.h>

#include <Swift/Controllers/Roster/Roster.h>

#include <Swift/Controllers/Roster/GroupRosterItem.h>

#include <Swift/Controllers/Roster/ItemOperations/SetPresence.h>

using namespace Swift;

class TableRosterTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(TableRosterTest);

CPPUNIT_TEST(testAddContact_EmptyRoster);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

jid1 = JID("jid1@example.com");

jid2 = JID("jid2@example.com");

}

void testAddContact_EmptyRoster() {

/*

std::shared_ptr<TableRoster> tableRoster(createTestling());

addContact(jid1, "1", "group1");

CPPUNIT_ASSERT_EQUAL(4, static_cast<int>(events.size()));

CPPUNIT_ASSERT(boost::get<BeginUpdatesEvent>(&events[0]));

CPPUNIT_ASSERT(boost::get<SectionsInsertedEvent>(&events[1]));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(boost::get<SectionsInsertedEvent>(events[1]).sections.size()));

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(boost::get<SectionsInsertedEvent>(events[1]).sections[0]));

CPPUNIT_ASSERT(boost::get<RowsInsertedEvent>(&events[2]));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(boost::get<RowsInsertedEvent>(events[2]).rows.size()));

CPPUNIT_ASSERT_EQUAL(TableRoster::Index(0, 0), boost::get<RowsInsertedEvent>(events[2]).rows[0]);

CPPUNIT_ASSERT(boost::get<EndUpdatesEvent>(&events[3]));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(tableRoster->getNumberOfSections()));

CPPUNIT_ASSERT_EQUAL(std::string("group1"), tableRoster->getSectionTitle(0));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(tableRoster->getNumberOfRowsInSection(0)));

CPPUNIT_ASSERT_EQUAL(jid1, tableRoster->getItem(TableRoster::Index(0, 0)).jid);

*/

}

private:

void addContact(const JID& jid, const std::string& name, const std::string& group) {

roster->addContact(jid, JID(), name, group, "");

dataStream >> jidString;

invites.push_back(Q2PSTRING(jidString));

}

return invites;

}

void QtChatWindow::resetDayChangeTimer() {

assert(dayChangeTimer);

// Add a second so the handled is definitly called on the next day, and not multiple times exactly at midnight.

dayChangeTimer->start(QtUtilities::secondsToNextMidnight(QDateTime::currentDateTime()) * 1000 + 1000);

}

void QtChatWindow::setAvailableOccupantActions(const std::vector<OccupantAction>& actions) {

treeWidget_->setAvailableOccupantActions(actions);

}

void QtChatWindow::setSubject(const std::string& subject) {

//subject_->setVisible(!subject.empty());

subject_->setText(P2QSTRING(subject));

subject_->setToolTip(P2QSTRING(subject));

subject_->setCursorPosition(0);

}

void QtChatWindow::handleEmojisButtonClicked() {

// Create QtEmojisSelector and QMenu

emojisGrid_ = new QtEmojisSelector(qtOnlySettings_->getQSettings(), emoticonsMap_);

auto emojisLayout = new QVBoxLayout();

emojisLayout->setContentsMargins(style()->pixelMetric(QStyle::PM_MenuHMargin),style()->pixelMetric(QStyle::PM_MenuVMargin),

style()->pixelMetric(QStyle::PM_MenuHMargin),style()->pixelMetric(QStyle::PM_MenuVMargin));

emojisLayout->addWidget(emojisGrid_);

emojisMenu_->setLayout(emojisLayout);

emojisMenu_->adjustSize();

connect(emojisGrid_, SIGNAL(emojiClicked(QString)), this, SLOT(handleEmojiClicked(QString)));

QSize menuSize = emojisMenu_->size();

emojisMenu_->exec(QPoint(QCursor::pos().x() - menuSize.width(), QCursor::pos().y() - menuSize.height()));

}

void QtChatWindow::handleEmojiClicked(QString emoji) {

if (isVisible()) {

input_->textCursor().insertText(emoji);

input_->setFocus();

// The next line also deletes the emojisGrid_, as it was added to the

// layout of the emojisMenu_.

emojisMenu_.reset();

}

}

void QtChatWindow::handleTextInputReceivedFocus() {

lastLineTracker_.setHasFocus(true);

input_->setFocus();

onAllMessagesRead();

}

void QtChatWindow::handleTextInputLostFocus() {

lastLineTracker_.setHasFocus(false);

}

void QtChatWindow::handleActionButtonClicked() {

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Crypto/PlatformCryptoProvider.h>

#include <Swiften/JID/JID.h>

#include <Swiften/MUC/MUCRegistry.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/StringCodecs/Hexify.h>

#include <Swiften/VCards/VCardManager.h>

#include <Swiften/VCards/VCardMemoryStorage.h>

using namespace Swift;

class CombinedAvatarProviderTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(CombinedAvatarProviderTest);

CPPUNIT_TEST(testGetAvatarWithNoAvatarProviderReturnsEmpty);

CPPUNIT_TEST(testGetAvatarWithSingleAvatarProvider);

CPPUNIT_TEST(testGetAvatarWithMultipleAvatarProviderReturnsFirstAvatar);

CPPUNIT_TEST(testGetAvatarWithMultipleAvatarProviderAndFailingFirstProviderReturnsSecondAvatar);

CPPUNIT_TEST(testProviderUpdateTriggersChange);

CPPUNIT_TEST(testProviderUpdateWithoutChangeDoesNotTriggerChange);

CPPUNIT_TEST(testProviderSecondUpdateTriggersChange);

CPPUNIT_TEST(testProviderUpdateWithAvatarDisappearingTriggersChange);

CPPUNIT_TEST(testProviderUpdateAfterAvatarDisappearedTriggersChange);

CPPUNIT_TEST(testProviderUpdateAfterGetDoesNotTriggerChange);

CPPUNIT_TEST(testProviderUpdateBareJIDAfterGetFullJID);

CPPUNIT_TEST(testRemoveProviderDisconnectsUpdates);

CPPUNIT_TEST(testAddRemoveFallthrough);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

user1 = JID("user1@bar.com/bla");

user2 = JID("user2@foo.com/baz");

avatarHash1 = "ABCDEFG";

avatarHash2 = "XYZU";

avatarHash3 = "IDGH";

}

void testGetAvatarWithNoAvatarProviderReturnsEmpty() {

std::shared_ptr<CombinedAvatarProvider> testling(createProvider());

boost::optional<std::string> hash = testling->getAvatarHash(user1);

CPPUNIT_ASSERT(!hash);

}

void testGetAvatarWithSingleAvatarProvider() {

std::shared_ptr<CombinedAvatarProvider> testling(createProvider());

avatarProvider1->avatars[user1] = avatarHash1;

testling->addProvider(avatarProvider1.get());

boost::optional<std::string> hash = testling->getAvatarHash(user1);

CPPUNIT_ASSERT(hash);

CPPUNIT_ASSERT_EQUAL(avatarHash1, *hash);

}

void testGetAvatarWithMultipleAvatarProviderReturnsFirstAvatar() {

std::shared_ptr<CombinedAvatarProvider> testling(createProvider());

avatarProvider1->avatars[user1] = avatarHash1;

avatarProvider2->avatars[user1] = avatarHash2;

testling->addProvider(avatarProvider1.get());

testling->addProvider(avatarProvider2.get());

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Client/ClientXMLTracer.h>

#include <iostream>

#include <boost/bind.hpp>

#include <Swiften/Base/Platform.h>

namespace Swift {

ClientXMLTracer::ClientXMLTracer(CoreClient* client, bool bosh) : bosh_(bosh) {

#ifdef SWIFTEN_PLATFORM_WIN32

#else

#endif

onDataReadConnection_ = client->onDataRead.connect(boost::bind(&ClientXMLTracer::printData, this, '<', _1));

onDataWrittenConnection_ = client->onDataWritten.connect(boost::bind(&ClientXMLTracer::printData, this, '>', _1));

}

void ClientXMLTracer::printData(char direction, const SafeByteArray& data) {

if (bosh_) {

printLine(direction);

std::string line = byteArrayToString(ByteArray(data.begin(), data.end()));

// Disabled because it swallows bits of XML (namespaces, if I recall)

// size_t endOfHTTP = line.find("\r\n\r\n");

// if (false && endOfHTTP != std::string::npos) {

// std::cerr << line.substr(0, endOfHTTP) << std::endl << beautifier->beautify(line.substr(endOfHTTP)) << std::endl;

// }

// else {

std::cerr << line << std::endl;

// }

}

else {

const auto& str = beautifier_->beautify(byteArrayToString(ByteArray(data.begin(), data.end())));

if (beautifier_->wasReset()) {

printLine(direction);

}

std::cerr << str;

if (beautifier_->getLevel() <= 1) {

std::cerr << std::endl;

}

}

/*

* Copyright (c) 2010-2017 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include "gtest/gtest.h"

#include <Swiften/Client/XMLBeautifier.h>

#include <iostream>

using namespace Swift;

namespace {

const static std::string FULL_FORMATTED_OUTPUT("<list>\n <el>aqq</el>\n <el>bzz</el>\n</list>");

}

TEST(XMLBeautifierTest, testBeautify) {

ASSERT_EQ(FULL_FORMATTED_OUTPUT, beautifier->beautify("<list><el>aqq</el><el>bzz</el></list>"));

ASSERT_TRUE(beautifier->wasReset());

ASSERT_EQ(0, beautifier->getLevel());

ASSERT_EQ(FULL_FORMATTED_OUTPUT, beautifier->beautify("<list><el>aqq</el><el>bzz</el></list>"));

ASSERT_TRUE(beautifier->wasReset());

ASSERT_EQ(0, beautifier->getLevel());

}

TEST(XMLBeautifierTest, testBeautifyMultipleChunks) {

auto result = beautifier->beautify("<list><el>aqq</el>");

ASSERT_TRUE(beautifier->wasReset());

ASSERT_EQ(1, beautifier->getLevel());

result += beautifier->beautify("<el>bzz</el></list>");

ASSERT_FALSE(beautifier->wasReset());

ASSERT_EQ(0, beautifier->getLevel());

ASSERT_EQ(FULL_FORMATTED_OUTPUT, result);

}

TEST(XMLBeautifierTest, testBeautifyMultipleChunksMiddleElement) {

auto result = beautifier->beautify("<l");

ASSERT_TRUE(beautifier->wasReset());

ASSERT_EQ(0, beautifier->getLevel());

result += beautifier->beautify("ist><el>aqq</el><el>bzz</el></list>");

ASSERT_FALSE(beautifier->wasReset());

ASSERT_EQ(0, beautifier->getLevel());

ASSERT_EQ(FULL_FORMATTED_OUTPUT, result);

}

TEST(XMLBeautifierTest, testBeautifyInvalidMultipleChunks) {

ASSERT_EQ(std::string("<list>\n <el>aqq"), beautifier->beautify("<list><el>aqq<"));

ASSERT_TRUE(beautifier->wasReset());

ASSERT_EQ(2, beautifier->getLevel());

ASSERT_EQ(FULL_FORMATTED_OUTPUT, beautifier->beautify("<list><el>aqq</el><el>bzz</el></list>"));

ASSERT_TRUE(beautifier->wasReset());

ASSERT_EQ(0, beautifier->getLevel());

}

#include <Swiften/Disco/CapsMemoryStorage.h>

#include <Swiften/Elements/CapsInfo.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Queries/IQRouter.h>

using namespace Swift;

class CapsManagerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(CapsManagerTest);

CPPUNIT_TEST(testReceiveNewHashRequestsDisco);

CPPUNIT_TEST(testReceiveSameHashDoesNotRequestDisco);

CPPUNIT_TEST(testReceiveLegacyCapsDoesNotRequestDisco);

CPPUNIT_TEST(testReceiveSameHashFromSameUserAfterFailedDiscoDoesNotRequestDisco);

CPPUNIT_TEST(testReceiveSameHashFromDifferentUserAfterFailedDiscoRequestsDisco);

CPPUNIT_TEST(testReceiveSameHashFromDifferentUserAfterIncorrectVerificationRequestsDisco);

CPPUNIT_TEST(testReceiveDifferentHashFromSameUserAfterFailedDiscoDoesNotRequestDisco);

CPPUNIT_TEST(testReceiveSameHashAfterSuccesfulDiscoDoesNotRequestDisco);

CPPUNIT_TEST(testReceiveSuccesfulDiscoStoresCaps);

CPPUNIT_TEST(testReceiveIncorrectVerificationDiscoDoesNotStoreCaps);

CPPUNIT_TEST(testReceiveFailingDiscoFallsBack);

CPPUNIT_TEST(testReceiveNoDiscoFallsBack);

CPPUNIT_TEST(testReceiveFailingFallbackDiscoFallsBack);

CPPUNIT_TEST(testReceiveSameHashFromFailingUserAfterReconnectRequestsDisco);

CPPUNIT_TEST(testReconnectResetsFallback);

CPPUNIT_TEST(testReconnectResetsRequests);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

crypto = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

user1 = JID("user1@bar.com/bla");

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

discoInfo1->addFeature("http://swift.im/feature1");

capsInfo1 = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node1.im", crypto.get()).generateCapsInfo(*discoInfo1.get()));

capsInfo1alt = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node2.im", crypto.get()).generateCapsInfo(*discoInfo1.get()));

user2 = JID("user2@foo.com/baz");

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

discoInfo2->addFeature("http://swift.im/feature2");

capsInfo2 = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node2.im", crypto.get()).generateCapsInfo(*discoInfo2.get()));

user3 = JID("user3@foo.com/baz");

legacyCapsInfo = std::make_shared<CapsInfo>("http://swift.im", "ver1", "");

}

void tearDown() {

iqRouter.reset();

}

void testReceiveNewHashRequestsDisco() {

std::shared_ptr<CapsManager> testling = createManager();

sendPresenceWithCaps(user1, capsInfo1);

CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(0, user1, IQ::Get));

std::shared_ptr<DiscoInfo> discoInfo(stanzaChannel->sentStanzas[0]->getPayload<DiscoInfo>());

CPPUNIT_ASSERT(discoInfo);

CPPUNIT_ASSERT_EQUAL("http://node1.im#" + capsInfo1->getVersion(), discoInfo->getNode());

}

void testReceiveSameHashDoesNotRequestDisco() {

std::shared_ptr<CapsManager> testling = createManager();

sendPresenceWithCaps(user1, capsInfo1);

#include <boost/bind.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Crypto/PlatformCryptoProvider.h>

#include <Swiften/Disco/CapsInfoGenerator.h>

#include <Swiften/Disco/CapsProvider.h>

#include <Swiften/Disco/EntityCapsManager.h>

#include <Swiften/Elements/CapsInfo.h>

using namespace Swift;

class EntityCapsManagerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(EntityCapsManagerTest);

CPPUNIT_TEST(testReceiveKnownHash);

CPPUNIT_TEST(testReceiveKnownHashTwiceDoesNotTriggerChange);

CPPUNIT_TEST(testReceiveUnknownHashDoesNotTriggerChange);

CPPUNIT_TEST(testReceiveUnknownHashAfterKnownHashTriggersChangeAndClearsCaps);

CPPUNIT_TEST(testReceiveUnavailablePresenceAfterKnownHashTriggersChangeAndClearsCaps);

CPPUNIT_TEST(testReconnectTriggersChangeAndClearsCaps);

CPPUNIT_TEST(testHashAvailable);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

crypto = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

user1 = JID("user1@bar.com/bla");

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

discoInfo1->addFeature("http://swift.im/feature1");

capsInfo1 = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node1.im", crypto.get()).generateCapsInfo(*discoInfo1.get()));

capsInfo1alt = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node2.im", crypto.get()).generateCapsInfo(*discoInfo1.get()));

user2 = JID("user2@foo.com/baz");

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

discoInfo2->addFeature("http://swift.im/feature2");

capsInfo2 = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node2.im", crypto.get()).generateCapsInfo(*discoInfo2.get()));

user3 = JID("user3@foo.com/baz");

legacyCapsInfo = std::make_shared<CapsInfo>("http://swift.im", "ver1", "");

}

void testReceiveKnownHash() {

std::shared_ptr<EntityCapsManager> testling = createManager();

capsProvider->caps[capsInfo1->getVersion()] = discoInfo1;

sendPresenceWithCaps(user1, capsInfo1);

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

CPPUNIT_ASSERT_EQUAL(user1, changes[0]);

CPPUNIT_ASSERT_EQUAL(discoInfo1, testling->getCaps(user1));

}

void testReceiveKnownHashTwiceDoesNotTriggerChange() {

std::shared_ptr<EntityCapsManager> testling = createManager();

capsProvider->caps[capsInfo1->getVersion()] = discoInfo1;

sendPresenceWithCaps(user1, capsInfo1);

changes.clear();

#include <Swiften/EventLoop/DummyEventLoop.h>

#include <Swiften/FileTransfer/ByteArrayReadBytestream.h>

#include <Swiften/FileTransfer/ByteArrayWriteBytestream.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Network/DummyConnection.h>

#include <Swiften/Network/DummyTimerFactory.h>

#include <Swiften/StringCodecs/Hexify.h>

using namespace Swift;

static boost::mt19937 randomGen;

class SOCKS5BytestreamClientSessionTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(SOCKS5BytestreamClientSessionTest);

CPPUNIT_TEST(testForSessionReady);

CPPUNIT_TEST(testErrorHandlingHello);

CPPUNIT_TEST(testErrorHandlingRequest);

CPPUNIT_TEST(testWriteBytestream);

CPPUNIT_TEST(testReadBytestream);

CPPUNIT_TEST_SUITE_END();

public:

SOCKS5BytestreamClientSessionTest() : destinationAddressPort(HostAddressPort(HostAddress::fromString("127.0.0.1").get(), 8888)) {}

void setUp() {

crypto = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

destination = "092a44d859d19c9eed676b551ee80025903351c2";

randomGen.seed(static_cast<unsigned int>(time(nullptr)));

connection = std::make_shared<MockeryConnection>(failingPorts, true, eventLoop.get());

//connection->onDataSent.connect(boost::bind(&SOCKS5BytestreamServerSessionTest::handleDataWritten, this, _1));

//stream1 = std::make_shared<ByteArrayReadBytestream>(createByteArray("abcdefg")));

// connection->onDataRead.connect(boost::bind(&SOCKS5BytestreamClientSessionTest::handleDataRead, this, _1));

}

void tearDown() {

//connection.reset();

}

void testForSessionReady() {

TestHelper helper;

connection->onDataSent.connect(boost::bind(&TestHelper::handleConnectionDataWritten, &helper, _1));

SOCKS5BytestreamClientSession::ref clientSession = std::make_shared<SOCKS5BytestreamClientSession>(connection, destinationAddressPort, destination, timerFactory.get());

clientSession->onSessionReady.connect(boost::bind(&TestHelper::handleSessionReady, &helper, _1));

clientSession->start();

eventLoop->processEvents();

CPPUNIT_ASSERT(createByteArray("\x05\x01\x00", 3) == helper.unprocessedInput);

helper.unprocessedInput.clear();

serverRespondHelloOK();

eventLoop->processEvents();

CPPUNIT_ASSERT_EQUAL(createByteArray("\x05\x01\x00\x03", 4), createByteArray(&helper.unprocessedInput[0], 4));

CPPUNIT_ASSERT_EQUAL(createByteArray(static_cast<char>(destination.size())), createByteArray(static_cast<char>(helper.unprocessedInput[4])));

CPPUNIT_ASSERT_EQUAL(createByteArray(destination), createByteArray(&helper.unprocessedInput[5], destination.size()));

CPPUNIT_ASSERT_EQUAL(createByteArray("\x00", 1), createByteArray(&helper.unprocessedInput[5 + destination.size()], 1));

helper.unprocessedInput.clear();

/*

* Copyright (c) 2010 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Parser/PlatformXMLParserFactory.h>

#include <cassert>

#ifdef HAVE_LIBXML

#include <Swiften/Parser/LibXMLParser.h>

#else

#include <Swiften/Parser/ExpatParser.h>

#endif

namespace Swift {

PlatformXMLParserFactory::PlatformXMLParserFactory() {

}

std::unique_ptr<XMLParser> PlatformXMLParserFactory::createXMLParser(XMLParserClient* client) {

#ifdef HAVE_LIBXML

#else

#endif

}

}

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <memory>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Presence/DirectedPresenceSender.h>

#include <Swiften/Presence/StanzaChannelPresenceSender.h>

using namespace Swift;

class DirectedPresenceSenderTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(DirectedPresenceSenderTest);

CPPUNIT_TEST(testSendPresence);

CPPUNIT_TEST(testSendPresence_UndirectedPresenceWithDirectedPresenceReceivers);

CPPUNIT_TEST(testSendPresence_DirectedPresenceWithDirectedPresenceReceivers);

CPPUNIT_TEST(testAddDirectedPresenceReceiver);

CPPUNIT_TEST(testAddDirectedPresenceReceiver_WithoutSendingPresence);

CPPUNIT_TEST(testAddDirectedPresenceReceiver_AfterSendingDirectedPresence);

CPPUNIT_TEST(testRemoveDirectedPresenceReceiver);

CPPUNIT_TEST(testRemoveDirectedPresenceReceiver_WithoutSendingPresence);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

testPresence = std::make_shared<Presence>();

testPresence->setStatus("Foo");

secondTestPresence = std::make_shared<Presence>();

secondTestPresence->setStatus("Bar");

}

void testSendPresence() {

std::shared_ptr<DirectedPresenceSender> testling(createPresenceSender());

testling->sendPresence(testPresence);

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel->sentStanzas.size()));

std::shared_ptr<Presence> presence = std::dynamic_pointer_cast<Presence>(channel->sentStanzas[0]);

CPPUNIT_ASSERT(testPresence == presence);

}

void testSendPresence_UndirectedPresenceWithDirectedPresenceReceivers() {

std::shared_ptr<DirectedPresenceSender> testling(createPresenceSender());

testling->addDirectedPresenceReceiver(JID("alice@wonderland.lit/teaparty"), DirectedPresenceSender::AndSendPresence);

testling->sendPresence(testPresence);

CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(channel->sentStanzas.size()));

std::shared_ptr<Presence> presence = std::dynamic_pointer_cast<Presence>(channel->sentStanzas[0]);

CPPUNIT_ASSERT(testPresence == presence);

presence = std::dynamic_pointer_cast<Presence>(channel->sentStanzas[1]);

CPPUNIT_ASSERT_EQUAL(testPresence->getStatus(), presence->getStatus());

CPPUNIT_ASSERT_EQUAL(JID("alice@wonderland.lit/teaparty"), presence->getTo());

}

void testSendPresence_DirectedPresenceWithDirectedPresenceReceivers() {

std::shared_ptr<DirectedPresenceSender> testling(createPresenceSender());

testling->addDirectedPresenceReceiver(JID("alice@wonderland.lit/teaparty"), DirectedPresenceSender::AndSendPresence);

channel->sentStanzas.clear();

#include <memory>

#include <boost/bind.hpp>

#include <QA/Checker/IO.h>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/TLS/CertificateFactory.h>

#include <SwifTools/Application/PlatformApplicationPathProvider.h>

using namespace Swift;

template<typename CERTIFICATE_FACTORY>

class CertificateTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(CertificateTest);

CPPUNIT_TEST(testConstructFromDER);

CPPUNIT_TEST(testToDER);

//CPPUNIT_TEST(testGetSubjectName);

CPPUNIT_TEST(testGetCommonNames);

CPPUNIT_TEST(testGetSRVNames);

CPPUNIT_TEST(testGetDNSNames);

CPPUNIT_TEST(testGetXMPPAddresses);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

readByteArrayFromFile(certificateData, (pathProvider->getExecutableDir() / "jabber_org.crt"));

certificateFactory = std::unique_ptr<CertificateFactory>(new CERTIFICATE_FACTORY());

}

void testConstructFromDER() {

Certificate::ref testling = Certificate::ref(certificateFactory->createCertificateFromDER(certificateData));

CPPUNIT_ASSERT_EQUAL(std::string("*.jabber.org"), testling->getCommonNames()[0]);

}

void testToDER() {

Certificate::ref testling = Certificate::ref(certificateFactory->createCertificateFromDER(certificateData));

CPPUNIT_ASSERT_EQUAL(certificateData, testling->toDER());

}

/*

void testGetSubjectName() {

Certificate::ref testling = Certificate::ref(certificateFactory->createCertificateFromDER(certificateData);

CPPUNIT_ASSERT_EQUAL(std::string("/description=114072-VMk8pdi1aj5kTXxO/C=US/ST=Colorado/L=Denver/O=Peter Saint-Andre/OU=StartCom Trusted Certificate Member/CN=*.jabber.org/emailAddress=hostmaster@jabber.org"), testling->getSubjectName());

}

*/

void testGetCommonNames() {

Certificate::ref testling = Certificate::ref(certificateFactory->createCertificateFromDER(certificateData));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(testling->getCommonNames().size()));

CPPUNIT_ASSERT_EQUAL(std::string("*.jabber.org"), testling->getCommonNames()[0]);

}

#include <memory>

#include <boost/bind.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Elements/Payload.h>

#include <Swiften/Queries/DummyIQChannel.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Queries/Requests/GetPrivateStorageRequest.h>

using namespace Swift;

class GetPrivateStorageRequestTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(GetPrivateStorageRequestTest);

CPPUNIT_TEST(testSend);

CPPUNIT_TEST(testHandleResponse);

CPPUNIT_TEST(testHandleResponse_Error);

CPPUNIT_TEST_SUITE_END();

public:

class MyPayload : public Payload {

public:

MyPayload(const std::string& text = "") : text(text) {}

std::string text;

};

public:

void setUp() {

}

void tearDown() {

router.reset();

}

void testSend() {

GetPrivateStorageRequest<MyPayload>::ref request = GetPrivateStorageRequest<MyPayload>::create(router.get());

request->send();

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel->iqs_.size()));

CPPUNIT_ASSERT_EQUAL(JID(), channel->iqs_[0]->getTo());

CPPUNIT_ASSERT_EQUAL(IQ::Get, channel->iqs_[0]->getType());

std::shared_ptr<PrivateStorage> storage = channel->iqs_[0]->getPayload<PrivateStorage>();

CPPUNIT_ASSERT(storage);

std::shared_ptr<MyPayload> payload = std::dynamic_pointer_cast<MyPayload>(storage->getPayload());

CPPUNIT_ASSERT(payload);

}

void testHandleResponse() {

GetPrivateStorageRequest<MyPayload>::ref testling = GetPrivateStorageRequest<MyPayload>::create(router.get());

testling->onResponse.connect(boost::bind(&GetPrivateStorageRequestTest::handleResponse, this, _1, _2));

testling->send();

channel->onIQReceived(createResponse("test-id", "foo"));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(responses.size()));

CPPUNIT_ASSERT_EQUAL(std::string("foo"), std::dynamic_pointer_cast<MyPayload>(responses[0])->text);

}

void testHandleResponse_Error() {

*/

#include <memory>

#include <boost/bind.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Elements/SoftwareVersion.h>

#include <Swiften/Queries/DummyIQChannel.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Queries/Responder.h>

using namespace Swift;

class ResponderTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(ResponderTest);

CPPUNIT_TEST(testConstructor);

CPPUNIT_TEST(testStart);

CPPUNIT_TEST(testStop);

CPPUNIT_TEST(testHandleIQ_Set);

CPPUNIT_TEST(testHandleIQ_Get);

CPPUNIT_TEST(testHandleIQ_Error);

CPPUNIT_TEST(testHandleIQ_Result);

CPPUNIT_TEST(testHandleIQ_NoPayload);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

payload_ = std::make_shared<SoftwareVersion>("foo");

}

void tearDown() {

router_.reset();

}

void testConstructor() {

MyResponder testling(router_.get());

channel_->onIQReceived(createRequest(IQ::Set));

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(testling.setPayloads_.size()));

}

void testStart() {

MyResponder testling(router_.get());

testling.start();

channel_->onIQReceived(createRequest(IQ::Set));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(testling.setPayloads_.size()));

}

void testStop() {

MyResponder testling(router_.get());

testling.start();

testling.stop();

channel_->onIQReceived(createRequest(IQ::Set));

* All rights reserved.

* See the COPYING file for more information.

*/

#include <memory>

#include <boost/bind.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Roster/UnitTest/XMPPRosterSignalHandler.h>

#include <Swiften/Roster/XMPPRosterImpl.h>

using namespace Swift;

class XMPPRosterImplTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(XMPPRosterImplTest);

CPPUNIT_TEST(testJIDAdded);

CPPUNIT_TEST(testJIDRemoved);

CPPUNIT_TEST(testJIDUpdated);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

jid1_ = JID("a@b.c");

jid2_ = JID("b@c.d");

jid3_ = JID("c@d.e");

groups1_.push_back("bobs");

groups1_.push_back("berts");

groups2_.push_back("ernies");

}

void testJIDAdded() {

roster_->addContact(jid1_, "NewName", groups1_, RosterItemPayload::Both);

CPPUNIT_ASSERT_EQUAL(Add, handler_->getLastEvent());

CPPUNIT_ASSERT_EQUAL(jid1_, handler_->getLastJID());

CPPUNIT_ASSERT_EQUAL(std::string("NewName"), roster_->getNameForJID(jid1_));

CPPUNIT_ASSERT(groups1_ == roster_->getGroupsForJID(jid1_));

handler_->reset();

roster_->addContact(jid2_, "NameTwo", groups1_, RosterItemPayload::Both);

CPPUNIT_ASSERT_EQUAL(Add, handler_->getLastEvent());

CPPUNIT_ASSERT_EQUAL(jid2_, handler_->getLastJID());

CPPUNIT_ASSERT_EQUAL(std::string("NameTwo"), roster_->getNameForJID(jid2_));

CPPUNIT_ASSERT_EQUAL(std::string("NewName"), roster_->getNameForJID(jid1_));

CPPUNIT_ASSERT(groups1_ == roster_->getGroupsForJID(jid2_));

CPPUNIT_ASSERT(groups1_ == roster_->getGroupsForJID(jid1_));

handler_->reset();

roster_->addContact(jid3_, "NewName", groups2_, RosterItemPayload::Both);

CPPUNIT_ASSERT_EQUAL(Add, handler_->getLastEvent());

CPPUNIT_ASSERT_EQUAL(jid3_, handler_->getLastJID());

CPPUNIT_ASSERT_EQUAL(std::string("NewName"), roster_->getNameForJID(jid3_));

CPPUNIT_ASSERT(groups2_ == roster_->getGroupsForJID(jid3_));

}

void testJIDRemoved() {

roster_->addContact(jid1_, "NewName", groups1_, RosterItemPayload::Both);

handler_->reset();