#include <Swiften/Base/Regex.h>

#include <Swiften/Base/String.h>

#include <SwifTools/Linkify.h>

return parsedMessage;

}

ChatWindow::ChatMessage parsedMessage = message;

std::string regexString;

/* Parse two, emoticons */

/* Construct a regexp that finds an instance of any of the emoticons inside a group

* at the start or end of the line, or beside whitespace.

*/

boost::regex emoticonRegex(regexString);

ChatWindow::ChatMessage newMessage;

std::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;

if ((textPart = std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(part))) {

try {

return parsedMessage;

}

ChatWindow::ChatMessage parsedMessage = message;

for (size_t i = 0; i < highlightRules_->getSize(); ++i) {

continue; /* do not try to highlight text, if no highlight color is specified */

}

const std::vector<boost::regex> keywordRegex = rule.getKeywordRegex(nick);

ChatWindow::ChatMessage newMessage;

std::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;

if ((textPart = std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(part))) {

try {

newMessage.append(part);

}

}

}

}

#include <Swiften/Disco/DummyEntityCapsProvider.h>

#include <Swiften/Elements/DeliveryReceipt.h>

#include <Swiften/Elements/DeliveryReceiptRequest.h>

#include <Swiften/FileTransfer/UnitTest/DummyFileTransferManager.h>

#include <Swiften/Jingle/JingleSessionManager.h>

#include <Swiften/MUC/MUCManager.h>

CPPUNIT_TEST(testChatControllerHighlightingNotificationTesting);

CPPUNIT_TEST(testChatControllerHighlightingNotificationDeduplicateSounds);

CPPUNIT_TEST(testChatControllerMeMessageHandling);

CPPUNIT_TEST_SUITE_END();

public:

mocks_ = new MockRepository();

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

stanzaChannel_ = new DummyStanzaChannel();

eventController_ = new EventController();

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

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

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

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

highlightManager_ = new HighlightManager(settings_);

handledHighlightActions_ = 0;

soundsPlayed_.clear();

highlightManager_->onHighlight.connect(boost::bind(&ChatsManagerTest::handleHighlightAction, this, _1));

void tearDown() {

delete highlightManager_;

delete profileSettings_;

delete avatarManager_;

delete manager_;

delete presenceOracle_;

delete nickResolver_;

delete mucRegistry_;

delete stanzaChannel_;

delete eventController_;

delete uiEventStream_;

delete mucManager_;

delete xmppRoster_;

std::string body("This is a legible message. >HEH@)oeueu");

message->setBody(body);

manager_->handleIncomingMessage(message);

}

void testSecondOpenWindowIncoming() {

std::string body1("This is a legible message. >HEH@)oeueu");

message1->setBody(body1);

manager_->handleIncomingMessage(message1);

JID messageJID2("testling@test.com/resource2");

std::string body2("This is a legible message. .cmaulm.chul");

message2->setBody(body2);

manager_->handleIncomingMessage(message2);

}

void testFirstOpenWindowOutgoing() {

std::string body("This is a legible message. mjuga3089gm8G(*>M)@*(");

message->setBody(body);

manager_->handleIncomingMessage(message);

}

void testSecondWindow() {

std::string messageBody1("This is a legible message.");

message1->setBody(messageBody1);

manager_->handleIncomingMessage(message1);

std::shared_ptr<Presence> jid1Online(new Presence());

jid1Online->setFrom(JID(fullJIDString1));

std::string messageBody2("This is another legible message.");

message2->setBody(messageBody2);

manager_->handleIncomingMessage(message2);

}

