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

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

}

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

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

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

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

};

}