5 files changed, 288 insertions, 15 deletions

diff --git a/kernel/src/devices/block_device.cpp b/kernel/src/devices/block_device.cpp
index c006198..b7cb26e 100644
--- a/kernel/src/devices/block_device.cpp
+++ b/kernel/src/devices/block_device.cpp
@@ -1,8 +1,7 @@
 #include "kernel/devices/block_device.hpp"
 
-#include "kapi/system.hpp"
-
 #include "kapi/devices/device.hpp"
+#include "kapi/system.hpp"
 
 #include <kstd/string>
 
diff --git a/kernel/src/devices/block_device.tests.cpp b/kernel/src/devices/block_device.tests.cpp
new file mode 100644
index 0000000..378437e
--- /dev/null
+++ b/kernel/src/devices/block_device.tests.cpp
@@ -0,0 +1,46 @@
+#include "kernel/test_support/devices/block_device.hpp"
+
+#include "kernel/test_support/cpu.hpp"
+
+#include <kstd/memory>
+#include <kstd/print>
+#include <kstd/string>
+#include <kstd/vector>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <cstddef>
+
+SCENARIO("Block device construction", "[devices][block_device]")
+{
+  GIVEN("parameters for a block device")
+  {
+    size_t major = 1;
+    size_t minor = 0;
+    kstd::string name = "test_block_device";
+    size_t block_size = 512;
+
+    WHEN("constructing a block device")
+    {
+      auto device =
+          kstd::make_shared<kernel::tests::devices::block_device>(major, minor, name, block_size, 3 * block_size);
+
+      THEN("the block device has the correct properties")
+      {
+        REQUIRE(device->major() == major);
+        REQUIRE(device->minor() == minor);
+        REQUIRE(device->name() == name);
+        REQUIRE(device->block_size() == block_size);
+        REQUIRE(device->capacity() == 3 * 512);
+      }
+    }
+
+    WHEN("constructing a block device with zero block size")
+    {
+      THEN("the constructor panics")
+      {
+        REQUIRE_THROWS_AS((kernel::tests::devices::block_device(major, minor, name, 0)), kernel::tests::cpu::halt);
+      }
+    }
+  }
+}
diff --git a/kernel/src/devices/block_device_utils.cpp b/kernel/src/devices/block_device_utils.cpp
index 6fe89fe..59e9b97 100644
--- a/kernel/src/devices/block_device_utils.cpp
+++ b/kernel/src/devices/block_device_utils.cpp
@@ -1,9 +1,9 @@
 #include "kernel/devices/block_device_utils.hpp"
 
+#include "kapi/devices/device.hpp"
 #include "kapi/system.hpp"
 
 #include "kernel/devices/block_device.hpp"
-#include "kapi/devices/device.hpp"
 
 #include <kstd/cstring>
 #include <kstd/memory>
@@ -31,12 +31,13 @@ namespace kernel::devices::block_device_utils
       return 0;
     }
 
-    auto * block_dev = static_cast<devices::block_device *>(device.get());
-    if (block_dev == nullptr)
+    if (!device->is_block_device())
     {
       kapi::system::panic("[FILESYSTEM] device_file: expected block_device.");
     }
 
+    auto * block_dev = static_cast<devices::block_device *>(device.get());
+
     size_t const block_size = block_dev->block_size();
     size_t const capacity = block_dev->capacity();
 
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);
+      }
+    }
+  }
+}
diff --git a/kernel/src/devices/storage/management.cpp b/kernel/src/devices/storage/management.cpp
index d440bf0..c9fa0a8 100644
--- a/kernel/src/devices/storage/management.cpp
+++ b/kernel/src/devices/storage/management.cpp
@@ -1,9 +1,9 @@
 #include "kernel/devices/storage/management.hpp"
 
 #include "kapi/boot_modules.hpp"
+#include "kapi/devices/device.hpp"
 #include "kapi/system.hpp"
 
-#include "kapi/devices/device.hpp"
 #include "kernel/devices/storage/controller.hpp"
 #include "kernel/devices/storage/ram_disk/controller.hpp"
 
@@ -14,17 +14,17 @@
 #include <cstddef>
 #include <optional>
 
-namespace kernel::devices::storage
+namespace
 {
-  namespace
-  {
-    constexpr size_t static MINORS_PER_DEVICE = 16;
-    constexpr size_t static START_MAJOR = 1;
-    constinit size_t static next_free_major = START_MAJOR;
+  constexpr size_t static MINORS_PER_DEVICE = 16;
+  constexpr size_t static START_MAJOR = 1;
+  constinit size_t static next_free_major = START_MAJOR;
 
-    constinit auto static active_storage_management = std::optional<management>{};
-  }  // namespace
+  constinit auto static active_storage_management = std::optional<kernel::devices::storage::management>{};
+}  // namespace
 
+namespace kernel::devices::storage
+{
   auto management::init() -> void
   {
     if (active_storage_management)
@@ -81,5 +81,13 @@ namespace kernel::devices::storage
   {
     return device_by_major_minor(START_MAJOR, 0);
   }
+}  // namespace kernel::devices::storage
 
-}  // namespace kernel::devices::storage
\ No newline at end of file
+namespace kernel::tests::devices::storage::management
+{
+  auto deinit() -> void
+  {
+    active_storage_management.reset();
+    next_free_major = START_MAJOR;
+  }
+}  // namespace kernel::tests::devices::storage::management