void replaceMessage(const std::string& message, const std::string& id, const boost::posix_time::ptime& time);

virtual void setOnline(bool online);

virtual void setEnabled(bool enabled);

/** Used for determining when something is recent.*/

boost::signal<void (const std::string& /*activity*/)> onActivity;

boost::signal<void ()> onUnreadCountChanged;

/**

* Pass the Message appended, and the stanza used to send it.

*/

virtual std::string senderDisplayNameFromMessage(const JID& from) = 0;

virtual bool isIncomingMessageFromMe(boost::shared_ptr<Message>) = 0;

virtual bool isFromContact(const JID& from);

virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(boost::shared_ptr<Message>) const = 0;

virtual void handleBareJIDCapsChanged(const JID& jid) = 0;

std::string getErrorMessage(boost::shared_ptr<ErrorPayload>);

virtual void setContactIsReceivingPresence(bool /* isReceivingPresence */) {}

enum JoinPart {Join, Part, JoinThenPart, PartThenJoin};

struct NickJoinPart {

std::string nick;

JoinPart type;

};

manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, NULL, mucRegistry_, entityCapsManager_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, NULL, wbManager_);

manager_->setAvatarManager(avatarManager_);

void tearDown() {

//delete chatListWindowFactory

muc_ = boost::make_shared<MUC>(stanzaChannel_, iqRouter_, directedPresenceSender_, mucJID_, mucRegistry_);

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_, NULL, NULL, mucRegistry_);

