TheCloud/dwarfs
1
0
Fork 0
mirror of https://github.com/mhx/dwarfs.git synced 2025-09-09 12:28:13 -04:00
Code Issues Packages Projects Releases Wiki Activity

More tools tests

Browse Source
This commit is contained in:
Marcus Holland-Moritz 2021-04-13 10:50:40 +02:00
parent de2f4388b2
commit c262ee197b
1 changed files with 80 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
test/dwarfs_tools.cpp
View File

@ -21,6 +21,7 @@
#include <chrono> #include <chrono>
#include <filesystem> #include <filesystem>
#include <iostream>
#include <thread> #include <thread>
#include <fcntl.h> #include <fcntl.h>
@ -63,15 +64,22 @@ pid_t get_dwarfs_pid(std::filesystem::path const& path) {
} }
template <typename... Args> template <typename... Args>
void run(Args&&... args) { folly::Subprocess make_subprocess(Args&&... args) {
std::vector<std::string> cmdline; std::vector<std::string> cmdline;
(cmdline.emplace_back(std::forward<Args>(args)), ...); (cmdline.emplace_back(std::forward<Args>(args)), ...);
folly::Subprocess proc( return folly::Subprocess(
cmdline, folly::Subprocess::Options().pipeStdout().pipeStderr()); cmdline, folly::Subprocess::Options().pipeStdout().pipeStderr());
}
template <typename... Args>
std::optional<std::string> check_run(Args&&... args) {
auto proc = make_subprocess(std::forward<Args>(args)...);
const auto [out, err] = proc.communicate(); const auto [out, err] = proc.communicate();
ASSERT_EQ(0, proc.wait().exitStatus()) << "stdout:\n" if (auto ec = proc.wait().exitStatus(); ec != 0) {
<< out << "\nstderr:\n" std::cerr << "stdout:\n" << out << "\nstderr:\n" << err << std::endl;
<< err; return std::nullopt;
}
return out;
} }
class process_guard { class process_guard {
@ -114,24 +122,29 @@ class process_guard {
class driver_runner { class driver_runner {
public: public:
driver_runner()
: fusermount_{find_fusermount()} {}
template <typename... Args> template <typename... Args>
driver_runner(std::filesystem::path const& driver, driver_runner(std::filesystem::path const& driver,
std::filesystem::path const& image, std::filesystem::path const& image,
std::filesystem::path const& mountpoint, Args&&... args) std::filesystem::path const& mountpoint, Args&&... args)
: fusermount_{find_fusermount()} : fusermount_{find_fusermount()}
, mountpoint_{mountpoint} { , mountpoint_{mountpoint} {
run(driver, image, mountpoint, std::forward<Args>(args)...); if (!check_run(driver, image, mountpoint, std::forward<Args>(args)...)) {
throw std::runtime_error("error running " + driver.string());
}
auto dwarfs_pid = get_dwarfs_pid(mountpoint); auto dwarfs_pid = get_dwarfs_pid(mountpoint);
dwarfs_guard_ = process_guard(dwarfs_pid); dwarfs_guard_ = process_guard(dwarfs_pid);
} }
~driver_runner() { ~driver_runner() {
run(fusermount_, "-u", mountpoint_); check_run(fusermount_, "-u", mountpoint_);
EXPECT_TRUE(dwarfs_guard_.check_exit(std::chrono::seconds(5))); EXPECT_TRUE(dwarfs_guard_.check_exit(std::chrono::seconds(5)));
} }
static void umount(std::filesystem::path const& mountpoint) { static bool umount(std::filesystem::path const& mountpoint) {
run(find_fusermount(), "-u", mountpoint); return static_cast<bool>(check_run(find_fusermount(), "-u", mountpoint));
} }
private: private:
@ -178,14 +191,24 @@ TEST(tools, everything) {
folly::test::TemporaryDirectory tempdir("dwarfs"); folly::test::TemporaryDirectory tempdir("dwarfs");
auto td = std::filesystem::path(tempdir.path().string()); auto td = std::filesystem::path(tempdir.path().string());
auto image = td / "test.dwarfs"; auto image = td / "test.dwarfs";
auto image_hdr = td / "test_hdr.dwarfs";
auto data_dir = td / "data"; auto data_dir = td / "data";
auto header_data = data_dir / "format.sh";
run(tar_bin, "xf", data_archive, "-C", td); ASSERT_TRUE(check_run(tar_bin, "xf", data_archive, "-C", td));
run(mkdwarfs_bin, "-i", data_dir, "-o", image, "--no-progress"); ASSERT_TRUE(
check_run(mkdwarfs_bin, "-i", data_dir, "-o", image, "--no-progress"));
ASSERT_TRUE(std::filesystem::exists(image)); ASSERT_TRUE(std::filesystem::exists(image));
ASSERT_GT(std::filesystem::file_size(image), 1000); ASSERT_GT(std::filesystem::file_size(image), 1000);
ASSERT_TRUE(check_run(mkdwarfs_bin, "-i", image, "-o", image_hdr,
"--no-progress", "--recompress=none", "--header",
header_data));
ASSERT_TRUE(std::filesystem::exists(image_hdr));
ASSERT_GT(std::filesystem::file_size(image_hdr), 1000);
auto mountpoint = td / "mnt"; auto mountpoint = td / "mnt";
auto extracted = td / "extracted"; auto extracted = td / "extracted";
auto untared = td / "untared"; auto untared = td / "untared";
@ -193,11 +216,12 @@ TEST(tools, everything) {
ASSERT_TRUE(std::filesystem::create_directory(mountpoint)); ASSERT_TRUE(std::filesystem::create_directory(mountpoint));
{ {
std::thread driver_thread([&] { run(fuse3_bin, image, mountpoint, "-f"); }); std::thread driver_thread(
[&] { check_run(fuse3_bin, image, mountpoint, "-f"); });
ASSERT_TRUE(wait_until_file_ready(mountpoint / "format.sh", timeout)); ASSERT_TRUE(wait_until_file_ready(mountpoint / "format.sh", timeout));
run(diff_bin, "-qruN", data_dir, mountpoint); ASSERT_TRUE(check_run(diff_bin, "-qruN", data_dir, mountpoint));
EXPECT_EQ(1, num_hardlinks(mountpoint / "format.sh")); EXPECT_EQ(1, num_hardlinks(mountpoint / "format.sh"));
@ -209,7 +233,7 @@ TEST(tools, everything) {
{ {
driver_runner driver(fuse3_bin, image, mountpoint); driver_runner driver(fuse3_bin, image, mountpoint);
run(diff_bin, "-qruN", data_dir, mountpoint); ASSERT_TRUE(check_run(diff_bin, "-qruN", data_dir, mountpoint));
EXPECT_EQ(1, num_hardlinks(mountpoint / "format.sh")); EXPECT_EQ(1, num_hardlinks(mountpoint / "format.sh"));
} }
@ -217,7 +241,7 @@ TEST(tools, everything) {
{ {
driver_runner driver(fuse3_bin, image, mountpoint, "-o", "enable_nlink"); driver_runner driver(fuse3_bin, image, mountpoint, "-o", "enable_nlink");
run(diff_bin, "-qruN", data_dir, mountpoint); ASSERT_TRUE(check_run(diff_bin, "-qruN", data_dir, mountpoint));
EXPECT_EQ(3, num_hardlinks(mountpoint / "format.sh")); EXPECT_EQ(3, num_hardlinks(mountpoint / "format.sh"));
} }
@ -225,29 +249,61 @@ TEST(tools, everything) {
if (std::filesystem::exists(fuse2_bin)) { if (std::filesystem::exists(fuse2_bin)) {
driver_runner driver(fuse2_bin, image, mountpoint); driver_runner driver(fuse2_bin, image, mountpoint);
run(diff_bin, "-qruN", data_dir, mountpoint); ASSERT_TRUE(check_run(diff_bin, "-qruN", data_dir, mountpoint));
EXPECT_EQ(1, num_hardlinks(mountpoint / "format.sh")); EXPECT_EQ(1, num_hardlinks(mountpoint / "format.sh"));
} }
{
auto proc =
make_subprocess(fuse3_bin, image_hdr, mountpoint, "-o", "enable_nlink");
const auto [out, err] = proc.communicate();
EXPECT_NE(0, proc.wait().exitStatus()) << "stdout:\n"
<< out << "\nstderr:\n"
<< err;
}
{
driver_runner driver(fuse3_bin, image_hdr, mountpoint, "-o",
"enable_nlink,offset=auto");
ASSERT_TRUE(check_run(diff_bin, "-qruN", data_dir, mountpoint));
EXPECT_EQ(3, num_hardlinks(mountpoint / "format.sh"));
}
auto meta_export = td / "test.meta"; auto meta_export = td / "test.meta";
run(dwarfsck_bin, image); ASSERT_TRUE(check_run(dwarfsck_bin, image));
run(dwarfsck_bin, image, "--check-integrity"); ASSERT_TRUE(check_run(dwarfsck_bin, image, "--check-integrity"));
run(dwarfsck_bin, image, "--export-metadata", meta_export); ASSERT_TRUE(check_run(dwarfsck_bin, image, "--export-metadata", meta_export));
{
std::string header;
EXPECT_TRUE(folly::readFile(header_data.c_str(), header));
auto output = check_run(dwarfsck_bin, image_hdr, "-H");
ASSERT_TRUE(output);
EXPECT_EQ(header, *output);
}
EXPECT_GT(std::filesystem::file_size(meta_export), 1000); EXPECT_GT(std::filesystem::file_size(meta_export), 1000);
ASSERT_TRUE(std::filesystem::create_directory(extracted)); ASSERT_TRUE(std::filesystem::create_directory(extracted));
run(dwarfsextract_bin, "-i", image, "-o", extracted); ASSERT_TRUE(check_run(dwarfsextract_bin, "-i", image, "-o", extracted));
run(diff_bin, "-qruN", data_dir, extracted); ASSERT_TRUE(check_run(diff_bin, "-qruN", data_dir, extracted));
auto tarfile = td / "test.tar"; auto tarfile = td / "test.tar";
run(dwarfsextract_bin, "-i", image, "-f", "gnutar", "-o", tarfile); ASSERT_TRUE(
check_run(dwarfsextract_bin, "-i", image, "-f", "gnutar", "-o", tarfile));
ASSERT_TRUE(std::filesystem::create_directory(untared)); ASSERT_TRUE(std::filesystem::create_directory(untared));
run(tar_bin, "xf", tarfile, "-C", untared); ASSERT_TRUE(check_run(tar_bin, "xf", tarfile, "-C", untared));
run(diff_bin, "-qruN", data_dir, untared); ASSERT_TRUE(check_run(diff_bin, "-qruN", data_dir, untared));
} }