Mirrors
/
gparted
mirror of https://gitlab.gnome.org/GNOME/gparted.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Switch to testing ext2 interface via SupportedFilesystems class (!49) 

Replace directly using ext2 derived FileSystem interface class with
using the SupportedFileSystems class.  This is a step in getting ready
for testing all the GParted file system interface classes in one go.

Closes !49 - Add file system interface tests
This commit is contained in:
Mike Fleetwood 2019-09-18 09:22:32 +01:00 committed by Curtis Gedak
parent 6d121ebb5d
commit 7c265d51c3
3 changed files with 71 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -55,5 +55,5 @@ tests/test-suite.log
tests/test_BlockSpecial tests/test_BlockSpecial
tests/test_PasswordRAMStore tests/test_PasswordRAMStore
tests/test_PipeCapture tests/test_PipeCapture
tests/test_SupportedFileSystems
tests/test_dummy tests/test_dummy
tests/test_ext2

14
tests/Makefile.am
View File

@ -11,19 +11,19 @@ LDADD = \
# Programs to be built by "make check" # Programs to be built by "make check"
check_PROGRAMS = \ check_PROGRAMS = \
test_dummy \ test_dummy \
test_ext2 \ test_BlockSpecial \
test_BlockSpecial \ test_PasswordRAMStore \
test_PasswordRAMStore \ test_PipeCapture \
test_PipeCapture test_SupportedFileSystems
# Test cases to be run by "make check" # Test cases to be run by "make check"
TESTS = $(check_PROGRAMS) TESTS = $(check_PROGRAMS)
test_dummy_SOURCES = test_dummy.cc test_dummy_SOURCES = test_dummy.cc
test_ext2_SOURCES = test_ext2.cc test_SupportedFileSystems_SOURCES = test_SupportedFileSystems.cc
test_ext2_LDADD = \ test_SupportedFileSystems_LDADD = \
$(top_builddir)/src/BlockSpecial.$(OBJEXT) \ $(top_builddir)/src/BlockSpecial.$(OBJEXT) \
$(top_builddir)/src/CopyBlocks.$(OBJEXT) \ $(top_builddir)/src/CopyBlocks.$(OBJEXT) \
$(top_builddir)/src/DMRaid.$(OBJEXT) \ $(top_builddir)/src/DMRaid.$(OBJEXT) \

119
tests/test_ext2.cc → tests/test_SupportedFileSystems.cc
View File