void tearDown() {

delete entityCapsProvider_;

class MockChatListWindow : public ChatListWindow {

public:

void addMUCBookmark(const MUCBookmark& /*bookmark*/) {}

void removeMUCBookmark(const MUCBookmark& /*bookmark*/) {}

void setBookmarksEnabled(bool /*enabled*/) {}

void setRecents(const std::list<ChatListWindow::Chat>& /*recents*/) {}

void setUnreadCount(int /*unread*/) {}

namespace Swift {

class DummySoundPlayer : public SoundPlayer {

public:

};

}

namespace Swift {

class DummySystemTray : public SystemTray {

public:

void setConnecting() {}

};

}

void applyOnItems(const RosterItemOperation& operation);

void applyOnAllItems(const RosterItemOperation& operation);

void applyOnItem(const RosterItemOperation& operation, const JID& jid);

void removeFilter(RosterFilter *filter);

GroupRosterItem* getRoot();

boost::signal<void (GroupRosterItem*)> onChildrenChanged;

boost::signal<void (GroupRosterItem*)> onGroupAdded;

boost::signal<void (RosterItem*)> onDataChanged;

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, FileTransferOverview* fileTransferOverview);

~RosterController();

void showRosterWindow();

boost::signal<void (StatusShow::Type, const std::string&)> onChangeStatusRequest;

boost::signal<void ()> onSignOutRequest;

void handleAvatarChanged(const JID& jid);

class RosterItemOperation {

public:

/**

* This is called when iterating over possible subjects, so must check it's

* applying to the right items - even if requiresLookup() is true an item

ftOverview_ = new FileTransferOverview(ftManager_);

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

mainWindow_ = mainWindowFactory_->last;

void tearDown() {

delete rosterController_;

delete uiEventStream_;

delete settings_;

delete xmppRoster_;

GroupRosterItem* groupChild(size_t i) {

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

CPPUNIT_ASSERT(item2);

CPPUNIT_ASSERT_EQUAL(presence->getStatus(), item2->getStatusText());

void testHighestPresence() {

std::vector<std::string> groups;

ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(dynamic_cast<GroupRosterItem*>(CHILDREN[0])->getChildren()[0]);

CPPUNIT_ASSERT(item);

CPPUNIT_ASSERT_EQUAL(highPresence->getStatus(), item->getStatusText());

void testNotHighestPresence() {

std::vector<std::string> groups;

ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(dynamic_cast<GroupRosterItem*>(CHILDREN[0])->getChildren()[0]);

CPPUNIT_ASSERT(item);

CPPUNIT_ASSERT_EQUAL(highPresence->getStatus(), item->getStatusText());

void testUnavailablePresence() {

std::vector<std::string> groups;

CPPUNIT_ASSERT_EQUAL(lowPresenceOffline->getStatus(), high->getStatus());

CPPUNIT_ASSERT_EQUAL(StatusShow::None, item->getStatusShow());

CPPUNIT_ASSERT_EQUAL(lowPresenceOffline->getStatus(), item->getStatusText());

void testAdd() {

std::vector<std::string> groups;

CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(CHILDREN.size()));

//CPPUNIT_ASSERT_EQUAL(std::string("Bob"), xmppRoster_->getNameForJID(JID("foo@bar.com")));

void testAddSubscription() {

std::vector<std::string> groups;

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

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(groupChild(0)->getChildren().size()));

void testReceiveRename() {

std::vector<std::string> groups;

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

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(groupChild(0)->getChildren().size()));

CPPUNIT_ASSERT_EQUAL(std::string("NewName"), groupChild(0)->getChildren()[0]->getDisplayName());

void testReceiveRegroup() {

std::vector<std::string> oldGroups;

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(groupChild(0)->getChildren().size()));

CPPUNIT_ASSERT_EQUAL(std::string("new name"), groupChild(0)->getChildren()[0]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("Best Group"), groupChild(0)->getDisplayName());

void testSendRename() {

JID jid("testling@wonderland.lit");

virtual ~DummySettingsProvider() {}

virtual std::string getSetting(const Setting<std::string>& setting) {

return stringValues.find(setting.getKey()) != stringValues.end() ? stringValues[setting.getKey()] : setting.getDefaultValue();

virtual void storeSetting(const Setting<std::string>& setting, const std::string& value) {

stringValues[setting.getKey()] = value;

onSettingChanged(setting.getKey());

virtual bool getSetting(const Setting<bool>& setting) {

return boolValues.find(setting.getKey()) != boolValues.end() ? boolValues[setting.getKey()] : setting.getDefaultValue();

virtual void storeSetting(const Setting<bool>& setting, const bool& value) {

boolValues[setting.getKey()] = value;

onSettingChanged(setting.getKey());

virtual int getSetting(const Setting<int>& setting) {

return intValues.find(setting.getKey()) != intValues.end() ? intValues[setting.getKey()] : setting.getDefaultValue();

virtual void storeSetting(const Setting<int>& setting, const int& value) {

intValues[setting.getKey()] = value;

onSettingChanged(setting.getKey());

virtual std::vector<std::string> getAvailableProfiles() {return std::vector<std::string>();}

virtual void createProfile(const std::string& ) {}

virtual void removeProfile(const std::string& ) {}

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

bottom = new DummySettingsProvider();

public:

SoundEventController(EventController* eventController, SoundPlayer* soundPlayer, SettingsProvider* settings);

void setPlaySounds(bool playSounds);

private:

void handleSettingChanged(const std::string& settingPath);

void handleEventQueueEventAdded(boost::shared_ptr<StanzaEvent> event);

namespace Swift {

class SoundPlayer {

public:

enum SoundEffect{MessageReceived};

virtual void playSound(SoundEffect sound) = 0;

};

namespace Swift {

class SystemTray {

public:

virtual void setUnreadMessages(bool some) = 0;

virtual void setStatusType(StatusShow::Type type) = 0;

virtual void setConnecting() = 0;

namespace Swift {

virtual std::string translate(const std::string& text, const std::string&) {

return text;

}

namespace Swift {

class AddContactUIEvent : public UIEvent {

public:

const std::string& getName() const {

return name_;

const JID& getJID() const {

return jid_;

const std::set<std::string>& getGroups() const {

return groups_;

namespace Swift {

class AddMUCBookmarkUIEvent : public UIEvent {

public:

const MUCBookmark& getBookmark() { return bookmark; }

private:

namespace Swift {

class EditMUCBookmarkUIEvent : public UIEvent {

public:

private:

MUCBookmark oldBookmark;

class JoinMUCUIEvent : public UIEvent {

public:

typedef boost::shared_ptr<JoinMUCUIEvent> ref;

const boost::optional<std::string>& getNick() const {return nick_;}

const JID& getJID() const {return jid_;}

bool getShouldJoinAutomatically() const {return joinAutomatically_;}

namespace Swift {

class RemoveMUCBookmarkUIEvent : public UIEvent {

public:

const MUCBookmark& getBookmark() { return bookmark; }

private:

class RemoveRosterItemUIEvent : public UIEvent {

public:

private:

JID jid_;

namespace Swift {

class RequestAdHocUIEvent : public UIEvent {

public:

const DiscoItems::Item& getCommand() const {return command_;}

private:

DiscoItems::Item command_;

class RequestAddUserDialogUIEvent : public UIEvent {

public:

private:

JID preJID_;

namespace Swift {

class RequestChatUIEvent : public UIEvent {

public:

JID getContact() {return contact_;}

private:

JID contact_;

namespace Swift {

class RequestWhiteboardUIEvent : public UIEvent {

public:

const JID& getContact() const {return contact_;}

private:

JID contact_;

namespace Swift {

class ShowWhiteboardUIEvent : public UIEvent {

public:

const JID& getContact() const {return contact_;}

private:

JID contact_;

void send(boost::shared_ptr<UIEvent> event) {

onUIEvent(event);

};

}

namespace Swift {

class AdHocCommandWindow {

public:

};

}

bool operator==(const Chat& other) const {

return jid.toBare() == other.jid.toBare()

&& isMUC == other.isMUC;

void setUnreadCount(int unread) {

unreadCount = unread;

}

enum FileTransferState {WaitingForAccept, Negotiating, Transferring, Canceled, Finished, FTFailed};

enum WhiteboardSessionState {WhiteboardAccepted, WhiteboardTerminated, WhiteboardRejected};

ChatWindow() {}

/** Add message to window.

* @return id of added message (for acks).

class UIEventStream;

class ChatWindowFactory {

public:

/**

* Transfers ownership of result.

*/

namespace Swift {

class ContactEditWindowFactory {

public:

virtual ContactEditWindow* createContactEditWindow() = 0;

};

return canDelete_;

}

virtual void addEvent(boost::shared_ptr<StanzaEvent> event, bool active) = 0;

virtual void removeEvent(boost::shared_ptr<StanzaEvent> event) = 0;

class EventWindowFactory {

public:

/**

* Transfers ownership of result.

*/

namespace Swift {

class HistoryWindow {

public:

virtual void activate() = 0;

virtual void setRosterModel(Roster*) = 0;

class UIEventStream;

class HistoryWindowFactory {

public:

virtual HistoryWindow* createHistoryWindow(UIEventStream* eventStream) = 0;

};

}

namespace Swift {

class InviteToChatWindow {

public:

virtual void setAutoCompletions(std::vector<std::pair<JID, std::string> > completions) = 0;

namespace Swift {

class JoinMUCWindow {

public:

virtual void setNick(const std::string& nick) = 0;

virtual void setMUC(const std::string& nick) = 0;

class UIEventStream;

class JoinMUCWindowFactory {

public:

virtual JoinMUCWindow* createJoinMUCWindow(UIEventStream* uiEventStream) = 0;

};

class MainWindow;

class LoginWindow {

public:

virtual void selectUser(const std::string&) = 0;

virtual void morphInto(MainWindow *mainWindow) = 0;

virtual void loggedOut() = 0;

class LoginWindowFactory {

public:

/**

* Transfers ownership of result.

class MUCSearchWindow {

public:

virtual void clearList() = 0;

virtual void addService(const MUCService& service) = 0;

class UIEventStream;

class MUCSearchWindowFactory {

public:

virtual MUCSearchWindow* createMUCSearchWindow() = 0;

};

class MainWindow {

public:

MainWindow(bool candelete = true) : canDelete_(candelete) {}

bool canDelete() const {

return canDelete_;

class MainWindowFactory {

public:

/**

* Transfers ownership of result.

*/

namespace Swift {

class ProfileWindow {

public:

virtual void setVCard(VCard::ref vcard) = 0;

namespace Swift {

class ProfileWindowFactory {

public:

virtual ProfileWindow* createProfileWindow() = 0;

};

class UIEventStream;

class UserSearchWindowFactory {

public:

virtual UserSearchWindow* createUserSearchWindow(UserSearchWindow::Type type, UIEventStream* eventStream, const std::set<std::string>& groups) = 0;

};

class WhiteboardWindowFactory {

public :

virtual WhiteboardWindow* createWhiteboardWindow(boost::shared_ptr<WhiteboardSession> whiteboardSession) = 0;

};

class UIEventStream;

class XMLConsoleWidgetFactory {

public:

virtual XMLConsoleWidget* createXMLConsoleWidget() = 0;

};

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

namespace Swift {

class MockChatWindow : public ChatWindow {

public:

virtual ~MockChatWindow();

// File transfer related stuff

virtual void setMessageReceiptState(const std::string &/* id */, ReceiptState /* state */) { }

virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() {return label_;}

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 setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&) {}

virtual InviteToChatWindow* createInviteToChatWindow() {return NULL;}

std::string name_;

class MockMainWindowFactory : public MainWindowFactory {

public:

/**

* Transfers ownership of result.

*/

MockMainWindow* last;

};

}

namespace Swift {

class ErrorEvent : public StanzaEvent {

public:

private:

JID jid_;

public:

typedef boost::shared_ptr<MessageEvent> ref;

boost::shared_ptr<Message> getStanza() {return stanza_;}

namespace Swift {

class StanzaEvent {

public:

/** Do not call this directly from outside the class.

* If you connect to this signal, you *must* disconnect from it manually. */

boost::signal<void()> onConclusion;

boost::posix_time::ptime getTime() {return time_;}

private:

bool concluded_;

namespace Swift {

class SubscriptionRequestEvent : public StanzaEvent {

public:

boost::signal<void()> onAccept;

boost::signal<void()> onDecline;

void accept() {

onAccept();

conclude();

void decline() {

onDecline();

conclude();

void defer() {

conclude();