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

ext2 and tests

See merge request teachos/kernel!22

1 files changed, 219 insertions, 0 deletions

diff --git a/kernel/src/devices/block_device_utils.tests.cpp b/kernel/src/devices/block_device_utils.tests.cpp
new file mode 100644
index 0000000..f78e477
--- /dev/null
+++ b/kernel/src/devices/block_device_utils.tests.cpp
@@ -0,0 +1,219 @@
+#include "kernel/devices/block_device_utils.hpp"
+
+#include "kernel/test_support/cpu.hpp"
+#include "kernel/test_support/devices/block_device.hpp"
+#include "kernel/test_support/devices/character_device.hpp"
+
+#include <kstd/memory>
+#include <kstd/print>
+#include <kstd/vector>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <cstddef>
+#include <cstdint>
+
+SCENARIO("reading from a block device with block_device_utils", "[devices][block_device_utils]")
+{
+  GIVEN("a block device with known data")
+  {
+    auto const block_size = 512;
+    auto device = kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "test_block_device", block_size);
+    kstd::vector<uint8_t> block_data(block_size);
+    for (size_t i = 0; i < block_data.size(); ++i)
+    {
+      block_data[i] = static_cast<uint8_t>(i % 256);
+    }
+    device->write_block(0, block_data.data());
+    device->write_block(1, block_data.data());
+
+    WHEN("reading from the block device using block_device_utils")
+    {
+      kstd::vector<uint8_t> read_buffer(block_size);
+      auto bytes_read = kernel::devices::block_device_utils::read(device, read_buffer.data(), 0, read_buffer.size());
+
+      THEN("the correct number of bytes is read")
+      {
+        REQUIRE(bytes_read == read_buffer.size());
+      }
+
+      THEN("the data read matches the data written to the block device")
+      {
+        REQUIRE(read_buffer == block_data);
+      }
+    }
+
+    WHEN("reading over block boundaries")
+    {
+      kstd::vector<uint8_t> read_buffer(1024);
+      auto bytes_read = kernel::devices::block_device_utils::read(device, read_buffer.data(), 256, read_buffer.size());
+
+      THEN("the correct number of bytes is read")
+      {
+        REQUIRE(bytes_read == 1.5 * block_size);
+      }
+
+      THEN("the data read matches the expected data across block boundaries")
+      {
+        for (size_t i = 0; i < bytes_read; ++i)
+        {
+          uint8_t expected_value = static_cast<uint8_t>((256 + i) % 256);
+          REQUIRE(read_buffer[i] == expected_value);
+        }
+      }
+    }
+
+    WHEN("reading beyond the device capacity")
+    {
+      kstd::vector<uint8_t> read_buffer(block_size);
+      auto bytes_read = kernel::devices::block_device_utils::read(device, read_buffer.data(), 1024, read_buffer.size());
+
+      THEN("no bytes are read")
+      {
+        REQUIRE(bytes_read == 0);
+      }
+    }
+
+    WHEN("reading nothing")
+    {
+      kstd::vector<uint8_t> read_buffer(block_size);
+      auto bytes_read = kernel::devices::block_device_utils::read(device, read_buffer.data(), 0, 0);
+
+      THEN("no bytes are read")
+      {
+        REQUIRE(bytes_read == 0);
+      }
+    }
+
+    WHEN("reading with a null buffer")
+    {
+      THEN("the system panics")
+      {
+        REQUIRE_THROWS_AS(kernel::devices::block_device_utils::read(device, nullptr, 0, 512), kernel::tests::cpu::halt);
+      }
+    }
+  }
+}
+
+SCENARIO("writing to a block device using block_device_utils", "[devices][block_device_utils]")
+{
+  GIVEN("a block device")
+  {
+    auto const block_size = 512;
+    auto device =
+        kstd::make_shared<kernel::tests::devices::block_device>(0, 0, "test_block_device", block_size, 2 * block_size);
+
+    WHEN("writing to the block device using block_device_utils")
+    {
+      kstd::vector<uint8_t> write_buffer(block_size);
+      for (size_t i = 0; i < write_buffer.size(); ++i)
+      {
+        write_buffer[i] = static_cast<uint8_t>(i % 256);
+      }
+
+      auto bytes_written =
+          kernel::devices::block_device_utils::write(device, write_buffer.data(), 0, write_buffer.size());
+
+      THEN("the correct number of bytes is written")
+      {
+        REQUIRE(bytes_written == write_buffer.size());
+      }
+
+      THEN("the data written matches the data read back from the block device")
+      {
+        kstd::vector<uint8_t> read_buffer(block_size);
+        device->read_block(0, read_buffer.data());
+        REQUIRE(read_buffer == write_buffer);
+      }
+    }
+
+    WHEN("writing over block boundaries")
+    {
+      kstd::vector<uint8_t> write_buffer(2 * block_size);
+      for (size_t i = 0; i < write_buffer.size(); ++i)
+      {
+        write_buffer[i] = static_cast<uint8_t>(i % 256);
+      }
+
+      auto bytes_written =
+          kernel::devices::block_device_utils::write(device, write_buffer.data(), 256, write_buffer.size());
+
+      THEN("the correct number of bytes is written")
+      {
+        REQUIRE(bytes_written == 1.5 * block_size);
+      }
+
+      THEN("the data written matches the data read back from the block device across block boundaries")
+      {
+        kstd::vector<uint8_t> read_buffer(2 * block_size);
+        auto bytes_read = kernel::devices::block_device_utils::read(device, read_buffer.data(), 256, 2 * block_size);
+
+        for (size_t i = 0; i < bytes_read; ++i)
+        {
+          REQUIRE(read_buffer[i] == write_buffer[i]);
+        }
+      }
+    }
+
+    WHEN("writing beyond the device capacity")
+    {
+      kstd::vector<uint8_t> write_buffer(block_size);
+      auto bytes_written =
+          kernel::devices::block_device_utils::write(device, write_buffer.data(), 1024, write_buffer.size());
+
+      THEN("no bytes are written")
+      {
+        REQUIRE(bytes_written == 0);
+      }
+    }
+
+    WHEN("writing nothing")
+    {
+      kstd::vector<uint8_t> write_buffer(block_size);
+      auto bytes_written = kernel::devices::block_device_utils::write(device, write_buffer.data(), 0, 0);
+
+      THEN("no bytes are written")
+      {
+        REQUIRE(bytes_written == 0);
+      }
+    }
+
+    WHEN("writing with a null buffer")
+    {
+      THEN("the system panics")
+      {
+        REQUIRE_THROWS_AS(kernel::devices::block_device_utils::write(device, nullptr, 0, block_size),
+                          kernel::tests::cpu::halt);
+      }
+    }
+  }
+}
+
+SCENARIO("block_device_utils with a non-block device", "[devices][block_device_utils]")
+{
+  GIVEN("a non-block device")
+  {
+    auto device = kstd::make_shared<kernel::tests::devices::character_device>(0, 0, "test_character_device");
+
+    WHEN("attempting to read from the non-block device using block_device_utils")
+    {
+      kstd::vector<uint8_t> read_buffer(512);
+      THEN("the system panics")
+      {
+        REQUIRE_THROWS_AS(kernel::devices::block_device_utils::read(device, read_buffer.data(), 0, read_buffer.size()),
+                          kernel::tests::cpu::halt);
+      }
+    }
+
+    WHEN("attempting to write to the non-block device using block_device_utils")
+    {
+      kstd::vector<uint8_t> write_buffer(512);
+      THEN("the system panics")
+      {
+        REQUIRE_THROWS_AS(
+            kernel::devices::block_device_utils::write(device, write_buffer.data(), 0, write_buffer.size()),
+            kernel::tests::cpu::halt);
+      }
+    }
+  }
+}