passenger 3.0.0 → 3.0.1

data/test/cxx/MessageChannelTest.cpp

@@ -205,7 +205,7 @@ namespace tut {
 	
 	TEST_METHOD(9) {
 		// readScalar() should be able to read messages constructed by writeScalar().
-		// This also tests readRaw()/writeRaw() because readScalar()/writeScalar() uses
+		// This also tests readExact()/writeExact() because readScalar()/writeScalar() uses
 		// them internally.
 		writer.writeScalar("hello\n\r world!!!");
 		writer.writeScalar("  and this is a second message");
@@ -380,121 +380,6 @@ namespace tut {
 		ensure(!channel.connected());
 	}
 	
-	TEST_METHOD(15) {
-		// waitUntilReadable() waits for the specified timeout if no data is readable.
-		unsigned long long timeout = 25;
-		ensure("No data is available", !reader.waitUntilReadable(&timeout));
-		ensure("The passed time is deducted from the timeout", timeout < 5);
-	}
-	
-	TEST_METHOD(16) {
-		// waitUntilReadable() waits for less than the specified timeout if data
-		// is not available immediately but still available before the timeout.
-		TempThread thr(boost::bind(&writeDataAfterSomeTime, writer.filenum(), 35));
-		
-		unsigned long long timeout = 1000;
-		ensure("Data is available", reader.waitUntilReadable(&timeout));
-		ensure("At least 35 msec passed.", timeout <= 1000 - 35);
-		ensure("At most 70 msec passed.", timeout >= 1000 - 70);  // depends on system scheduler though
-	}
-	
-	TEST_METHOD(17) {
-		// waitUntilReadable() returns immediately if timeout is 0.
-		unsigned long long timeout = 0;
-		ensure("No data is available", !reader.waitUntilReadable(&timeout));
-		ensure_equals("Timeout is not modified", timeout, 0u);
-		
-		write(writer.filenum(), "hi", 2);
-		ensure("Data is available", reader.waitUntilReadable(&timeout));
-		ensure_equals("Timeout is not modified", timeout, 0u);
-	}
-	
-	TEST_METHOD(18) {
-		// waitUntilReadable() returns immediately if there's data immediately available.
-		unsigned long long timeout = 100;
-		writer.writeRaw("hi", 2);
-		ensure("Data is available", reader.waitUntilReadable(&timeout));
-		ensure("Timeout is not modified", timeout >= 100 - 5);
-	}
-	
-	TEST_METHOD(19) {
-		// readRaw() throws TimeoutException if no data is received within the timeout.
-		unsigned long long timeout = 50;
-		char buf;
-		try {
-			reader.readRaw(&buf, 1, &timeout);
-			fail("No TimeoutException thrown.");
-		} catch (const TimeoutException &) {
-			ensure("The passed time is deducted from timeout", timeout < 5);
-		}
-	}
-	
-	TEST_METHOD(20) {
-		// readRaw() throws TimeoutException if not enough data is received within the timeout.
-		unsigned long long timeout = 20;
-		char buf[100];
-		
-		TempThread thr(boost::bind(&writeDataSlowly, writer.filenum(), sizeof(buf), 1));
-		
-		try {
-			reader.readRaw(&buf, sizeof(buf), &timeout);
-			fail("No TimeoutException thrown.");
-		} catch (const TimeoutException &) {
-			ensure("The passed time is deducted from timeout", timeout < 5);
-		}
-	}
-	
-	TEST_METHOD(21) {
-		// readRaw() throws TimeException if timeout is 0 and no data is immediately available.
-		unsigned long long timeout = 0;
-		char buf;
-		try {
-			reader.readRaw(&buf, 1, &timeout);
-			fail("No TimeoutException thrown.");
-		} catch (const TimeoutException &) {
-			ensure_equals("Timeout unchanged", timeout, 0u);
-		}
-	}
-	
-	TEST_METHOD(22) {
-		// readRaw() throws TimeoutException if timeout is 0 and not enough data is
-		// immediately available.
-		unsigned long long timeout = 0;
-		writer.writeRaw("hi", 2);
-		try {
-			char buf[100];
-			reader.readRaw(&buf, sizeof(buf), &timeout);
-			fail("No TimeoutException thrown.");
-		} catch (const TimeoutException &) {
-			ensure_equals("Timeout is unchanged", timeout, 0u);
-		}
-	}
-	
-	TEST_METHOD(23) {
-		// readRaw() deducts the amount of time spent on waiting from the timeout variable.
-		unsigned long long timeout = 60;
-		char buf[3];
-		
-		// Spawn a thread that writes 100 bytes per second, i.e. each byte takes 10 msec.
-		TempThread thr(boost::bind(&writeDataSlowly, writer.filenum(), 1000, 100));
-		
-		// We read 3 bytes.
-		reader.readRaw(&buf, sizeof(buf), &timeout);
-		ensure("Should have taken at least 20 msec", timeout <= 60 - 20);
-		ensure("Should have taken at most 40 msec", timeout >= 60 - 40);
-	}
-	
-	TEST_METHOD(24) {
-		// readRaw() does not wait and does not modify the timeout variable if there's
-		// immediately enough data available.
-		unsigned long long timeout = 100;
-		char buf[2];
-		
-		writer.writeRaw("hi", 2);
-		reader.readRaw(&buf, 2, &timeout);
-		ensure_equals("Timeout not modified", timeout, 100u);
-	}
-	
 	TEST_METHOD(25) {
 		// readScalar() doesn't throw SecurityException if maxSize is
 		// given but the available amount of data equals maxSize.
@@ -533,7 +418,7 @@ namespace tut {
 		// within the timeout.
 		unsigned long long timeout = 30;
 		string str;
-		writer.writeRaw("xxx", 3); // A part of a random 32-bit integer header.
+		writeExact(writer.filenum(), "xxx", 3); // A part of a random 32-bit integer header.
 		try {
 			reader.readScalar(str, 0, &timeout);
 			fail("TimeoutException expected");
@@ -612,7 +497,7 @@ namespace tut {
 	
 	TEST_METHOD(33) {
 		// readUint32() returns false if EOF was reached prematurely.
-		writer.writeRaw("x", 1);
+		writeExact(writer.filenum(), "x", 1);
 		writer.close();
 		unsigned int i;
 		ensure(!reader.readUint32(i));
@@ -634,7 +519,7 @@ namespace tut {
 		// readUint32() throws TimeoutException if not enough data was available within the timeout.
 		unsigned long long timeout = 30;
 		unsigned int i;
-		writer.writeRaw("xx", 2);
+		writeExact(writer.filenum(), "xx", 2);
 		try {
 			reader.readUint32(i, &timeout);
 			fail("TimeoutException expected");
@@ -661,7 +546,7 @@ namespace tut {
 		// data is immediately available.
 		unsigned long long timeout = 0;
 		unsigned int i;
-		writer.writeRaw("xx", 2);
+		writeExact(writer.filenum(), "xx", 2);
 		try {
 			reader.readUint32(i, &timeout);
 			fail("TimeoutException expected");

data/test/cxx/ProcessMetricsCollectorTest.cpp

@@ -0,0 +1,121 @@
+#include <sys/wait.h>
+#include <signal.h>
+#include <unistd.h>
+#include <cstdio>
+#include <cerrno>
+#include "TestSupport.h"
+#include "Utils/StrIntUtils.h"
+#include "Utils/ProcessMetricsCollector.h"
+
+using namespace Passenger;
+
+namespace tut {
+	struct ProcessMetricsCollectorTest {
+		ProcessMetricsCollector collector;
+		pid_t child;
+		
+		ProcessMetricsCollectorTest() {
+			child = -1;
+		}
+		
+		~ProcessMetricsCollectorTest() {
+			if (child != -1) {
+				kill(child, SIGKILL);
+				waitpid(child, NULL, 0);
+			}
+		}
+		
+		pid_t spawnChild(int memory) {
+			string memoryStr = toString(memory);
+			pid_t pid = fork();
+			if (pid == 0) {
+				execlp("support/allocate_memory",
+					"support/allocate_memory",
+					memoryStr.c_str(),
+					(char *) 0);
+				
+				int e = errno;
+				fprintf(stderr, "Cannot execute support/allocate_memory: %s\n",
+					strerror(e));
+				fflush(stderr);
+				_exit(1);
+			} else {
+				return pid;
+			}
+		}
+	};
+	
+	DEFINE_TEST_GROUP(ProcessMetricsCollectorTest);
+	
+	TEST_METHOD(1) {
+		// It collects the metrics for the given PIDs.
+		collector.setPsOutput(
+			"  PID  PPID  %CPU    RSS      VSZ  PGID COMMAND\n"
+			"    1     0   0.0   1276  2456836     1 /sbin/launchd\n"
+			"34678  1265  95.2   4128  2437812 34677 /bin/bash -li\n"
+		);
+		vector<pid_t> pids;
+		pids.push_back(1);
+		pids.push_back(34678);
+		ProcessMetricMap result = collector.collect(pids);
+		
+		ensure_equals(result.size(), 2u);
+		
+		ensure_equals(result[1].pid, (pid_t) 1);
+		ensure_equals(result[1].ppid, (pid_t) 0);
+		ensure_equals(result[1].cpu, 0u);
+		ensure_equals(result[1].rss, 1276u);
+		ensure_equals(result[1].processGroupId, (pid_t) 1);
+		ensure_equals(result[1].command, "/sbin/launchd");
+		
+		ensure_equals(result[34678].pid, (pid_t) 34678);
+		ensure_equals(result[34678].ppid, (pid_t) 1265);
+		ensure_equals(result[34678].cpu, 95u);
+		ensure_equals(result[34678].rss, 4128u);
+		ensure_equals(result[34678].processGroupId, (pid_t) 34677);
+		ensure_equals(result[34678].command, "/bin/bash -li");
+	}
+	
+	TEST_METHOD(2) {
+		// It does not collect the metrics for PIDs that don't exist.
+		collector.setPsOutput(
+			"  PID  PPID  %CPU    RSS      VSZ  PGID COMMAND\n"
+			"    1     0   0.0   1276  2456836     1 /sbin/launchd\n"
+		);
+		vector<pid_t> pids;
+		pids.push_back(1);
+		pids.push_back(34678);
+		ProcessMetricMap result = collector.collect(pids);
+		
+		ensure_equals(result.size(), 1u);
+		ensure(result.find(1) != result.end());
+		ensure(result.find(34678) == result.end());
+	}
+	
+	TEST_METHOD(3) {
+		// Measuring real memory usage works.
+		ssize_t pss, privateDirty, swap;
+		child = spawnChild(50);
+		usleep(500000);
+		collector.measureRealMemory(child, pss, privateDirty, swap);
+		#ifdef __APPLE__
+			if (geteuid() == 0) {
+				ensure(pss > 50000 && pss < 60000);
+				ensure(privateDirty > 50000 && privateDirty < 60000);
+				ensure_equals(swap, (ssize_t) -1);
+			} else {
+				ensure_equals(pss, (ssize_t) -1);
+				ensure_equals(privateDirty, (ssize_t) -1);
+				ensure_equals(swap, (ssize_t) -1);
+			}
+		#elif defined(__linux__)
+			ensure("PSS is correct", (pss > 50000 && pss < 60000) || pss == -1);
+			ensure("Private dirty is correct", privateDirty > 50000 && privateDirty < 60000);
+			ensure("Swap is correct", swap < 10000);
+		#else
+			ensure((pss > 50000 && pss < 60000) || pss == -1);
+			ensure((privateDirty > 50000 && privateDirty < 60000) || privateDirty == -1);
+			ensure(swap < 10000 || swap == -1);
+		#endif
+	}
+}

data/test/cxx/StaticStringTest.cpp

@@ -83,4 +83,138 @@ namespace tut {
 			string("hello world") < string("hello")
 		);
 	}
+	
+	TEST_METHOD(4) {
+		// Test find(char)
+		ensure_equals("Assertion 1",
+			StaticString("").find('c'),
+			string::npos
+		);
+		ensure_equals("Assertion 2",
+			StaticString("hello world").find('c'),
+			string::npos
+		);
+		ensure_equals("Assertion 3",
+			StaticString("hello world").find('h'),
+			(string::size_type) 0
+		);
+		ensure_equals("Assertion 4",
+			StaticString("hello world").find('o'),
+			(string::size_type) 4
+		);
+		
+		ensure_equals("Assertion 5",
+			StaticString("hello world").find('h', 1),
+			string::npos
+		);
+		ensure_equals("Assertion 6",
+			StaticString("hello world").find('o', 1),
+			(string::size_type) 4
+		);
+		ensure_equals("Assertion 7",
+			StaticString("hello world").find('o', 5),
+			(string::size_type) 7
+		);
+		
+		ensure_equals("Assertion 8",
+			StaticString("hello world").find('h', 12),
+			string::npos
+		);
+		ensure_equals("Assertion 9",
+			StaticString("hello world").find('h', 20),
+			string::npos
+		);
+	}
+	
+	TEST_METHOD(5) {
+		// Test find(str)
+		ensure_equals("Assertion 1",
+			StaticString("").find(""),
+			(string::size_type) 0
+		);
+		ensure_equals("Assertion 2",
+			StaticString("").find("c"),
+			string::npos
+		);
+		ensure_equals("Assertion 3",
+			StaticString("hello world").find("c"),
+			string::npos
+		);
+		ensure_equals("Assertion 4",
+			StaticString("hello world").find("h"),
+			(string::size_type) 0
+		);
+		ensure_equals("Assertion 5",
+			StaticString("hello world").find("o"),
+			(string::size_type) 4
+		);
+		ensure_equals("Assertion 6",
+			StaticString("hello world").find("ello"),
+			(string::size_type) 1
+		);
+		ensure_equals("Assertion 7",
+			StaticString("hello world").find("world"),
+			(string::size_type) 6
+		);
+		ensure_equals("Assertion 8",
+			StaticString("hello world").find("worldd"),
+			string::npos
+		);
+		ensure_equals("Assertion 9",
+			StaticString("hello world").find(""),
+			(string::size_type) 0
+		);
+		
+		ensure_equals("Assertion 10",
+			StaticString("hello world").find("h", 1),
+			string::npos
+		);
+		ensure_equals("Assertion 11",
+			StaticString("hello hello").find("ll", 1),
+			(string::size_type) 2
+		);
+		ensure_equals("Assertion 12",
+			StaticString("hello hello").find("ll", 3),
+			(string::size_type) 8
+		);
+		
+		ensure_equals("Assertion 13",
+			StaticString("hello world").find("he", 12),
+			string::npos
+		);
+		ensure_equals("Assertion 14",
+			StaticString("hello world").find("he", 20),
+			string::npos
+		);
+	}
+	
+	TEST_METHOD(6) {
+		// Test substr()
+		ensure_equals("Assertion 1",
+			StaticString("hello world").substr(),
+			"hello world");
+		ensure_equals("Assertion 2",
+			StaticString("hello world").substr(1),
+			"ello world");
+		ensure_equals("Assertion 3",
+			StaticString("hello world").substr(4),
+			"o world");
+		ensure_equals("Assertion 4",
+			StaticString("hello world").substr(11),
+			"");
+		
+		try {
+			StaticString("hello world").substr(12);
+			fail("out_of_range expected");
+		} catch (out_of_range &) {
+			// Success.
+		}
+		
+		ensure_equals("Assertion 5",
+			StaticString("hello world").substr(2, 3),
+			"llo");
+		ensure_equals("Assertion 6",
+			StaticString("hello world").substr(6, 10),
+			"world");
+	}
 }

data/test/cxx/UtilsTest.cpp

@@ -1,7 +1,6 @@
 #include "TestSupport.h"
 #include "Utils.h"
 #include "Utils/StrIntUtils.h"
-#include "Utils/IOUtils.h"
 #include "Utils/MemZeroGuard.h"
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -316,9 +315,9 @@ namespace tut {
 		stat("tmp.dir/foo", &buf);
 		stat("tmp.dir/foo/bar", &buf2);
 		ensure_equals(buf.st_mode, buf2.st_mode);
-		ensure_equals(buf.st_mode & 0xFFF,
-			S_IRUSR | S_IWUSR | S_IXUSR | S_ISUID |
-			S_IROTH | S_IXOTH);
+		ensure_equals((mode_t) (buf.st_mode & 0xFFF),
+			(mode_t) (S_IRUSR | S_IWUSR | S_IXUSR | S_ISUID |
+			S_IROTH | S_IXOTH));
 	}
 	
 	TEST_METHOD(43) {
@@ -466,50 +465,9 @@ namespace tut {
 		ensure_equals(stringToLL("    -5abcdef1234"), -5ll);
 	}
 	
-	/***** Test getSocketAddressType() *****/
-	
-	TEST_METHOD(51) {
-		ensure_equals(getSocketAddressType(""), SAT_UNKNOWN);
-		ensure_equals(getSocketAddressType("/foo.socket"), SAT_UNKNOWN);
-		ensure_equals(getSocketAddressType("unix:"), SAT_UNKNOWN);
-		ensure_equals(getSocketAddressType("unix:/"), SAT_UNIX);
-		ensure_equals(getSocketAddressType("unix:/foo.socket"), SAT_UNIX);
-		ensure_equals(getSocketAddressType("tcp:"), SAT_UNKNOWN);
-		ensure_equals(getSocketAddressType("tcp://"), SAT_UNKNOWN);
-		// Doesn't check whether it contains port
-		ensure_equals(getSocketAddressType("tcp://127.0.0.1"), SAT_TCP);
-		ensure_equals(getSocketAddressType("tcp://127.0.0.1:80"), SAT_TCP);
-	}
-	
-	TEST_METHOD(52) {
-		ensure_equals(parseUnixSocketAddress("unix:/foo.socket"), "/foo.socket");
-		try {
-			parseUnixSocketAddress("unix:");
-			fail("ArgumentException expected");
-		} catch (const ArgumentException &e) {
-			// Pass.
-		}
-	}
-	
-	TEST_METHOD(53) {
-		string host;
-		unsigned short port;
-		
-		parseTcpSocketAddress("tcp://127.0.0.1:80", host, port);
-		ensure_equals(host, "127.0.0.1");
-		ensure_equals(port, 80);
-		
-		try {
-			parseTcpSocketAddress("tcp://", host, port);
-			fail("ArgumentException expected");
-		} catch (const ArgumentException &e) {
-			// Pass.
-		}
-	}
-	
 	/***** Test cEscapeString() *****/
 	
-	TEST_METHOD(54) {
+	TEST_METHOD(51) {
 		ensure_equals(cEscapeString(""), "");
 		ensure_equals(cEscapeString("abcdXYZ123!?"), "abcdXYZ123!?");
 		ensure_equals(cEscapeString("foo\n"), "foo\\n");
@@ -518,4 +476,16 @@ namespace tut {
 			"\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t");
 		ensure_equals(cEscapeString("\xFF\xFE\t\xD0"), "\\xFF\\xFE\\t\\xD0");
 	}
+	
+	/***** Test escapeHTML() *****/
+	
+	TEST_METHOD(52) {
+		const char weird[] = "Weird \x01\x00 characters?";
+		ensure_equals(escapeHTML(""), "");
+		ensure_equals(escapeHTML("hello\n\r\t WORLD!"), "hello\n\r\t WORLD!");
+		ensure_equals(escapeHTML("<b>bold</b>"), "&lt;b&gt;bold&lt;/b&gt;");
+		ensure_equals(escapeHTML(StaticString(weird, sizeof(weird) - 1)),
+			"Weird &#1;&#0; characters?");
+		ensure_equals(escapeHTML("UTF-8: ☃ ☀; ☁ ☂\x01"), "UTF-8: ☃ ☀; ☁ ☂&#1;");
+	}
 }