7 files changed, 537 insertions, 50 deletions
diff --git a/Swift/Controllers/UnitTest/ChatMessageSummarizerTest.cpp b/Swift/Controllers/UnitTest/ChatMessageSummarizerTest.cpp
index ee0ee9f..dd2a8e5 100644
--- a/Swift/Controllers/UnitTest/ChatMessageSummarizerTest.cpp
+++ b/Swift/Controllers/UnitTest/ChatMessageSummarizerTest.cpp
@@ -27,5 +27,5 @@ class ChatMessageSummarizerTest : public CppUnit::TestFixture {
 
 public:
-	ChatMessageSummarizerTest() {};
+	ChatMessageSummarizerTest() {}
 
 	void setUp() {
@@ -73,5 +73,5 @@ public:
 		unreads.push_back(UnreadPair("Betty", 7));
 		ChatMessageSummarizer summary;
-		CPPUNIT_ASSERT_EQUAL(string("Bob (3), Betty (7)"), summary.getSummary(current, unreads));
+		CPPUNIT_ASSERT_EQUAL(string("Bob (3); Betty (7)"), summary.getSummary(current, unreads));
 	}
 
@@ -83,5 +83,5 @@ public:
 		unreads.push_back(UnreadPair("Betty", 7));
 		ChatMessageSummarizer summary;
-		CPPUNIT_ASSERT_EQUAL(string("Bob, Betty (7)"), summary.getSummary(current, unreads));
+		CPPUNIT_ASSERT_EQUAL(string("Bob; Betty (7)"), summary.getSummary(current, unreads));
 	}
 
