passenger 4.0.60 → 5.0.0.beta1

data/test/cxx/DataStructures/StringKeyTableTest.cpp

@@ -0,0 +1,199 @@
+#include <TestSupport.h>
+#include <string>
+#include <DataStructures/StringKeyTable.h>
+
+using namespace Passenger;
+using namespace std;
+
+namespace tut {
+	struct DataStructures_StringKeyTableTest {
+		StringKeyTable<string> table;
+		string *value;
+
+		DataStructures_StringKeyTableTest() {
+			value = NULL;
+		}
+	};
+
+	DEFINE_TEST_GROUP(DataStructures_StringKeyTableTest);
+
+	TEST_METHOD(1) {
+		set_test_name("Initial state");
+		ensure_equals(table.size(), 0u);
+		ensure_equals(table.arraySize(), (unsigned int) StringKeyTable<string>::DEFAULT_SIZE);
+	}
+
+	TEST_METHOD(2) {
+		set_test_name("On an empty StringKeyTable, iterators reach the end immediately");
+		StringKeyTable<string>::Iterator it(table);
+		ensure_equals<void *>(*it, NULL);
+	}
+
+	TEST_METHOD(3) {
+		set_test_name("On an empty StringKeyTable, lookups return NULL");
+		ensure(!table.lookup("hello", &value));
+		ensure_equals<void *>(value, NULL);
+		ensure(!table.lookup("?", &value));
+		ensure_equals<void *>(value, NULL);
+		ensure(!table.lookupRandom(NULL, &value));
+		ensure_equals<void *>(value, NULL);
+	}
+
+	TEST_METHOD(4) {
+		set_test_name("Insertions work");
+
+		table.insert("Content-Length", "5");
+		ensure_equals(table.size(), 1u);
+		ensure(!table.lookup("hello", &value));
+		ensure_equals<void *>("(1)", value, NULL);
+		ensure(!table.lookup("Host", &value));
+		ensure_equals<void *>("(2)", value, NULL);
+		ensure(table.lookup("Content-Length", &value));
+		ensure_equals("(3)", *value, "5");
+
+		table.insert("Host", "foo.com");
+		ensure_equals(table.size(), 2u);
+		ensure(!table.lookup("hello", &value));
+		ensure_equals<void *>("(5)", value, NULL);
+		ensure(table.lookup("Host", &value));
+		ensure_equals("(6)", *value, "foo.com");
+		ensure(table.lookup("Content-Length", &value));
+		ensure_equals("(7)", *value, "5");
+	}
+
+	TEST_METHOD(5) {
+		set_test_name("Large amounts of insertions");
+
+		table.insert("Host", "foo.com");
+		table.insert("Content-Length", "5");
+		table.insert("Accept", "text/html");
+		table.insert("Accept-Encoding", "gzip");
+		table.insert("Accept-Language", "nl");
+		table.insert("User-Agent", "Mozilla");
+		table.insert("Set-Cookie", "foo=bar");
+		table.insert("Connection", "keep-alive");
+		table.insert("Cache-Control", "no-cache");
+		table.insert("Pragma", "no-cache");
+
+		ensure(!table.lookup("MyHeader", &value));
+
+		ensure(table.lookup("Host", &value));
+		ensure_equals(*value, "foo.com");
+		ensure(table.lookup("Content-Length", &value));
+		ensure_equals(*value, "5");
+		ensure(table.lookup("Accept", &value));
+		ensure_equals(*value, "text/html");
+		ensure(table.lookup("Accept-Encoding", &value));
+		ensure_equals(*value, "gzip");
+		ensure(table.lookup("Accept-Language", &value));
+		ensure_equals(*value, "nl");
+		ensure(table.lookup("User-Agent", &value));
+		ensure_equals(*value, "Mozilla");
+		ensure(table.lookup("Set-Cookie", &value));
+		ensure_equals(*value, "foo=bar");
+		ensure(table.lookup("Connection", &value));
+		ensure_equals(*value, "keep-alive");
+		ensure(table.lookup("Cache-Control", &value));
+		ensure_equals(*value, "no-cache");
+		ensure(table.lookup("Pragma", &value));
+		ensure_equals(*value, "no-cache");
+	}
+
+	TEST_METHOD(6) {
+		set_test_name("Iterators work");
+		table.insert("Content-Length", "5");
+		table.insert("Host", "foo.com");
+
+		StringKeyTable<string>::Iterator it(table);
+		ensure(*it != NULL);
+		if (it.getKey() == "Content-Length") {
+			ensure_equals(it.getKey(), "Content-Length");
+			it.next();
+			ensure_equals(it.getKey(), "Host");
+		} else {
+			ensure_equals(it.getKey(), "Host");
+			it.next();
+			ensure_equals(it.getKey(), "Content-Length");
+		}
+
+		it.next();
+		ensure_equals<void *>(*it, NULL);
+	}
+
+	TEST_METHOD(7) {
+		set_test_name("Dynamically growing the bucket on insert");
+		table = StringKeyTable<string>(4);
+		ensure_equals(table.size(), 0u);
+		ensure_equals(table.arraySize(), 4u);
+
+		table.insert("Host", "foo.com");
+		table.insert("Content-Length", "5");
+		ensure_equals(table.size(), 2u);
+		ensure_equals(table.arraySize(), 4u);
+
+		table.insert("Accept", "text/html");
+		ensure_equals(table.size(), 3u);
+		ensure_equals(table.arraySize(), 8u);
+
+		ensure(!table.lookup("MyHeader", &value));
+		ensure_equals<void *>(value, NULL);
+		ensure(table.lookup("Host", &value));
+		ensure_equals(*value, "foo.com");
+		ensure(table.lookup("Content-Length", &value));
+		ensure_equals(*value, "5");
+		ensure(table.lookup("Accept", &value));
+		ensure_equals(*value, "text/html");
+	}
+
+	TEST_METHOD(8) {
+		set_test_name("Clearing");
+
+		table.insert("Host", "foo.com");
+		table.insert("Content-Length", "5");
+		table.insert("Accept", "text/html");
+
+		table.clear();
+		ensure_equals(table.size(), 0u);
+		ensure_equals(table.arraySize(), (unsigned int) StringKeyTable<string>::DEFAULT_SIZE);
+
+		ensure(!table.lookup("Host", &value));
+		ensure_equals<void *>(value, NULL);
+		ensure(!table.lookup("Content-Length", &value));
+		ensure_equals<void *>(value, NULL);
+		ensure(!table.lookup("Accept", &value));
+		ensure_equals<void *>(value, NULL);
+	}
+
+	TEST_METHOD(9) {
+		set_test_name("lookupRandom() works");
+		HashedStaticString key;
+
+		table.insert("a", "1");
+		ensure(table.lookupRandom(&key, &value));
+		ensure_equals(key, "a");
+		ensure_equals(*value, "1");
+
+		table.insert("b", "2");
+		ensure(table.lookupRandom(&key, &value));
+		ensure_equals(key, "b");
+		ensure_equals(*value, "2");
+
+		table.insert("c", "3");
+		ensure(table.lookupRandom(&key, &value));
+		ensure_equals(key, "c");
+		ensure_equals(*value, "3");
+
+		ensure(table.erase("b"));
+		ensure(table.lookupRandom(&key, &value));
+		ensure_equals(key, "c");
+		ensure_equals(*value, "3");
+
+		ensure(table.erase("c"));
+		ensure(table.lookupRandom(&key, &value));
+		ensure_equals(key, "a");
+		ensure_equals(*value, "1");
+
+		ensure(table.erase("a"));
+		ensure(!table.lookupRandom(&key, &value));
+	}
+}

