passenger 2.2.2 → 2.2.3

data/test/Base64Test.cpp

@@ -0,0 +1,48 @@
+#include "tut.h"
+#include "Base64.h"
+
+using namespace Passenger;
+using namespace std;
+
+namespace tut {
+	struct Base64Test {
+	};
+	
+	DEFINE_TEST_GROUP(Base64Test);
+
+	TEST_METHOD(1) {
+		// Test encoding.
+		ensure_equals(Base64::encode(""), "");
+		ensure_equals(Base64::encode("a"), "YQ==");
+		ensure_equals(Base64::encode("b"), "Yg==");
+		ensure_equals(Base64::encode("ab"), "YWI=");
+		ensure_equals(Base64::encode("abc"), "YWJj");
+		ensure_equals(Base64::encode("abcd"), "YWJjZA==");
+		ensure_equals(Base64::encode("\1\2\3\4\5\6\7\255"), "AQIDBAUGB60=");
+		ensure_equals(Base64::encode("The gamma-ray burst from April 23, a "
+			"powerful explosion from a dying star, was detected by the "
+			"Swift satellite using on-board gamma-ray and X-ray instruments."),
+			"VGhlIGdhbW1hLXJheSBidXJzdCBmcm9tIEFwcmlsIDIzLCBhIHBvd2VyZnVs"
+			"IGV4cGxvc2lvbiBmcm9tIGEgZHlpbmcgc3Rhciwgd2FzIGRldGVjdGVkIGJ5"
+			"IHRoZSBTd2lmdCBzYXRlbGxpdGUgdXNpbmcgb24tYm9hcmQgZ2FtbWEtcmF5"
+			"IGFuZCBYLXJheSBpbnN0cnVtZW50cy4=");
+	}
+	
+	TEST_METHOD(2) {
+		// Test decoding.
+		ensure_equals(Base64::decode(""), "");
+		ensure_equals(Base64::decode("YQ=="), "a");
+		ensure_equals(Base64::decode("Yg=="), "b");
+		ensure_equals(Base64::decode("YWI="), "ab");
+		ensure_equals(Base64::decode("YWJj"), "abc");
+		ensure_equals(Base64::decode("YWJjZA=="), "abcd");
+		ensure_equals(Base64::decode("AQIDBAUGB60="), "\1\2\3\4\5\6\7\255");
+		ensure_equals(Base64::decode("VGhlIGdhbW1hLXJheSBidXJzdCBmcm9tIEFwcmlsIDIzLCBhIHBvd2VyZnVs"
+			"IGV4cGxvc2lvbiBmcm9tIGEgZHlpbmcgc3Rhciwgd2FzIGRldGVjdGVkIGJ5"
+			"IHRoZSBTd2lmdCBzYXRlbGxpdGUgdXNpbmcgb24tYm9hcmQgZ2FtbWEtcmF5"
+			"IGFuZCBYLXJheSBpbnN0cnVtZW50cy4="),
+			"The gamma-ray burst from April 23, a "
+			"powerful explosion from a dying star, was detected by the "
+			"Swift satellite using on-board gamma-ray and X-ray instruments.");
+	}
+}

data/test/CachedFileStatTest.cpp

@@ -1,5 +1,5 @@
 #include "tut.h"
-#include "CachedFileStat.h"
+#include "CachedFileStat.hpp"
 #include "SystemTime.h"
 #include <sys/types.h>
 #include <utime.h>
