void ChatControllerBase::handleCapsChanged(const JID& jid) {

if (jid.compare(toJID_, JID::WithoutResource) == 0) {

handleBareJIDCapsChanged(jid);

}

}

void ChatControllerBase::createDayChangeTimer() {

if (timerFactory_) {

boost::posix_time::ptime now = boost::posix_time::second_clock::local_time();

boost::posix_time::ptime midnight(now.date() + boost::gregorian::days(1));

long millisecondsUntilMidnight = (midnight - now).total_milliseconds();

dateChangeTimer_ = boost::shared_ptr<Timer>(timerFactory_->createTimer(millisecondsUntilMidnight));

dateChangeTimer_->onTick.connect(boost::bind(&ChatControllerBase::handleDayChangeTick, this));

dateChangeTimer_->start();

}

}

void ChatControllerBase::handleDayChangeTick() {

dateChangeTimer_->stop();

boost::posix_time::ptime now = boost::posix_time::second_clock::local_time();

chatWindow_->addSystemMessage(str(format(QT_TRANSLATE_NOOP("", "The day is now %1%")) % std::string(boost::posix_time::to_iso_extended_string(now)).substr(0,10)));

dayTicked();

createDayChangeTimer();

}

void ChatControllerBase::setEnabled(bool enabled) {

chatWindow_->setInputEnabled(enabled);

}

void ChatControllerBase::setOnline(bool online) {

setEnabled(online);

}

void ChatControllerBase::setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info) {

if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::SecurityLabelsCatalogFeature)) {

GetSecurityLabelsCatalogRequest::ref request = GetSecurityLabelsCatalogRequest::create(JID(toJID_.toBare()), iqRouter_);

request->onResponse.connect(boost::bind(&ChatControllerBase::handleSecurityLabelsCatalogResponse, this, _1, _2));

request->send();

} else {

chatWindow_->setSecurityLabelsEnabled(false);

labelsEnabled_ = false;

}

}

void ChatControllerBase::handleAllMessagesRead() {

if (!unreadMessages_.empty()) {

foreach (boost::shared_ptr<MessageEvent> messageEvent, unreadMessages_) {

messageEvent->read();

}

unreadMessages_.clear();

chatWindow_->setUnreadMessageCount(0);

onUnreadCountChanged();

}

}

int ChatControllerBase::getUnreadCount() {

return unreadMessages_.size();

}

void ChatControllerBase::handleSendMessageRequest(const std::string &body, bool isCorrectionMessage) {

if (!stanzaChannel_->isAvailable() || body.empty()) {

return;

}

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

message->setTo(toJID_);

message->setType(Swift::Message::Chat);

message->setBody(body);

if (labelsEnabled_) {

}

preSendMessageRequest(message);

if (useDelayForLatency_) {

boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();

message->addPayload(boost::shared_ptr<Delay>(new Delay(now, selfJID_)));

}

if (isCorrectionMessage) {

message->addPayload(boost::shared_ptr<Replace> (new Replace(lastSentMessageStanzaID_)));

}

message->setID(lastSentMessageStanzaID_ = idGenerator_.generateID());

stanzaChannel_->sendMessage(message);

postSendMessage(message->getBody(), boost::dynamic_pointer_cast<Stanza>(message));

onActivity(message->getBody());

}

void ChatControllerBase::handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog> catalog, ErrorPayload::ref error) {

if (!error) {

if (catalog->getItems().size() == 0) {

chatWindow_->setSecurityLabelsEnabled(false);

labelsEnabled_ = false;

} else {

labelsEnabled_ = true;

chatWindow_->setAvailableSecurityLabels(catalog->getItems());

chatWindow_->setSecurityLabelsEnabled(true);

}

} else {

labelsEnabled_ = false;

chatWindow_->setSecurityLabelsError();

}

}

void ChatControllerBase::showChatWindow() {

chatWindow_->show();

}

*/

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <boost/algorithm/string.hpp>

#include "3rdParty/hippomocks.h"

#include "Swift/Controllers/XMPPEvents/EventController.h"

#include "Swiften/Presence/DirectedPresenceSender.h"

#include "Swiften/Presence/StanzaChannelPresenceSender.h"

#include "Swiften/Avatars/NullAvatarManager.h"

