Add tests for inode creation

1 files changed, 82 insertions, 0 deletions

diff --git a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
index 2528db4b..277ff385 100644
--- a/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
+++ b/kernel/kernel/filesystem/ext2/filesystem.tests.cpp
@@ -7,6 +7,7 @@
 #include <kernel/filesystem/ext2/inode.hpp>
 #include <kernel/filesystem/ext2/superblock.hpp>
 #include <kernel/filesystem/filesystem.hpp>
+#include <kernel/filesystem/vfs_types.hpp>
 #include <kernel/test_support/devices/block_device.hpp>
 #include <kernel/test_support/filesystem/ext2.hpp>
 #include <kernel/test_support/filesystem/storage_boot_module_fixture.hpp>
@@ -21,6 +22,7 @@
 #include <cstdint>
 #include <cstring>
 #include <filesystem>
+#include <string_view>
 #include <vector>
 
 SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
@@ -73,6 +75,86 @@ SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
   }
 }
 
+SCENARIO_METHOD(kernel::tests::filesystem::storage_boot_module_fixture,
+                "Ext2 filesystem create new inodes with real image", "[filesystem][ext2][filesystem][img]")
+{
+  auto const image_path = std::filesystem::path{KERNEL_TEST_ASSETS_DIR} / "ext2_1KB_fs.img";
+
+  GIVEN("a mounted ext2 filesystem from a real image")
+  {
+    REQUIRE(std::filesystem::exists(image_path));
+    REQUIRE_NOTHROW(setup_modules_from_img({"test_img_module"}, {image_path}));
+
+    auto boot_device = kernel::devices::storage::management::get().determine_boot_device();
+    REQUIRE(boot_device != nullptr);
+
+    auto dev_inode = kstd::make_shared<kernel::filesystem::device_inode>(boot_device);
+
+    auto fs = kernel::filesystem::ext2::filesystem{};
+    REQUIRE(fs.mount(dev_inode) == kernel::filesystem::filesystem::operation_result::success);
+
+    THEN("a file can be created")
+    {
+      auto lookup_result = fs.lookup(fs.root_inode(), "blub");
+      REQUIRE(lookup_result == nullptr);
+
+      auto new_inode = fs.create_inode(fs.root_inode(), "blub", kernel::filesystem::vfs_types::inode_type::regular);
+      REQUIRE(new_inode != nullptr);
+      REQUIRE(new_inode->is_regular());
+
+      lookup_result = fs.lookup(fs.root_inode(), "blub");
+      REQUIRE(lookup_result != nullptr);
+    }
+
+    THEN("a directory can be created")
+    {
+      auto lookup_result = fs.lookup(fs.root_inode(), "blub");
+      REQUIRE(lookup_result == nullptr);
+
+      auto new_directory =
+          fs.create_inode(fs.root_inode(), "blub", kernel::filesystem::vfs_types::inode_type::directory);
+      REQUIRE(new_directory != nullptr);
+      REQUIRE(new_directory->is_directory());
+
+      lookup_result = fs.lookup(fs.root_inode(), "blub");
+      REQUIRE(lookup_result != nullptr);
+    }
+
+    THEN("a directory and a file within can be created")
+    {
+      auto new_directory =
+          fs.create_inode(fs.root_inode(), "blub", kernel::filesystem::vfs_types::inode_type::directory);
+      REQUIRE(new_directory != nullptr);
+
+      auto new_file = fs.create_inode(new_directory, "blub_file", kernel::filesystem::vfs_types::inode_type::regular);
+      REQUIRE(new_file != nullptr);
+
+      auto lookup_result = fs.lookup(new_directory, "blub_file");
+      REQUIRE(lookup_result != nullptr);
+      REQUIRE(lookup_result->is_regular());
+    }
+
+    THEN("a file can be created and written to")
+    {
+      auto new_inode = fs.create_inode(fs.root_inode(), "blub", kernel::filesystem::vfs_types::inode_type::regular);
+      REQUIRE(new_inode != nullptr);
+
+      auto buffer = std::vector<std::byte>{std::byte{'H'}, std::byte{'e'}, std::byte{'l'}, std::byte{'l'},
+                                           std::byte{'o'}, std::byte{' '}, std::byte{'W'}, std::byte{'o'},
+                                           std::byte{'r'}, std::byte{'l'}, std::byte{'d'}, std::byte{'!'}};
+      auto bytes_written = new_inode->write(buffer.data(), 0, buffer.size());
+      REQUIRE(bytes_written == buffer.size());
+
+      auto read_buffer = std::vector<std::byte>(5, std::byte{0xAA});
+      auto bytes_read = new_inode->read(read_buffer.data(), 0, read_buffer.size());
+      REQUIRE(bytes_read == read_buffer.size());
+
+      std::string_view result{reinterpret_cast<char *>(read_buffer.data()), static_cast<size_t>(bytes_read)};
+      REQUIRE(result == "Hello");
+    }
+  }
+}
+
 SCENARIO("Ext2 filesystem rejects invalid magic", "[filesystem][ext2][filesystem]")
 {
   auto const block_size = 1024;