chore: support map_file without size argument

include/dwarfs/os_access.h

@@ -48,6 +48,8 @@ class os_access {
   virtual std::filesystem::path
   read_symlink(std::filesystem::path const& path) const = 0;
   virtual std::unique_ptr<mmif>
+  map_file(std::filesystem::path const& path) const = 0;
+  virtual std::unique_ptr<mmif>
   map_file(std::filesystem::path const& path, size_t size) const = 0;
   virtual int access(std::filesystem::path const& path, int mode) const = 0;
   virtual std::filesystem::path

include/dwarfs/os_access_generic.h

@@ -41,6 +41,8 @@ class os_access_generic : public os_access {
   std::filesystem::path
   read_symlink(std::filesystem::path const& path) const override;
   std::unique_ptr<mmif>
+  map_file(std::filesystem::path const& path) const override;
+  std::unique_ptr<mmif>
   map_file(std::filesystem::path const& path, size_t size) const override;
   int access(std::filesystem::path const& path, int mode) const override;
   std::filesystem::path

src/dwarfs/os_access_generic.cpp

@@ -67,6 +67,10 @@ fs::path os_access_generic::read_symlink(fs::path const& path) const {
   return fs::read_symlink(path);
 }
 
+std::unique_ptr<mmif> os_access_generic::map_file(fs::path const& path) const {
+  return std::make_unique<mmap>(path);
+}
+
 std::unique_ptr<mmif>
 os_access_generic::map_file(fs::path const& path, size_t size) const {
   return std::make_unique<mmap>(path, size);

test/mmap_mock.h

@@ -27,13 +27,20 @@ namespace test {
 class mmap_mock : public mmif {
  public:
   mmap_mock(const std::string& data)
-      : data_(data)
+      : mmap_mock{data, "<mock-file>"} {}
-      , path_{"<mock-file>"} {}
 
   mmap_mock(const std::string& data, std::filesystem::path const& path)
       : data_{data}
       , path_{path} {}
 
+  mmap_mock(const std::string& data, size_t size)
+      : mmap_mock{data, size, "<mock-file>"} {}
+
+  mmap_mock(const std::string& data, size_t size,
+            std::filesystem::path const& path)
+      : data_{data, 0, std::min(size, data.size())}
+      , path_{path} {}
+
   void const* addr() const override { return data_.data(); }
 
   size_t size() const override { return data_.size(); }

test/test_helpers.cpp

@@ -425,20 +425,27 @@ std::unique_ptr<mmif>
 os_access_mock::map_file(fs::path const& path, size_t size) const {
   if (auto de = find(path);
       de && de->status.type() == posix_file_type::regular) {
-    return std::make_unique<mmap_mock>(std::visit(
+    return std::make_unique<mmap_mock>(
-        overloaded{
+        std::visit(overloaded{
-            [this](std::string const& str) { return str; },
+                       [this](std::string const& str) { return str; },
-            [this](std::function<std::string()> const& fun) { return fun(); },
+                       [this](std::function<std::string()> const& fun) {
-            [this](auto const&) -> std::string {
+                         return fun();
-              throw std::runtime_error("oops in overloaded");
+                       },
-            },
+                       [this](auto const&) -> std::string {
-        },
+                         throw std::runtime_error("oops in overloaded");
-        de->v));
+                       },
+                   },
+                   de->v),
+        size);
   }
 
   throw std::runtime_error(fmt::format("oops in map_file: {}", path.string()));
 }
 
+std::unique_ptr<mmif> os_access_mock::map_file(fs::path const& path) const {
+  return map_file(path, std::numeric_limits<size_t>::max());
+}
+
 int os_access_mock::access(fs::path const& path, int) const {
   return access_fail_set_.count(path) ? -1 : 0;
 }

test/test_helpers.h

@@ -101,6 +101,8 @@ class os_access_mock : public os_access {
   std::filesystem::path
   read_symlink(std::filesystem::path const& path) const override;
 
+  std::unique_ptr<mmif>
+  map_file(std::filesystem::path const& path) const override;
   std::unique_ptr<mmif>
   map_file(std::filesystem::path const& path, size_t size) const override;