name : CachedFileStatTest.cpp #include <TestSupport.h> #include <Utils/CachedFileStat.hpp> #include <SystemTools/SystemTime.h> #include <sys/types.h> #include <utime.h> using namespace std; using namespace Passenger; namespace tut { struct CachedFileStatTest: public TestBase { struct stat buf; ~CachedFileStatTest() { SystemTime::release(); unlink("test.txt"); unlink("test2.txt"); unlink("test3.txt"); unlink("test4.txt"); } }; DEFINE_TEST_GROUP(CachedFileStatTest); static void touch(const char *filename, time_t timestamp = 0) { FILE *f = fopen(filename, "w"); fprintf(f, "hi"); fclose(f); if (timestamp != 0) { struct utimbuf buf; buf.actime = timestamp; buf.modtime = timestamp; utime(filename, &buf); } } /************ Tests involving a single file ************/ TEST_METHOD(1) { // Statting a new file works. touch("test.txt"); CachedFileStat stat(1); ensure_equals(stat.stat("test.txt", &buf, 1), 0); ensure_equals((long) buf.st_size, (long) 2); } TEST_METHOD(2) { // It does not re-stat an existing file until the cache has expired. CachedFileStat stat(1); SystemTime::force(5); touch("test.txt", 1); ensure_equals("1st stat succceeded", stat.stat("test.txt", &buf, 1), 0); touch("test.txt", 1000); ensure_equals("2nd stat succceeded", stat.stat("test.txt", &buf, 1), 0); ensure_equals("Cached value was used", buf.st_mtime, (time_t) 1); SystemTime::force(6); ensure_equals("3rd stat succceeded", stat.stat("test.txt", &buf, 1), 0); ensure_equals("Cache has been invalidated", buf.st_mtime, (time_t) 1000); } 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(4) { // It does not re-stat a previously nonexistant file until // the cache has expired. SystemTime::force(5); 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; 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", buf.st_mtime, (time_t) 0); SystemTime::force(6); ensure_equals("3rd stat succeeded", stat.stat("test.txt", &buf, 1), 0); ensure_equals("Cache has been invalidated", buf.st_mtime, (time_t) 1000); unlink("test.txt"); ensure_equals("4th stat succeeded even though file was unlinked", stat.stat("test.txt", &buf, 1), 0); ensure_equals("Cached value was used", buf.st_mtime, (time_t) 1000); } 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"); ensure_equals("2nd stat did not go through the cache", stat.stat("test.txt", &buf, 0), 0); } /************ 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 // the old info. touch("test.txt", 10); ensure_equals( stat.stat("test.txt", &buf, 1), 0); ensure_equals(buf.st_mtime, (time_t) 10); touch("test.txt", 20); ensure_equals( stat.stat("test.txt", &buf, 1), 0); ensure_equals(buf.st_mtime, (time_t) 10); // Touch and stat test2.txt. The next stat should return // the old info. touch("test2.txt", 30); ensure_equals( stat.stat("test2.txt", &buf, 1), 0); ensure_equals(buf.st_mtime, (time_t) 30); touch("test2.txt", 40); ensure_equals( stat.stat("test2.txt", &buf, 1), 0); ensure_equals(buf.st_mtime, (time_t) 30); // Forward timer, then stat both files again. The most recent // information should be returned. SystemTime::force(6); ensure_equals( stat.stat("test.txt", &buf, 1), 0); ensure_equals(buf.st_mtime, (time_t) 20); ensure_equals( stat.stat("test2.txt", &buf, 1), 0); ensure_equals(buf.st_mtime, (time_t) 40); } TEST_METHOD(11) { // Cache limiting works. CachedFileStat stat(3); SystemTime::force(5); // Create and stat test.txt, test2.txt and test3.txt. touch("test.txt", 1000); ensure_equals( stat.stat("test.txt", &buf, 1), 0); ensure_equals(buf.st_mtime, (time_t) 1000); touch("test2.txt", 1001); ensure_equals( stat.stat("test2.txt", &buf, 1), 0); ensure_equals(buf.st_mtime, (time_t) 1001); touch("test3.txt", 1003); ensure_equals( stat.stat("test3.txt", &buf, 1), 0); ensure_equals(buf.st_mtime, (time_t) 1003); // Stat test2.txt, then create and stat test4.txt, then touch test.txt. // test.txt should have been removed from the cache, and thus // upon statting it again its new timestamp should be returned. ensure_equals( stat.stat("test2.txt", &buf, 1), 0); touch("test4.txt", 1004); ensure_equals( stat.stat("test4.txt", &buf, 1), 0); touch("test.txt", 3000); ensure_equals( 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("(1)", !stat.knows("test.txt")); ensure("(2)", !stat.knows("test2.txt")); ensure("(3)", !stat.knows("test3.txt")); ensure("(4)", stat.knows("test4.txt")); ensure("(5)", stat.knows("test5.txt")); } }