/**

std::string body3("This is a legible message3.");

message3->setBody(body3);

manager_->handleIncomingMessage(message3);

std::shared_ptr<Message> message2b(new Message());

message2b->setFrom(messageJID2);

std::string body2b("This is a legible message2b.");

message2b->setBody(body2b);

manager_->handleIncomingMessage(message2b);

}

/**

std::shared_ptr<Message> message = makeDeliveryReceiptTestMessage(messageJID, "1");

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT(stanzaContactOnRoster->getPayload<DeliveryReceipt>() != nullptr);

xmppRoster_->removeContact(messageJID);

message->setID("2");

manager_->handleIncomingMessage(message);

}

/**

std::shared_ptr<Message> message = makeDeliveryReceiptTestMessage(messageJID, "1");

manager_->handleIncomingMessage(message);

xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), RosterItemPayload::Both);

message->setID("2");

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT(stanzaContactOnRoster->getPayload<DeliveryReceipt>() != nullptr);

}

window->onSendMessageRequest("hello there", false);

// A bare message is send because no resources is bound.

// Two resources respond with message receipts.

foreach(const JID& senderJID, senderResource) {

receiptReply->setTo(ownJID);

std::shared_ptr<DeliveryReceipt> receipt = std::make_shared<DeliveryReceipt>();

receiptReply->addPayload(receipt);

manager_->handleIncomingMessage(receiptReply);

}

window->onSendMessageRequest("great to hear.", false);

// The chat session is bound to the full JID of the first resource.

CPPUNIT_ASSERT(stanzaChannel_->getStanzaAtIndex<Message>(2)->getPayload<DeliveryReceiptRequest>());

// Receive random receipt from second sender resource.

window->onSendMessageRequest("okay", false);

// The chat session is now bound to the full JID of the second resource.

}

void testChatControllerFullJIDBindingOnTypingAndNotActive() {

window->onSendMessageRequest("hello there", false);

// A bare message is send because no resources is bound.

// Two resources respond with message receipts.

foreach(const JID& senderJID, senderResource) {

window->onSendMessageRequest("great to hear.", false);

// The chat session is now bound to the full JID of the first resource due to its recent composing message.

// Reply with a message including a CSN from the other resource.

reply = std::make_shared<Message>();

window->onSendMessageRequest("ping.", false);

// The chat session is now bound to the full JID of the second resource due to its recent composing message.

}

void testChatControllerPMPresenceHandling() {

CPPUNIT_ASSERT_EQUAL(false, window->impromptuMUCSupported_);

std::shared_ptr<IQ> infoResponse = IQ::createResult(infoRequest->getFrom(), infoRequest->getTo(), infoRequest->getID());

DiscoInfo info;

info.addIdentity(DiscoInfo::Identity("Shakespearean Chat Service", "conference", "text"));

info.addFeature("http://jabber.org/protocol/muc");

infoResponse->addPayload(std::make_shared<DiscoInfo>(info));

CPPUNIT_ASSERT_EQUAL(true, window->impromptuMUCSupported_);

manager_->setOnline(false);

std::shared_ptr<Message> message = makeDeliveryReceiptTestMessage(messageJID, "1");

manager_->handleIncomingMessage(message);

xmppRoster_->addContact(messageJID, "foo", std::vector<std::string>(), to);

message->setID("2");

manager_->handleIncomingMessage(message);

CPPUNIT_ASSERT(stanzaContactOnRoster->getPayload<DeliveryReceipt>() != nullptr);

}

std::string body("/me is feeling delighted.");

message->setBody(body);

manager_->handleIncomingMessage(message);

}

private:

JID jid_;

ChatsManager* manager_;

DummyStanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;

EventController* eventController_;

ChatWindowFactory* chatWindowFactory_;

virtual ~MockChatWindow();

virtual std::string addMessage(const ChatMessage& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, std::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/) {

return "id";

}

virtual std::string addAction(const ChatMessage& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, std::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/) {

return "id";

}

virtual void setBookmarkState(RoomBookmarkState) {}

static std::string bodyFromMessage(const ChatMessage& message) {

std::shared_ptr<ChatTextMessagePart> text;

foreach (std::shared_ptr<ChatMessagePart> part, message.getParts()) {

if ((text = std::dynamic_pointer_cast<ChatTextMessagePart>(part))) {

}

}

}

std::string name_;

ChatMessage lastAddedPresence_;

ChatMessage lastReplacedMessage_;

ChatMessage lastAddedSystemMessage_;

return std::dynamic_pointer_cast<T>(sentStanzas[index]);

}

std::vector<Certificate::ref> getPeerCertificateChain() const {

return std::vector<Certificate::ref>();

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Elements/MUCOccupant.h>

#include <Swiften/JID/JID.h>

namespace Swift {

struct MUCItem {

MUCItem() {}

boost::optional<JID> realJID;

boost::optional<std::string> nick;

boost::optional<MUCOccupant::Affiliation> affiliation;