data/test/cxx/MemoryKit/MbufTest.cpp

@@ -0,0 +1,213 @@
+#include <TestSupport.h>
+#include <boost/move/move.hpp>
+#include <Constants.h>
+#include <MemoryKit/mbuf.h>
+
+using namespace Passenger;
+using namespace Passenger::MemoryKit;
+using namespace std;
+
+namespace tut {
+	struct MemoryKit_MbufTest {
+		struct mbuf_pool pool;
+
+		MemoryKit_MbufTest() {
+			pool.mbuf_block_chunk_size = DEFAULT_MBUF_CHUNK_SIZE;
+			mbuf_pool_init(&pool);
+		}
+
+		~MemoryKit_MbufTest() {
+			mbuf_pool_deinit(&pool);
+		}
+	};
+
+	DEFINE_TEST_GROUP(MemoryKit_MbufTest);
+
+	TEST_METHOD(1) {
+		set_test_name("Initial pool state");
+		ensure_equals(pool.nfree_mbuf_blockq, 0u);
+		ensure_equals(pool.nactive_mbuf_blockq, 0u);
+	}
+
+	TEST_METHOD(2) {
+		set_test_name("mbuf_block_get() and mbuf_block_put()");
+
+		struct mbuf_block *block = mbuf_block_get(&pool);
+		ensure_equals("(1)", block->refcount, 1u);
+		ensure_equals("(2)", pool.nfree_mbuf_blockq, 0u);
+		ensure_equals("(3)", pool.nactive_mbuf_blockq, 1u);
+
+		struct mbuf_block *block2 = mbuf_block_get(&pool);
+		ensure_equals("(4)", block->refcount, 1u);
+		ensure_equals("(5)", block2->refcount, 1u);
+		ensure_equals("(6)", pool.nfree_mbuf_blockq, 0u);
+		ensure_equals("(7)", pool.nactive_mbuf_blockq, 2u);
+
+		block->refcount = 0;
+		mbuf_block_put(block);
+		ensure_equals("(8)", pool.nfree_mbuf_blockq, 1u);
+		ensure_equals("(9)", pool.nactive_mbuf_blockq, 1u);
+
+		block2->refcount = 0;
+		mbuf_block_put(block2);
+		ensure_equals("(10)", pool.nfree_mbuf_blockq, 2u);
+		ensure_equals("(11)", pool.nactive_mbuf_blockq, 0u);
+	}
+
+	TEST_METHOD(3) {
+		set_test_name("mbuf_block reference counting");
+		struct mbuf_block *block = mbuf_block_get(&pool);
+
+		mbuf_block_ref(block);
+		ensure_equals("(1)", block->refcount, 2u);
+		ensure_equals("(2)", pool.nfree_mbuf_blockq, 0u);
+		ensure_equals("(3)", pool.nactive_mbuf_blockq, 1u);
+
+		mbuf_block_unref(block);
+		ensure_equals("(4)", block->refcount, 1u);
+		ensure_equals("(5)", pool.nfree_mbuf_blockq, 0u);
+		ensure_equals("(6)", pool.nactive_mbuf_blockq, 1u);
+
+		mbuf_block_unref(block);
+		ensure_equals("(7)", pool.nfree_mbuf_blockq, 1u);
+		ensure_equals("(8)", pool.nactive_mbuf_blockq, 0u);
+	}
+
+	TEST_METHOD(4) {
+		set_test_name("mbuf_block freelist reuse");
+		struct mbuf_block *block = mbuf_block_get(&pool);
+		struct mbuf_block *block2 = mbuf_block_get(&pool);
+		mbuf_block_unref(block);
+		block = mbuf_block_get(&pool);
+
+		ensure_equals("(1)", pool.nfree_mbuf_blockq, 0u);
+		ensure_equals("(2)", pool.nactive_mbuf_blockq, 2u);
+		mbuf_block_unref(block);
+		mbuf_block_unref(block2);
+	}
+
+	TEST_METHOD(5) {
+		set_test_name("mbuf class");
+		mbuf buffer(mbuf_get(&pool));
+		ensure_equals("(1)", buffer.mbuf_block->refcount, 1u);
+		ensure_equals("(2)", pool.nfree_mbuf_blockq, 0u);
+		ensure_equals("(3)", pool.nactive_mbuf_blockq, 1u);
+
+		buffer = mbuf();
+		ensure_equals("(2)", pool.nfree_mbuf_blockq, 1u);
+		ensure_equals("(3)", pool.nactive_mbuf_blockq, 0u);
+	}
+
+	TEST_METHOD(6) {
+		set_test_name("mbuf class copy constructor");
+		mbuf buffer(mbuf_get(&pool));
+
+		{
+			mbuf buffer2(buffer);
+			ensure_equals("(1)", buffer.mbuf_block, buffer2.mbuf_block);
+			ensure_equals("(2)", buffer.mbuf_block->refcount, 2u);
+			ensure_equals("(3)", pool.nfree_mbuf_blockq, 0u);
+			ensure_equals("(4)", pool.nactive_mbuf_blockq, 1u);
+		}
+
+		ensure_equals("(5)", buffer.mbuf_block->refcount, 1u);
+		ensure_equals("(6)", pool.nfree_mbuf_blockq, 0u);
+		ensure_equals("(7)", pool.nactive_mbuf_blockq, 1u);
+
+		buffer = mbuf();
+		ensure_equals("(8)", pool.nfree_mbuf_blockq, 1u);
+		ensure_equals("(9)", pool.nactive_mbuf_blockq, 0u);
+	}
+
+	TEST_METHOD(7) {
+		set_test_name("mbuf class move constructor");
+		mbuf buffer(mbuf_get(&pool));
+
+		{
+			mbuf buffer2(boost::move(buffer));
+			ensure_equals<void *>("(1)", buffer.mbuf_block, NULL);
+			ensure_equals<void *>("(2)", buffer.start, NULL);
+			ensure_equals<void *>("(3)", buffer.end, NULL);
+			ensure_equals("(4)", buffer2.mbuf_block->refcount, 1u);
+			ensure_equals("(5)", pool.nfree_mbuf_blockq, 0u);
+			ensure_equals("(6)", pool.nactive_mbuf_blockq, 1u);
+		}
+
+		ensure_equals("(8)", pool.nfree_mbuf_blockq, 1u);
+		ensure_equals("(9)", pool.nactive_mbuf_blockq, 0u);
+	}
+
+	TEST_METHOD(8) {
+		set_test_name("mbuf class copy assignment");
+		mbuf buffer(mbuf_get(&pool));
+
+		{
+			mbuf buffer2;
+			buffer2 = buffer;
+			ensure_equals("(1)", buffer.mbuf_block, buffer2.mbuf_block);
+			ensure_equals("(2)", buffer.mbuf_block->refcount, 2u);
+			ensure_equals("(3)", pool.nfree_mbuf_blockq, 0u);
+			ensure_equals("(4)", pool.nactive_mbuf_blockq, 1u);
+		}
+
+		ensure_equals("(5)", buffer.mbuf_block->refcount, 1u);
+		ensure_equals("(6)", pool.nfree_mbuf_blockq, 0u);
+		ensure_equals("(7)", pool.nactive_mbuf_blockq, 1u);
+
+		buffer = mbuf();
+		ensure_equals("(8)", pool.nfree_mbuf_blockq, 1u);
+		ensure_equals("(9)", pool.nactive_mbuf_blockq, 0u);
+	}
+
+	TEST_METHOD(9) {
+		set_test_name("mbuf class move assignment");
+		mbuf buffer(mbuf_get(&pool));
+
+		{
+			mbuf buffer2;
+			buffer2 = boost::move(buffer);
+			ensure_equals<void *>("(1)", buffer.mbuf_block, NULL);
+			ensure_equals<void *>("(2)", buffer.start, NULL);
+			ensure_equals<void *>("(3)", buffer.end, NULL);
+			ensure_equals("(4)", buffer2.mbuf_block->refcount, 1u);
+			ensure_equals("(5)", pool.nfree_mbuf_blockq, 0u);
+			ensure_equals("(6)", pool.nactive_mbuf_blockq, 1u);
+		}
+
+		ensure_equals("(8)", pool.nfree_mbuf_blockq, 1u);
+		ensure_equals("(9)", pool.nactive_mbuf_blockq, 0u);
+	}
+
+	TEST_METHOD(10) {
+		set_test_name("mbuf class slicing");
+		mbuf buffer(mbuf_get(&pool));
+
+		{
+			mbuf buffer2(buffer, 1, 2);
+			ensure_equals("(1)", buffer.mbuf_block, buffer2.mbuf_block);
+			ensure_equals("(2)", buffer.mbuf_block->refcount, 2u);
+			ensure_equals("(3)", buffer2.start, buffer.start + 1);
+			ensure_equals("(4)", buffer2.end, buffer.start + 3);
+			ensure_equals("(5)", pool.nfree_mbuf_blockq, 0u);
+			ensure_equals("(6)", pool.nactive_mbuf_blockq, 1u);
+		}
+
+		ensure_equals("(7)", buffer.mbuf_block->refcount, 1u);
+		ensure_equals("(8)", pool.nfree_mbuf_blockq, 0u);
+		ensure_equals("(9)", pool.nactive_mbuf_blockq, 1u);
+
+		buffer = mbuf();
+		ensure_equals("(10)", pool.nfree_mbuf_blockq, 1u);
+		ensure_equals("(11)", pool.nactive_mbuf_blockq, 0u);
+	}
+
+	TEST_METHOD(11) {
+		set_test_name("mbuf class freelist reuse");
+		mbuf buffer(mbuf_get(&pool));
+		mbuf buffer2(mbuf_get(&pool));
+		buffer = mbuf();
+		buffer = mbuf_get(&pool);
+		ensure_equals("(1)", pool.nfree_mbuf_blockq, 0u);
+		ensure_equals("(2)", pool.nactive_mbuf_blockq, 2u);
+	}
+}

