1 files changed, 20 insertions, 72 deletions

diff --git a/kernel/src/test_support/kapi/memory.cpp b/kernel/src/test_support/kapi/memory.cpp
index 652a3d3..7b7a81e 100644
--- a/kernel/src/test_support/kapi/memory.cpp
+++ b/kernel/src/test_support/kapi/memory.cpp
@@ -2,15 +2,12 @@
 
 #include <kapi/memory.hpp>
 
-#include "kernel/tests/simulated_memory.hpp"
+#include "kernel/tests/bump_frame_allocator.hpp"
+#include "kernel/tests/page_mapper.hpp"
 
-#include <kstd/print>
 #include <kstd/units>
 
-#include <cstddef>
-#include <cstdint>
 #include <optional>
-#include <utility>
 
 namespace kapi::memory
 {
@@ -18,97 +15,48 @@ namespace kapi::memory
   namespace
   {
     //! The size of the simulated RAM.
-    constexpr auto simulate_memory_size = kstd::units::MiB(32);
-    constexpr auto number_of_simulated_frames = simulate_memory_size / frame::size;
+    constexpr auto memory_size = kstd::units::MiB(32);
+    constexpr auto number_of_frames = memory_size / frame::size;
 
-    struct test_bootstrap_frame_allocator : frame_allocator
-    {
-      auto mark_used(frame) -> void override {}
-
-      auto allocate_many(std::size_t count) noexcept -> std::optional<std::pair<frame, std::size_t>> override
-      {
-        auto start = next_free_frame;
-        next_free_frame += count;
-        return std::pair{frame{start}, count};
-      }
-
-      auto release_many(std::pair<frame, std::size_t>) -> void override {}
+    auto constinit bump_allocator = std::optional<kernel::tests::bump_frame_allocator>{};
+    auto constinit test_mapper = std::optional<kernel::tests::page_mapper>{};
 
-      std::size_t next_free_frame{};
-    };
-
-    auto constinit bootstrap_allocator = std::optional<test_bootstrap_frame_allocator>{};
-
-    struct test_page_mapper : page_mapper
-    {
-      auto map(page page, frame frame, flags flags) -> std::byte * override
-      {
-        kstd::println("mapping page {} onto frame {} with flags {}", page.number(), frame.number(),
-                      static_cast<std::uint64_t>(flags));
-
-        if ((page.start_address() & pmm_metadata_base.raw()) == pmm_metadata_base.raw())
-        {
-          auto offset = page.start_address() & ~pmm_metadata_base.raw();
-          return kernel::tests::simulated_memory::pmm_metadata_base() + offset;
-        }
-
-        return nullptr;
-      }
-
-      auto unmap(page page) -> void override
-      {
-        kstd::println("unmapping page {}", page.number());
-      }
-
-      auto try_unmap(page page) noexcept -> bool override
-      {
-        kstd::println("trying to unmap page {}", page.number());
-        return false;
-      }
-    };
-
-    auto constinit test_mapper = std::optional<test_page_mapper>{};
+    auto constinit old_allocator = std::optional<frame_allocator *>{};
+    auto constinit old_mapper = std::optional<page_mapper *>{};
 
     auto handoff_to_kernel_pmm(frame_allocator & new_allocator) -> void
     {
-      auto first_free_frame = bootstrap_allocator->next_free_frame;
-      auto number_of_free_frames = number_of_simulated_frames - first_free_frame;
+      auto first_free_frame = bump_allocator->next_free_frame;
+      auto number_of_free_frames = number_of_frames - first_free_frame;
       new_allocator.release_many({frame{first_free_frame}, number_of_free_frames});
     }
 
-    auto constinit previous_frame_allocator = std::optional<frame_allocator *>{};
-    auto constinit previous_page_mapper = std::optional<page_mapper *>{};
-
   }  // namespace
 
   auto init() -> void
   {
-    kernel::tests::simulated_memory::init(simulate_memory_size);
+    bump_allocator.emplace();
+    test_mapper.emplace(memory_size);
 
-    bootstrap_allocator.emplace();
-    test_mapper.emplace();
+    old_allocator = set_frame_allocator(*bump_allocator);
+    old_mapper = set_page_mapper(*test_mapper);
 
-    previous_frame_allocator = set_frame_allocator(*bootstrap_allocator);
-    previous_page_mapper = set_page_mapper(*test_mapper);
-
-    init_pmm(simulate_memory_size / frame::size, handoff_to_kernel_pmm);
+    init_pmm(memory_size / frame::size, handoff_to_kernel_pmm);
   }
 
   auto reset() -> void
   {
-    kernel::tests::simulated_memory::reset();
-
-    if (previous_frame_allocator && *previous_frame_allocator)
+    if (old_allocator && *old_allocator)
     {
-      set_frame_allocator(**previous_frame_allocator);
+      set_frame_allocator(**old_allocator);
     }
 
-    if (previous_page_mapper && *previous_page_mapper)
+    if (old_mapper && *old_mapper)
     {
-      set_page_mapper(**previous_page_mapper);
+      set_page_mapper(**old_mapper);
     }
 
-    bootstrap_allocator.reset();
+    bump_allocator.reset();
     test_mapper.reset();
   }