passenger 4.0.60 → 5.0.0.beta1

data/test/cxx/BufferedIOTest.cpp

@@ -11,13 +11,13 @@ namespace tut {
 	struct BufferedIOTest {
 		FileDescriptor reader, writer;
 		BufferedIO io;
-		
+
 		string readData;
 		unsigned int counter;
 		char buf[100];
 		BufferedIO::AcceptFunction a_eof;
 		BufferedIO::AcceptFunction a_twoBytesRead;
-		
+
 		BufferedIOTest() {
 			Pipe p = createPipe();
 			reader = p.first;
@@ -28,11 +28,11 @@ namespace tut {
 			a_eof = boost::bind(&BufferedIOTest::eof, this, _1, _2);
 			a_twoBytesRead = boost::bind(&BufferedIOTest::twoBytesRead, this, _1, _2);
 		}
-		
+
 		void write(const StaticString &data) {
 			::write(writer, data.c_str(), data.size());
 		}
-		
+
 		pair<unsigned int, bool> twoBytesRead(const char *data, unsigned int size) {
 			if (counter == 2) {
 				return make_pair(0, true);
@@ -43,27 +43,27 @@ namespace tut {
 				return make_pair(toRead, counter == 2);
 			}
 		}
-		
+
 		pair<unsigned int, bool> eof(const char *data, unsigned int size) {
 			readData.append(data, size);
 			return make_pair(size, false);
 		}
-		
+
 		static void writeAfterSomeTime(int fd, int sleepTime, string data) {
 			syscalls::usleep(sleepTime);
 			writeExact(fd, data);
 		}
-		
+
 		static void closeAfterSomeTime(FileDescriptor fd, int sleepTime) {
 			syscalls::usleep(sleepTime);
 			fd.close();
 		}
 	};
-	
+
 	DEFINE_TEST_GROUP(BufferedIOTest);
 
 	/***** Test readUntil() *****/
-	
+
 	TEST_METHOD(1) {
 		// If the connection is already closed and the buffer is empty, then it returns 0.
 		writer.close();
@@ -71,7 +71,7 @@ namespace tut {
 		ensure_equals(readData, "");
 		ensure_equals(io.getBuffer(), "");
 	}
-	
+
 	TEST_METHOD(2) {
 		// If the connection is already closed and the buffer is non-empty,
 		// then it reads from the buffer.
@@ -83,7 +83,7 @@ namespace tut {
 		ensure_equals(readData, "hello world");
 		ensure_equals(io.getBuffer(), "");
 	}
-	
+
 	TEST_METHOD(3) {
 		// If the buffer is empty then it reads from the connection.
 		write("hello world");
@@ -96,14 +96,14 @@ namespace tut {
 		ensure_equals("(8)", readData, "hello world");
 		ensure_equals(io.getBuffer(), "");
 	}
-	
+
 	TEST_METHOD(4) {
 		// If the buffer is non-empty then it reads from the
 		// buffer first, then from the connection.
 		io.unread("hel");
 		write("lo world");
 		writer.close();
-		
+
 		ensure_equals("(1)", io.readUntil(a_twoBytesRead), 2u);
 		ensure_equals("(2)", readData, "he");
 		counter = 0;
@@ -115,7 +115,7 @@ namespace tut {
 		ensure_equals("(8)", readData, "hello world");
 		ensure_equals(io.getBuffer(), "");
 	}
-	
+
 	TEST_METHOD(5) {
 		// It blocks until the acceptor function says it's done or until EOF.
 		TempThread thr1(boost::bind(writeAfterSomeTime, writer, 20000, "aa"));
@@ -124,7 +124,7 @@ namespace tut {
 		ensure_equals(readData, "aa");
 		ensure("At least 18 msec elapsed", timer1.elapsed() >= 18);
 		ensure("At most 90 msec elapsed", timer1.elapsed() <= 90);
-		
+
 		TempThread thr2(boost::bind(closeAfterSomeTime, writer, 20000));
 		Timer timer2;
 		ensure_equals(io.readUntil(a_twoBytesRead), 0u);
@@ -132,7 +132,7 @@ namespace tut {
 		ensure("At least 18 msec elapsed", timer2.elapsed() >= 18);
 		ensure("At most 90 msec elapsed", timer2.elapsed() <= 90);
 	}
-	
+
 	TEST_METHOD(6) {
 		// It throws TimeoutException if it cannot read enough data
 		// within the specified timeout.
@@ -151,16 +151,16 @@ namespace tut {
 			ensure_equals(io.getBuffer(), "");
 		}
 	}
-	
+
 	/***** Test read() *****/
-	
+
 	TEST_METHOD(10) {
 		// If the connection is already closed and the buffer is empty, then it returns 0.
 		writer.close();
 		ensure_equals(io.read(buf, sizeof(buf)), 0u);
 		ensure_equals(io.getBuffer(), "");
 	}
-	
+
 	TEST_METHOD(11) {
 		// If the connection is already closed and the buffer is non-empty
 		// and >= N bytes, then it reads everything from the buffer.
@@ -171,7 +171,7 @@ namespace tut {
 		ensure_equals(StaticString(buf), "hello");
 		ensure_equals(io.getBuffer(), " world");
 	}
-	
+
 	TEST_METHOD(12) {
 		// If the connection is already closed and the buffer is non-empty
 		// and < N bytes, then it reads N bytes from the buffer and the rest
@@ -183,7 +183,7 @@ namespace tut {
 		ensure_equals(StaticString(buf), "hello world");
 		ensure_equals(io.getBuffer(), "");
 	}
-	
+
 	TEST_METHOD(13) {
 		// If the buffer is empty then it reads from the connection.
 		write("hello world");
@@ -191,21 +191,21 @@ namespace tut {
 		ensure_equals(StaticString(buf), "hello");
 		ensure_equals(io.getBuffer(), " world");
 	}
-	
+
 	TEST_METHOD(14) {
 		// If the buffer is non-empty then it reads from the
 		// buffer first, then from the connection.
 		write("hello world");
-		
+
 		ensure_equals(io.read(buf, 2), 2u);
 		ensure_equals(StaticString(buf), "he");
 		ensure_equals(io.getBuffer(), "llo world");
-		
+
 		ensure_equals(io.read(buf, 7), 7u);
 		ensure_equals(StaticString(buf), "llo wor");
 		ensure_equals(io.getBuffer(), "ld");
 	}
-	
+
 	TEST_METHOD(15) {
 		// It blocks until the given number of bytes are read or until EOF.
 		TempThread thr1(boost::bind(writeAfterSomeTime, writer, 20000, "aa"));
@@ -214,7 +214,7 @@ namespace tut {
 		ensure_equals(StaticString(buf), "aa");
 		ensure("At least 18 msec elapsed", timer1.elapsed() >= 18);
 		ensure("At most 90 msec elapsed", timer1.elapsed() <= 90);
-		
+
 		TempThread thr2(boost::bind(closeAfterSomeTime, writer, 20000));
 		Timer timer2;
 		ensure_equals(io.read(buf, sizeof(buf)), 0u);
@@ -222,7 +222,7 @@ namespace tut {
 		ensure("At least 18 msec elapsed", timer2.elapsed() >= 18);
 		ensure("At most 90 msec elapsed", timer2.elapsed() <= 90);
 	}
-	
+
 	TEST_METHOD(16) {
 		// It throws TimeoutException if it cannot read enough data
 		// within the specified timeout.
@@ -240,9 +240,9 @@ namespace tut {
 			ensure_equals(io.getBuffer(), "");
 		}
 	}
-	
+
 	/***** Test readAll() *****/
-	
+
 	TEST_METHOD(20) {
 		// It reads everything until EOF.
 		TempThread thr1(boost::bind(writeAfterSomeTime, writer, 20000, "aa"));
@@ -251,9 +251,9 @@ namespace tut {
 		ensure_equals(io.readAll(), "aa");
 		ensure_equals(io.getBuffer(), "");
 		ensure("At least 38 msec elapsed", timer.elapsed() >= 38);
-		ensure("At most 95 msec elapsed", timer.elapsed() <= 95);
+		ensure("At most 150 msec elapsed", timer.elapsed() <= 150);
 	}
-	
+
 	TEST_METHOD(21) {
 		// It throws TimeoutException if it cannot read enough data
 		// within the specified timeout.
@@ -271,9 +271,9 @@ namespace tut {
 			ensure_equals(io.getBuffer(), "");
 		}
 	}
-	
+
 	/***** Test readLine() *****/
-	
+
 	TEST_METHOD(25) {
 		// If the connection is already closed and the buffer is empty,
 		// then it returns the empty string.
@@ -281,7 +281,7 @@ namespace tut {
 		ensure_equals(io.readLine(), "");
 		ensure_equals(io.getBuffer(), "");
 	}
-	
+
 	TEST_METHOD(26) {
 		// If the connection is already closed and the buffer is non-empty,
 		// then it returns the first line in the buffer.
@@ -294,14 +294,14 @@ namespace tut {
 		ensure_equals(io.readLine(), ".");
 		ensure_equals(io.getBuffer(), "");
 	}
-	
+
 	TEST_METHOD(27) {
 		// If the buffer is empty then it reads from the connection.
 		write("hello\nworld\n.");
 		ensure_equals(io.readLine(), "hello\n");
 		ensure_equals(io.getBuffer(), "world\n.");
 	}
-	
+
 	TEST_METHOD(28) {
 		// If the buffer is non-empty then it reads from the
 		// buffer first, then from the connection.
@@ -312,7 +312,7 @@ namespace tut {
 		ensure_equals(io.readLine(), "world\n");
 		ensure_equals(io.getBuffer(), ".");
 	}
-	
+
 	TEST_METHOD(29) {
 		// If the line is too long then it throws a SecurityException.
 		write("abcd");
@@ -323,7 +323,7 @@ namespace tut {
 			// Pass.
 		}
 	}
-	
+
 	TEST_METHOD(30) {
 		// It blocks until a line can be read or until EOF.
 		TempThread thr1(boost::bind(writeAfterSomeTime, writer, 20000, "hello"));
@@ -333,7 +333,7 @@ namespace tut {
 		ensure_equals(io.getBuffer(), "world\n.");
 		ensure("At least 33 msec elapsed", timer1.elapsed() >= 33);
 		ensure("At most 95 msec elapsed", timer1.elapsed() <= 90);
-		
+
 		TempThread thr3(boost::bind(closeAfterSomeTime, writer, 20000));
 		Timer timer2;
 		ensure_equals(io.readLine(), "world\n");
@@ -343,7 +343,7 @@ namespace tut {
 		ensure("At least 18 msec elapsed", timer2.elapsed() >= 18);
 		ensure("At most 95 msec elapsed", timer2.elapsed() <= 95);
 	}
-	
+
 	TEST_METHOD(31) {
 		// It throws TimeoutException if it cannot read enough data
 		// within the specified timeout.

data/test/cxx/CxxTestMain.cpp

@@ -1,6 +1,5 @@
 #include <TestSupport.h>
 #include "../tut/tut_reporter.h"
-#include "../support/valgrind.h"
 #include <oxt/initialize.hpp>
 #include <oxt/system_calls.hpp>
 #include <string>
@@ -12,7 +11,6 @@
 #include <cstring>
 #include <unistd.h>
 
-#include <MultiLibeio.cpp>
 #include <Utils.h>
 #include <Utils/IOUtils.h>
 #include <Utils/StrIntUtils.h>
@@ -123,11 +121,6 @@ parseOptions(int argc, char *argv[]) {
 	}
 }
 
-static int
-doNothing(eio_req *req) {
-	return 0;
-}
-
 static void
 loadConfigFile() {
 	Json::Reader reader;
@@ -169,32 +162,22 @@ main(int argc, char *argv[]) {
 	setenv("RAILS_ENV", "production", 1);
 	setenv("TESTING_PASSENGER", "1", 1);
 	setenv("PYTHONDONTWRITEBYTECODE", "1", 1);
-	unsetenv("PASSENGER_TMPDIR");
-	unsetenv("PASSENGER_TEMP_DIR");
+	unsetenv("TMPDIR");
 	oxt::initialize();
 	oxt::setup_syscall_interruption_support();
-    
+
 	tut::reporter reporter;
 	tut::runner.get().set_callback(&reporter);
 	allGroups = tut::runner.get().list_groups();
 	parseOptions(argc, argv);
-	
+
 	char path[PATH_MAX + 1];
 	getcwd(path, PATH_MAX);
 	resourceLocator = new ResourceLocator(extractDirName(path));
 
-	Passenger::MultiLibeio::init();
-	eio_set_idle_timeout(9999); // Never timeout.
-	eio_set_min_parallel(1);
-	eio_set_max_parallel(1);
-	if (RUNNING_ON_VALGRIND) {
-		// Start an EIO thread to warm up Valgrind.
-		eio_nop(0, doNothing, NULL);
-	}
-
 	loadConfigFile();
 	installAbortHandler();
-	
+
 	bool all_ok = true;
 	if (runMode == RUN_ALL_GROUPS) {
 		tut::runner.get().run_tests();
@@ -202,7 +185,6 @@ main(int argc, char *argv[]) {
 		tut::runner.get().run_tests(groupsToRun);
 	}
 	all_ok = reporter.all_ok();
-	Passenger::MultiLibeio::shutdown();
 	if (all_ok) {
 		return 0;
 	} else {

data/test/cxx/DataStructures/LStringTest.cpp

@@ -0,0 +1,275 @@
+#include <TestSupport.h>
+#include <DataStructures/LString.h>
+#include <MemoryKit/palloc.h>
+
+using namespace Passenger;
+using namespace std;
+
+namespace tut {
+	struct DataStructures_LStringTest {
+		LString str, str2;
+		psg_pool_t *pool;
+
+		DataStructures_LStringTest() {
+			psg_lstr_init(&str);
+			psg_lstr_init(&str2);
+			pool = psg_create_pool(PSG_DEFAULT_POOL_SIZE);
+		}
+
+		~DataStructures_LStringTest() {
+			psg_lstr_deinit(&str);
+			psg_lstr_deinit(&str2);
+			psg_destroy_pool(pool);
+		}
+
+		void reset() {
+			psg_lstr_deinit(&str);
+			psg_lstr_deinit(&str2);
+			psg_lstr_init(&str);
+			psg_lstr_init(&str2);
+		}
+	};
+
+	DEFINE_TEST_GROUP(DataStructures_LStringTest);
+
+	TEST_METHOD(1) {
+		set_test_name("It is empty upon initialization");
+		ensure_equals(str.size, 0u);
+		ensure_equals<void *>(str.start, NULL);
+		ensure_equals<void *>(str.end, NULL);
+	}
+
+	TEST_METHOD(2) {
+		set_test_name("Appending updates the links and the size");
+
+		psg_lstr_append(&str, pool, "ab");
+		ensure_equals(str.size, 2u);
+		ensure(str.start != NULL);
+		ensure_equals<void *>(str.start, str.end);
+
+		psg_lstr_append(&str, pool, "cde");
+		ensure_equals(str.size, 5u);
+		ensure(str.start != NULL);
+		ensure(str.start != str.end);
+	}
+
+	TEST_METHOD(3) {
+		set_test_name("Appending an empty string does nothing");
+	}
+
+
+	/***** Comparison with StaticString *****/
+
+	TEST_METHOD(10) {
+		set_test_name("Comparing an empty LString with an empty StaticString");
+		ensure(psg_lstr_cmp(&str, ""));
+	}
+
+	TEST_METHOD(11) {
+		set_test_name("Comparing an empty LString with a non-empty StaticString");
+		ensure(!psg_lstr_cmp(&str, "foo"));
+		ensure(!psg_lstr_cmp(&str, "bar"));
+	}
+
+	TEST_METHOD(12) {
+		set_test_name("Comparing an single-part LString with an empty StaticString");
+		psg_lstr_append(&str, pool, "hi");
+		ensure(!psg_lstr_cmp(&str, ""));
+	}
+
+	TEST_METHOD(13) {
+		set_test_name("Comparing an single-part LString with a non-empty StaticString");
+		psg_lstr_append(&str, pool, "hi");
+		ensure(psg_lstr_cmp(&str, "hi"));
+		ensure(!psg_lstr_cmp(&str, "ho"));
+	}
+
+	TEST_METHOD(14) {
+		set_test_name("Comparing an multi-part LString with an empty StaticString");
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str, pool, "ho");
+		ensure(!psg_lstr_cmp(&str, ""));
+	}
+
+	TEST_METHOD(15) {
+		set_test_name("Comparing an multi-part LString with a non-empty StaticString");
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str, pool, "ho");
+		ensure(psg_lstr_cmp(&str, "hiho"));
+		ensure(!psg_lstr_cmp(&str, "hiho!"));
+		ensure(!psg_lstr_cmp(&str, "hihi"));
+		ensure(!psg_lstr_cmp(&str, "hm"));
+		ensure(!psg_lstr_cmp(&str, ""));
+	}
+
+
+	/***** Comparison with StaticString, with size argument *****/
+
+	TEST_METHOD(20) {
+		set_test_name("Comparing an empty LString with an empty StaticString, with size argument");
+		ensure(psg_lstr_cmp(&str, "", 0));
+		ensure(psg_lstr_cmp(&str, "", 1));
+		ensure(psg_lstr_cmp(&str, "", 2));
+	}
+
+	TEST_METHOD(21) {
+		set_test_name("Comparing an empty LString with a non-empty StaticString, with size argument");
+		ensure(psg_lstr_cmp(&str, "hello", 0));
+		ensure(!psg_lstr_cmp(&str, "hello", 1));
+	}
+
+	TEST_METHOD(22) {
+		set_test_name("Comparing an single-part LString with an empty StaticString, with size argument");
+		psg_lstr_append(&str, pool, "hi");
+		ensure(psg_lstr_cmp(&str, "", 0));
+		ensure(!psg_lstr_cmp(&str, "", 1));
+	}
+
+	TEST_METHOD(23) {
+		set_test_name("Comparing an single-part LString with a non-empty StaticString, with size argument");
+		psg_lstr_append(&str, pool, "hi");
+		ensure(psg_lstr_cmp(&str, "hi!", 0));
+		ensure(psg_lstr_cmp(&str, "hi!", 1));
+		ensure(psg_lstr_cmp(&str, "hi!", 2));
+		ensure(!psg_lstr_cmp(&str, "hi!", 3));
+		ensure(!psg_lstr_cmp(&str, "ho", 2));
+	}
+
+	TEST_METHOD(24) {
+		set_test_name("Comparing an multi-part LString with an empty StaticString, with size argument");
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str, pool, "hoi");
+		ensure(psg_lstr_cmp(&str, "", 0));
+		ensure(!psg_lstr_cmp(&str, "", 1));
+	}
+
+	TEST_METHOD(25) {
+		set_test_name("Comparing an multi-part LString with a non-empty StaticString, with size argument");
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str, pool, "hoi");
+		ensure(psg_lstr_cmp(&str, "", 0));
+		ensure(psg_lstr_cmp(&str, "h", 1));
+		ensure(psg_lstr_cmp(&str, "hi", 2));
+		ensure(psg_lstr_cmp(&str, "hihoi", 0));
+		ensure(psg_lstr_cmp(&str, "hihoi", 1));
+		ensure(psg_lstr_cmp(&str, "hihoi", 2));
+		ensure(psg_lstr_cmp(&str, "hihoi", 3));
+		ensure(psg_lstr_cmp(&str, "hihoi", 5));
+		ensure(psg_lstr_cmp(&str, "hihoi!", 5));
+		ensure(!psg_lstr_cmp(&str, "hihoi!", 6));
+		ensure(!psg_lstr_cmp(&str, "hihoo", 5));
+		ensure(psg_lstr_cmp(&str, "hihoo", 4));
+	}
+
+
+	/***** Comparison with LString *****/
+
+	TEST_METHOD(30) {
+		set_test_name("Comparing an empty LString with an empty LString");
+		ensure(psg_lstr_cmp(&str, &str2));
+	}
+
+	TEST_METHOD(31) {
+		set_test_name("Comparing an empty LString with a one-part LString");
+		psg_lstr_append(&str2, pool, "hi");
+		ensure(!psg_lstr_cmp(&str, &str2));
+	}
+
+	TEST_METHOD(32) {
+		set_test_name("Comparing an empty LString with a multi-part LString");
+		psg_lstr_append(&str2, pool, "hi");
+		psg_lstr_append(&str2, pool, "hoi");
+		ensure(!psg_lstr_cmp(&str, &str2));
+	}
+
+	TEST_METHOD(33) {
+		set_test_name("Comparing an one-part LString with a one-part LString");
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str2, pool, "hi");
+		ensure(psg_lstr_cmp(&str, &str2));
+
+		reset();
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str2, pool, "ho");
+		ensure(!psg_lstr_cmp(&str, &str2));
+
+		reset();
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str2, pool, "hii");
+		ensure(!psg_lstr_cmp(&str, &str2));
+	}
+
+	TEST_METHOD(34) {
+		set_test_name("Comparing an one-part LString with a multi-part LString");
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str2, pool, "h");
+		psg_lstr_append(&str2, pool, "i");
+		ensure(psg_lstr_cmp(&str, &str2));
+
+		reset();
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str2, pool, "h");
+		psg_lstr_append(&str2, pool, "o");
+		ensure(!psg_lstr_cmp(&str, &str2));
+
+		reset();
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str2, pool, "hi");
+		psg_lstr_append(&str2, pool, "o");
+		ensure(!psg_lstr_cmp(&str, &str2));
+
+		reset();
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str2, pool, "hi");
+		psg_lstr_append(&str2, pool, "i");
+		ensure(!psg_lstr_cmp(&str, &str2));
+	}
+
+	TEST_METHOD(35) {
+		set_test_name("Comparing an multi-part LString with a multi-part LString");
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str, pool, "ho!");
+		psg_lstr_append(&str2, pool, "hi");
+		psg_lstr_append(&str2, pool, "ho!");
+		ensure(psg_lstr_cmp(&str, &str2));
+
+		reset();
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str, pool, "ho!");
+		psg_lstr_append(&str2, pool, "h");
+		psg_lstr_append(&str2, pool, "iho!");
+		ensure(psg_lstr_cmp(&str, &str2));
+
+		reset();
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str, pool, "ho!");
+		psg_lstr_append(&str2, pool, "h");
+		psg_lstr_append(&str2, pool, "iho");
+		ensure(!psg_lstr_cmp(&str, &str2));
+
+		reset();
+		psg_lstr_append(&str, pool, "hi");
+		psg_lstr_append(&str, pool, "ho!");
+		psg_lstr_append(&str2, pool, "h");
+		psg_lstr_append(&str2, pool, "i");
+		psg_lstr_append(&str2, pool, "h");
+		psg_lstr_append(&str2, pool, "o!");
+		ensure(psg_lstr_cmp(&str, &str2));
+	}
+
+
+	/***** psg_lstr_make_contiguous *****/
+
+	TEST_METHOD(40) {
+		const LString *cstr;
+
+		psg_lstr_append(&str, pool, "hey");
+		psg_lstr_append(&str, pool, "my");
+		psg_lstr_append(&str, pool, "world");
+
+		cstr = psg_lstr_make_contiguous(&str, pool);
+		ensure_equals(cstr->size, strlen("heymyworld"));
+		ensure_equals<void *>(cstr->start->next, NULL);
+		ensure_equals(StaticString(cstr->start->data, cstr->size), "heymyworld");
+	}
+}