data/test/cxx/MessageServerTest.cpp

@@ -3,9 +3,9 @@
 #include <boost/thread.hpp>
 #include <boost/bind.hpp>
 
-#include "MessageServer.h"
-#include "MessageClient.h"
-#include "Utils.h"
+#include <MessageServer.h>
+#include <MessageClient.h>
+#include <Utils.h>
 #include <string>
 #include <cstring>
 #include <unistd.h>
@@ -17,40 +17,39 @@ using namespace std;
 
 namespace tut {
 	struct MessageServerTest {
-		ServerInstanceDirPtr serverInstanceDir;
-		ServerInstanceDir::GenerationPtr generation;
+		InstanceDirectoryPtr instanceDir;
 		string socketFilename;
 		string socketAddress;
 		AccountsDatabasePtr accountsDatabase;
 		AccountPtr clientAccount;
 		boost::shared_ptr<MessageServer> server;
 		boost::shared_ptr<oxt::thread> serverThread;
-		
+
 		MessageServerTest() {
-			createServerInstanceDirAndGeneration(serverInstanceDir, generation);
-			socketFilename = generation->getPath() + "/socket";
+			createInstanceDir(instanceDir);
+			socketFilename = instanceDir->getPath() + "/socket";
 			socketAddress = "unix:" + socketFilename;
 			accountsDatabase = ptr(new AccountsDatabase());
 			clientAccount = accountsDatabase->add("test", "12345", false);
-			
+
 			server = ptr(new MessageServer(socketFilename, accountsDatabase));
 			serverThread  = ptr(new oxt::thread(
 				boost::bind(&MessageServer::mainLoop, server.get())
 			));
 		}
-		
+
 		~MessageServerTest() {
 			if (serverThread != NULL) {
 				serverThread->interrupt_and_join();
 			}
-			Passenger::setLogLevel(0);
+			Passenger::setLogLevel(DEFAULT_LOG_LEVEL);
 		}
-		
+
 		class SlowClient: public MessageClient {
 		private:
 			unsigned int timeToSendUsername;
 			unsigned int timeToSendPassword;
-			
+
 		protected:
 			virtual void sendUsername(int fd, const StaticString &username, unsigned long long *timeout) {
 				if (timeToSendUsername > 0) {
@@ -65,7 +64,7 @@ namespace tut {
 				}
 				writeScalarMessage(fd, userSuppliedPassword);
 			}
-			
+
 		public:
 			SlowClient(unsigned int timeToSendUsername,
 			           unsigned int timeToSendPassword)
@@ -75,7 +74,7 @@ namespace tut {
 				this->timeToSendPassword = timeToSendPassword;
 			}
 		};
-		
+
 		class CustomClient: public MessageClient {
 		public:
 			CustomClient *sendText(const string &text) {
@@ -83,19 +82,19 @@ namespace tut {
 				return this;
 			}
 		};
-		
+
 		class LoggingHandler: public MessageServer::Handler {
 		public:
 			struct SpecificContext: public MessageServer::ClientContext {
 				int id;
-				
+
 				SpecificContext(int i) {
 					id = i;
 				}
 			};
-			
+
 			typedef boost::shared_ptr<SpecificContext> SpecificContextPtr;
-			
+
 			boost::mutex mutex;
 			volatile int clientsAccepted;
 			volatile int clientsDisconnected;
@@ -103,26 +102,26 @@ namespace tut {
 			volatile int id;
 			volatile int returnValue;
 			SpecificContextPtr latestContext;
-			
+
 			LoggingHandler() {
 				clientsAccepted = 0;
 				clientsDisconnected = 0;
 				returnValue = true;
 			}
-			
+
 			virtual MessageServer::ClientContextPtr newClient(MessageServer::CommonClientContext &context) {
 				boost::lock_guard<boost::mutex> l(mutex);
 				clientsAccepted++;
 				return ptr(new SpecificContext(id));
 			}
-			
+
 			virtual void clientDisconnected(MessageServer::CommonClientContext &context,
 			                                MessageServer::ClientContextPtr &handlerSpecificContext)
 			{
 				boost::lock_guard<boost::mutex> l(mutex);
 				clientsDisconnected++;
 			}
-			
+
 			virtual bool processMessage(MessageServer::CommonClientContext &commonContext,
 			                            MessageServer::ClientContextPtr &handlerSpecificContext,
 			                            const vector<string> &args)
@@ -133,9 +132,9 @@ namespace tut {
 				return returnValue;
 			}
 		};
-		
+
 		typedef boost::shared_ptr<LoggingHandler> LoggingHandlerPtr;
-		
+
 		class ProcessMessageReturnsFalseHandler: public MessageServer::Handler {
 		public:
 			virtual bool processMessage(MessageServer::CommonClientContext &commonContext,
@@ -148,11 +147,11 @@ namespace tut {
 	};
 
 	DEFINE_TEST_GROUP(MessageServerTest);
-	
+
 	TEST_METHOD(1) {
 		// It rejects the connection if the an invalid username or password was sent.
 		accountsDatabase->add("hashed_user", Account::createHash("67890"), true);
-		
+
 		try {
 			MessageClient().connect(socketAddress, "testt", "12345");
 			fail("SecurityException expected when invalid username is given");
@@ -172,26 +171,26 @@ namespace tut {
 			// Pass.
 		}
 	}
-	
+
 	TEST_METHOD(2) {
 		// It supports hashed passwords.
 		accountsDatabase->add("hashed_user", Account::createHash("67890"), true);
 		MessageClient().connect(socketAddress, "hashed_user", "67890"); // Should not throw exception.
 	}
-	
+
 	TEST_METHOD(3) {
 		// It disconnects the client if the client does not supply a username and
 		// password within a time limit.
-		Passenger::setLogLevel(-1);
+		Passenger::setLogLevel(LVL_ERROR);
 		server->setLoginTimeout(30000);
-		
+
 		/* These can throw either an IOException or SystemException:
 		 * - An IOException is raised when connect() encounters EOF.
 		 * - But when connect() fails during the middle of a read()
 		 *   or write() (e.g. because the server disconnects before
 		 *   connect() is done writing), then SystemException is raised.
 		 */
-		
+
 		try {
 			// This client takes too much time on sending the username.
 			SlowClient(50, 0).connect(socketAddress, "test", "12345");
@@ -201,7 +200,7 @@ namespace tut {
 		} catch (const SystemException &e) {
 			// Pass.
 		}
-		
+
 		try {
 			// This client takes too much time on sending the password.
 			SlowClient(0, 50).connect(socketAddress, "test", "12345");
@@ -211,7 +210,7 @@ namespace tut {
 		} catch (const SystemException &e) {
 			// Pass.
 		}
-		
+
 		try {
 			// This client is fast enough at sending the username and
 			// password individually, but the combined time is too long.
@@ -223,7 +222,7 @@ namespace tut {
 			// Pass.
 		}
 	}
-	
+
 	TEST_METHOD(4) {
 		// It disconnects the client if it provides a username that's too large.
 		char username[1024];
@@ -234,9 +233,13 @@ namespace tut {
 			fail("SecurityException expected");
 		} catch (const SecurityException &e) {
 			// Pass.
+		} catch (const SystemException &e) {
+			if (e.code() != EPIPE) {
+				fail(("Unexpected SystemException: " + string(e.what())).c_str());
+			}
 		}
 	}
-	
+
 	TEST_METHOD(5) {
 		// It disconnects the client if it provides a password that's too large.
 		char password[1024];
@@ -247,9 +250,13 @@ namespace tut {
 			fail("SecurityException expected");
 		} catch (const SecurityException &e) {
 			// Pass.
+		} catch (const SystemException &e) {
+			if (e.code() != EPIPE) {
+				fail(("Unexpected SystemException: " + string(e.what())).c_str());
+			}
 		}
 	}
-	
+
 	TEST_METHOD(6) {
 		// It notifies all handlers when a new client has connected.
 		LoggingHandlerPtr handler1(new LoggingHandler());
@@ -258,12 +265,12 @@ namespace tut {
 		server->addHandler(handler2);
 		MessageClient().connect(socketAddress, "test", "12345");
 		MessageClient().connect(socketAddress, "test", "12345");
-		
+
 		usleep(10000); // Give the threads some time to do work.
 		ensure_equals(handler1->clientsAccepted, 2);
 		ensure_equals(handler2->clientsAccepted, 2);
 	}
-	
+
 	TEST_METHOD(7) {
 		// It notifies all handlers when a message is sent, but stops
 		// at the first handler that returns true.
@@ -274,22 +281,22 @@ namespace tut {
 		server->addHandler(handler2);
 		server->addHandler(handler3);
 		handler1->returnValue = false;
-		
+
 		CustomClient c1, c2;
 		c1.connect(socketAddress, "test", "12345");
 		c1.sendText("hello");
 		c1.sendText(" ");
 		usleep(10000); // Give the thread some time to do work.
-		
+
 		c2.connect(socketAddress, "test", "12345");
 		c2.sendText("world");
 		usleep(10000); // Give the thread some time to do work.
-		
+
 		ensure_equals("(1)", handler1->receivedData, "hello world");
 		ensure_equals("(2)", handler2->receivedData, "hello world");
 		ensure_equals("(3)", handler3->receivedData, "");
 	}
-	
+
 	TEST_METHOD(8) {
 		// It does not close the connection if some, but not all of the handlers'
 		// processMessage() methods return false.
@@ -297,15 +304,15 @@ namespace tut {
 		MessageServer::HandlerPtr handler2(new ProcessMessageReturnsFalseHandler());
 		server->addHandler(handler1);
 		server->addHandler(handler2);
-		
+
 		CustomClient c;
 		c.connect(socketAddress, "test", "12345");
 		c.sendText("hi");
 		usleep(10000); // Give the thread some time to do work.
-		
+
 		c.sendText("hi"); // Connection should still be valid.
 	}
-	
+
 	TEST_METHOD(9) {
 		// It closes the connection if all of the handlers'
 		// processMessage() methods return false.
@@ -313,12 +320,12 @@ namespace tut {
 		MessageServer::HandlerPtr handler2(new ProcessMessageReturnsFalseHandler());
 		server->addHandler(handler1);
 		server->addHandler(handler2);
-		
+
 		CustomClient c;
 		c.connect(socketAddress, "test", "12345");
 		c.sendText("hi");
 		usleep(10000); // Give the thread some time to do work.
-		
+
 		try {
 			c.sendText("hi");
 			fail("SystemException expected.");
@@ -326,7 +333,7 @@ namespace tut {
 			ensure_equals(e.code(), EPIPE);
 		}
 	}
-	
+
 	TEST_METHOD(10) {
 		// The specific context as returned by the handler's newClient()
 		// method is passed to processMessage().
@@ -338,9 +345,9 @@ namespace tut {
 		server->addHandler(handler3);
 		handler1->returnValue = false;
 		handler2->returnValue = false;
-		
+
 		CustomClient c1, c2;
-		
+
 		handler1->id = 100;
 		handler2->id = 101;
 		c1.connect(socketAddress, "test", "12345");
@@ -348,7 +355,7 @@ namespace tut {
 		usleep(10000); // Give the thread some time to do work.
 		ensure_equals(handler1->latestContext->id, 100);
 		ensure_equals(handler2->latestContext->id, 101);
-		
+
 		handler1->id = 200;
 		handler2->id = 201;
 		c2.connect(socketAddress, "test", "12345");
@@ -356,13 +363,13 @@ namespace tut {
 		usleep(10000); // Give the thread some time to do work.
 		ensure_equals(handler1->latestContext->id, 200);
 		ensure_equals(handler2->latestContext->id, 201);
-		
+
 		c1.sendText("hi");
 		usleep(10000); // Give the thread some time to do work.
 		ensure_equals(handler1->latestContext->id, 100);
 		ensure_equals(handler2->latestContext->id, 101);
 	}
-	
+
 	TEST_METHOD(11) {
 		// It notifies all handlers when a client is disconnected.
 		LoggingHandlerPtr handler1(new LoggingHandler());
@@ -376,7 +383,7 @@ namespace tut {
 			usleep(10000); // Give the threads some time to do work.
 			ensure_equals(handler1->clientsDisconnected, 1);
 			ensure_equals(handler2->clientsDisconnected, 1);
-			
+
 			MessageClient().connect(socketAddress, "test", "12345");
 		}
 		usleep(10000); // Give the threads some time to do work.