diff --git a/Swift/Controllers/UnitTest/ContactSuggesterTest.cpp b/Swift/Controllers/UnitTest/ContactSuggesterTest.cpp
new file mode 100644
index 0000000..222491b
--- /dev/null
+++ b/Swift/Controllers/UnitTest/ContactSuggesterTest.cpp
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2014 Kevin Smith
+ * Licensed under the GNU General Public License v3.
+ * See Documentation/Licenses/GPLv3.txt for more information.
+ */
+
+#include <cppunit/extensions/HelperMacros.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+
+#include <Swiften/Base/foreach.h>
+#include "Swift/Controllers/ContactSuggester.h"
+
+using namespace Swift;
+
+class ContactSuggesterTest : public CppUnit::TestFixture {
+	CPPUNIT_TEST_SUITE(ContactSuggesterTest);
+	CPPUNIT_TEST(equalityTest);
+	CPPUNIT_TEST(lexicographicalSortTest);
+	CPPUNIT_TEST(sortTest);
+	CPPUNIT_TEST_SUITE_END();
+
+public:
+
+	std::vector<std::string> wordList() {
+		const std::string words[] = {
+			"abc",
+			"ab",
+			"bc",
+			"d"
+		};
+
+		return std::vector<std::string>(words, words+sizeof(words)/sizeof(*words));
+	}
+
+	std::vector<StatusShow::Type> statusList() {
+		StatusShow::Type types[] = {
+			StatusShow::Online,
+			StatusShow::Away,
+			StatusShow::FFC,
+			StatusShow::XA,
+			StatusShow::DND,
+			StatusShow::None
+		};
+
+		return std::vector<StatusShow::Type>(types, types+sizeof(types)/sizeof(*types));
+	}
+
+	std::vector<Contact::ref> contactList() {
+		std::vector<Contact::ref> contacts;
+		std::vector<std::string> words = wordList();
+		std::vector<StatusShow::Type> statuses = statusList();
+		foreach (const std::string& name, words) {
+			foreach (const std::string& jid, words) {
+				foreach (const StatusShow::Type& status, statuses) {
+					contacts.push_back(boost::make_shared<Contact>(name, jid, status, ""));
+				}
+			}
+		}
+		return contacts;
+	}
+
+	/* a = a */
+	bool isReflexive(const boost::function<bool (const Contact::ref&, const Contact::ref&)>& comparitor) {
+		std::vector<Contact::ref> contacts = contactList();
+		foreach (const Contact::ref& a, contacts) {
+			if (!comparitor(a, a)) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/* a = b -> b = a */
+	bool isSymmetric(const boost::function<bool (const Contact::ref&, const Contact::ref&)>& comparitor) {
+		std::vector<Contact::ref> contacts = contactList();
+		foreach (const Contact::ref& a, contacts) {
+			foreach (const Contact::ref& b, contacts) {
+				if (comparitor(a, b)) {
+					if (!comparitor(b, a)) {
+						return false;
+					}
+				}
+			}
+		}
+		return true;
+	}
+
+	/* a = b && b = c -> a = c */
+	bool isTransitive(const boost::function<bool (const Contact::ref&, const Contact::ref&)>& comparitor) {
+		std::vector<Contact::ref> contacts = contactList();
+		foreach (const Contact::ref& a, contacts) {
+			foreach (const Contact::ref& b, contacts) {
+				foreach (const Contact::ref& c, contacts) {
+					if (comparitor(a, b) && comparitor(b, c)) {
+						if (!comparitor(a, c)) {
+							return false;
+						}
+					}
+				}
+			}
+		}
+		return true;
+	}
+
+	void equalityTest() {
+		CPPUNIT_ASSERT(isReflexive(Contact::equalityPredicate));
+		CPPUNIT_ASSERT(isSymmetric(Contact::equalityPredicate));
+		CPPUNIT_ASSERT(isTransitive(Contact::equalityPredicate));
+	}
+
+	void lexicographicalSortTest() {
+		CPPUNIT_ASSERT(isTransitive(Contact::lexicographicalSortPredicate));
+	}
+
+	void sortTest() {
+		std::vector<std::string> words = wordList();
+		foreach (const std::string& word, words) {
+			CPPUNIT_ASSERT(isTransitive(boost::bind(Contact::sortPredicate, _1, _2, word)));
+		}
+	}
+
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ContactSuggesterTest);
diff --git a/Swift/Controllers/UnitTest/HighlightRuleTest.cpp b/Swift/Controllers/UnitTest/HighlightRuleTest.cpp
new file mode 100644
index 0000000..c988b8d
--- /dev/null
+++ b/Swift/Controllers/UnitTest/HighlightRuleTest.cpp
@@ -0,0 +1,324 @@
+/*
+ * Copyright (c) 2012 Maciej Niedzielski
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+/*
+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon
+ * Licensed under the GNU General Public License v3.
+ * See Documentation/Licenses/GPLv3.txt for more information.
+ */
+
+#include <vector>
+#include <string>
+
+#include <cppunit/extensions/HelperMacros.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+
+#include <Swift/Controllers/HighlightRule.h>
+
+using namespace Swift;
+
+class HighlightRuleTest : public CppUnit::TestFixture {
+		CPPUNIT_TEST_SUITE(HighlightRuleTest);
+		CPPUNIT_TEST(testEmptyRuleNeverMatches);
+		CPPUNIT_TEST(testKeyword);
+		CPPUNIT_TEST(testNickKeyword);
+		CPPUNIT_TEST(testNickWithoutOtherKeywords);
+		CPPUNIT_TEST(testSender);
+		CPPUNIT_TEST(testSenderAndKeyword);
+		CPPUNIT_TEST(testWholeWords);
+		CPPUNIT_TEST(testCase);
+		CPPUNIT_TEST(testWholeWordsAndCase);
+		CPPUNIT_TEST(testMUC);
+		CPPUNIT_TEST_SUITE_END();
+
+	public:
+		void setUp() {
+			std::vector<std::string> keywords;
+			keywords.push_back("keyword1");
+			keywords.push_back("KEYWORD2");
+
+			std::vector<std::string> senders;
+			senders.push_back("sender1");
+			senders.push_back("SENDER2");
+
+			emptyRule = new HighlightRule();
+
+			keywordRule = new HighlightRule();
+			keywordRule->setKeywords(keywords);
+
+			keywordChatRule = new HighlightRule();
+			keywordChatRule->setKeywords(keywords);
+			keywordChatRule->setMatchChat(true);
+
+			keywordNickChatRule = new HighlightRule();
+			keywordNickChatRule->setKeywords(keywords);
+			keywordNickChatRule->setNickIsKeyword(true);
+			keywordNickChatRule->setMatchChat(true);
+
+			nickChatRule = new HighlightRule();
+			nickChatRule->setNickIsKeyword(true);
+			nickChatRule->setMatchChat(true);
+
+			nickRule = new HighlightRule();
+			nickRule->setNickIsKeyword(true);
+
+			senderRule = new HighlightRule();
+			senderRule->setSenders(senders);
+
+			senderChatRule = new HighlightRule();
+			senderChatRule->setSenders(senders);
+			senderChatRule->setMatchChat(true);
+
+			senderKeywordChatRule = new HighlightRule();
+			senderKeywordChatRule->setSenders(senders);
+			senderKeywordChatRule->setKeywords(keywords);
+			senderKeywordChatRule->setMatchChat(true);
+
+			senderKeywordNickChatRule = new HighlightRule();
+			senderKeywordNickChatRule->setSenders(senders);
+			senderKeywordNickChatRule->setKeywords(keywords);
+			senderKeywordNickChatRule->setNickIsKeyword(true);
+			senderKeywordNickChatRule->setMatchChat(true);
+
+			senderKeywordNickWordChatRule = new HighlightRule();
+			senderKeywordNickWordChatRule->setSenders(senders);
+			senderKeywordNickWordChatRule->setKeywords(keywords);
+			senderKeywordNickWordChatRule->setNickIsKeyword(true);
+			senderKeywordNickWordChatRule->setMatchWholeWords(true);
+			senderKeywordNickWordChatRule->setMatchChat(true);
+
+			senderKeywordNickCaseChatRule = new HighlightRule();
+			senderKeywordNickCaseChatRule->setSenders(senders);
+			senderKeywordNickCaseChatRule->setKeywords(keywords);
+			senderKeywordNickCaseChatRule->setNickIsKeyword(true);
+			senderKeywordNickCaseChatRule->setMatchCase(true);
+			senderKeywordNickCaseChatRule->setMatchChat(true);
+
+			senderKeywordNickCaseWordChatRule = new HighlightRule();
+			senderKeywordNickCaseWordChatRule->setSenders(senders);
+			senderKeywordNickCaseWordChatRule->setKeywords(keywords);
+			senderKeywordNickCaseWordChatRule->setNickIsKeyword(true);
+			senderKeywordNickCaseWordChatRule->setMatchCase(true);
+			senderKeywordNickCaseWordChatRule->setMatchWholeWords(true);
+			senderKeywordNickCaseWordChatRule->setMatchChat(true);
+
+			senderKeywordNickMUCRule = new HighlightRule();
+			senderKeywordNickMUCRule->setSenders(senders);
+			senderKeywordNickMUCRule->setKeywords(keywords);
+			senderKeywordNickMUCRule->setNickIsKeyword(true);
+			senderKeywordNickMUCRule->setMatchMUC(true);
+		}
+
+		void tearDown() {
+			delete emptyRule;
+
+			delete keywordRule;
+			delete keywordChatRule;
+			delete keywordNickChatRule;
+			delete nickChatRule;
+			delete nickRule;
+
+			delete senderRule;
+			delete senderChatRule;
+			delete senderKeywordChatRule;
+			delete senderKeywordNickChatRule;
+
+			delete senderKeywordNickWordChatRule;
+			delete senderKeywordNickCaseChatRule;
+			delete senderKeywordNickCaseWordChatRule;
+
+			delete senderKeywordNickMUCRule;
+		}
+
+		void testEmptyRuleNeverMatches() {
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "from", "nick", HighlightRule::MUCMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "from", "", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "from", "", HighlightRule::MUCMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "", "nick", HighlightRule::MUCMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "from", "nick", HighlightRule::MUCMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "", "", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "", "", HighlightRule::MUCMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "from", "", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "from", "", HighlightRule::MUCMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "", "nick", HighlightRule::MUCMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "", "", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "", "", HighlightRule::MUCMessage), false);
+		}
+
+		void testKeyword() {
+			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("body", "from", "nick", HighlightRule::MUCMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("keyword1", "from", "nick", HighlightRule::MUCMessage), false);
+			CPPUNIT_ASSERT_EQUAL(keywordRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("body", "sender contains keyword1", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("abc keyword1 xyz", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("abckeyword1xyz", "from", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("KEYword1", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("abc KEYword1 xyz", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("abcKEYword1xyz", "from", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("keyword2", "from", "nick", HighlightRule::ChatMessage), false);
+		}
+
+		void testNickKeyword() {
+			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::ChatMessage), true);
+			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::MUCMessage), false);
+			CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body", "sender contains nick", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body contains mixed-case NiCk", "sender", "nick", HighlightRule::ChatMessage), true);
+
+			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("nickname", "from", "nick", HighlightRule::ChatMessage), true);
+			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("NIckNAME", "from", "nick", HighlightRule::ChatMessage), true);
+
+			CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body", "from", "", HighlightRule::ChatMessage), false);
+		}
+
+		void testNickWithoutOtherKeywords() {
+			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::ChatMessage), true);
+			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::MUCMessage), false);
+			CPPUNIT_ASSERT_EQUAL(nickRule->isMatch("body contains nick", "from", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body", "sender contains nick but it does't matter", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body contains mixed-case NiCk", "from", "nick", HighlightRule::ChatMessage), true);
+
+			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("nickname", "from", "nick", HighlightRule::ChatMessage), true);
+			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("NIckNAME", "from", "nick", HighlightRule::ChatMessage), true);
+
+			// there are no keywords in this rule and empty nick is not treated as a keyword, so we don't check for keywords to get a match
+			CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body", "from", "", HighlightRule::ChatMessage), true);
+		}
+
+		void testSender() {
+			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "from", "nick", HighlightRule::MUCMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "sender1", "nick", HighlightRule::ChatMessage), true);
+			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "sender1", "nick", HighlightRule::MUCMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderRule->isMatch("body", "sender1", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(senderRule->isMatch("body contains sender1", "from", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "abc sender1 xyz", "nick", HighlightRule::ChatMessage), true);
+			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "abcsender1xyz", "nick", HighlightRule::ChatMessage), true);
+
+			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "SENDer1", "nick", HighlightRule::ChatMessage), true);
+			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "abc SENDer1 xyz", "nick", HighlightRule::ChatMessage), true);
+			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "abcSENDer1xyz", "nick", HighlightRule::ChatMessage), true);
+
+			CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "sender2", "nick", HighlightRule::ChatMessage), true);
+		}
+
+		void testSenderAndKeyword() {
+			CPPUNIT_ASSERT_EQUAL(senderKeywordChatRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordChatRule->isMatch("body", "sender1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordChatRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), false);
+		}
+
+		void testWholeWords() {
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("body", "sender1", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("xkeyword1", "sender1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("keyword1", "xsender1", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("body contains nick", "sender1", "nick", HighlightRule::ChatMessage), true);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("body contains xnick", "sender1", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("KEYword1", "SENDer1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("body contains NiCk", "sender1", "nick", HighlightRule::ChatMessage), true);
+		}
+
+		void testCase() {
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("body", "sender1", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("xkeyword1", "xsender1", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("body contains nick", "sender1", "nick", HighlightRule::ChatMessage), true);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("body contains xnick", "sender1", "nick", HighlightRule::ChatMessage), true);
+
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("KEYword1", "SENDer1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("keyword1", "SENDer1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("KEYword1", "sender1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("body contains NiCk", "sender1", "nick", HighlightRule::ChatMessage), false);
+		}
+
+		void testWholeWordsAndCase() {
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("body", "sender1", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("xkeyword1", "sender1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("keyword1", "xsender1", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("body contains nick", "sender1", "nick", HighlightRule::ChatMessage), true);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("body contains xnick", "sender1", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("KEYword1", "SENDer1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("keyword1", "SENDer1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("KEYword1", "sender1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("body contains NiCk", "sender1", "nick", HighlightRule::ChatMessage), false);
+		}
+
+		void testMUC() {
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickMUCRule->isMatch("body", "from", "nick", HighlightRule::ChatMessage), false);
+
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickMUCRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickMUCRule->isMatch("keyword1", "sender1", "nick", HighlightRule::MUCMessage), false);
+			CPPUNIT_ASSERT_EQUAL(senderKeywordNickMUCRule->isMatch("body contains nick", "sender1", "nick", HighlightRule::MUCMessage), true);
+		}
+
+	private:
+		HighlightRule* emptyRule;
+
+		HighlightRule* keywordRule;
+		HighlightRule* keywordChatRule;
+		HighlightRule* keywordNickChatRule;
+		HighlightRule* nickChatRule;
+		HighlightRule* nickRule;
+
+		HighlightRule* senderRule;
+		HighlightRule* senderChatRule;
+		HighlightRule* senderKeywordChatRule;
+		HighlightRule* senderKeywordNickChatRule;
+
+		HighlightRule* senderKeywordNickWordChatRule;
+		HighlightRule* senderKeywordNickCaseChatRule;
+		HighlightRule* senderKeywordNickCaseWordChatRule;
+
+		HighlightRule* senderKeywordNickMUCRule;
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(HighlightRuleTest);
diff --git a/Swift/Controllers/UnitTest/MockChatWindow.h b/Swift/Controllers/UnitTest/MockChatWindow.h
index e0e18a0..774bdd9 100644
--- a/Swift/Controllers/UnitTest/MockChatWindow.h
+++ b/Swift/Controllers/UnitTest/MockChatWindow.h
@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2010 Kevin Smith
+ * Copyright (c) 2010-2014 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
@@ -7,52 +7,82 @@
 #pragma once
 
-#include "Swift/Controllers/UIInterfaces/ChatWindow.h"
+#include <boost/shared_ptr.hpp>
+
+#include <Swift/Controllers/UIInterfaces/ChatWindow.h>
+#include <Swiften/Base/foreach.h>
+
 
 namespace Swift {
 	class MockChatWindow : public ChatWindow {
 		public:
-			MockChatWindow() : labelsEnabled_(false) {};
+			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*/) {};
+			virtual std::string addMessage(const ChatMessage& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {
+			lastMessageBody_ = bodyFromMessage(message); return "id";}
+
+			virtual std::string addAction(const ChatMessage& /*message*/, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {return "id";}
+
+			virtual void addSystemMessage(const ChatMessage& /*message*/, Direction /*direction*/) {}
+			virtual void addPresenceMessage(const ChatMessage& /*message*/, Direction /*direction*/) {}
+
+			virtual void addErrorMessage(const ChatMessage& /*message*/) {}
+			virtual void replaceMessage(const ChatMessage& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {}
+			virtual void replaceWithAction(const ChatMessage& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/) {}
+			virtual void replaceLastMessage(const ChatMessage& /*message*/, const TimestampBehaviour /*timestampBehaviour*/) {}
 
 			// 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 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 setMessageReceiptState(const std::string &/* id */, ReceiptState /* state */) { }
 
-			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 setContactChatState(ChatState::ChatStateType /*state*/) {}
+			virtual void setName(const std::string& name) {name_ = name;}
+			virtual void show() {}
+			virtual bool isVisible() const { return true; }
+			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(MUCType /*mucType*/) {}
+			virtual void setSecurityLabelsError() {}
 			virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() {return label_;}
-			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&) {};
-			virtual void replaceWithAction(const std::string& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/) {};
-			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 setInputEnabled(bool /*enabled*/) {}
+			virtual void setRosterModel(Roster* roster) { roster_ = roster; }
+			Roster* getRosterModel() { return roster_; }
+			virtual void setTabComplete(TabComplete*) {}
+
+			void setAckState(const std::string& /*id*/, AckState /*state*/) {}
+			virtual void flash() {}
+			virtual AlertID addAlert(const std::string& /*alertText*/) { return 0; }
+			virtual void removeAlert(const AlertID /*id*/) {}
 			virtual void setCorrectionEnabled(Tristate /*enabled*/) {}
+			virtual void setFileTransferEnabled(Tristate /*enabled*/) {}
 			void setAvailableOccupantActions(const std::vector<OccupantAction>&/* actions*/) {}
 			void setSubject(const std::string& /*subject*/) {}
 			virtual void showRoomConfigurationForm(Form::ref) {}
-			virtual void addMUCInvitation(const std::string& /*senderName*/, const JID& /*jid*/, const std::string& /*reason*/, const std::string& /*password*/, bool = true) {};
+			virtual void addMUCInvitation(const std::string& /*senderName*/, const JID& /*jid*/, const std::string& /*reason*/, const std::string& /*password*/, bool = true, bool = false, bool = false) {}
+
+			virtual std::string addWhiteboardRequest(bool) {return "";}
+			virtual void setWhiteboardSessionStatus(std::string, const ChatWindow::WhiteboardSessionState){}
+
 			virtual void setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&) {}
-			virtual void setAvailableRoomActions(const std::vector<RoomAction> &) {};
+			virtual void setAvailableRoomActions(const std::vector<RoomAction> &) {}
+
+			virtual void setBlockingState(BlockingState) {}
+			virtual void setCanInitiateImpromptuChats(bool /*supportsImpromptu*/) {}
+			virtual void showBookmarkWindow(const MUCBookmark& /*bookmark*/) {}
+
+			std::string bodyFromMessage(const ChatMessage& message) {
+				boost::shared_ptr<ChatTextMessagePart> text;
+				foreach (boost::shared_ptr<ChatMessagePart> part, message.getParts()) {
+					if ((text = boost::dynamic_pointer_cast<ChatTextMessagePart>(part))) {
+						return text->text;
+					}
+				}
+				return "";
+			}
 
 			std::string name_;
@@ -61,4 +91,5 @@ namespace Swift {
 			bool labelsEnabled_;
 			SecurityLabelsCatalog::Item label_;
+			Roster* roster_;
 	};
 }
diff --git a/Swift/Controllers/UnitTest/MockMainWindow.h b/Swift/Controllers/UnitTest/MockMainWindow.h
index f773062..b56f352 100644
--- a/Swift/Controllers/UnitTest/MockMainWindow.h
+++ b/Swift/Controllers/UnitTest/MockMainWindow.h
@@ -7,5 +7,5 @@
 #pragma once
 
-#include "Swift/Controllers/UIInterfaces/MainWindow.h"
+#include <Swift/Controllers/UIInterfaces/MainWindow.h>
 
 namespace Swift {
@@ -13,14 +13,18 @@ namespace Swift {
 	class MockMainWindow : public MainWindow {
 		public:
-			MockMainWindow() : roster(NULL) {};
-			virtual ~MockMainWindow() {};
-			virtual void setRosterModel(Roster* roster) {this->roster = roster;};
-			virtual void setMyNick(const std::string& /*name*/) {};;
-			virtual void setMyJID(const JID& /*jid*/) {};;
-			virtual void setMyAvatarPath(const std::string& /*path*/) {};
-			virtual void setMyStatusText(const std::string& /*status*/) {};
-			virtual void setMyStatusType(StatusShow::Type /*type*/) {};
-			virtual void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& /*commands*/) {};
-			virtual void setConnecting() {};
+			MockMainWindow() : roster(NULL) {}
+			virtual ~MockMainWindow() {}
+			virtual void setRosterModel(Roster* roster) {this->roster = roster;}
+			virtual void setMyNick(const std::string& /*name*/) {}
+			virtual void setMyJID(const JID& /*jid*/) {}
+			virtual void setMyAvatarPath(const std::string& /*path*/) {}
+			virtual void setMyStatusText(const std::string& /*status*/) {}
+			virtual void setMyStatusType(StatusShow::Type /*type*/) {}
+			virtual void setMyContactRosterItem(boost::shared_ptr<ContactRosterItem> /*contact*/) {}
+			virtual void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& /*commands*/) {}
+			virtual void setConnecting() {}
+			virtual void setStreamEncryptionStatus(bool /*tlsInPlaceAndValid*/) {}
+			virtual void openCertificateDialog(const std::vector<Certificate::ref>& /*chain*/) {}
+			virtual void setBlockingCommandAvailable(bool /*isAvailable*/) {}
 			Roster* roster;
 
diff --git a/Swift/Controllers/UnitTest/MockMainWindowFactory.h b/Swift/Controllers/UnitTest/MockMainWindowFactory.h
index d130b39..279a6dd 100644
--- a/Swift/Controllers/UnitTest/MockMainWindowFactory.h
+++ b/Swift/Controllers/UnitTest/MockMainWindowFactory.h
@@ -14,12 +14,12 @@ namespace Swift {
 	class MockMainWindowFactory : public MainWindowFactory {
 		public:
-			MockMainWindowFactory() : last(NULL) {};
+			MockMainWindowFactory() : last(NULL) {}
 
-			virtual ~MockMainWindowFactory() {};
+			virtual ~MockMainWindowFactory() {}
 
 			/**
 			 * Transfers ownership of result.
 			 */
-			virtual MainWindow* createMainWindow(UIEventStream*) {last = new MockMainWindow();return last;};
+			virtual MainWindow* createMainWindow(UIEventStream*) {last = new MockMainWindow();return last;}
 			MockMainWindow* last;
 	};
diff --git a/Swift/Controllers/UnitTest/PreviousStatusStoreTest.cpp b/Swift/Controllers/UnitTest/PreviousStatusStoreTest.cpp
index 9489e5b..0ccbc4a 100644
--- a/Swift/Controllers/UnitTest/PreviousStatusStoreTest.cpp
+++ b/Swift/Controllers/UnitTest/PreviousStatusStoreTest.cpp
@@ -31,5 +31,5 @@ public:
 
 	void tearDown() {
-		
+		delete store_;
 	}