From 3012fa5dfe5dfed5e83baf9b40934ed8e8317627 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@ost.ch>
Date: Fri, 3 Jul 2026 09:32:30 +0200
Subject: kernel: rearrange sources according to p1204

---
 kernel/src/devices/block_device_utils.tests.cpp | 219 ------------------------
 1 file changed, 219 deletions(-)
 delete mode 100644 kernel/src/devices/block_device_utils.tests.cpp

(limited to 'kernel/src/devices/block_device_utils.tests.cpp')

diff --git a/kernel/src/devices/block_device_utils.tests.cpp b/kernel/src/devices/block_device_utils.tests.cpp
deleted file mode 100644
index e2e1e65e..00000000
--- a/kernel/src/devices/block_device_utils.tests.cpp
+++ /dev/null
@@ -1,219 +0,0 @@
-#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);
-      }
-    }
-  }
-}
-- 
cgit v1.2.3