7 files changed, 274 insertions, 0 deletions
diff --git a/kernel/src/main.tests.cpp b/kernel/src/main.tests.cpp
new file mode 100644
index 0000000..b3ae142
--- /dev/null
+++ b/kernel/src/main.tests.cpp
@@ -0,0 +1,38 @@
+#include "kapi/interrupts.hpp"
+#include "kapi/memory.hpp"
+#include <kapi/cio.hpp>
+#include <kapi/cpu.hpp>
+
+#include <catch2/catch_session.hpp>
+
+auto main(int argc, char ** argv) -> int
+{
+  auto session = Catch::Session{};
+
+  if (auto result = session.applyCommandLine(argc, argv); result != 0)
+  {
+    return result;
+  }
+
+  auto const & config = session.configData();
+  auto skip_init = config.listTests ||      //
+                   config.listTags ||       //
+                   config.listReporters ||  //
+                   config.listListeners ||  //
+                   config.showHelp;
+
+  if (!skip_init)
+  {
+    kapi::cio::init();
+    kapi::cpu::init();
+    kapi::interrupts::enable();
+
+    kapi::memory::init();
+    // note: no kernel heap is created, since we are in the test environment. Nonetheless, we still initialize the
+    // memory subsystem, so that components that rely on it can be tested. No component must ever rely on the heap
+    // allocator directly, rather they have to go through the new and delete. However, some components may use the frame
+    // allocator and page mapper in order to perform their tasks.
+  }
+
+  return session.run();
+}
diff --git a/kernel/src/test_support/kapi/cio.cpp b/kernel/src/test_support/kapi/cio.cpp
new file mode 100644
index 0000000..6359fa8
--- /dev/null
+++ b/kernel/src/test_support/kapi/cio.cpp
@@ -0,0 +1,38 @@
+#include <kapi/cio.hpp>
+
+#include "kernel/tests/log_buffer.hpp"
+
+#include <iostream>
+#include <string>
+#include <string_view>
+
+namespace kapi::cio
+{
+
+  namespace
+  {
+
+    class test_output_device : public output_device
+    {
+    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
+
+  auto init() -> void
+  {
+    set_output_device(device);
+  }
+
+}  // namespace kapi::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
new file mode 100644
index 0000000..3ecaadc
--- /dev/null
+++ b/kernel/src/test_support/kapi/cpu.cpp
@@ -0,0 +1,29 @@
+#include "kernel/tests/cpu.hpp"
+
+#include <kapi/cpu.hpp>
+
+#include <atomic>
+#include <stdexcept>
+
+namespace kapi::cpu
+{
+
+  auto init() -> void
+  {
+    auto static initialized = std::atomic_flag{};
+    if (initialized.test_and_set())
+    {
+      throw std::logic_error("kapi::cpu::init() called more than once");
+    }
+
+    // TODO: make sure that simulated interrupt can run.
+
+    return;
+  }
+
+  auto halt() -> void
+  {
+    throw kernel::tests::cpu::halt{};
+  }
+
+}  // namespace kapi::cpu
+\ No newline at end of file
diff --git a/kernel/src/test_support/kapi/interrupts.cpp b/kernel/src/test_support/kapi/interrupts.cpp
new file mode 100644
index 0000000..0077266
--- /dev/null
+++ b/kernel/src/test_support/kapi/interrupts.cpp
@@ -0,0 +1,11 @@
+#include <kapi/interrupts.hpp>
+
+namespace kapi::interrupts
+{
+
+  auto enable() -> void
+  {
+    // TODO: enable simulated interrupts.
+  }
+
+}  // namespace kapi::interrupts
+\ No newline at end of file
diff --git a/kernel/src/test_support/kapi/memory.cpp b/kernel/src/test_support/kapi/memory.cpp
new file mode 100644
index 0000000..6de2f60
--- /dev/null
+++ b/kernel/src/test_support/kapi/memory.cpp
@@ -0,0 +1,86 @@
+#include "kapi/memory.hpp"
+
+#include <kapi/memory.hpp>
+
+#include "kernel/tests/simulated_memory.hpp"
+
+#include <kstd/print>
+#include <kstd/units>
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <utility>
+
+namespace kapi::memory
+{
+
+  namespace
+  {
+    //! The size of the simulated RAM.
+    constexpr auto simulate_memory_size = kstd::units::MiB(32);
+
+    struct test_boostrap_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 {}
+
+      std::size_t next_free_frame{};
+    } boostrap_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;
+      }
+    } test_mapper;
+
+    auto handoff_to_kernel_pmm(frame_allocator & new_allocator) -> void
+    {
+      for (auto i = 0uz; i < boostrap_allocator.next_free_frame; ++i)
+      {
+        new_allocator.mark_used(frame{i});
+      }
+    }
+
+  }  // namespace
+
+  auto init() -> void
+  {
+    kernel::tests::simulated_memory::init(simulate_memory_size);
+    set_frame_allocator(boostrap_allocator);
+    set_page_mapper(test_mapper);
+
+    init_pmm(simulate_memory_size / frame::size, handoff_to_kernel_pmm);
+  }
+
+}  // namespace kapi::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
new file mode 100644
index 0000000..9e30afb
--- /dev/null
+++ b/kernel/src/test_support/log_buffer.cpp
@@ -0,0 +1,39 @@
+#include "kernel/tests/log_buffer.hpp"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+namespace kernel::tests::log_buffer
+{
+
+  namespace
+  {
+    std::vector<std::string> recorded_messages{};
+  }
+
+  auto append(std::string const & message) -> void
+  {
+    recorded_messages.push_back(message);
+  }
+
+  auto clear() -> void
+  {
+    recorded_messages.clear();
+  }
+
+  auto flat_messages() -> std::string
+  {
+    return std::ranges::fold_left(recorded_messages, std::string{},
+                                  [](std::string accumulator, std::string const & message) {
+                                    accumulator += message;
+                                    return accumulator;
+                                  });
+  }
+
+  auto messages() -> std::vector<std::string> const &
+  {
+    return recorded_messages;
+  }
+
+}  // namespace kernel::tests::log_buffer
diff --git a/kernel/src/test_support/simulated_memory.cpp b/kernel/src/test_support/simulated_memory.cpp
new file mode 100644
index 0000000..9a9b354
--- /dev/null
+++ b/kernel/src/test_support/simulated_memory.cpp
@@ -0,0 +1,33 @@
+#include "kernel/tests/simulated_memory.hpp"
+
+#include <kstd/units>
+
+#include <cstddef>
+#include <vector>
+
+namespace kernel::tests::simulated_memory
+{
+
+  namespace
+  {
+    auto constinit ram_storage = std::vector<std::byte>{};
+    auto constinit pmm_storage = std::vector<std::byte>{};
+  }  // namespace
+
+  auto init(kstd::units::bytes size) -> void
+  {
+    ram_storage.resize(size / kstd::units::bytes{1});
+    pmm_storage.resize(size / kstd::units::bytes{1});
+  }
+
+  auto pmm_metadata_base() -> std::byte *
+  {
+    return pmm_storage.data();
+  }
+
+  auto ram_base() -> std::byte *
+  {
+    return ram_storage.data();
+  }
+
+}  // namespace kernel::tests::simulated_memory
+\ No newline at end of file