@@ -9,21 +9,9 @@ using namespace Passenger;
 
 namespace tut {
 	struct CachedFileStatTest {
-		CachedFileStat *stat;
-		CachedMultiFileStat *mstat;
-		
-		CachedFileStatTest() {
-			stat = (CachedFileStat *) NULL;
-			mstat = (CachedMultiFileStat *) NULL;
-		}
+		struct stat buf;
 		
 		~CachedFileStatTest() {
-			if (stat != NULL) {
-				delete stat;
-			}
-			if (mstat != NULL) {
-				cached_multi_file_stat_free(mstat);
-			}
 			SystemTime::release();
 			unlink("test.txt");
 			unlink("test2.txt");
@@ -32,6 +20,8 @@ namespace tut {
 		}
 	};
 	
+	DEFINE_TEST_GROUP(CachedFileStatTest);
+	
 	static void touch(const char *filename, time_t timestamp = 0) {
 		FILE *f = fopen(filename, "w");
 		fprintf(f, "hi");
@@ -44,129 +34,106 @@ namespace tut {
 		}
 	}
 	
-	DEFINE_TEST_GROUP(CachedFileStatTest);
-	
-	/************ Tests for CachedFileStat ************/
+	/************ Tests involving a single file ************/
 	
 	TEST_METHOD(1) {
-		// cached_file_stat_new() does not stat the file immediately.
+		// Statting a new file works.
 		touch("test.txt");
-		stat = new CachedFileStat("test.txt");
-		ensure_equals((long) stat->info.st_size, (long) 0);
-		ensure_equals(stat->info.st_mtime, (time_t) 0);
+		CachedFileStat stat(1);
+		ensure_equals(stat.stat("test.txt", &buf, 1), 0);
+		ensure_equals((long) buf.st_size, (long) 2);
 	}
 	
 	TEST_METHOD(2) {
-		// cached_file_stat_refresh() on a newly created
-		// CachedFileStat works.
-		touch("test.txt");
-		stat = new CachedFileStat("test.txt");
-		ensure_equals(stat->refresh(1), 0);
-		ensure_equals((long) stat->info.st_size, (long) 2);
-	}
-	
-	TEST_METHOD(3) {
-		// cached_file_stat_refresh() does not re-stat the file
-		// until the cache has expired.
+		// It does not re-stat an existing file until the cache has expired.
+		CachedFileStat stat(1);
+		
 		SystemTime::force(5);
-		stat = new CachedFileStat("test.txt");
 		touch("test.txt", 1);
-		ensure_equals("1st refresh succceeded",
-			stat->refresh(1),
+		ensure_equals("1st stat succceeded",
+			stat.stat("test.txt", &buf, 1),
 			0);
 		
 		touch("test.txt", 1000);
-		ensure_equals("2nd refresh succceeded",
-			stat->refresh(1),
+		ensure_equals("2nd stat succceeded",
+			stat.stat("test.txt", &buf, 1),
 			0);
 		ensure_equals("Cached value was used",
-			stat->info.st_mtime,
+			buf.st_mtime,
 			(time_t) 1);
 		
 		SystemTime::force(6);
-		ensure_equals("3rd refresh succceeded",
-			stat->refresh(1),
+		ensure_equals("3rd stat succceeded",
+			stat.stat("test.txt", &buf, 1),
 			0);
 		ensure_equals("Cache has been invalidated",
-			stat->info.st_mtime,
+			buf.st_mtime,
 			(time_t) 1000);
 	}
 	
-	TEST_METHOD(5) {
-		// cached_file_stat_refresh() on a nonexistant file returns
-		// an error.
-		stat = new CachedFileStat("test.txt");
-		ensure_equals(stat->refresh(1), -1);
+	TEST_METHOD(3) {
+		// Statting a nonexistant file returns an error.
+		CachedFileStat stat(1);
+		ensure_equals(stat.stat("test.txt", &buf, 1), -1);
 		ensure_equals("It sets errno appropriately", errno, ENOENT);
 	}
 	
-	TEST_METHOD(6) {
-		// cached_file_stat_refresh() on a nonexistant file does not
-		// re-stat the file until the cache has expired.
+	TEST_METHOD(4) {
+		// It does not re-stat a previously nonexistant file until
+		// the cache has expired.
 		SystemTime::force(5);
-		stat = new CachedFileStat("test.txt");
-		ensure_equals("1st refresh failed",
-			stat->refresh(1),
+		CachedFileStat stat(1);
+		ensure_equals("1st stat failed",
+			stat.stat("test.txt", &buf, 1),
 			-1);
 		ensure_equals("It sets errno appropriately", errno, ENOENT);
 		
 		errno = EEXIST;
-		ensure_equals("2nd refresh failed",
-			stat->refresh(1),
+		touch("test.txt", 1000);
+		ensure_equals("2nd stat failed",
+			stat.stat("test.txt", &buf, 1),
 			-1);
 		ensure_equals("It sets errno appropriately", errno, ENOENT);
 		ensure_equals("Cached value was used",
-			stat->info.st_mtime,
+			buf.st_mtime,
 			(time_t) 0);
 		
-		touch("test.txt", 1000);
 		SystemTime::force(6);
-		ensure_equals("3rd refresh succeeded",
-			stat->refresh(1),
+		ensure_equals("3rd stat succeeded",
+			stat.stat("test.txt", &buf, 1),
 			0);
 		ensure_equals("Cache has been invalidated",
-			stat->info.st_mtime,
+			buf.st_mtime,
 			(time_t) 1000);
 		
 		unlink("test.txt");
-		ensure_equals("4th refresh succeeded even though file was unlinked",
-			stat->refresh(1),
+		ensure_equals("4th stat succeeded even though file was unlinked",
+			stat.stat("test.txt", &buf, 1),
 			0);
 		ensure_equals("Cached value was used",
-			stat->info.st_mtime,
+			buf.st_mtime,
 			(time_t) 1000);
 	}
 	
-	
-	/************ Tests for CachedMultiFileStat ************/
-	
-	TEST_METHOD(10) {
-		// Statting an existing file works.
-		struct stat buf;
-		
+	TEST_METHOD(5) {
+		// If the throttling rate is 0 then the cache will be bypassed.
+		SystemTime::force(5);
+		CachedFileStat stat(2);
+		ensure_equals("1st stat returns -1",
+			stat.stat("test.txt", &buf, 0),
+			-1);
 		touch("test.txt");
-		mstat = cached_multi_file_stat_new(1);
-		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test.txt", &buf, 0),
+		ensure_equals("2nd stat did not go through the cache",
+			stat.stat("test.txt", &buf, 0),
 			0);
-		ensure_equals((long) buf.st_size, (long) 2);
 	}
 	
-	TEST_METHOD(11) {
-		// Statting a nonexistant file works.
-		struct stat buf;
-		
-		mstat = cached_multi_file_stat_new(1);
-		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test.txt", &buf, 0),
-			-1);
-	}
 	
-	TEST_METHOD(12) {
-		// Throttling works.
-		struct stat buf;
-		
-		mstat = cached_multi_file_stat_new(2);
+	/************ Tests involving multiple files ************/
+	
+	TEST_METHOD(10) {
+		// Throttling in combination with multiple files works.
+		CachedFileStat stat(2);
 		SystemTime::force(5);
 		
 		// Touch and stat test.txt. The next stat should return
@@ -174,13 +141,13 @@ namespace tut {
 		
 		touch("test.txt", 10);
 		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test.txt", &buf, 1),
+			stat.stat("test.txt", &buf, 1),
 			0);
 		ensure_equals(buf.st_mtime, (time_t) 10);
 		
 		touch("test.txt", 20);
 		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test.txt", &buf, 1),
+			stat.stat("test.txt", &buf, 1),
 			0);
 		ensure_equals(buf.st_mtime, (time_t) 10);
 		
@@ -189,13 +156,13 @@ namespace tut {
 		
 		touch("test2.txt", 30);
 		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test2.txt", &buf, 1),
+			stat.stat("test2.txt", &buf, 1),
 			0);
 		ensure_equals(buf.st_mtime, (time_t) 30);
 		
 		touch("test2.txt", 40);
 		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test2.txt", &buf, 1),
+			stat.stat("test2.txt", &buf, 1),
 			0);
 		ensure_equals(buf.st_mtime, (time_t) 30);
 		
@@ -204,39 +171,37 @@ namespace tut {
 		
 		SystemTime::force(6);
 		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test.txt", &buf, 1),
+			stat.stat("test.txt", &buf, 1),
 			0);
 		ensure_equals(buf.st_mtime, (time_t) 20);
 		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test2.txt", &buf, 1),
+			stat.stat("test2.txt", &buf, 1),
 			0);
 		ensure_equals(buf.st_mtime, (time_t) 40);
 	}
 	
-	TEST_METHOD(13) {
+	TEST_METHOD(11) {
 		// Cache limiting works.
-		struct stat buf;
-		
-		mstat = cached_multi_file_stat_new(3);
+		CachedFileStat stat(3);
 		SystemTime::force(5);
 		
 		// Create and stat test.txt, test2.txt and test3.txt.
 		
 		touch("test.txt", 1000);
 		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test.txt", &buf, 1),
+			stat.stat("test.txt", &buf, 1),
 			0);
 		ensure_equals(buf.st_mtime, (time_t) 1000);
 		
 		touch("test2.txt", 1001);
 		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test2.txt", &buf, 1),
+			stat.stat("test2.txt", &buf, 1),
 			0);
 		ensure_equals(buf.st_mtime, (time_t) 1001);
 		
 		touch("test3.txt", 1003);
 		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test3.txt", &buf, 1),
+			stat.stat("test3.txt", &buf, 1),
 			0);
 		ensure_equals(buf.st_mtime, (time_t) 1003);
 		
@@ -245,18 +210,193 @@ namespace tut {
 		// upon statting it again its new timestamp should be returned.
 		
 		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test2.txt", &buf, 1),
+			stat.stat("test2.txt", &buf, 1),
 			0);
 		
 		touch("test4.txt", 1004);
 		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test4.txt", &buf, 1),
+			stat.stat("test4.txt", &buf, 1),
 			0);
 		
 		touch("test.txt", 3000);
 		ensure_equals(
-			cached_multi_file_stat_perform(mstat, "test.txt", &buf, 1),
+			stat.stat("test.txt", &buf, 1),
 			0);
 		ensure_equals(buf.st_mtime, (time_t) 3000);
 	}
+	
+	TEST_METHOD(12) {
+		// Increasing the cache size dynamically works.
+		SystemTime::force(5);
+		CachedFileStat stat(2);
+		touch("test.txt", 1);
+		touch("test2.txt", 2);
+		touch("test3.txt", 3);
+		
+		ensure_equals("1st stat succeeded",
+			stat.stat("test.txt", &buf, 1),
+			0);
+		ensure_equals("2nd stat succeeded",
+			stat.stat("test2.txt", &buf, 1),
+			0);
+		ensure_equals("3rd stat succeeded",
+			stat.stat("test3.txt", &buf, 1),
+			0);
+		
+		// test.txt should now be removed from the cache.
+		
+		touch("test.txt", 10);
+		ensure_equals("4th stat succeeded",
+			stat.stat("test.txt", &buf, 1),
+			0);
+		ensure_equals(buf.st_mtime, (time_t) 10);
+		
+		// test2.txt should now be removed from the cache.
+		// If we stat test2.txt now, test3.txt would normally
+		// be removed from the cache. But if we increase the
+		// cache size here then that won't happen:
+		stat.setMaxSize(3);
+		touch("test2.txt", 11);
+		touch("test3.txt", 12);
+		
+		ensure_equals("5th stat succeeded",
+			stat.stat("test2.txt", &buf, 1),
+			0);
+		ensure_equals(buf.st_mtime, (time_t) 11);
+		
+		ensure_equals("6th stat succeeded",
+			stat.stat("test3.txt", &buf, 1),
+			0);
+		ensure_equals("test3.txt is still cached",
+			buf.st_mtime,
+			(time_t) 3);
+		
+		ensure_equals("7th stat succeeded",
+			stat.stat("test.txt", &buf, 1),
+			0);
+		ensure_equals("test.txt is still cached",
+			buf.st_mtime,
+			(time_t) 10);
+	}
+	
+	TEST_METHOD(13) {
+		// If we decrease the cache size dynamically, then
+		// the oldest entries will be removed.
+		SystemTime::force(5);
+		CachedFileStat stat(3);
+		touch("test.txt", 1);
+		touch("test2.txt", 2);
+		touch("test3.txt", 3);
+		
+		ensure_equals("1st stat succeeded",
+			stat.stat("test.txt", &buf, 1),
+			0);
+		ensure_equals("2nd stat succeeded",
+			stat.stat("test2.txt", &buf, 1),
+			0);
+		ensure_equals("3rd stat succeeded",
+			stat.stat("test3.txt", &buf, 1),
+			0);
+		
+		// The following should remove test.txt and test2.txt from the cache.
+		stat.setMaxSize(1);
+		
+		touch("test.txt", 10);
+		touch("test2.txt", 11);
+		touch("test3.txt", 12);
+		
+		ensure_equals("6th stat succeeded",
+			stat.stat("test3.txt", &buf, 1),
+			0);
+		ensure_equals("test3.txt is still in the cache",
+			buf.st_mtime,
+			(time_t) 3);
+		
+		ensure_equals("4th stat succeeded",
+			stat.stat("test.txt", &buf, 1),
+			0);
+		ensure_equals("test.txt is removed from the cache",
+			buf.st_mtime,
+			(time_t) 10);
+		
+		ensure_equals("5th stat succeeded",
+			stat.stat("test2.txt", &buf, 1),
+			0);
+		ensure_equals("test2.txt is removed from the cache",
+			buf.st_mtime,
+			(time_t) 11);
+	}
+	
+	TEST_METHOD(14) {
+		// An initial cache size of 0 means that the cache size is unlimited.
+		SystemTime::force(1);
+		CachedFileStat stat(0);
+		
+		touch("test.txt", 1);
+		touch("test2.txt", 2);
+		touch("test3.txt", 3);
+		stat.stat("test.txt", &buf, 1);
+		stat.stat("test2.txt", &buf, 1);
+		stat.stat("test3.txt", &buf, 1);
+		
+		touch("test.txt", 11);
+		touch("test2.txt", 12);
+		touch("test3.txt", 13);
+		stat.stat("test.txt", &buf, 1);
+		ensure_equals(buf.st_mtime, (time_t) 1);
+		stat.stat("test2.txt", &buf, 1);
+		ensure_equals(buf.st_mtime, (time_t) 2);
+		stat.stat("test3.txt", &buf, 1);
+		ensure_equals(buf.st_mtime, (time_t) 3);
+	}
+	
+	TEST_METHOD(15) {
+		// Setting the cache size dynamically to 0 makes the cache size unlimited.
+		SystemTime::force(1);
+		CachedFileStat stat(2);
+		
+		touch("test.txt", 1);
+		touch("test2.txt", 2);
+		touch("test3.txt", 3);
+		stat.stat("test.txt", &buf, 1);
+		stat.stat("test2.txt", &buf, 1);
+		stat.stat("test3.txt", &buf, 1);
+		
+		// test.txt is now no longer in the cache.
+		
+		stat.setMaxSize(0);
+		touch("test.txt", 11);
+		touch("test2.txt", 12);
+		touch("test3.txt", 13);
+		stat.stat("test.txt", &buf, 1);
+		stat.stat("test2.txt", &buf, 1);
+		stat.stat("test3.txt", &buf, 1);
+		
+		// test.txt should now have been re-statted while test2.txt
+		// and test3.txt are still cached.
+		
+		stat.stat("test.txt", &buf, 1);
+		ensure_equals("test.txt is re-statted", buf.st_mtime, (time_t) 11);
+		stat.stat("test2.txt", &buf, 1);
+		ensure_equals("test2.txt is still cached", buf.st_mtime, (time_t) 2);
+		stat.stat("test3.txt", &buf, 1);
+		ensure_equals("test3.txt is still cached", buf.st_mtime, (time_t) 3);
+	}
+	
+	TEST_METHOD(16) {
+		// Changing the cache size dynamically from 0 to non-0 works;
+		// it removes the oldest entries, if necessary.
+		CachedFileStat stat(0);
+		stat.stat("test.txt", &buf, 1);
+		stat.stat("test2.txt", &buf, 1);
+		stat.stat("test3.txt", &buf, 1);
+		stat.stat("test4.txt", &buf, 1);
+		stat.stat("test5.txt", &buf, 1);
+		stat.setMaxSize(2);
+		ensure(!stat.knows("test.txt"));
+		ensure(!stat.knows("test2.txt"));
+		ensure(!stat.knows("test3.txt"));
+		ensure(stat.knows("test4.txt"));
+		ensure(stat.knows("test5.txt"));
+	}
 }