@ -14,11 +14,11 @@
* along with this program; if not, see <http://www.gnu.org/licenses/>. * along with this program; if not, see <http://www.gnu.org/licenses/>.
*/ */
/* Test ext2 /* Test SupportedFileSystems
* *
* Test the derived FileSystem interface classes which call the file system specific * Test the derived FileSystem interface classes which call the file system specific
* executables. Rather than mocking command execution and returned output just run real * executables via the SupportedFileSystems class. Rather than mocking command execution
* commands, effectively making this integration testing. * and returned output just run real commands, effectively making this integration testing.
* *
* Test case setup determines the file system supported actions using * Test case setup determines the file system supported actions using
* get_filesystem_support() and individual tests are skipped if a feature is not * get_filesystem_support() and individual tests are skipped if a feature is not
@ -38,7 +38,7 @@
#include "OperationDetail.h" #include "OperationDetail.h"
#include "Partition.h" #include "Partition.h"
#include "Utils.h" #include "Utils.h"
#include "ext2.h" #include "SupportedFileSystems.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <iostream> #include <iostream>
@ -170,7 +170,7 @@ std::ostream& operator<<(std::ostream& out, const OperationDetail& od)
// https://github.com/google/googletest/pull/1544 // https://github.com/google/googletest/pull/1544
// (Merged after Google Test 1.8.1) // (Merged after Google Test 1.8.1)
#define SKIP_IF_FS_DOESNT_SUPPORT(opt) \ #define SKIP_IF_FS_DOESNT_SUPPORT(opt) \
if (s_ext2_support.opt != FS::EXTERNAL) \ if (s_supported_filesystems->get_fs_support(FS_EXT2).opt != FS::EXTERNAL) \
{ \ { \
std::cout << __FILE__ << ":" << __LINE__ << ": Skip test. " \ std::cout << __FILE__ << ":" << __LINE__ << ": Skip test. " \
<< #opt << " not supported or support not found" << std::endl; \ << #opt << " not supported or support not found" << std::endl; \
@ -182,11 +182,11 @@ const Byte_Value IMAGESIZE_Default = 256*MEBIBYTE;
const Byte_Value IMAGESIZE_Larger = 512*MEBIBYTE; const Byte_Value IMAGESIZE_Larger = 512*MEBIBYTE;
class ext2Test : public ::testing::Test class SupportedFileSystemsTest : public ::testing::Test
{ {
protected: protected:
// Initialise top-level operation detail object with description ... // Initialise top-level operation detail object with description ...
ext2Test() : m_operation_detail("Operation details:", STATUS_NONE) {}; SupportedFileSystemsTest() : m_operation_detail("Operation details:", STATUS_NONE) {};
virtual void extra_setup(Byte_Value size = IMAGESIZE_Default); virtual void extra_setup(Byte_Value size = IMAGESIZE_Default);
virtual void TearDown(); virtual void TearDown();
@ -198,21 +198,21 @@ protected:
virtual void resize_image(Byte_Value new_size); virtual void resize_image(Byte_Value new_size);
virtual void shrink_partition(Byte_Value size); virtual void shrink_partition(Byte_Value size);
static FileSystem* s_ext2_obj; static SupportedFileSystems* s_supported_filesystems; // Owning pointer
static FS s_ext2_support; static FileSystem* s_fs_object; // Alias pointer
static const char* s_image_name; static const char* s_image_name;
Partition m_partition; Partition m_partition;
OperationDetail m_operation_detail; OperationDetail m_operation_detail;
}; };
FileSystem* ext2Test::s_ext2_obj = NULL; SupportedFileSystems* SupportedFileSystemsTest::s_supported_filesystems = NULL;
FS ext2Test::s_ext2_support; FileSystem* SupportedFileSystemsTest::s_fs_object = NULL;
const char* ext2Test::s_image_name = "test_ext2.img"; const char* SupportedFileSystemsTest::s_image_name = "test_SupportedFileSystems.img";
void ext2Test::extra_setup(Byte_Value size) void SupportedFileSystemsTest::extra_setup(Byte_Value size)
{ {
// Create new image file to work with. // Create new image file to work with.
unlink(s_image_name); unlink(s_image_name);
@ -227,32 +227,39 @@ void ext2Test::extra_setup(Byte_Value size)
} }
void ext2Test::TearDown() void SupportedFileSystemsTest::TearDown()
{ {
unlink(s_image_name); unlink(s_image_name);
} }
// Common test case initialisation creating ext2 interface object and querying supported // Common test case initialisation creating the supported file system interface object.
// operations. void SupportedFileSystemsTest::SetUpTestCase()
void ext2Test::SetUpTestCase()
{ {
s_ext2_obj = new ext2(FS_EXT2); s_supported_filesystems = new SupportedFileSystems();
s_ext2_support = s_ext2_obj->get_filesystem_support();
// Discover available file systems support capabilities, base on available file
// system specific tools.
s_supported_filesystems->find_supported_filesystems();
// Lookup ext2 derived FileSystem object.
s_fs_object = s_supported_filesystems->get_fs_object(FS_EXT2);
} }
// Common test case teardown destroying the ext2 interface object. // Common test case teardown destroying the supported file systems interface object.
void ext2Test::TearDownTestCase() void SupportedFileSystemsTest::TearDownTestCase()
{ {
delete s_ext2_obj; s_fs_object = NULL;
s_ext2_obj = NULL;
delete s_supported_filesystems;
s_supported_filesystems = NULL;
} }
// (Re)initialise m_partition as a Partition object spanning the whole of the image file // (Re)initialise m_partition as a Partition object spanning the whole of the image file
// with file system type only. No file system usage, label or UUID. // with file system type only. No file system usage, label or UUID.
void ext2Test::reload_partition() void SupportedFileSystemsTest::reload_partition()
{ {
m_partition.Reset(); m_partition.Reset();
@ -273,7 +280,7 @@ void ext2Test::reload_partition()
} }
void ext2Test::resize_image(Byte_Value new_size) void SupportedFileSystemsTest::resize_image(Byte_Value new_size)
{ {
int fd = open(s_image_name, O_WRONLY|O_NONBLOCK); int fd = open(s_image_name, O_WRONLY|O_NONBLOCK);
ASSERT_GE(fd, 0) << "Failed to open image file '" << s_image_name << "'. errno=" ASSERT_GE(fd, 0) << "Failed to open image file '" << s_image_name << "'. errno="
@ -284,7 +291,7 @@ void ext2Test::resize_image(Byte_Value new_size)
} }
void ext2Test::shrink_partition(Byte_Value new_size) void SupportedFileSystemsTest::shrink_partition(Byte_Value new_size)
{ {
ASSERT_LE(new_size, m_partition.get_byte_length()) << __func__ << "(): TEST_BUG: Cannot grow Partition object size"; ASSERT_LE(new_size, m_partition.get_byte_length()) << __func__ << "(): TEST_BUG: Cannot grow Partition object size";
Sector new_sectors = (new_size + m_partition.sector_size - 1) / m_partition.sector_size; Sector new_sectors = (new_size + m_partition.sector_size - 1) / m_partition.sector_size;
@ -292,25 +299,25 @@ void ext2Test::shrink_partition(Byte_Value new_size)
} }
TEST_F(ext2Test, Create) TEST_F(SupportedFileSystemsTest, Create)
{ {
SKIP_IF_FS_DOESNT_SUPPORT(create); SKIP_IF_FS_DOESNT_SUPPORT(create);
extra_setup(); extra_setup();
// Call create, check for success and print operation details on failure. // Call create, check for success and print operation details on failure.
ASSERT_TRUE(s_ext2_obj->create(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->create(m_partition, m_operation_detail)) << m_operation_detail;
} }
TEST_F(ext2Test, CreateAndReadUsage) TEST_F(SupportedFileSystemsTest, CreateAndReadUsage)
{ {
SKIP_IF_FS_DOESNT_SUPPORT(create); SKIP_IF_FS_DOESNT_SUPPORT(create);
SKIP_IF_FS_DOESNT_SUPPORT(read); SKIP_IF_FS_DOESNT_SUPPORT(read);
extra_setup(); extra_setup();
ASSERT_TRUE(s_ext2_obj->create(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->create(m_partition, m_operation_detail)) << m_operation_detail;
reload_partition(); reload_partition();
s_ext2_obj->set_used_sectors(m_partition); s_fs_object->set_used_sectors(m_partition);
// Test file system usage is reported correctly. // Test file system usage is reported correctly.
// Used is between 0 and length. // Used is between 0 and length.
EXPECT_LE(0, m_partition.sectors_used); EXPECT_LE(0, m_partition.sectors_used);
@ -328,7 +335,7 @@ TEST_F(ext2Test, CreateAndReadUsage)
} }
TEST_F(ext2Test, CreateAndReadLabel) TEST_F(SupportedFileSystemsTest, CreateAndReadLabel)
{ {
SKIP_IF_FS_DOESNT_SUPPORT(create); SKIP_IF_FS_DOESNT_SUPPORT(create);
SKIP_IF_FS_DOESNT_SUPPORT(read_label); SKIP_IF_FS_DOESNT_SUPPORT(read_label);
@ -336,11 +343,11 @@ TEST_F(ext2Test, CreateAndReadLabel)
const char* fs_label = "TEST_LABEL"; const char* fs_label = "TEST_LABEL";
extra_setup(); extra_setup();
m_partition.set_filesystem_label(fs_label); m_partition.set_filesystem_label(fs_label);
ASSERT_TRUE(s_ext2_obj->create(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->create(m_partition, m_operation_detail)) << m_operation_detail;
// Test reading the label is successful. // Test reading the label is successful.
reload_partition(); reload_partition();
s_ext2_obj->read_label(m_partition); s_fs_object->read_label(m_partition);
EXPECT_STREQ(fs_label, m_partition.get_filesystem_label().c_str()); EXPECT_STREQ(fs_label, m_partition.get_filesystem_label().c_str());
// Test messages from read operation are empty or print them. // Test messages from read operation are empty or print them.
@ -348,17 +355,17 @@ TEST_F(ext2Test, CreateAndReadLabel)
} }
TEST_F(ext2Test, CreateAndReadUUID) TEST_F(SupportedFileSystemsTest, CreateAndReadUUID)
{ {
SKIP_IF_FS_DOESNT_SUPPORT(create); SKIP_IF_FS_DOESNT_SUPPORT(create);
SKIP_IF_FS_DOESNT_SUPPORT(read_uuid); SKIP_IF_FS_DOESNT_SUPPORT(read_uuid);
extra_setup(); extra_setup();
ASSERT_TRUE(s_ext2_obj->create(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->create(m_partition, m_operation_detail)) << m_operation_detail;
// Test reading the UUID is successful. // Test reading the UUID is successful.
reload_partition(); reload_partition();
s_ext2_obj->read_uuid(m_partition); s_fs_object->read_uuid(m_partition);
EXPECT_EQ(m_partition.uuid.size(), 36U); EXPECT_EQ(m_partition.uuid.size(), 36U);
// Test messages from read operation are empty or print them. // Test messages from read operation are empty or print them.
@ -366,87 +373,87 @@ TEST_F(ext2Test, CreateAndReadUUID)
} }
TEST_F(ext2Test, CreateAndWriteLabel) TEST_F(SupportedFileSystemsTest, CreateAndWriteLabel)
{ {
SKIP_IF_FS_DOESNT_SUPPORT(create); SKIP_IF_FS_DOESNT_SUPPORT(create);
SKIP_IF_FS_DOESNT_SUPPORT(write_label); SKIP_IF_FS_DOESNT_SUPPORT(write_label);
extra_setup(); extra_setup();
m_partition.set_filesystem_label("FIRST"); m_partition.set_filesystem_label("FIRST");
ASSERT_TRUE(s_ext2_obj->create(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->create(m_partition, m_operation_detail)) << m_operation_detail;
// Test writing a label is successful. // Test writing a label is successful.
m_partition.set_filesystem_label("SECOND"); m_partition.set_filesystem_label("SECOND");
ASSERT_TRUE(s_ext2_obj->write_label(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->write_label(m_partition, m_operation_detail)) << m_operation_detail;
} }
TEST_F(ext2Test, CreateAndWriteUUID) TEST_F(SupportedFileSystemsTest, CreateAndWriteUUID)
{ {
SKIP_IF_FS_DOESNT_SUPPORT(create); SKIP_IF_FS_DOESNT_SUPPORT(create);
SKIP_IF_FS_DOESNT_SUPPORT(write_uuid); SKIP_IF_FS_DOESNT_SUPPORT(write_uuid);
extra_setup(); extra_setup();
ASSERT_TRUE(s_ext2_obj->create(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->create(m_partition, m_operation_detail)) << m_operation_detail;
// Test writing a new random UUID is successful. // Test writing a new random UUID is successful.
ASSERT_TRUE(s_ext2_obj->write_uuid(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->write_uuid(m_partition, m_operation_detail)) << m_operation_detail;
} }
TEST_F(ext2Test, CreateAndCheck) TEST_F(SupportedFileSystemsTest, CreateAndCheck)
{ {
SKIP_IF_FS_DOESNT_SUPPORT(create); SKIP_IF_FS_DOESNT_SUPPORT(create);
SKIP_IF_FS_DOESNT_SUPPORT(check); SKIP_IF_FS_DOESNT_SUPPORT(check);
extra_setup(); extra_setup();
ASSERT_TRUE(s_ext2_obj->create(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->create(m_partition, m_operation_detail)) << m_operation_detail;
// Test checking the file system is successful. // Test checking the file system is successful.
ASSERT_TRUE(s_ext2_obj->check_repair(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->check_repair(m_partition, m_operation_detail)) << m_operation_detail;
} }
TEST_F(ext2Test, CreateAndRemove) TEST_F(SupportedFileSystemsTest, CreateAndRemove)
{ {
SKIP_IF_FS_DOESNT_SUPPORT(create); SKIP_IF_FS_DOESNT_SUPPORT(create);
SKIP_IF_FS_DOESNT_SUPPORT(remove); SKIP_IF_FS_DOESNT_SUPPORT(remove);
extra_setup(); extra_setup();
ASSERT_TRUE(s_ext2_obj->create(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->create(m_partition, m_operation_detail)) << m_operation_detail;
// Test removing the file system is successful. Note that most file systems don't // Test removing the file system is successful. Note that most file systems don't
// implement remove so will skip this test. // implement remove so will skip this test.
ASSERT_TRUE(s_ext2_obj->remove(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->remove(m_partition, m_operation_detail)) << m_operation_detail;
} }
TEST_F(ext2Test, CreateAndGrow) TEST_F(SupportedFileSystemsTest, CreateAndGrow)
{ {
SKIP_IF_FS_DOESNT_SUPPORT(create); SKIP_IF_FS_DOESNT_SUPPORT(create);
SKIP_IF_FS_DOESNT_SUPPORT(grow); SKIP_IF_FS_DOESNT_SUPPORT(grow);
extra_setup(IMAGESIZE_Default); extra_setup(IMAGESIZE_Default);
ASSERT_TRUE(s_ext2_obj->create(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->create(m_partition, m_operation_detail)) << m_operation_detail;
// Test growing the file system is successful. // Test growing the file system is successful.
resize_image(IMAGESIZE_Larger); resize_image(IMAGESIZE_Larger);
reload_partition(); reload_partition();
ASSERT_TRUE(s_ext2_obj->resize(m_partition, m_operation_detail, true)) << m_operation_detail; ASSERT_TRUE(s_fs_object->resize(m_partition, m_operation_detail, true)) << m_operation_detail;
} }
TEST_F(ext2Test, CreateAndShrink) TEST_F(SupportedFileSystemsTest, CreateAndShrink)
{ {
SKIP_IF_FS_DOESNT_SUPPORT(create); SKIP_IF_FS_DOESNT_SUPPORT(create);
SKIP_IF_FS_DOESNT_SUPPORT(shrink); SKIP_IF_FS_DOESNT_SUPPORT(shrink);
extra_setup(IMAGESIZE_Larger); extra_setup(IMAGESIZE_Larger);
ASSERT_TRUE(s_ext2_obj->create(m_partition, m_operation_detail)) << m_operation_detail; ASSERT_TRUE(s_fs_object->create(m_partition, m_operation_detail)) << m_operation_detail;
// Test shrinking the file system is successful. // Test shrinking the file system is successful.
shrink_partition(IMAGESIZE_Default); shrink_partition(IMAGESIZE_Default);
ASSERT_TRUE(s_ext2_obj->resize(m_partition, m_operation_detail, false)) << m_operation_detail; ASSERT_TRUE(s_fs_object->resize(m_partition, m_operation_detail, false)) << m_operation_detail;
} }