kernel/tests: clean up implementation structure

18 files changed, 261 insertions, 187 deletions

diff --git a/kernel/CMakeLists.txt b/kernel/CMakeLists.txt
index 1b71a5f..f283588 100644
--- a/kernel/CMakeLists.txt
+++ b/kernel/CMakeLists.txt
@@ -94,6 +94,7 @@ else()
         "src/test_support/kapi/interrupts.cpp"
         "src/test_support/kapi/memory.cpp"
         "src/test_support/log_buffer.cpp"
+        "src/test_support/output_device.cpp"
         "src/test_support/page_mapper.cpp"
         "src/test_support/simulated_memory.cpp"
         "src/test_support/state_reset_listener.cpp"
diff --git a/kernel/include/kernel/test_support/cio.hpp b/kernel/include/kernel/test_support/cio.hpp
new file mode 100644
index 0000000..4b897b5
--- /dev/null
+++ b/kernel/include/kernel/test_support/cio.hpp
@@ -0,0 +1,29 @@
+#ifndef TEACHOS_KERNEL_TEST_SUPPORT_CIO_HPP
+#define TEACHOS_KERNEL_TEST_SUPPORT_CIO_HPP
+
+#include "kapi/cio.hpp"
+
+#include "kernel/test_support/log_buffer.hpp"
+
+#include <string_view>
+
+namespace kernel::tests::cio
+{
+  struct output_device : kapi::cio::output_device
+  {
+    output_device() = default;
+
+    auto write(kapi::cio::output_stream stream, std::string_view text) -> void override;
+
+    [[nodiscard]] auto log_buffer() noexcept -> kernel::tests::log_buffer &;
+
+  private:
+    kernel::tests::log_buffer m_log_buffer{};
+  };
+
+  auto deinit() -> void;
+
+  [[nodiscard]] auto log_buffer() -> kernel::tests::log_buffer &;
+}  // namespace kernel::tests::cio
+
+#endif
\ No newline at end of file
diff --git a/kernel/include/kernel/test_support/cpu.hpp b/kernel/include/kernel/test_support/cpu.hpp
index 5445473..037b1b2 100644
--- a/kernel/include/kernel/test_support/cpu.hpp
+++ b/kernel/include/kernel/test_support/cpu.hpp
@@ -13,6 +13,8 @@ namespace kernel::tests::cpu
     {}
   };
 
+  auto deinit() -> void;
+
 }  // namespace kernel::tests::cpu
 
 #endif
\ No newline at end of file
diff --git a/kernel/include/kernel/test_support/log_buffer.hpp b/kernel/include/kernel/test_support/log_buffer.hpp
index 581b32f..41d9a76 100644
--- a/kernel/include/kernel/test_support/log_buffer.hpp
+++ b/kernel/include/kernel/test_support/log_buffer.hpp
@@ -4,29 +4,34 @@
 #include <string>
 #include <vector>
 
-namespace kernel::tests::log_buffer
+namespace kernel::tests
 {
 
-  //! Append a message to the testing log buffer.
-  //!
-  //! @param message The message to append.
-  auto append(std::string const & message) -> void;
-
-  //! Clear the testing log buffer.
-  auto clear() -> void;
-
-  //! Get the testing log buffer as a single string.
-  //!
-  //! @return The testing log buffer as a single string.
-  auto flat_messages() -> std::string;
-
-  //! Get the testing log buffer.
-  //!
-  //! @note Messages may be split across multiple entries if they are longer than the internal kernel print buffer size.
-  //!
-  //! @return The testing log buffer.
-  auto messages() -> std::vector<std::string> const &;
-
-}  // namespace kernel::tests::log_buffer
+  struct log_buffer
+  {
+    //! Append a message to this buffer.
+    //! @param message The message to append.
+    auto append(std::string const & message) -> void;
+
+    //! Clear this buffer.
+    auto clear() -> void;
+
+    //! Get all messages in this buffer as a single string.
+    //!
+    //! @return All messages in this buffer as a single string.
+    auto flat_messages() -> std::string;
+
+    //! Get all messages in this buffer.
+    //!
+    //! @note Messages may be split across multiple entries if they are longer than the internal kernel print buffer
+    //! size.
+    //!
+    //! @return All messages in this buffer.
+    auto messages() -> std::vector<std::string> const &;
+
+  private:
+    std::vector<std::string> m_messages{};
+  };
+}  // namespace kernel::tests
 
 #endif