#include "Swift/Controllers/Chat/MUCController.h"

#include "Swift/Controllers/UIInterfaces/ChatWindow.h"

#include "Swift/Controllers/UIInterfaces/ChatWindowFactory.h"

#include "Swiften/Client/NickResolver.h"

#include "Swiften/Roster/XMPPRoster.h"

#include "Swift/Controllers/UIEvents/UIEventStream.h"

#include "Swift/Controllers/UnitTest/MockChatWindow.h"

#include "Swiften/Client/DummyStanzaChannel.h"

#include "Swiften/Queries/DummyIQChannel.h"

#include "Swiften/Presence/PresenceOracle.h"

#include "Swiften/Network/TimerFactory.h"

#include "Swiften/Elements/MUCUserPayload.h"

#include "Swiften/Disco/DummyEntityCapsProvider.h"

using namespace Swift;

class MUCControllerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(MUCControllerTest);

CPPUNIT_TEST(testJoinPartStringContructionSimple);

CPPUNIT_TEST(testJoinPartStringContructionMixed);

CPPUNIT_TEST(testAppendToJoinParts);

CPPUNIT_TEST(testAddressedToSelf);

CPPUNIT_TEST(testNotAddressedToSelf);

CPPUNIT_TEST(testAddressedToSelfBySelf);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

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

nick_ = "aLiCe";

mocks_ = new MockRepository();

stanzaChannel_ = new DummyStanzaChannel();

iqChannel_ = new DummyIQChannel();

iqRouter_ = new IQRouter(iqChannel_);

eventController_ = new EventController();

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

presenceOracle_ = new PresenceOracle(stanzaChannel_);

presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);

directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);

uiEventStream_ = new UIEventStream();

avatarManager_ = new NullAvatarManager();

TimerFactory* timerFactory = NULL;

mucRegistry_ = new MUCRegistry();

entityCapsProvider_ = new DummyEntityCapsProvider();

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(muc_->getJID(), uiEventStream_).Return(window_);

controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_);

};

void tearDown() {

delete entityCapsProvider_;

delete controller_;

delete eventController_;

delete presenceOracle_;

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 testAddressedToSelf() {

finishJoin();

Message::ref message(new Message());

message = Message::ref(new Message());

message->setFrom(JID(muc_->getJID().toString() + "/other3"));

message->setBody("Hi bert.");

message->setType(Message::Groupchat);

controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

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

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

}

void testNotAddressedToSelf() {

finishJoin();

Message::ref message(new Message());

message->setFrom(JID(muc_->getJID().toString() + "/other3"));

message->setBody("Hi there Hatter");

message->setType(Message::Groupchat);

controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

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

}

void testAddressedToSelfBySelf() {

finishJoin();

Message::ref message(new Message());

message->setFrom(JID(muc_->getJID().toString() + "/" + nick_));

message->setBody("Hi there " + nick_);

message->setType(Message::Groupchat);

controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));

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

}

void checkEqual(const std::vector<NickJoinPart>& expected, const std::vector<NickJoinPart>& actual) {

CPPUNIT_ASSERT_EQUAL(expected.size(), actual.size());

for (size_t i = 0; i < expected.size(); i++) {

CPPUNIT_ASSERT_EQUAL(expected[i].nick, actual[i].nick);

CPPUNIT_ASSERT_EQUAL(expected[i].type, actual[i].type);

}

}

void testAppendToJoinParts() {

std::vector<NickJoinPart> list;

std::vector<NickJoinPart> gold;

MUCController::appendToJoinParts(list, NickJoinPart("Kev", Join));

gold.push_back(NickJoinPart("Kev", Join));

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Remko", Join));

gold.push_back(NickJoinPart("Remko", Join));

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Bert", Join));

gold.push_back(NickJoinPart("Bert", Join));

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Bert", Part));

gold[2].type = JoinThenPart;

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Kev", Part));

gold[0].type = JoinThenPart;

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Remko", Part));

gold[1].type = JoinThenPart;

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Part));

gold.push_back(NickJoinPart("Ernie", Part));

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Join));

gold[3].type = PartThenJoin;

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Kev", Join));

gold[0].type = Join;

checkEqual(gold, list);

MUCController::appendToJoinParts(list, NickJoinPart("Ernie", Part));

gold[3].type = Part;

