Viewing file:  CachedFileStatTest.cpp (9.89 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
#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"));
}
}
|