\ No newline at end of file
diff --git a/kernel/include/kernel/test_support/memory.hpp b/kernel/include/kernel/test_support/memory.hpp
index c6b7449..b475116 100644
--- a/kernel/include/kernel/test_support/memory.hpp
+++ b/kernel/include/kernel/test_support/memory.hpp
@@ -5,7 +5,9 @@
 
 namespace kernel::tests::memory
 {
-  auto heap_base() -> kapi::memory::linear_address;
-}
+  auto deinit() -> void;
+
+  auto virtual_base() -> kapi::memory::linear_address;
+}  // namespace kernel::tests::memory
 
 #endif
\ No newline at end of file
diff --git a/kernel/include/kernel/test_support/page_mapper.hpp b/kernel/include/kernel/test_support/page_mapper.hpp
index a40aa2e..1658455 100644
--- a/kernel/include/kernel/test_support/page_mapper.hpp
+++ b/kernel/include/kernel/test_support/page_mapper.hpp
@@ -16,7 +16,7 @@ namespace kernel::tests
 
   struct page_mapper : kapi::memory::page_mapper
   {
-    explicit page_mapper(kstd::units::bytes memory_size);
+    page_mapper(kstd::units::bytes physical_size, kstd::units::bytes virtual_size);
 
     auto map(kapi::memory::page page, kapi::memory::frame frame, flags) -> std::byte * override;
 
diff --git a/kernel/include/kernel/test_support/simulated_memory.hpp b/kernel/include/kernel/test_support/simulated_memory.hpp
index 9a391d8..1619f31 100644
--- a/kernel/include/kernel/test_support/simulated_memory.hpp
+++ b/kernel/include/kernel/test_support/simulated_memory.hpp
@@ -6,27 +6,34 @@
 #include <kstd/units>
 
 #include <cstddef>
+#include <sys/types.h>
 
 namespace kernel::tests
 {
 
   struct simulated_memory
   {
-    explicit simulated_memory(kstd::units::bytes size);
+    simulated_memory(kstd::units::bytes physical_size, kstd::units::bytes virtual_size);
 
     ~simulated_memory();
 
     auto clear() -> void;
 
-    [[nodiscard]] auto ram_base() noexcept -> std::byte *;
-    [[nodiscard]] auto ram_base() const noexcept -> std::byte const *;
-    [[nodiscard]] auto heap_base() const noexcept -> kapi::memory::linear_address;
-    [[nodiscard]] auto heap_size() const noexcept -> kstd::units::bytes;
-    [[nodiscard]] auto memory_descriptor() const noexcept -> int;
+    [[nodiscard]] auto physical_base() noexcept -> std::byte *;
+    [[nodiscard]] auto physical_base() const noexcept -> std::byte const *;
+    [[nodiscard]] auto physical_size() const noexcept -> kstd::units::bytes;
+
+    [[nodiscard]] auto virtual_base() const noexcept -> kapi::memory::linear_address;
+    [[nodiscard]] auto virtual_size() const noexcept -> kstd::units::bytes;
+
+    [[nodiscard]] auto descriptor() const noexcept -> int;
+
+    [[nodiscard]] auto map(kstd::units::bytes size, std::byte * to, off_t offset) -> std::byte *;
 
   private:
-    int m_memory_descriptor{};
-    kstd::units::bytes m_size{0};
+    int m_descriptor{};
+    kstd::units::bytes m_physical_size{0};
+    kstd::units::bytes m_virtual_size{0};
     std::byte * m_physical_base{nullptr};
     std::byte * m_virtual_base{nullptr};
   };
diff --git a/kernel/kapi/system.tests.cpp b/kernel/kapi/system.tests.cpp
index ee31c51..687053e 100644
--- a/kernel/kapi/system.tests.cpp
+++ b/kernel/kapi/system.tests.cpp
@@ -1,7 +1,7 @@
 #include "kapi/system.hpp"
 
+#include "kernel/test_support/cio.hpp"
 #include "kernel/test_support/cpu.hpp"
-#include "kernel/test_support/log_buffer.hpp"
 
 #include <kstd/print>
 
@@ -13,7 +13,7 @@ SCENARIO("Kernel testing kapi::system shims", "[support]")
   {
     WHEN("a the system panics")
     {
-      kernel::tests::log_buffer::clear();
+      kernel::tests::cio::log_buffer().clear();
 
       THEN("the correct exception is thrown")
       {
@@ -23,7 +23,7 @@ SCENARIO("Kernel testing kapi::system shims", "[support]")
       THEN("the message is appended to the log buffer")
       {
         CHECK_THROWS(kapi::system::panic("[kernel:tests] Test Panic"));
-        REQUIRE(kernel::tests::log_buffer::flat_messages().contains("[kernel:tests] Test Panic"));
+        REQUIRE(kernel::tests::cio::log_buffer().flat_messages().contains("[kernel:tests] Test Panic"));
       }
     }
   }
diff --git a/kernel/kstd/print.tests.cpp b/kernel/kstd/print.tests.cpp
index f8e600f..8deeb17 100644
--- a/kernel/kstd/print.tests.cpp
+++ b/kernel/kstd/print.tests.cpp
@@ -1,6 +1,6 @@
 #include "kstd/print"
 
-#include "kernel/test_support/log_buffer.hpp"
+#include "kernel/test_support/cio.hpp"
 
 #include <catch2/catch_test_macros.hpp>
 
@@ -10,13 +10,13 @@ SCENARIO("Kernel testing kstd shims", "[support]")
   {
     WHEN("a regular print is issued")
     {
-      kernel::tests::log_buffer::clear();
+      kernel::tests::cio::log_buffer().clear();
 
       kstd::println("[kernel:tests] Test Print");
 
       THEN("the message is appended to the log buffer")
       {
-        REQUIRE(kernel::tests::log_buffer::flat_messages().contains("[kernel:tests] Test Print"));
+        REQUIRE(kernel::tests::cio::log_buffer().flat_messages().contains("[kernel:tests] Test Print"));
       }
     }
   }
diff --git a/kernel/src/memory/block_list_allocator.tests.cpp b/kernel/src/memory/block_list_allocator.tests.cpp
index 8ca426d..0571441 100644
--- a/kernel/src/memory/block_list_allocator.tests.cpp
+++ b/kernel/src/memory/block_list_allocator.tests.cpp
@@ -12,22 +12,14 @@
 
 using namespace kstd::units_literals;
 
-namespace kapi
-{
-  namespace memory
-  {
-    auto reset() -> void;
-  }
-}  // namespace kapi
-
 SCENARIO("Block List Allocator Operations", "[memory][allocator]")
 {
   GIVEN("A newly initialized block list allocator mapped via the test sandbox")
   {
-    kapi::memory::reset();
+    kernel::tests::memory::deinit();
     kapi::memory::init();
 
-    auto sandbox_base = kernel::tests::memory::heap_base();
+    auto sandbox_base = kernel::tests::memory::virtual_base();
     kernel::memory::block_list_allocator allocator{sandbox_base};
 
     WHEN("a basic allocation request is made")
diff --git a/kernel/src/test_support/kapi/cio.cpp b/kernel/src/test_support/kapi/cio.cpp
index 35452d4..4a1cd1f 100644
--- a/kernel/src/test_support/kapi/cio.cpp
+++ b/kernel/src/test_support/kapi/cio.cpp
@@ -1,43 +1,54 @@
+#include "kernel/test_support/cio.hpp"
+
 #include <kapi/cio.hpp>
 
 #include "kernel/test_support/log_buffer.hpp"
 
-#include <iostream>
-#include <string>
-#include <string_view>
+#include <atomic>
+#include <optional>
+#include <stdexcept>
+
+namespace
+{
+
+  auto constinit is_initialized = std::atomic_flag{};
+  auto constinit device = std::optional<kernel::tests::cio::output_device>{};
+
+}  // namespace
 
 namespace kapi::cio
 {
 
-  namespace
+  auto init() -> void
   {
-
-    class test_output_device : public output_device
+    if (is_initialized.test_and_set())
     {
-    public:
-      test_output_device() = default;
-
-      auto write(output_stream stream, std::string_view text) -> void override
-      {
-        auto & standard_stream = stream == output_stream::stdout ? std::cout : std::cerr;
-        standard_stream << text;
-        if (text != "\n")
-        {
-          kernel::tests::log_buffer::append(std::string{text});
-        }
-      }
-    } device{};
-
-  }  // namespace
+      throw std::logic_error("kapi::cio::init() called more than once");
+    }
 
-  auto init() -> void
+    device.emplace();
+    set_output_device(*device);
+  }
+
+}  // namespace kapi::cio
+
+namespace kernel::tests::cio
+{
+
+  auto deinit() -> void
   {
-    set_output_device(device);
+    if (!is_initialized.test())
+    {
+      throw std::logic_error("kapi::cio::deinit() called before kapi::cio::init()");
+    }
+
+    device.reset();
+    is_initialized.clear();
   }
 
-  auto reset() -> void
+  auto log_buffer() -> kernel::tests::log_buffer &
   {
-    kernel::tests::log_buffer::clear();
+    return device->log_buffer();
   }
 
-}  // namespace kapi::cio
\ No newline at end of file
+}  // namespace kernel::tests::cio
\ No newline at end of file
diff --git a/kernel/src/test_support/kapi/cpu.cpp b/kernel/src/test_support/kapi/cpu.cpp
index 6592d15..96dd10a 100644
--- a/kernel/src/test_support/kapi/cpu.cpp
+++ b/kernel/src/test_support/kapi/cpu.cpp
@@ -5,23 +5,13 @@
 #include <atomic>
 #include <stdexcept>
 
-namespace kapi::cpu
+namespace
 {
+  auto static initialized = std::atomic_flag{};
+}
 
-  namespace
-  {
-    auto static initialized = std::atomic_flag{};
-  }
-
-  auto reset() -> void
-  {
-    if (!initialized.test())
-    {
-      throw std::logic_error{"kapi::cpu::reset() called before kapi::cpu::init()"};
-    }
-
-    initialized.clear();
-  }
+namespace kapi::cpu
+{
 
   auto init() -> void
   {
@@ -38,4 +28,19 @@ namespace kapi::cpu
     throw kernel::tests::cpu::halt{};
   }
 
-}  // namespace kapi::cpu
\ No newline at end of file
+}  // namespace kapi::cpu
+
+namespace kernel::tests::cpu
+{
+
+  auto deinit() -> void
+  {
+    if (!initialized.test())
+    {
+      throw std::logic_error{"kapi::cpu::reset() called before kapi::cpu::init()"};
+    }
+
+    initialized.clear();
+  }
+
+}  // namespace kernel::tests::cpu
\ No newline at end of file
diff --git a/kernel/src/test_support/kapi/memory.cpp b/kernel/src/test_support/kapi/memory.cpp
index f244b7f..e926ba6 100644
--- a/kernel/src/test_support/kapi/memory.cpp
+++ b/kernel/src/test_support/kapi/memory.cpp
@@ -12,8 +12,10 @@
 namespace
 {
   //! The size of the simulated RAM.
-  constexpr auto memory_size = kstd::units::MiB(32);
-  constexpr auto number_of_frames = memory_size / kapi::memory::frame::size;
+  constexpr auto physical_size = kstd::units::MiB(32);
+  constexpr auto virtual_size = kstd::units::GiB(1);
+
+  constexpr auto number_of_frames = physical_size / kapi::memory::frame::size;
 
   auto constinit bump_allocator = std::optional<kernel::tests::bump_frame_allocator>{};
   auto constinit test_mapper = std::optional<kernel::tests::page_mapper>{};
@@ -36,15 +38,19 @@ namespace kapi::memory
   auto init() -> void
   {
     bump_allocator.emplace();
-    test_mapper.emplace(memory_size);
+    test_mapper.emplace(physical_size, virtual_size);
 
     old_allocator = set_frame_allocator(*bump_allocator);
     old_mapper = set_page_mapper(*test_mapper);
 
-    init_pmm(memory_size / frame::size, handoff_to_kernel_pmm);
+    init_pmm(physical_size / frame::size, handoff_to_kernel_pmm);
   }
+}  // namespace kapi::memory
+
+namespace kernel::tests::memory
+{
 
-  auto reset() -> void
+  auto deinit() -> void
   {
     if (old_allocator && *old_allocator)
     {
@@ -60,12 +66,9 @@ namespace kapi::memory
     test_mapper.reset();
   }
 
-}  // namespace kapi::memory
-
-namespace kernel::tests::memory
-{
-  auto heap_base() -> kapi::memory::linear_address
+  auto virtual_base() -> kapi::memory::linear_address
   {
-    return test_mapper->memory.heap_base();
+    return test_mapper->memory.virtual_base();
   }
+
 }  // namespace kernel::tests::memory
\ No newline at end of file
diff --git a/kernel/src/test_support/log_buffer.cpp b/kernel/src/test_support/log_buffer.cpp
index 36ed15e..9cff596 100644
--- a/kernel/src/test_support/log_buffer.cpp
+++ b/kernel/src/test_support/log_buffer.cpp
@@ -4,36 +4,30 @@
 #include <string>
 #include <vector>
 
-namespace kernel::tests::log_buffer
+namespace kernel::tests
 {
 
-  namespace
+  auto log_buffer::append(std::string const & message) -> void
   {
-    std::vector<std::string> recorded_messages{};
+    m_messages.push_back(message);
   }
 
-  auto append(std::string const & message) -> void
+  auto log_buffer::clear() -> void
   {
-    recorded_messages.push_back(message);
+    m_messages.clear();
   }
 
-  auto clear() -> void
+  auto log_buffer::flat_messages() -> std::string
   {
-    recorded_messages.clear();
+    return std::ranges::fold_left(m_messages, std::string{}, [](std::string accumulator, std::string const & message) {
+      accumulator += message;
+      return accumulator;
+    });
   }
 
-  auto flat_messages() -> std::string
+  auto log_buffer::messages() -> std::vector<std::string> const &
   {
-    return std::ranges::fold_left(recorded_messages, std::string{},
-                                  [](std::string accumulator, std::string const & message) {
-                                    accumulator += message;
-                                    return accumulator;
-                                  });
+    return m_messages;
   }
 
-  auto messages() -> std::vector<std::string> const &
-  {
-    return recorded_messages;
-  }
-
-}  // namespace kernel::tests::log_buffer
+}  // namespace kernel::tests
diff --git a/kernel/src/test_support/output_device.cpp b/kernel/src/test_support/output_device.cpp
new file mode 100644
index 0000000..83dcbcc
--- /dev/null
+++ b/kernel/src/test_support/output_device.cpp
@@ -0,0 +1,28 @@
+#include "kapi/cio.hpp"
+
+#include "kernel/test_support/cio.hpp"
+#include "kernel/test_support/log_buffer.hpp"
+
+#include <iostream>
+#include <string>
+#include <string_view>
+
+namespace kernel::tests::cio
+{
+
+  auto output_device::write(kapi::cio::output_stream stream, std::string_view text) -> void
+  {
+    auto & standard_stream = stream == kapi::cio::output_stream::stdout ? std::cout : std::cerr;
+    standard_stream << text;
+    if (text != "\n")
+    {
+      m_log_buffer.append(std::string{text});
+    }
+  }
+
+  auto output_device::log_buffer() noexcept -> kernel::tests::log_buffer &
+  {
+    return m_log_buffer;
+  }
+
+}  // namespace kernel::tests::cio
\ No newline at end of file
diff --git a/kernel/src/test_support/page_mapper.cpp b/kernel/src/test_support/page_mapper.cpp
index abdcae5..9236deb 100644
--- a/kernel/src/test_support/page_mapper.cpp
+++ b/kernel/src/test_support/page_mapper.cpp
@@ -7,13 +7,12 @@
 #include <cstddef>
 #include <format>
 #include <stdexcept>
-#include <sys/mman.h>
 
 namespace kernel::tests
 {
 
-  page_mapper::page_mapper(kstd::units::bytes memory_size)
-      : memory{memory_size}
+  page_mapper::page_mapper(kstd::units::bytes physical_size, kstd::units::bytes virtual_size)
+      : memory{physical_size, virtual_size}
   {}
 
   auto page_mapper::map(kapi::memory::page page, kapi::memory::frame frame, flags) -> std::byte *
@@ -26,21 +25,14 @@ namespace kernel::tests
     }
 
     auto page_address = page.start_address();
-    auto sandbox_start = memory.heap_base();
-    auto sandbox_end = sandbox_start + memory.heap_size();
+    auto virtual_base = memory.virtual_base();
+    auto virtual_end = virtual_base + memory.virtual_size();
 
-    if (page_address >= sandbox_start && page_address < sandbox_end)
+    if (page_address >= virtual_base && page_address < virtual_end)
     {
       auto virtual_target = static_cast<std::byte *>(page_address);
       auto physical_offset = frame.number() * kapi::memory::frame::size;
-      auto mapped_ptr = mmap(virtual_target, kapi::memory::page::size.value, PROT_READ | PROT_WRITE,
-                             MAP_SHARED | MAP_FIXED, memory.memory_descriptor(), physical_offset.value);
-      if (mapped_ptr == MAP_FAILED)
-      {
-        throw std::runtime_error("Failed to map page");
-      }
-
-      return static_cast<std::byte *>(mapped_ptr);
+      return memory.map(kapi::memory::page::size, virtual_target, physical_offset.value);
     }
     else if (page_address >= kapi::memory::mmio_base)
     {
@@ -49,7 +41,7 @@ namespace kernel::tests
     else if (page_address >= kapi::memory::higher_half_direct_map_base)
     {
       auto offset = frame.number() * kapi::memory::frame::size;
-      return memory.ram_base() + offset;
+      return memory.physical_base() + offset;
     }
 
     return nullptr;
diff --git a/kernel/src/test_support/simulated_memory.cpp b/kernel/src/test_support/simulated_memory.cpp
index fa3d36c..0648df2 100644
--- a/kernel/src/test_support/simulated_memory.cpp
+++ b/kernel/src/test_support/simulated_memory.cpp
@@ -4,50 +4,50 @@
 
 #include <kstd/units>
 
+#include <cerrno>
 #include <cstddef>
 #include <cstring>
+#include <format>
 #include <stdexcept>
 #include <sys/mman.h>
 #include <sys/types.h>
 #include <unistd.h>
 
-using namespace kstd::units_literals;
-
 namespace kernel::tests
 {
-  namespace
-  {
-    constexpr auto virtual_size = 1_GiB;
-  }
 
-  simulated_memory::simulated_memory(kstd::units::bytes size)
-      : m_memory_descriptor{memfd_create("teachos_simulated_memory", 0)}
-      , m_size{size}
+  simulated_memory::simulated_memory(kstd::units::bytes physical_size, kstd::units::bytes virtual_size)
+      : m_descriptor{memfd_create("teachos_simulated_memory", 0)}
+      , m_physical_size{physical_size}
+      , m_virtual_size{virtual_size}
   {
-    if (m_memory_descriptor < 0)
+    if (m_descriptor < 0)
     {
-      throw std::runtime_error("Failed to create simulated memory");
+      auto error = std::format("Failed to allocate backing memory: {}", strerror(errno));
+      throw std::runtime_error(error);
     }
 
-    if (ftruncate(m_memory_descriptor, static_cast<off_t>(m_size.value)) < 0)
+    if (ftruncate(m_descriptor, static_cast<off_t>(m_physical_size.value)) < 0)
     {
-      throw std::runtime_error("Failed to resize simulated memory");
+      auto error = std::format("Failed to reserve backing memory: {}", strerror(errno));
+      throw std::runtime_error(error);
     }
 
-    auto mapped_pointer = mmap(nullptr, m_size.value, PROT_READ | PROT_WRITE, MAP_SHARED, m_memory_descriptor, 0);
-    if (mapped_pointer == MAP_FAILED)
+    auto physical_storage = mmap(nullptr, m_physical_size.value, PROT_READ | PROT_WRITE, MAP_SHARED, m_descriptor, 0);
+    if (physical_storage == MAP_FAILED)
     {
-      throw std::runtime_error("Failed to map simulated memory");
+      auto error = std::format("Failed to map backing memory: {}", strerror(errno));
+      throw std::runtime_error(error);
     }
 
-    m_physical_base = static_cast<std::byte *>(mapped_pointer);
-
     auto virtual_pointer = mmap(nullptr, virtual_size.value, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
     if (virtual_pointer == MAP_FAILED)
     {
-      throw std::runtime_error("Failed to map simulated memory");
+      auto error = std::format("Failed to reserve virtual memory: {}", strerror(errno));
+      throw std::runtime_error(error);
     }
 
+    m_physical_base = static_cast<std::byte *>(physical_storage);
     m_virtual_base = static_cast<std::byte *>(virtual_pointer);
 
     clear();
@@ -55,39 +55,56 @@ namespace kernel::tests
 
   simulated_memory::~simulated_memory()
   {
-    munmap(m_physical_base, m_size.value);
-    munmap(m_virtual_base, virtual_size.value);
-    close(m_memory_descriptor);
+    munmap(m_virtual_base, m_virtual_size.value);
+    munmap(m_physical_base, m_physical_size.value);
+    close(m_descriptor);
   }
 
   auto simulated_memory::clear() -> void
   {
-    std::memset(m_physical_base, 0, m_size.value);
+    std::memset(m_physical_base, 0, m_physical_size.value);
   }
 
-  auto simulated_memory::ram_base() noexcept -> std::byte *
+  auto simulated_memory::physical_base() noexcept -> std::byte *
   {
     return m_physical_base;
   }
 
-  auto simulated_memory::ram_base() const noexcept -> std::byte const *
+  auto simulated_memory::physical_base() const noexcept -> std::byte const *
   {
     return m_physical_base;
   }
 
-  auto simulated_memory::heap_base() const noexcept -> kapi::memory::linear_address
+  auto simulated_memory::physical_size() const noexcept -> kstd::units::bytes
+  {
+    return m_physical_size;
+  }
+
+  auto simulated_memory::virtual_base() const noexcept -> kapi::memory::linear_address
   {
     return kapi::memory::linear_address{m_virtual_base};
   }
 
-  auto simulated_memory::heap_size() const noexcept -> kstd::units::bytes
+  auto simulated_memory::virtual_size() const noexcept -> kstd::units::bytes
   {
-    return virtual_size;
+    return m_virtual_size;
   }
 
-  auto simulated_memory::memory_descriptor() const noexcept -> int
+  auto simulated_memory::descriptor() const noexcept -> int
   {
-    return m_memory_descriptor;
+    return m_descriptor;
+  }
+
+  auto simulated_memory::map(kstd::units::bytes size, std::byte * to, off_t offset) -> std::byte *
+  {
+    auto mapped_ptr = mmap(to, size.value, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, m_descriptor, offset);
+    if (mapped_ptr == MAP_FAILED)
+    {
+      auto error = std::format("Failed to map page: {}", strerror(errno));
+      throw std::runtime_error(error);
+    }
+
+    return static_cast<std::byte *>(mapped_ptr);
   }
 
 }  // namespace kernel::tests
\ No newline at end of file
diff --git a/kernel/src/test_support/state_reset_listener.cpp b/kernel/src/test_support/state_reset_listener.cpp
index e201a10..8c95cc8 100644
--- a/kernel/src/test_support/state_reset_listener.cpp
+++ b/kernel/src/test_support/state_reset_listener.cpp
@@ -2,29 +2,15 @@
 #include "kapi/cpu.hpp"
 #include "kapi/memory.hpp"
 
+#include "kernel/test_support/cio.hpp"
+#include "kernel/test_support/cpu.hpp"
+#include "kernel/test_support/memory.hpp"
+
 #include <catch2/catch_test_case_info.hpp>
 #include <catch2/interfaces/catch_interfaces_reporter.hpp>
 #include <catch2/reporters/catch_reporter_event_listener.hpp>
 #include <catch2/reporters/catch_reporter_registrars.hpp>
 
-namespace kapi
-{
-  namespace cio
-  {
-    auto reset() -> void;
-  }
-
-  namespace cpu
-  {
-    auto reset() -> void;
-  }
-
-  namespace memory
-  {
-    auto reset() -> void;
-  }
-}  // namespace kapi
-
 struct state_reset_listener : Catch::EventListenerBase
 {
   using EventListenerBase::EventListenerBase;
@@ -38,9 +24,9 @@ struct state_reset_listener : Catch::EventListenerBase
 
   void testCaseEnded(Catch::TestCaseStats const &) override
   {
-    kapi::memory::reset();
-    kapi::cpu::reset();
-    kapi::cio::reset();
+    kernel::tests::memory::deinit();
+    kernel::tests::cpu::deinit();
+    kernel::tests::cio::deinit();
   }
 };