diff options
Diffstat (limited to 'kernel/src/devices')
| -rw-r--r-- | kernel/src/devices/block_device.cpp | 42 | ||||
| -rw-r--r-- | kernel/src/devices/block_device.tests.cpp | 46 | ||||
| -rw-r--r-- | kernel/src/devices/block_device_utils.cpp | 106 | ||||
| -rw-r--r-- | kernel/src/devices/block_device_utils.tests.cpp | 219 | ||||
| -rw-r--r-- | kernel/src/devices/root_bus.cpp | 12 | ||||
| -rw-r--r-- | kernel/src/devices/storage/controller.cpp | 44 | ||||
| -rw-r--r-- | kernel/src/devices/storage/management.cpp | 95 | ||||
| -rw-r--r-- | kernel/src/devices/storage/ram_disk/controller.cpp | 27 | ||||
| -rw-r--r-- | kernel/src/devices/storage/ram_disk/device.cpp | 71 | ||||
| -rw-r--r-- | kernel/src/devices/storage/ram_disk/device.tests.cpp | 116 |
10 files changed, 0 insertions, 778 deletions
diff --git a/kernel/src/devices/block_device.cpp b/kernel/src/devices/block_device.cpp deleted file mode 100644 index 13d73acd..00000000 --- a/kernel/src/devices/block_device.cpp +++ /dev/null @@ -1,42 +0,0 @@ -#include <kernel/devices/block_device.hpp> - -#include <kapi/devices/device.hpp> -#include <kapi/system.hpp> - -#include <kstd/string> - -#include <cstddef> - -namespace kernel::devices -{ - block_device::block_device(size_t major, size_t minor, kstd::string const & name, size_t block_size) - : kapi::devices::device(major, minor, name) - , m_block_size(block_size) - { - if (m_block_size == 0) - { - kapi::system::panic("[DEVICES] block_device constructed with zero block size."); - } - } - - auto block_device::calculate_transfer(size_t block_index) const -> transfer_info - { - size_t const offset = block_index * m_block_size; - size_t const limit = size(); - - size_t const available = (offset < limit) ? (limit - offset) : 0; - size_t const to_transfer = (available < m_block_size) ? available : m_block_size; - - return {offset, to_transfer, m_block_size - to_transfer}; - } - - auto block_device::block_size() const -> size_t - { - return m_block_size; - } - - auto block_device::capacity() const -> size_t - { - return size(); - } -} // namespace kernel::devices
\ No newline at end of file diff --git a/kernel/src/devices/block_device.tests.cpp b/kernel/src/devices/block_device.tests.cpp deleted file mode 100644 index a2ddd2bb..00000000 --- a/kernel/src/devices/block_device.tests.cpp +++ /dev/null @@ -1,46 +0,0 @@ -#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 deleted file mode 100644 index 18d1e9d7..00000000 --- a/kernel/src/devices/block_device_utils.cpp +++ /dev/null @@ -1,106 +0,0 @@ -#include <kernel/devices/block_device_utils.hpp> - -#include <kernel/devices/block_device.hpp> - -#include <kapi/devices/device.hpp> -#include <kapi/system.hpp> - -#include <kstd/cstring> -#include <kstd/memory> -#include <kstd/vector> - -#include <algorithm> -#include <cstddef> - -namespace kernel::devices::block_device_utils -{ - - using block_op = void (*)(size_t idx, size_t off, size_t len, size_t done, devices::block_device * device, - std::byte * scratch, void * buffer); - - auto process_blocks(kstd::shared_ptr<kapi::devices::device> const & device, size_t offset, size_t size, void * buffer, - block_op op) -> size_t - { - if (buffer == nullptr) - { - kapi::system::panic("[FILESYSTEM] device_file::process_blocks called with null buffer."); - } - - if (size == 0) - { - return 0; - } - - 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(); - - if (offset >= capacity) - { - return 0; - } - size_t const total_to_process = std::min(size, capacity - offset); - - kstd::vector<std::byte> scratch_buffer{block_size}; - auto processed = 0uz; - - while (processed < total_to_process) - { - size_t const absolute_offset = offset + processed; - size_t const block_index = absolute_offset / block_size; - size_t const in_block_offset = absolute_offset % block_size; - size_t const chunk_size = std::min(total_to_process - processed, block_size - in_block_offset); - - op(block_index, in_block_offset, chunk_size, processed, block_dev, scratch_buffer.data(), buffer); - - processed += chunk_size; - } - - return processed; - } - - auto read(kstd::shared_ptr<kapi::devices::device> const & device, void * buffer, size_t offset, size_t size) -> size_t - { - return process_blocks(device, offset, size, buffer, - [](size_t idx, size_t off, size_t len, size_t done, devices::block_device * device, - std::byte * scratch, void * buffer) { - auto * out = static_cast<std::byte *>(buffer); - if (off == 0 && len == device->block_size()) - { - device->read_block(idx, out + done); - } - else - { - device->read_block(idx, scratch); - kstd::libc::memcpy(out + done, scratch + off, len); - } - }); - } - - auto write(kstd::shared_ptr<kapi::devices::device> const & device, void const * buffer, size_t offset, size_t size) - -> size_t - { - return process_blocks(device, offset, size, const_cast<void *>(buffer), - [](size_t idx, size_t off, size_t len, size_t done, devices::block_device * device, - std::byte * scratch, void * buffer) { - auto const * in = static_cast<std::byte const *>(buffer); - if (off == 0 && len == device->block_size()) - { - device->write_block(idx, in + done); - } - else - { - device->read_block(idx, scratch); - kstd::libc::memcpy(scratch + off, in + done, len); - device->write_block(idx, scratch); - } - }); - } - -} // namespace kernel::devices::block_device_utils
\ No newline at end of file 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); - } - } - } -} diff --git a/kernel/src/devices/root_bus.cpp b/kernel/src/devices/root_bus.cpp deleted file mode 100644 index 1b754f23..00000000 --- a/kernel/src/devices/root_bus.cpp +++ /dev/null @@ -1,12 +0,0 @@ -#include <kernel/devices/root_bus.hpp> - -#include <kapi/devices.hpp> - -namespace kernel::devices -{ - - root_bus::root_bus() - : kapi::devices::bus{0, 0, "system"} - {} - -} // namespace kernel::devices
\ No newline at end of file diff --git a/kernel/src/devices/storage/controller.cpp b/kernel/src/devices/storage/controller.cpp deleted file mode 100644 index 171b918e..00000000 --- a/kernel/src/devices/storage/controller.cpp +++ /dev/null @@ -1,44 +0,0 @@ -#include <kernel/devices/storage/controller.hpp> - -#include <kapi/devices/device.hpp> - -#include <kstd/memory> -#include <kstd/vector> - -#include <algorithm> -#include <cstddef> - -namespace kernel::devices::storage -{ - auto controller::set_ids(size_t major, size_t minors_per_dev) -> void - { - m_major = major; - m_minors_per_device = minors_per_dev; - } - - auto controller::major() const -> size_t - { - return m_major; - } - - auto controller::device_by_minor(size_t minor) const -> kstd::shared_ptr<kapi::devices::device> - { - auto it = std::ranges::find_if(m_devices, [minor](auto const & device) { return device->minor() == minor; }); - - if (it != m_devices.end()) - { - return *it; - } - return nullptr; - } - - auto controller::devices_count() const -> size_t - { - return m_devices.size(); - } - - auto controller::all_devices() const -> kstd::vector<kstd::shared_ptr<kapi::devices::device>> const & - { - return m_devices; - } -} // namespace kernel::devices::storage
\ No newline at end of file diff --git a/kernel/src/devices/storage/management.cpp b/kernel/src/devices/storage/management.cpp deleted file mode 100644 index 06efc27d..00000000 --- a/kernel/src/devices/storage/management.cpp +++ /dev/null @@ -1,95 +0,0 @@ -#include <kernel/devices/storage/management.hpp> - -#include <kernel/devices/storage/controller.hpp> -#include <kernel/devices/storage/ram_disk/controller.hpp> - -#include <kapi/boot_modules.hpp> -#include <kapi/devices/device.hpp> -#include <kapi/system.hpp> - -#include <kstd/memory> -#include <kstd/vector> - -#include <algorithm> -#include <cstddef> -#include <optional> -#include <ranges> - -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; - - constinit auto static storage_management = std::optional<kernel::devices::storage::management>{}; -} // namespace - -namespace kernel::devices::storage -{ - auto management::init() -> void - { - if (storage_management) - { - kapi::system::panic("[DEVICES] Storage management has already been initialized."); - } - storage_management.emplace(management{}); - - auto ram_disk_controller = kstd::make_shared<ram_disk::controller>(&kapi::boot_modules::get_boot_module_registry()); - storage_management->add_controller(ram_disk_controller); - - std::ranges::for_each(storage_management->m_controllers, [](auto controller) { controller->probe(); }); - } - - auto management::get() -> management & - { - if (!storage_management) - { - kapi::system::panic("[DEVICES] Storage management has not been initialized."); - } - - return *storage_management; - } - - auto management::add_controller(kstd::shared_ptr<controller> const & controller) -> void - { - controller->set_ids(next_free_major++, minors_per_device); - m_controllers.push_back(controller); - } - - auto management::all_controllers() const -> kstd::vector<kstd::shared_ptr<controller>> const & - { - return m_controllers; - } - - auto management::device_by_major_minor(size_t major, size_t minor) -> kstd::shared_ptr<kapi::devices::device> - { - auto found = std::ranges::find_if(m_controllers, [=](auto const & controller) { - if (controller != nullptr && controller->major() == major) - { - return controller->device_by_minor(minor) != nullptr; - } - return false; - }); - - if (found != std::ranges::cend(m_controllers)) - { - return found->get()->device_by_minor(minor); - } - - return nullptr; - } - - auto management::determine_boot_device() -> kstd::shared_ptr<kapi::devices::device> - { - return device_by_major_minor(start_major, 0); - } -} // namespace kernel::devices::storage - -namespace kernel::tests::devices::storage::management -{ - auto deinit() -> void - { - storage_management.reset(); - next_free_major = start_major; - } -} // namespace kernel::tests::devices::storage::management diff --git a/kernel/src/devices/storage/ram_disk/controller.cpp b/kernel/src/devices/storage/ram_disk/controller.cpp deleted file mode 100644 index 30441fa5..00000000 --- a/kernel/src/devices/storage/ram_disk/controller.cpp +++ /dev/null @@ -1,27 +0,0 @@ -#include <kernel/devices/storage/ram_disk/controller.hpp> - -#include <kernel/devices/storage/ram_disk/device.hpp> - -#include <kapi/boot_module/boot_module_registry.hpp> - -#include <kstd/memory> - -#include <algorithm> -#include <cstddef> - -namespace kernel::devices::storage::ram_disk -{ - controller::controller(kapi::boot_modules::boot_module_registry const * registry) - : m_boot_module_registry(registry) - {} - - auto controller::probe() -> void - { - size_t current_device_index = 0; - - std::ranges::for_each(*m_boot_module_registry, [this, ¤t_device_index](auto const & module) { - auto const minor = current_device_index++ * m_minors_per_device; - m_devices.push_back(kstd::make_shared<device>(module, m_major, minor)); - }); - } -} // namespace kernel::devices::storage::ram_disk
\ No newline at end of file diff --git a/kernel/src/devices/storage/ram_disk/device.cpp b/kernel/src/devices/storage/ram_disk/device.cpp deleted file mode 100644 index 1557204b..00000000 --- a/kernel/src/devices/storage/ram_disk/device.cpp +++ /dev/null @@ -1,71 +0,0 @@ -#include <kernel/devices/storage/ram_disk/device.hpp> - -#include <kernel/devices/block_device.hpp> - -#include <kapi/boot_module/boot_module.hpp> -#include <kapi/system.hpp> - -#include <kstd/cstring> -#include <kstd/string> - -#include <cstddef> - -namespace kernel::devices::storage::ram_disk -{ - namespace - { - constexpr size_t ram_disk_block_size = 512uz; - } // namespace - - device::device(kapi::boot_modules::boot_module const & module, size_t major, size_t minor) - : block_device(major, minor, "ram" + kstd::to_string(minor), ram_disk_block_size) - , m_boot_module(module) - {} - - auto device::init() -> bool - { - return m_boot_module.start_address.raw() != 0 && m_boot_module.size > 0; - } - - auto device::read_block(size_t block_index, void * buffer) const -> void - { - if (buffer == nullptr) - { - kapi::system::panic("[RAM DISK DEVICE] read_block called with null buffer."); - } - - auto const info = calculate_transfer(block_index); - - if (info.to_transfer > 0) - { - auto const src = static_cast<std::byte const *>(m_boot_module.start_address) + info.offset; - kstd::libc::memcpy(buffer, src, info.to_transfer); - } - - if (info.remainder > 0) - { - kstd::libc::memset(static_cast<std::byte *>(buffer) + info.to_transfer, 0, info.remainder); - } - } - - auto device::write_block(size_t block_index, void const * buffer) -> void - { - if (buffer == nullptr) - { - kapi::system::panic("[RAM DISK DEVICE] write_block called with null buffer."); - } - - auto const info = calculate_transfer(block_index); - - if (info.to_transfer > 0) - { - auto const dest = static_cast<std::byte *>(m_boot_module.start_address) + info.offset; - kstd::libc::memcpy(dest, buffer, info.to_transfer); - } - } - - auto device::size() const -> size_t - { - return m_boot_module.size; - } -} // namespace kernel::devices::storage::ram_disk
\ No newline at end of file diff --git a/kernel/src/devices/storage/ram_disk/device.tests.cpp b/kernel/src/devices/storage/ram_disk/device.tests.cpp deleted file mode 100644 index d0fab76b..00000000 --- a/kernel/src/devices/storage/ram_disk/device.tests.cpp +++ /dev/null @@ -1,116 +0,0 @@ -#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 |