hardcoresushi/libcryfs
1
0
Fork 0
Code Issues Pull Requests Releases Activity

Use parametrized test cases

Browse Source
This commit is contained in:
Sebastian Messmer 2014-11-20 17:11:03 +01:00
parent 0c74355812
commit 862cb1b26c
8 changed files with 121 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
src/test/fspp/fuse/lstat/FuseLstatReturnAtimeTest.cpp
View File

@ -1,33 +1,27 @@
#include "testutils/FuseLstatReturnTest.h"
class FuseLstatReturnATimeTest: public FuseLstatReturnTest<time_t> {
public:
const time_t ATIME1 = 0;
const time_t ATIME2 = 100;
const time_t ATIME3 = 1416496809; // current timestamp as of writing the test
const time_t ATIME4 = 32503680000; // needs a 64bit timestamp
using ::testing::WithParamInterface;
using ::testing::Values;
class FuseLstatReturnATimeTest: public FuseLstatReturnTest<time_t>, public WithParamInterface<time_t> {
private:
void set(struct stat *stat, time_t value) override {
stat->st_atime = value;
}
};
INSTANTIATE_TEST_CASE_P(FuseLstatReturnATimeTest, FuseLstatReturnATimeTest, Values(
0,
100,
1416496809, // current timestamp as of writing the test
32503680000 // needs a 64bit timestamp
));
TEST_F(FuseLstatReturnATimeTest, ReturnedFileAtimeIsCorrect1) {
struct ::stat result = CallFileLstatWithValue(ATIME1);
EXPECT_EQ(ATIME1, result.st_atime);
TEST_P(FuseLstatReturnATimeTest, ReturnedFileAtimeIsCorrect) {
struct ::stat result = CallFileLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_atime);
}
TEST_F(FuseLstatReturnATimeTest, ReturnedFileAtimeIsCorrect2) {
struct ::stat result = CallFileLstatWithValue(ATIME2);
EXPECT_EQ(ATIME2, result.st_atime);
}
TEST_F(FuseLstatReturnATimeTest, ReturnedFileAtimeIsCorrect3) {
struct ::stat result = CallFileLstatWithValue(ATIME3);
EXPECT_EQ(ATIME3, result.st_atime);
}
TEST_F(FuseLstatReturnATimeTest, ReturnedFileAtimeIsCorrect4) {
struct ::stat result = CallFileLstatWithValue(ATIME4);
EXPECT_EQ(ATIME4, result.st_atime);
TEST_P(FuseLstatReturnATimeTest, ReturnedDirAtimeIsCorrect) {
struct ::stat result = CallDirLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_atime);
}

38
src/test/fspp/fuse/lstat/FuseLstatReturnCtimeTest.cpp
View File

@ -1,33 +1,27 @@
#include "testutils/FuseLstatReturnTest.h"
class FuseLstatReturnCtimeTest: public FuseLstatReturnTest<time_t> {
public:
const time_t CTIME1 = 0;
const time_t CTIME2 = 100;
const time_t CTIME3 = 1416496809; // current timestamp as of writing the test
const time_t CTIME4 = 32503680000; // needs a 64bit timestamp
using ::testing::WithParamInterface;
using ::testing::Values;
class FuseLstatReturnCtimeTest: public FuseLstatReturnTest<time_t>, public WithParamInterface<time_t> {
private:
void set(struct stat *stat, time_t value) override {
stat->st_ctime = value;
}
};
INSTANTIATE_TEST_CASE_P(FuseLstatReturnCtimeTest, FuseLstatReturnCtimeTest, Values(
0,
100,
1416496809, // current timestamp as of writing the test
32503680000 // needs a 64bit timestamp
));
TEST_F(FuseLstatReturnCtimeTest, ReturnedFileCtimeIsCorrect1) {
struct ::stat result = CallFileLstatWithValue(CTIME1);
EXPECT_EQ(CTIME1, result.st_ctime);
TEST_P(FuseLstatReturnCtimeTest, ReturnedFileCtimeIsCorrect) {
struct ::stat result = CallFileLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_ctime);
}
TEST_F(FuseLstatReturnCtimeTest, ReturnedFileCtimeIsCorrect2) {
struct ::stat result = CallFileLstatWithValue(CTIME2);
EXPECT_EQ(CTIME2, result.st_ctime);
}
TEST_F(FuseLstatReturnCtimeTest, ReturnedFileCtimeIsCorrect3) {
struct ::stat result = CallFileLstatWithValue(CTIME3);
EXPECT_EQ(CTIME3, result.st_ctime);
}
TEST_F(FuseLstatReturnCtimeTest, ReturnedFileCtimeIsCorrect4) {
struct ::stat result = CallFileLstatWithValue(CTIME4);
EXPECT_EQ(CTIME4, result.st_ctime);
TEST_P(FuseLstatReturnCtimeTest, ReturnedDirCtimeIsCorrect) {
struct ::stat result = CallDirLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_ctime);
}

34
src/test/fspp/fuse/lstat/FuseLstatReturnGidTest.cpp
View File

@ -1,31 +1,25 @@
#include "testutils/FuseLstatReturnTest.h"
class FuseLstatReturnGidTest: public FuseLstatReturnTest<gid_t> {
public:
const gid_t GID1 = 0;
const gid_t GID2 = 10;
using ::testing::WithParamInterface;
using ::testing::Values;
class FuseLstatReturnGidTest: public FuseLstatReturnTest<gid_t>, public WithParamInterface<gid_t> {
private:
void set(struct stat *stat, gid_t value) override {
stat->st_gid = value;
}
};
INSTANTIATE_TEST_CASE_P(FuseLstatReturnGidTest, FuseLstatReturnGidTest, Values(
0,
10
));
TEST_F(FuseLstatReturnGidTest, ReturnedFileGidIsCorrect1) {
struct ::stat result = CallFileLstatWithValue(GID1);
EXPECT_EQ(GID1, result.st_gid);
TEST_P(FuseLstatReturnGidTest, ReturnedFileGidIsCorrect) {
struct ::stat result = CallFileLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_gid);
}
TEST_F(FuseLstatReturnGidTest, ReturnedFileGidIsCorrect2) {
struct ::stat result = CallFileLstatWithValue(GID2);
EXPECT_EQ(GID2, result.st_gid);
}
TEST_F(FuseLstatReturnGidTest, ReturnedDirGidIsCorrect1) {
struct ::stat result = CallDirLstatWithValue(GID1);
EXPECT_EQ(GID1, result.st_gid);
}
TEST_F(FuseLstatReturnGidTest, ReturnedDirGidIsCorrect2) {
struct ::stat result = CallDirLstatWithValue(GID2);
EXPECT_EQ(GID2, result.st_gid);
TEST_P(FuseLstatReturnGidTest, ReturnedDirGidIsCorrect) {
struct ::stat result = CallDirLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_gid);
}

25
src/test/fspp/fuse/lstat/FuseLstatReturnModeTest.cpp
View File

@ -1,23 +1,24 @@
#include "testutils/FuseLstatReturnTest.h"
class FuseLstatReturnModeTest: public FuseLstatTest {
public:
const mode_t MODE1 = S_IFREG | S_IRUSR | S_IWGRP | S_IXOTH;
const mode_t MODE2 = S_IFDIR | S_IWUSR | S_IXGRP | S_IROTH;
using ::testing::WithParamInterface;
using ::testing::Values;
class FuseLstatReturnModeTest: public FuseLstatTest, public WithParamInterface<mode_t> {
public:
struct stat CallLstatWithValue(mode_t mode) {
return CallLstatWithImpl([mode] (struct stat *stat) {
stat->st_mode = mode;
});
}
};
INSTANTIATE_TEST_CASE_P(FuseLstatReturnModeTest, FuseLstatReturnModeTest, Values(
S_IFREG,
S_IFDIR,
S_IFREG | S_IRUSR | S_IWGRP | S_IXOTH, // a file with some access bits set
S_IFDIR | S_IWUSR | S_IXGRP | S_IROTH // a dir with some access bits set
));
TEST_F(FuseLstatReturnModeTest, ReturnedModeIsCorrect1) {
struct ::stat result = CallLstatWithValue(MODE1);
EXPECT_EQ(MODE1, result.st_mode);
}
TEST_F(FuseLstatReturnModeTest, ReturnedModeIsCorrect2) {
struct ::stat result = CallLstatWithValue(MODE2);
EXPECT_EQ(MODE2, result.st_mode);
TEST_P(FuseLstatReturnModeTest, ReturnedModeIsCorrect) {
struct ::stat result = CallLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_mode);
}

38
src/test/fspp/fuse/lstat/FuseLstatReturnMtimeTest.cpp
View File

@ -1,33 +1,27 @@
#include "testutils/FuseLstatReturnTest.h"
class FuseLstatReturnMtimeTest: public FuseLstatReturnTest<time_t> {
public:
const time_t MTIME1 = 0;
const time_t MTIME2 = 100;
const time_t MTIME3 = 1416496809; // current timestamp as of writing the test
const time_t MTIME4 = 32503680000; // needs a 64bit timestamp
using ::testing::WithParamInterface;
using ::testing::Values;
class FuseLstatReturnMtimeTest: public FuseLstatReturnTest<time_t>, public WithParamInterface<time_t> {
private:
void set(struct stat *stat, time_t value) override {
stat->st_mtime = value;
}
};
INSTANTIATE_TEST_CASE_P(FuseLstatReturnMtimeTest, FuseLstatReturnMtimeTest, Values(
0,
100,
1416496809, // current timestamp as of writing the test
32503680000 // needs a 64bit timestamp
));
TEST_F(FuseLstatReturnMtimeTest, ReturnedFileMtimeIsCorrect1) {
struct ::stat result = CallFileLstatWithValue(MTIME1);
EXPECT_EQ(MTIME1, result.st_mtime);
TEST_P(FuseLstatReturnMtimeTest, ReturnedFileMtimeIsCorrect) {
struct ::stat result = CallFileLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_mtime);
}
TEST_F(FuseLstatReturnMtimeTest, ReturnedFileMtimeIsCorrect2) {
struct ::stat result = CallFileLstatWithValue(MTIME2);
EXPECT_EQ(MTIME2, result.st_mtime);
}
TEST_F(FuseLstatReturnMtimeTest, ReturnedFileMtimeIsCorrect3) {
struct ::stat result = CallFileLstatWithValue(MTIME3);
EXPECT_EQ(MTIME3, result.st_mtime);
}
TEST_F(FuseLstatReturnMtimeTest, ReturnedFileMtimeIsCorrect4) {
struct ::stat result = CallFileLstatWithValue(MTIME4);
EXPECT_EQ(MTIME4, result.st_mtime);
TEST_P(FuseLstatReturnMtimeTest, ReturnedDirMtimeIsCorrect) {
struct ::stat result = CallDirLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_mtime);
}

35
src/test/fspp/fuse/lstat/FuseLstatReturnNlinkTest.cpp
View File

@ -1,31 +1,28 @@
#include "testutils/FuseLstatReturnTest.h"
class FuseLstatReturnNlinkTest: public FuseLstatReturnTest<nlink_t> {
public:
const nlink_t NLINK1 = 1;
const nlink_t NLINK2 = 5;
using ::testing::WithParamInterface;
using ::testing::Values;
class FuseLstatReturnNlinkTest: public FuseLstatReturnTest<nlink_t>, public WithParamInterface<nlink_t> {
private:
void set(struct stat *stat, nlink_t value) override {
stat->st_nlink = value;
}
};
INSTANTIATE_TEST_CASE_P(FuseLstatReturnNlinkTest, FuseLstatReturnNlinkTest, Values(
1,
2,
5,
100
));
TEST_F(FuseLstatReturnNlinkTest, ReturnedFileNlinkIsCorrect1) {
struct ::stat result = CallDirLstatWithValue(NLINK1);
EXPECT_EQ(NLINK1, result.st_nlink);
TEST_P(FuseLstatReturnNlinkTest, ReturnedFileNlinkIsCorrect) {
struct ::stat result = CallDirLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_nlink);
}
TEST_F(FuseLstatReturnNlinkTest, ReturnedFileNlinkIsCorrect2) {
struct ::stat result = CallDirLstatWithValue(NLINK2);
EXPECT_EQ(NLINK2, result.st_nlink);
TEST_P(FuseLstatReturnNlinkTest, ReturnedDirNlinkIsCorrect) {
struct ::stat result = CallDirLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_nlink);
}
TEST_F(FuseLstatReturnNlinkTest, ReturnedDirNlinkIsCorrect1) {
struct ::stat result = CallDirLstatWithValue(NLINK1);
EXPECT_EQ(NLINK1, result.st_nlink);
}
TEST_F(FuseLstatReturnNlinkTest, ReturnedDirNlinkIsCorrect2) {
struct ::stat result = CallDirLstatWithValue(NLINK2);
EXPECT_EQ(NLINK2, result.st_nlink);
}

47
src/test/fspp/fuse/lstat/FuseLstatReturnSizeTest.cpp
View File

@ -1,42 +1,27 @@
#include "testutils/FuseLstatReturnTest.h"
class FuseLstatReturnSizeTest: public FuseLstatReturnTest<off_t> {
public:
const off_t SIZE1 = 0;
const off_t SIZE2 = 4096;
const off_t SIZE3 = 1024*1024*1024;
using ::testing::WithParamInterface;
using ::testing::Values;
class FuseLstatReturnSizeTest: public FuseLstatReturnTest<off_t>, public WithParamInterface<off_t> {
private:
void set(struct stat *stat, off_t value) override {
stat->st_size = value;
}
};
INSTANTIATE_TEST_CASE_P(FuseLstatReturnSizeTest, FuseLstatReturnSizeTest, Values(
0,
1,
4096,
1024*1024*1024
));
TEST_F(FuseLstatReturnSizeTest, ReturnedFileSizeIsCorrect1) {
struct ::stat result = CallDirLstatWithValue(SIZE1);
EXPECT_EQ(SIZE1, result.st_size);
TEST_P(FuseLstatReturnSizeTest, ReturnedFileSizeIsCorrect) {
struct ::stat result = CallDirLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_size);
}
TEST_F(FuseLstatReturnSizeTest, ReturnedFileSizeIsCorrect2) {
struct ::stat result = CallDirLstatWithValue(SIZE2);
EXPECT_EQ(SIZE2, result.st_size);
}
TEST_F(FuseLstatReturnSizeTest, ReturnedFileSizeIsCorrect3) {
struct ::stat result = CallDirLstatWithValue(SIZE3);
EXPECT_EQ(SIZE3, result.st_size);
}
TEST_F(FuseLstatReturnSizeTest, ReturnedDirSizeIsCorrect1) {
struct ::stat result = CallDirLstatWithValue(SIZE1);
EXPECT_EQ(SIZE1, result.st_size);
}
TEST_F(FuseLstatReturnSizeTest, ReturnedDirSizeIsCorrect2) {
struct ::stat result = CallDirLstatWithValue(SIZE2);
EXPECT_EQ(SIZE2, result.st_size);
}
TEST_F(FuseLstatReturnSizeTest, ReturnedDirSizeIsCorrect3) {
struct ::stat result = CallDirLstatWithValue(SIZE3);
EXPECT_EQ(SIZE3, result.st_size);
TEST_P(FuseLstatReturnSizeTest, ReturnedDirSizeIsCorrect) {
struct ::stat result = CallDirLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_size);
}

34
src/test/fspp/fuse/lstat/FuseLstatReturnUidTest.cpp
View File

@ -1,31 +1,25 @@
#include "testutils/FuseLstatReturnTest.h"
class FuseLstatReturnUidTest: public FuseLstatReturnTest<uid_t> {
public:
const uid_t UID1 = 0;
const uid_t UID2 = 10;
using ::testing::WithParamInterface;
using ::testing::Values;
class FuseLstatReturnUidTest: public FuseLstatReturnTest<uid_t>, public WithParamInterface<uid_t> {
private:
void set(struct stat *stat, uid_t value) override {
stat->st_uid = value;
}
};
INSTANTIATE_TEST_CASE_P(FuseLstatReturnUidTest, FuseLstatReturnUidTest, Values(
0,
10
));
TEST_F(FuseLstatReturnUidTest, ReturnedFileUidIsCorrect1) {
struct ::stat result = CallFileLstatWithValue(UID1);
EXPECT_EQ(UID1, result.st_uid);
TEST_P(FuseLstatReturnUidTest, ReturnedFileUidIsCorrect) {
struct ::stat result = CallFileLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_uid);
}
TEST_F(FuseLstatReturnUidTest, ReturnedFileUidIsCorrect2) {
struct ::stat result = CallFileLstatWithValue(UID2);
EXPECT_EQ(UID2, result.st_uid);
}
TEST_F(FuseLstatReturnUidTest, ReturnedDirUidIsCorrect1) {
struct ::stat result = CallDirLstatWithValue(UID1);
EXPECT_EQ(UID1, result.st_uid);
}
TEST_F(FuseLstatReturnUidTest, ReturnedDirUidIsCorrect2) {
struct ::stat result = CallDirLstatWithValue(UID2);
EXPECT_EQ(UID2, result.st_uid);
TEST_P(FuseLstatReturnUidTest, ReturnedDirUidIsCorrect) {
struct ::stat result = CallDirLstatWithValue(GetParam());
EXPECT_EQ(GetParam(), result.st_uid);
}