Merge branch 'develop-BA-FS26' into 'develop'HEADdevelop

Merge of BA-FS26 branch into develop

See merge request teachos/kernel!49

1 files changed, 116 insertions, 0 deletions

diff --git a/kernel/src/devices/storage/ram_disk/device.tests.cpp b/kernel/src/devices/storage/ram_disk/device.tests.cpp
new file mode 100644
index 0000000..d0fab76
--- /dev/null
+++ b/kernel/src/devices/storage/ram_disk/device.tests.cpp
@@ -0,0 +1,116 @@
+#include <kernel/devices/storage/ram_disk/device.hpp>
+
+#include <kapi/boot_module/boot_module.hpp>
+#include <kapi/memory.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers.hpp>
+#include <catch2/matchers/catch_matchers_range_equals.hpp>
+
+#include <cstddef>
+#include <ranges>
+#include <stdexcept>
+#include <vector>
+
+SCENARIO("RAM Disk Device Construction and Initialization", "[ram_disk_device]")
+{
+  GIVEN("an empty boot module")
+  {
+    kapi::boot_modules::boot_module boot_module{};
+    boot_module.start_address = kapi::memory::linear_address{nullptr};
+    boot_module.size = 0;
+
+    WHEN("constructing the device")
+    {
+      kernel::devices::storage::ram_disk::device device{boot_module, 0, 0};
+
+      THEN("init return false")
+      {
+        REQUIRE_FALSE(device.init());
+      }
+    }
+  }
+
+  GIVEN("a boot module with a valid start address and size")
+  {
+    kapi::boot_modules::boot_module boot_module{};
+    boot_module.start_address = kapi::memory::linear_address{reinterpret_cast<std::byte *>(0x1000)};
+    boot_module.size = 512;
+
+    WHEN("constructing the device")
+    {
+      kernel::devices::storage::ram_disk::device device{boot_module, 0, 0};
+
+      THEN("init return true")
+      {
+        REQUIRE(device.init());
+      }
+    }
+  }
+}
+
+SCENARIO("RAM Disk Device Read and Write", "[ram_disk_device]")
+{
+  GIVEN("a device initialized with a valid boot module")
+  {
+    auto storage = std::vector{4096, std::byte{0xff}};
+    auto module =
+        kapi::boot_modules::boot_module{"test_module", kapi::memory::linear_address{storage.data()}, storage.size()};
+    auto device = kernel::devices::storage::ram_disk::device{module, 0, 0};
+    REQUIRE(device.init());
+
+    WHEN("reading a full block from the device")
+    {
+      auto buffer = std::vector<std::byte>(device.block_size());
+      device.read_block(0, buffer.data());
+
+      THEN("the buffer is filled with the module data")
+      {
+        REQUIRE_THAT(buffer, Catch::Matchers::RangeEquals(std::views::take(storage, device.block_size())));
+      }
+    }
+
+    WHEN("reading from a block index beyond the module size")
+    {
+      auto buffer = std::vector<std::byte>(device.block_size());
+      device.read_block(10, buffer.data());
+
+      THEN("the buffer is filled with zeros")
+      {
+        REQUIRE_THAT(buffer, Catch::Matchers::RangeEquals(std::vector<std::byte>(device.block_size(), std::byte{0})));
+      }
+    }
+
+    WHEN("reading into a null buffer")
+    {
+      REQUIRE_THROWS_AS(device.read_block(0, nullptr), std::runtime_error);
+    }
+
+    WHEN("writing to a full block")
+    {
+      auto buffer = std::vector<std::byte>(device.block_size(), std::byte{0x01});
+      device.write_block(0, buffer.data());
+
+      THEN("the module data is updated")
+      {
+        REQUIRE_THAT(std::views::take(storage, device.block_size()), Catch::Matchers::RangeEquals(buffer));
+      }
+    }
+
+    WHEN("writing to a block index beyond the module size")
+    {
+      auto buffer = std::vector<std::byte>(device.block_size(), std::byte{0x01});
+      device.write_block(10, buffer.data());
+
+      THEN("the module data is not updated")
+      {
+        REQUIRE_THAT(storage, Catch::Matchers::RangeEquals(std::vector{4096, std::byte{0xff}}));
+      }
+    }
+
+    WHEN("writing from a null buffer")
+    {
+      REQUIRE_THROWS_AS(device.write_block(0, nullptr), std::runtime_error);
+    }
+  }
+}
\ No newline at end of file