checkEqual(gold, list);

}

void testJoinPartStringContructionSimple() {

std::vector<NickJoinPart> list;

list.push_back(NickJoinPart("Kev", Join));

CPPUNIT_ASSERT_EQUAL(std::string("Kev has entered the room"), MUCController::generateJoinPartString(list));

list.push_back(NickJoinPart("Remko", Part));

CPPUNIT_ASSERT_EQUAL(std::string("Kev has entered the room and Remko has left the room"), MUCController::generateJoinPartString(list));

list.push_back(NickJoinPart("Bert", Join));

CPPUNIT_ASSERT_EQUAL(std::string("Kev and Bert have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list));

list.push_back(NickJoinPart("Ernie", Join));

CPPUNIT_ASSERT_EQUAL(std::string("Kev, Bert and Ernie have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list));

}

void testJoinPartStringContructionMixed() {

std::vector<NickJoinPart> list;

list.push_back(NickJoinPart("Kev", JoinThenPart));

CPPUNIT_ASSERT_EQUAL(std::string("Kev has entered then left the room"), MUCController::generateJoinPartString(list));

list.push_back(NickJoinPart("Remko", Part));

CPPUNIT_ASSERT_EQUAL(std::string("Remko has left the room and Kev has entered then left the room"), MUCController::generateJoinPartString(list));

list.push_back(NickJoinPart("Bert", PartThenJoin));

CPPUNIT_ASSERT_EQUAL(std::string("Remko has left the room, Kev has entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list));

list.push_back(NickJoinPart("Ernie", JoinThenPart));

CPPUNIT_ASSERT_EQUAL(std::string("Remko has left the room, Kev and Ernie have entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list));

}

private:

JID self_;

MUC::ref muc_;

std::string nick_;

IQRouter* iqRouter_;

EventController* eventController_;

ChatWindowFactory* chatWindowFactory_;

MUCController* controller_;

// NickResolver* nickResolver_;

PresenceOracle* presenceOracle_;

AvatarManager* avatarManager_;

StanzaChannelPresenceSender* presenceSender_;

DirectedPresenceSender* directedPresenceSender_;

MockRepository* mocks_;

UIEventStream* uiEventStream_;

MockChatWindow* window_;

MUCRegistry* mucRegistry_;

DummyEntityCapsProvider* entityCapsProvider_;

};

CPPUNIT_TEST_SUITE_REGISTRATION(MUCControllerTest);

* Copyright (c) 2010 Kevin Smith

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include "Swift/Controllers/UIInterfaces/ChatWindow.h"

namespace Swift {

class MockChatWindow : public ChatWindow {

public:

MockChatWindow() : labelsEnabled_(false) {};

virtual ~MockChatWindow();

virtual std::string addMessage(const std::string& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime&) {lastMessageBody_ = message; return "";};

virtual std::string addAction(const std::string& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime&) {lastMessageBody_ = message; return "";};

virtual void addSystemMessage(const std::string& /*message*/) {};

virtual void addErrorMessage(const std::string& /*message*/) {};

virtual void addPresenceMessage(const std::string& /*message*/) {};

// File transfer related stuff

virtual std::string addFileTransfer(const std::string& /*senderName*/, bool /*senderIsSelf*/,const std::string& /*filename*/, const boost::uintmax_t /*sizeInBytes*/) { return 0; };

virtual void setFileTransferProgress(std::string /*id*/, const int /*alreadyTransferedBytes*/) { };

virtual void setFileTransferStatus(std::string /*id*/, const FileTransferState /*state*/, const std::string& /*msg*/) { };

virtual void setContactChatState(ChatState::ChatStateType /*state*/) {};

virtual void setName(const std::string& name) {name_ = name;};

virtual void show() {};

virtual void activate() {};

virtual void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) {labels_ = labels;};

virtual void setSecurityLabelsEnabled(bool enabled) {labelsEnabled_ = enabled;};

virtual void setUnreadMessageCount(int /*count*/) {};

virtual void convertToMUC() {};

virtual void setSecurityLabelsError() {};

virtual void setInputEnabled(bool /*enabled*/) {};

virtual void setRosterModel(Roster* /*roster*/) {};

virtual void setTabComplete(TabComplete*) {};

virtual void replaceLastMessage(const std::string&) {};

virtual void replaceMessage(const std::string&, const std::string&, const boost::posix_time::ptime&) {};

void setAckState(const std::string& /*id*/, AckState /*state*/) {};

virtual void flash() {};

virtual void setAlert(const std::string& /*alertText*/, const std::string& /*buttonText*/) {};

virtual void cancelAlert() {};

virtual void setCorrectionEnabled(Tristate /*enabled*/) {}

void setAvailableOccupantActions(const std::vector<OccupantAction>&/* actions*/) {}

void setSubject(const std::string& /*subject*/) {}

virtual void showRoomConfigurationForm(Form::ref) {}

virtual void addMUCInvitation(const JID& /*jid*/, const std::string& /*reason*/, const std::string& /*password*/) {};

std::string name_;

std::string lastMessageBody_;

std::vector<SecurityLabelsCatalog::Item> labels_;

bool labelsEnabled_;

};

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <vector>

#include <string>

#include <Swiften/Elements/Payload.h>

namespace Swift {

class SecurityLabel : public Payload {

public:

SecurityLabel() {}

const std::string& getDisplayMarking() const { return displayMarking_; }

void setDisplayMarking(const std::string& displayMarking) {

displayMarking_ = displayMarking;

}

const std::string& getForegroundColor() const {

return foregroundColor_;

}

void setForegroundColor(const std::string& foregroundColor) {

foregroundColor_ = foregroundColor;

}

const std::string& getBackgroundColor() const {

return backgroundColor_;

}

void setBackgroundColor(const std::string& backgroundColor) {

backgroundColor_ = backgroundColor;

}

const std::string& getLabel() const { return label_; }

void setLabel(const std::string& label) {

label_ = label;

}

const std::vector<std::string>& getEquivalentLabels() const { return equivalentLabels_; }

void addEquivalentLabel(const std::string& label) {

equivalentLabels_.push_back(label);

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <vector>

#include <string>

#include <boost/shared_ptr.hpp>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/Payload.h>

#include <Swiften/Elements/SecurityLabel.h>

namespace Swift {

class SecurityLabelsCatalog : public Payload {

public:

class Item {

public:

Item() : default_(false) {}

const boost::shared_ptr<SecurityLabel> getLabel() const {

return label_;

}

void setLabel(boost::shared_ptr<SecurityLabel> label) {

label_ = label;

}

const std::string& getSelector() const { return selector_; }

void setSelector(const std::string& selector) {

selector_ = selector;

}

bool getIsDefault() const { return default_; }

void setIsDefault(bool isDefault) {

default_ = isDefault;

}

private:

boost::shared_ptr<SecurityLabel> label_;

std::string selector_;

bool default_;

};

SecurityLabelsCatalog(const JID& to = JID()) : to_(to) {}

const std::vector<Item>& getItems() const {

return items_;

}

void addItem(const Item& item) {

items_.push_back(item);

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/EventLoop/EventLoop.h>

#include <algorithm>

#include <boost/bind.hpp>

#include <iostream>

#include <cassert>

#include <Swiften/Base/Log.h>

namespace Swift {

inline void invokeCallback(const Event& event) {

try {

assert(!event.callback.empty());

event.callback();

}

catch (const std::exception& e) {

std::cerr << "Uncaught exception in event loop: " << e.what() << std::endl;

}

}

EventLoop::EventLoop() : nextEventID_(0), handlingEvents_(false) {

}

EventLoop::~EventLoop() {

}

void EventLoop::handleEvent(const Event& event) {

//SWIFT_LOG(debug) << "Handling event " << event.id << std::endl;

if (handlingEvents_) {

// We're being called recursively. Push in the list of events to

// handle in the parent handleEvent()

eventsToHandle_.push_back(event);

return;

}

bool doCallback = false;

{

boost::lock_guard<boost::mutex> lock(eventsMutex_);

std::list<Event>::iterator i = std::find(events_.begin(), events_.end(), event);

if (i != events_.end()) {

doCallback = true;

events_.erase(i);

}

}

if (doCallback) {

handlingEvents_ = true;

invokeCallback(event);

// Process events that were passed to handleEvent during the callback

// (i.e. through recursive calls of handleEvent)

while (!eventsToHandle_.empty()) {

Event nextEvent = eventsToHandle_.front();