system_test.h File Reference

#include <etl/vector.h>
#include <cstdint>
#include <type_traits>
#include "kernel_log.hpp"

Include dependency graph for system_test.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	TestResult
	单个测试线程的结果记录 More...

Macros
#define	EXPECT_EQ(val1, val2, msg)
#define	EXPECT_NE(val1, val2, msg)
#define	EXPECT_GT(val1, val2, msg)
#define	EXPECT_LT(val1, val2, msg)
#define	EXPECT_GE(val1, val2, msg)
#define	EXPECT_LE(val1, val2, msg)
#define	EXPECT_TRUE(cond, msg)
#define	EXPECT_FALSE(cond, msg)

Enumerations
enum class	TestThreadStatus : uint8_t {   kPending , kRunning , kPassed , kFailed ,   kTimeout }
	测试线程运行状态 More...

Functions
template<typename T1 , typename T2 >
bool	expect_eq_helper (const T1 &val1, const T2 &val2, const char *msg)
template<typename T1 , typename T2 >
bool	expect_ne_helper (const T1 &val1, const T2 &val2, const char *msg)
template<typename T1 , typename T2 >
bool	expect_gt_helper (const T1 &val1, const T2 &val2, const char *msg)
template<typename T1 , typename T2 >
bool	expect_lt_helper (const T1 &val1, const T2 &val2, const char *msg)
template<typename T1 , typename T2 >
bool	expect_ge_helper (const T1 &val1, const T2 &val2, const char *msg)
template<typename T1 , typename T2 >
bool	expect_le_helper (const T1 &val1, const T2 &val2, const char *msg)
auto	ctor_dtor_test () -> bool
auto	spinlock_test () -> bool
auto	virtual_memory_test () -> bool
auto	interrupt_test () -> bool
auto	fifo_scheduler_test () -> bool
auto	rr_scheduler_test () -> bool
auto	cfs_scheduler_test () -> bool
auto	idle_scheduler_test () -> bool
auto	thread_group_system_test () -> bool
	线程组系统测试入口
auto	wait_system_test () -> bool
	Wait 系统测试入口
auto	clone_system_test () -> bool
auto	exit_system_test () -> bool
	Exit 系统测试入口
auto	ramfs_system_test () -> bool
auto	fatfs_system_test () -> bool
auto	memory_test () -> bool
auto	kernel_task_test () -> bool
auto	user_task_test () -> bool
auto	mutex_test () -> bool
void	QemuExit (bool success)
	测试结束后退出 QEMU，success=true 表示全部通过

Macro Definition Documentation

EXPECT_EQ

#define EXPECT_EQ	(		val1,
			val2,
			msg
	)

Value:

  if (!expect_eq_helper(val1, val2, msg)) { \
    return false;                           \
  }

Definition at line 126 of file system_test.h.

                                          { \
    return false;                           \
  }

EXPECT_FALSE

#define EXPECT_FALSE	(		cond,
			msg
	)

Value:

  if (cond) {                   \
    klog::Err("FAIL: {}", msg); \
    return false;               \
  }

Definition at line 162 of file system_test.h.

            {                   \
    klog::Err("FAIL: {}", msg); \
    return false;               \
  }

EXPECT_GE

#define EXPECT_GE	(		val1,
			val2,
			msg
	)

Value:

  if (!expect_ge_helper(val1, val2, msg)) { \
    return false;                           \
  }

Definition at line 146 of file system_test.h.

                                          { \
    return false;                           \
  }

EXPECT_GT

#define EXPECT_GT	(		val1,
			val2,
			msg
	)

Value:

  if (!expect_gt_helper(val1, val2, msg)) { \
    return false;                           \
  }

Definition at line 136 of file system_test.h.

                                          { \
    return false;                           \
  }

EXPECT_LE

#define EXPECT_LE	(		val1,
			val2,
			msg
	)

Value:

  if (!expect_le_helper(val1, val2, msg)) { \
    return false;                           \
  }

Definition at line 151 of file system_test.h.

                                          { \
    return false;                           \
  }

EXPECT_LT

#define EXPECT_LT	(		val1,
			val2,
			msg
	)

Value:

  if (!expect_lt_helper(val1, val2, msg)) { \
    return false;                           \
  }

Definition at line 141 of file system_test.h.

                                          { \
    return false;                           \
  }

EXPECT_NE

#define EXPECT_NE	(		val1,
			val2,
			msg
	)

Value:

  if (!expect_ne_helper(val1, val2, msg)) { \
    return false;                           \
  }

Definition at line 131 of file system_test.h.

                                          { \
    return false;                           \
  }

EXPECT_TRUE

#define EXPECT_TRUE	(		cond,
			msg
	)

Value:

  if (!(cond)) {                \
    klog::Err("FAIL: {}", msg); \
    return false;               \
  }

Definition at line 156 of file system_test.h.

               {                \
    klog::Err("FAIL: {}", msg); \
    return false;               \
  }

Enumeration Type Documentation

TestThreadStatus

enum class TestThreadStatus : uint8_t

strong

测试线程运行状态

Enumerator
kPending	等待启动
kRunning	运行中
kPassed	测试通过
kFailed	测试失败
kTimeout	超时未完成

Definition at line 222 of file system_test.h.

                            : uint8_t {
  kPending,  
  kRunning,  
  kPassed,   
  kFailed,   
  kTimeout,  
};

Function Documentation

cfs_scheduler_test()

auto cfs_scheduler_test

(

)

-> bool

Definition at line 554 of file cfs_scheduler_test.cpp.

                                  {
  klog::Info("\n=== CFS Scheduler System Tests ===\n");
 
  if (!test_cfs_basic_functionality()) {
    return false;
  }
 
  if (!test_cfs_vruntime_ordering()) {
    return false;
  }
 
  if (!test_cfs_new_task_vruntime()) {
    return false;
  }
 
  if (!test_cfs_weight_impact()) {
    return false;
  }
 
  if (!test_cfs_preemption()) {
    return false;
  }
 
  if (!test_cfs_no_preemption()) {
    return false;
  }
 
  if (!test_cfs_dequeue()) {
    return false;
  }
 
  if (!test_cfs_statistics()) {
    return false;
  }
 
  if (!test_cfs_min_vruntime_update()) {
    return false;
  }
 
  if (!test_cfs_multiple_ticks()) {
    return false;
  }
 
  if (!test_cfs_fairness()) {
    return false;
  }
 
  if (!test_cfs_mixed_operations()) {
    return false;
  }
 
  if (!test_cfs_robustness()) {
    return false;
  }
 
  klog::Info("=== All CFS Scheduler Tests Passed ===\n");
  return true;
}

Here is the call graph for this function:

clone_system_test()

auto clone_system_test

(

)

-> bool

Definition at line 425 of file clone_system_test.cpp.

                                 {
  klog::Info("===== Clone System Test Start =====");
 
  g_tests_completed = 0;
  g_tests_failed = 0;
 
  auto& task_mgr = TaskManagerSingleton::instance();
 
  auto test1 = kstd::make_unique<TaskControlBlock>("TestCloneProcess", 10,
                                                   test_clone_process, nullptr);
  task_mgr.AddTask(std::move(test1));
 
  auto test2 = kstd::make_unique<TaskControlBlock>("TestCloneThread", 10,
                                                   test_clone_thread, nullptr);
  task_mgr.AddTask(std::move(test2));
 
  auto test3 = kstd::make_unique<TaskControlBlock>(
      "TestCloneParentFlag", 10, test_clone_parent_flag, nullptr);
  task_mgr.AddTask(std::move(test3));
 
  auto test4 = kstd::make_unique<TaskControlBlock>(
      "TestCloneFlagsAutoCompletion", 10, test_clone_flags_auto_completion,
      nullptr);
  task_mgr.AddTask(std::move(test4));
 
  int timeout = 200;
  while (timeout > 0) {
    (void)sys_sleep(50);
    if (g_tests_completed >= 4) {
      break;
    }
    timeout--;
  }
 
  EXPECT_EQ(g_tests_completed, 4, "tests completed");
  EXPECT_EQ(g_tests_failed, 0, "tests failed");
 
  klog::Info("Clone System Test Suite: COMPLETED");
  return true;
}

Here is the call graph for this function:

ctor_dtor_test()

auto ctor_dtor_test

(

)

-> bool

Definition at line 63 of file ctor_dtor_test.cpp.

                              {
#ifdef __aarch64__
  cpu_io::SetupFpu();
#endif
 
  klog::Info("Running C++ Runtime Tests...");
 
  // 1. Verify Global Initialization
  EXPECT_EQ(global_value_with_init, 42, "Global int init");
  EXPECT_EQ(global_u32_value_with_init, 0xa1a2a3a4UL, "Global uint32 init");
  EXPECT_EQ(global_u64_value_with_init, 0xb1b2b3b4b5b6b7b8ULL,
            "Global uint64 init");
  EXPECT_EQ(global_u16_value_with_init, 0x1234, "Global uint16 init");
  EXPECT_EQ(global_u8a_value_with_init, 0x42, "Global uint8 a init");
  EXPECT_EQ(global_u8b_value_with_init, 0x43, "Global uint8 b init");
  EXPECT_EQ(global_u8c_value_with_init, 0x44, "Global uint8 c init");
  EXPECT_EQ(global_u8d_value_with_init, 0x45, "Global uint8 d init");
 
  // 2. Verify Global Constructors
  // global_value1_with_constructor was initialized to 1
  // constructor_destructor_1 adds 0x200
  // constructor_destructor_4 adds 0x100000
  // Expected: 1 | 0x200 | 0x100000 = 0x100201 (1049089)
  unsigned int expected_v1 = 1 | 0x200 | 0x100000;
  EXPECT_EQ(global_value1_with_constructor, expected_v1,
            "Global constructor execution 1");
 
  unsigned int expected_v2 = 2 | 0x200 | 0x100000;
  EXPECT_EQ(global_value2_with_constructor, expected_v2,
            "Global constructor execution 2");
 
  // 3. Verify Class Member, Virtual Function, and Stack Object Destructor
  int start_dtor = g_dtor_count;
  {
    auto inst_class = InsClass();
    EXPECT_EQ(inst_class.val, 'B', "Class constructor body");
    inst_class.Func();
    EXPECT_EQ(inst_class.val, 'C', "Virtual function dispatch");
  }
  EXPECT_EQ(g_dtor_count, start_dtor + 1,
            "Stack object destructor verification");
 
  // 4. Verify Static Local Variable
  static InsClass inst_class_static;
  EXPECT_TRUE(inst_class_static.val == 'B' || inst_class_static.val == 'C',
              "Static local object constructor/persistence");
  inst_class_static.Func();
  EXPECT_EQ(inst_class_static.val, 'C', "Static local object virtual func");
 
  klog::Info("PASS: All C++ Runtime Tests passed.");
 
  return true;
}

Here is the call graph for this function:

exit_system_test()

auto exit_system_test

(

)

-> bool

Exit 系统测试入口

Definition at line 452 of file exit_system_test.cpp.

                                {
  klog::Info("===== Exit System Test Start =====");
 
  // 重置全局计数器
  g_tests_completed = 0;
  g_tests_failed = 0;
  g_exit_test_counter = 0;
 
  auto& task_mgr = TaskManagerSingleton::instance();
 
  // 测试 1: Normal exit
  auto test1 = kstd::make_unique<TaskControlBlock>("TestExitNormal", 10,
                                                   test_exit_normal, nullptr);
  task_mgr.AddTask(std::move(test1));
 
  // 测试 2: Exit with error
  auto test2 = kstd::make_unique<TaskControlBlock>(
      "TestExitWithError", 10, test_exit_with_error, nullptr);
  task_mgr.AddTask(std::move(test2));
 
  // 测试 3: Thread exit
  auto test3 = kstd::make_unique<TaskControlBlock>("TestThreadExit", 10,
                                                   test_thread_exit, nullptr);
  task_mgr.AddTask(std::move(test3));
 
  // 测试 4: Orphan exit
  auto test4 = kstd::make_unique<TaskControlBlock>("TestOrphanExit", 10,
                                                   test_orphan_exit, nullptr);
  task_mgr.AddTask(std::move(test4));
 
  // 测试 5: Zombie process
  auto test5 = kstd::make_unique<TaskControlBlock>(
      "TestZombieProcess", 10, test_zombie_process, nullptr);
  task_mgr.AddTask(std::move(test5));
 
  klog::Info("Waiting for all 5 sub-tests to complete...");
 
  // 等待所有子测试完成（每个子测试在退出前会增加 g_tests_completed）
  // 超时: 200 * 50ms = 10s
  int timeout = 200;
  while (timeout > 0) {
    (void)sys_sleep(50);
    if (g_tests_completed.load() >= 5) {
      break;
    }
    timeout--;
  }
 
  klog::Info("Exit System Test: completed={}, failed={}",
             g_tests_completed.load(), g_tests_failed.load());
 
  EXPECT_EQ(g_tests_completed, 5, "All 5 sub-tests completed");
  EXPECT_EQ(g_tests_failed, 0, "No sub-tests failed");
 
  klog::Info("===== Exit System Test End =====");
  return true;
}

Here is the call graph for this function:

expect_eq_helper()

template<typename T1 , typename T2 >

bool expect_eq_helper	(	const T1 &	val1,
		const T2 &	val2,
		const char *	msg
	)

Copyright

Copyright The SimpleKernel Contributors

Definition at line 19 of file system_test.h.

                                                                       {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-compare"
  if (val1 != val2) {
#pragma GCC diagnostic pop
    if constexpr (std::is_convertible_v<T1, uint64_t> &&
                  std::is_convertible_v<T2, uint64_t>) {
      klog::Err("FAIL: {}. Expected {}, got {}", msg,
                static_cast<uint64_t>(val2), static_cast<uint64_t>(val1));
    } else {
      klog::Err("FAIL: {}", msg);
    }
    return false;
  }
  return true;
}

Here is the call graph for this function:

expect_ge_helper()

template<typename T1 , typename T2 >

bool expect_ge_helper	(	const T1 &	val1,
		const T2 &	val2,
		const char *	msg
	)

Definition at line 91 of file system_test.h.

                                                                       {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-compare"
  if (!(val1 >= val2)) {
#pragma GCC diagnostic pop
    if constexpr (std::is_convertible_v<T1, uint64_t> &&
                  std::is_convertible_v<T2, uint64_t>) {
      klog::Err("FAIL: {}. Expected {} >= {}", msg, static_cast<uint64_t>(val1),
                static_cast<uint64_t>(val2));
    } else {
      klog::Err("FAIL: {}", msg);
    }
    return false;
  }
  return true;
}

Here is the call graph for this function:

expect_gt_helper()

template<typename T1 , typename T2 >

bool expect_gt_helper	(	const T1 &	val1,
		const T2 &	val2,
		const char *	msg
	)

Definition at line 55 of file system_test.h.

                                                                       {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-compare"
  if (!(val1 > val2)) {
#pragma GCC diagnostic pop
    if constexpr (std::is_convertible_v<T1, uint64_t> &&
                  std::is_convertible_v<T2, uint64_t>) {
      klog::Err("FAIL: {}. Expected {} > {}", msg, static_cast<uint64_t>(val1),
                static_cast<uint64_t>(val2));
    } else {
      klog::Err("FAIL: {}", msg);
    }
    return false;
  }
  return true;
}

Here is the call graph for this function:

expect_le_helper()

template<typename T1 , typename T2 >

bool expect_le_helper	(	const T1 &	val1,
		const T2 &	val2,
		const char *	msg
	)

Definition at line 109 of file system_test.h.

                                                                       {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-compare"
  if (!(val1 <= val2)) {
#pragma GCC diagnostic pop
    if constexpr (std::is_convertible_v<T1, uint64_t> &&
                  std::is_convertible_v<T2, uint64_t>) {
      klog::Err("FAIL: {}. Expected {} <= {}", msg, static_cast<uint64_t>(val1),
                static_cast<uint64_t>(val2));
    } else {
      klog::Err("FAIL: {}", msg);
    }
    return false;
  }
  return true;
}

Here is the call graph for this function:

expect_lt_helper()

template<typename T1 , typename T2 >

bool expect_lt_helper	(	const T1 &	val1,
		const T2 &	val2,
		const char *	msg
	)

Definition at line 73 of file system_test.h.

                                                                       {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-compare"
  if (!(val1 < val2)) {
#pragma GCC diagnostic pop
    if constexpr (std::is_convertible_v<T1, uint64_t> &&
                  std::is_convertible_v<T2, uint64_t>) {
      klog::Err("FAIL: {}. Expected {} < {}", msg, static_cast<uint64_t>(val1),
                static_cast<uint64_t>(val2));
    } else {
      klog::Err("FAIL: {}", msg);
    }
    return false;
  }
  return true;
}

Here is the call graph for this function:

expect_ne_helper()

template<typename T1 , typename T2 >

bool expect_ne_helper	(	const T1 &	val1,
		const T2 &	val2,
		const char *	msg
	)

Definition at line 37 of file system_test.h.

                                                                       {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-compare"
  if (val1 == val2) {
#pragma GCC diagnostic pop
    if constexpr (std::is_convertible_v<T1, uint64_t> &&
                  std::is_convertible_v<T2, uint64_t>) {
      klog::Err("FAIL: {}. Expected not {}, got {}", msg,
                static_cast<uint64_t>(val2), static_cast<uint64_t>(val1));
    } else {
      klog::Err("FAIL: {}", msg);
    }
    return false;
  }
  return true;
}

Here is the call graph for this function:

fatfs_system_test()

auto fatfs_system_test

(

)

-> bool

Copyright

Copyright The SimpleKernel Contributors

Definition at line 16 of file fatfs_system_test.cpp.

                                 {
  klog::Info("fatfs_system_test: start");
 
  // T1: Get virtio-blk device via DeviceManager
  DeviceNode* blk_nodes[4]{};
  const size_t blk_count = DeviceManagerSingleton::instance().FindDevicesByType(
      DeviceType::kBlock, blk_nodes, 4);
  if (blk_count == 0 || blk_nodes[0]->block_device == nullptr) {
    klog::Info(
        "fatfs_system_test: SKIP — no virtio-blk device "
        "available");
    return true;  // Graceful skip, not a failure
  }
  vfs::BlockDevice* blk = blk_nodes[0]->block_device;
  klog::Info("fatfs_system_test: virtio-blk device: {}", blk->GetName());
  EXPECT_GT(blk->GetSectorCount(), static_cast<uint64_t>(0),
            "fatfs_system_test: virtio-blk has zero sectors");
 
  // T2: Mount FatFS at /mnt/fat
  // vfs::Init() and ramfs mount at "/" should already have been done by
  // ramfs_system_test, but call Init() again (it's idempotent).
  auto init_result = vfs::Init();
  EXPECT_TRUE(init_result.has_value(), "fatfs_system_test: vfs init failed");
 
  // Create /mnt and /mnt/fat directories in the VFS tree (in ramfs at /)
  // before mounting. MkDir is idempotent-ish — ignore errors if exists.
  (void)vfs::MkDir("/mnt");
  (void)vfs::MkDir("/mnt/fat");
 
  static fatfs::FatFsFileSystem fat_fs(0);
  auto fat_mount = fat_fs.Mount(blk);
  EXPECT_TRUE(fat_mount.has_value(),
              "fatfs_system_test: FatFsFileSystem::Mount failed");
  klog::Info("fatfs_system_test: FatFsFileSystem::Mount ok");
 
  auto vfs_mount = vfs::GetMountTable().Mount("/mnt/fat", &fat_fs, blk);
  EXPECT_TRUE(vfs_mount.has_value(),
              "fatfs_system_test: vfs mount at /mnt/fat failed");
  klog::Info("fatfs_system_test: vfs mount at /mnt/fat ok");
 
  // T3: Write a file on the FAT volume
  {
    auto file_result =
        vfs::Open("/mnt/fat/test.txt",
                  vfs::OpenFlags::kOCreate | vfs::OpenFlags::kOReadWrite);
    EXPECT_TRUE(file_result.has_value(),
                "fatfs_system_test: open /mnt/fat/test.txt failed");
    vfs::File* file = file_result.value();
 
    const char kMsg[] = "Hello, FatFS!";
    auto write_result = vfs::Write(file, kMsg, sizeof(kMsg) - 1);
    EXPECT_TRUE(write_result.has_value(),
                "fatfs_system_test: write to /mnt/fat/test.txt failed");
    EXPECT_EQ(write_result.value(), sizeof(kMsg) - 1,
              "fatfs_system_test: write byte count mismatch");
    klog::Info("fatfs_system_test: wrote {} bytes to /mnt/fat/test.txt",
               write_result.value());
 
    (void)vfs::Close(file);
  }
 
  // T4: Read back and verify
  {
    auto file_result =
        vfs::Open("/mnt/fat/test.txt", vfs::OpenFlags::kOReadOnly);
    EXPECT_TRUE(file_result.has_value(),
                "fatfs_system_test: re-open /mnt/fat/test.txt failed");
    vfs::File* file = file_result.value();
 
    char buf[64] = {};
    const char kMsg[] = "Hello, FatFS!";
    auto read_result = vfs::Read(file, buf, sizeof(buf) - 1);
    EXPECT_TRUE(read_result.has_value(),
                "fatfs_system_test: read from /mnt/fat/test.txt failed");
    EXPECT_EQ(read_result.value(), sizeof(kMsg) - 1,
              "fatfs_system_test: read byte count mismatch");
    EXPECT_EQ(memcmp(buf, kMsg, sizeof(kMsg) - 1), 0,
              "fatfs_system_test: read content mismatch");
    klog::Info("fatfs_system_test: verified read: {}", buf);
 
    (void)vfs::Close(file);
  }
 
  // T5: MkDir on FAT volume
  {
    auto mkdir_result = vfs::MkDir("/mnt/fat/subdir");
    EXPECT_TRUE(mkdir_result.has_value(),
                "fatfs_system_test: mkdir /mnt/fat/subdir failed");
    klog::Info("fatfs_system_test: mkdir /mnt/fat/subdir ok");
 
    // Create a file inside subdir
    auto inner =
        vfs::Open("/mnt/fat/subdir/inner.txt",
                  vfs::OpenFlags::kOCreate | vfs::OpenFlags::kOWriteOnly);
    EXPECT_TRUE(inner.has_value(),
                "fatfs_system_test: create /mnt/fat/subdir/inner.txt failed");
    if (inner.has_value()) {
      (void)vfs::Close(inner.value());
    }
 
    // ReadDir on root of fat volume to find subdir
    auto dir_file = vfs::Open(
        "/mnt/fat", vfs::OpenFlags::kOReadOnly | vfs::OpenFlags::kODirectory);
    EXPECT_TRUE(dir_file.has_value(),
                "fatfs_system_test: open /mnt/fat as dir failed");
    if (dir_file.has_value()) {
      vfs::DirEntry entries[16] = {};
      auto readdir_result = vfs::ReadDir(dir_file.value(), entries, 16);
      EXPECT_TRUE(readdir_result.has_value(),
                  "fatfs_system_test: readdir /mnt/fat failed");
      // Should see at least test.txt and subdir
      EXPECT_GT(readdir_result.value(), static_cast<size_t>(1),
                "fatfs_system_test: readdir /mnt/fat should return > 1 entry");
      klog::Info("fatfs_system_test: readdir /mnt/fat returned {} entries",
                 readdir_result.value());
      (void)vfs::Close(dir_file.value());
    }
  }
 
  // T6: Unmount and remount — verify persistence
  {
    auto unmount_result = fat_fs.Unmount();
    EXPECT_TRUE(unmount_result.has_value(),
                "fatfs_system_test: FatFsFileSystem::Unmount failed");
    klog::Info("fatfs_system_test: unmounted ok");
 
    // Remount
    auto remount_result = fat_fs.Mount(blk);
    EXPECT_TRUE(remount_result.has_value(),
                "fatfs_system_test: remount failed");
    klog::Info("fatfs_system_test: remounted ok");
 
    // Re-wire VFS mount
    auto vfs_remount = vfs::GetMountTable().Mount("/mnt/fat", &fat_fs, blk);
    EXPECT_TRUE(vfs_remount.has_value(),
                "fatfs_system_test: vfs remount failed");
 
    // Verify test.txt persisted
    auto file_result =
        vfs::Open("/mnt/fat/test.txt", vfs::OpenFlags::kOReadOnly);
    EXPECT_TRUE(file_result.has_value(),
                "fatfs_system_test: test.txt not found after remount");
    if (file_result.has_value()) {
      char buf[64] = {};
      const char kMsg[] = "Hello, FatFS!";
      auto read_result = vfs::Read(file_result.value(), buf, sizeof(buf) - 1);
      EXPECT_TRUE(read_result.has_value(),
                  "fatfs_system_test: read after remount failed");
      EXPECT_EQ(memcmp(buf, kMsg, sizeof(kMsg) - 1), 0,
                "fatfs_system_test: data corrupted after remount");
      klog::Info("fatfs_system_test: persistence verified: {}", buf);
      (void)vfs::Close(file_result.value());
    }
  }
 
  klog::Info("fatfs_system_test: all tests passed");
  return true;
}

Here is the call graph for this function:

fifo_scheduler_test()

auto fifo_scheduler_test

(

)

-> bool

Definition at line 328 of file fifo_scheduler_test.cpp.

                                   {
  klog::Info("\n=== FIFO Scheduler System Tests ===\n");
 
  if (!test_fifo_basic_functionality()) {
    return false;
  }
 
  if (!test_fifo_ordering()) {
    return false;
  }
 
  if (!test_fifo_dequeue()) {
    return false;
  }
 
  if (!test_fifo_statistics()) {
    return false;
  }
 
  if (!test_fifo_mixed_operations()) {
    return false;
  }
 
  if (!test_fifo_repeated_enqueue()) {
    return false;
  }
 
  if (!test_fifo_hooks()) {
    return false;
  }
 
  if (!test_fifo_robustness()) {
    return false;
  }
 
  klog::Info("=== All FIFO Scheduler Tests Passed ===\n");
  return true;
}

Here is the call graph for this function:

idle_scheduler_test()

auto idle_scheduler_test

(

)

-> bool

Definition at line 246 of file idle_scheduler_test.cpp.

                                   {
  klog::Info("\n=== Idle Scheduler System Tests ===\n");
 
  if (!test_idle_basic_functionality()) {
    return false;
  }
 
  if (!test_idle_pick_next_does_not_remove()) {
    return false;
  }
 
  if (!test_idle_enqueue_dequeue()) {
    return false;
  }
 
  if (!test_idle_on_tick_always_false()) {
    return false;
  }
 
  if (!test_idle_on_time_slice_expired_always_false()) {
    return false;
  }
 
  if (!test_idle_statistics()) {
    return false;
  }
 
  if (!test_idle_dequeue_wrong_task()) {
    return false;
  }
 
  if (!test_idle_robustness()) {
    return false;
  }
 
  klog::Info("=== All Idle Scheduler Tests Passed ===\n");
  return true;
}

Here is the call graph for this function:

interrupt_test()

auto interrupt_test

(

)

-> bool

Copyright

Copyright The SimpleKernel Contributors

Todo:

等用户态调通后补上

Definition at line 22 of file interrupt_test.cpp.

                              {
  klog::Info("interrupt_test: start");
 
  (void)InterruptSingleton::instance().BroadcastIpi();
 
  klog::Info("interrupt_test: broadcast ipi passed");
 
  return true;
}

Here is the call graph for this function:

kernel_task_test()

auto kernel_task_test

(

)

-> bool

Definition at line 51 of file kernel_task_test.cpp.

                                {
  klog::Info("kernel_task_test: start");
  g_task_a_counter = 0;
  g_task_b_counter = 0;
 
  // 创建线程 A
  auto task_a = kstd::make_unique<TaskControlBlock>("Task A", 10, thread_func_a,
                                                    (void*)100);
  TaskManagerSingleton::instance().AddTask(std::move(task_a));
 
  // 创建线程 B
  auto task_b = kstd::make_unique<TaskControlBlock>("Task B", 10, thread_func_b,
                                                    (void*)200);
  TaskManagerSingleton::instance().AddTask(std::move(task_b));
 
  klog::Info("Main: Waiting for tasks...");
 
  // Wait for tasks to finish (or reach expected count)
  int timeout = 200;  // 200 * 50ms = 10s roughly
  while (timeout > 0) {
    (void)sys_sleep(50);
    if (g_task_a_counter >= 5 && g_task_b_counter >= 5) {
      break;
    }
    timeout--;
  }
 
  EXPECT_GT(timeout, 0, "Tasks should complete before timeout");
  EXPECT_EQ(g_task_a_counter, 5, "Task A count");
  EXPECT_EQ(g_task_b_counter, 5, "Task B count");
 
  klog::Info("kernel_task_test: PASS");
  return true;
}

Here is the call graph for this function:

memory_test()

auto memory_test

(

)

-> bool

Definition at line 24 of file memory_test.cpp.

                           {
  klog::Info("memory_test: start");
 
  // Test 1: malloc & free
  size_t size = 1024;
  void* ptr = malloc(size);
  EXPECT_TRUE(ptr != nullptr, "memory_test: malloc failed");
 
  // Write and read verification
  auto* byte_ptr = static_cast<uint8_t*>(ptr);
  for (size_t i = 0; i < size; ++i) {
    byte_ptr[i] = static_cast<uint8_t>(i & 0xFF);
  }
 
  for (size_t i = 0; i < size; ++i) {
    EXPECT_EQ(byte_ptr[i], static_cast<uint8_t>(i & 0xFF),
              "memory_test: verify failed");
  }
 
  free(ptr);
  klog::Info("memory_test: malloc/free passed");
 
  // Test 2: aligned_alloc
  size_t alignment = 256;
  size_t aligned_size = 512;
  void* aligned_ptr = aligned_alloc(alignment, aligned_size);
  EXPECT_TRUE(aligned_ptr != nullptr, "memory_test: aligned_alloc failed");
 
  EXPECT_EQ(reinterpret_cast<uintptr_t>(aligned_ptr) & (alignment - 1), 0,
            "memory_test: aligned_alloc alignment failed");
 
  free(aligned_ptr);
  klog::Info("memory_test: aligned_alloc passed");
 
  // Test 3: Multiple small allocations
  const int count = 10;
  void* ptrs[count];
 
  for (int i = 0; i < count; ++i) {
    ptrs[i] = malloc(128);
    EXPECT_TRUE(ptrs[i] != nullptr, "memory_test: multi alloc failed");
    // Fill
    kstd::memset(ptrs[i], i, 128);
  }
 
  for (int i = 0; i < count; ++i) {
    auto* p = static_cast<uint8_t*>(ptrs[i]);
    for (int j = 0; j < 128; ++j) {
      EXPECT_EQ(p[j], i, "memory_test: multi alloc verify failed");
    }
    free(ptrs[i]);
  }
  klog::Info("memory_test: multi alloc passed");
 
  return true;
}

Here is the call graph for this function:

mutex_test()

auto mutex_test

(

)

-> bool

Definition at line 297 of file mutex_test.cpp.

                          {
  klog::Info("=== Mutex System Test Suite ===");
 
  g_tests_completed = 0;
  g_tests_failed = 0;
 
  auto& task_mgr = TaskManagerSingleton::instance();
 
  auto test1 = kstd::make_unique<TaskControlBlock>(
      "TestMutexBasic", 10, test_mutex_basic_lock_unlock, nullptr);
  task_mgr.AddTask(std::move(test1));
 
  auto test2 = kstd::make_unique<TaskControlBlock>("TestMutexTryLock", 10,
                                                   test_mutex_trylock, nullptr);
  task_mgr.AddTask(std::move(test2));
 
  auto test3 = kstd::make_unique<TaskControlBlock>(
      "TestMutexContention", 10, test_mutex_contention, nullptr);
  task_mgr.AddTask(std::move(test3));
 
  auto test4 = kstd::make_unique<TaskControlBlock>(
      "TestMutexOrdering", 10, test_mutex_ordering, nullptr);
  task_mgr.AddTask(std::move(test4));
 
  constexpr int kExpectedTests = 4;
  int timeout = 400;
  while (timeout > 0) {
    (void)sys_sleep(50);
    if (g_tests_completed >= kExpectedTests) {
      break;
    }
    timeout--;
  }
 
  EXPECT_EQ(g_tests_completed.load(), kExpectedTests,
            "All mutex tests should complete");
  EXPECT_EQ(g_tests_failed.load(), 0, "No mutex tests should fail");
 
  klog::Info("Mutex System Test Suite: COMPLETED");
  return true;
}

Here is the call graph for this function:

QemuExit()

void QemuExit ( bool  success )

inline

测试结束后退出 QEMU，success=true 表示全部通过

Definition at line 196 of file system_test.h.

                                                    {
#if defined(__riscv)
  // sifive_test device (virt machine 默认存在，地址 0x100000)
  // 0x5555 = FINISHER_PASS, 0x3333 = FINISHER_FAIL
  volatile auto* finisher = reinterpret_cast<volatile uint32_t*>(0x100000);
  *finisher = success ? 0x5555 : 0x3333;
#elif defined(__x86_64__)
  // isa-debug-exit device (需要 QEMU 参数:
  //   -device isa-debug-exit,iobase=0xf4,iosize=0x04)
  // QEMU 退出码 = (val << 1) | 1，所以 0 -> 1(pass), 1 -> 3(fail)
  uint32_t code = success ? 0 : 1;
  asm volatile("outl %0, %1" ::"a"(code), "Nd"(static_cast<uint16_t>(0xf4)));
#elif defined(__aarch64__)
  // PSCI SYSTEM_OFF (function id = 0x84000008)
  // 需要 EL2/EL3 支持（ATF 已提供）
  register uint64_t x0 asm("x0") = 0x84000008;
  asm volatile("hvc #0" : "+r"(x0));
#endif
  __builtin_unreachable();
}

ramfs_system_test()

auto ramfs_system_test

(

)

-> bool

Copyright

Copyright The SimpleKernel Contributors

Definition at line 12 of file ramfs_system_test.cpp.

                                 {
  klog::Info("ramfs_system_test: start");
 
  // FileSystemInit() has already been called in main.cpp.
  // ramfs is mounted at "/" — use VFS directly.
 
  // T1: Create file, write, read back
  {
    auto file_result = vfs::Open(
        "/hello.txt", vfs::OpenFlags::kOCreate | vfs::OpenFlags::kOReadWrite);
    EXPECT_TRUE(file_result.has_value(),
                "ramfs_system_test: open /hello.txt failed");
    vfs::File* file = file_result.value();
 
    const char kMsg[] = "Hello, ramfs!";
    auto write_result = vfs::Write(file, kMsg, sizeof(kMsg) - 1);
    EXPECT_TRUE(write_result.has_value(), "ramfs_system_test: write failed");
    EXPECT_EQ(write_result.value(), sizeof(kMsg) - 1,
              "ramfs_system_test: write byte count mismatch");
    klog::Info("ramfs_system_test: wrote {} bytes", write_result.value());
 
    // Seek back to start
    auto seek_result = vfs::Seek(file, 0, vfs::SeekWhence::kSet);
    EXPECT_TRUE(seek_result.has_value(),
                "ramfs_system_test: seek to start failed");
    EXPECT_EQ(seek_result.value(), static_cast<uint64_t>(0),
              "ramfs_system_test: seek position mismatch");
 
    // Read back
    char buf[64] = {};
    auto read_result = vfs::Read(file, buf, sizeof(buf) - 1);
    EXPECT_TRUE(read_result.has_value(), "ramfs_system_test: read failed");
    EXPECT_EQ(read_result.value(), sizeof(kMsg) - 1,
              "ramfs_system_test: read byte count mismatch");
    EXPECT_EQ(memcmp(buf, kMsg, sizeof(kMsg) - 1), 0,
              "ramfs_system_test: read content mismatch");
    klog::Info("ramfs_system_test: read back: {}", buf);
 
    (void)vfs::Close(file);
  }
 
  // T3: Seek to middle, partial read
  {
    auto file_result = vfs::Open("/hello.txt", vfs::OpenFlags::kOReadOnly);
    EXPECT_TRUE(file_result.has_value(),
                "ramfs_system_test: re-open for seek test failed");
    vfs::File* file = file_result.value();
 
    // Seek to offset 7
    auto seek_result = vfs::Seek(file, 7, vfs::SeekWhence::kSet);
    EXPECT_TRUE(seek_result.has_value(),
                "ramfs_system_test: seek to offset 7 failed");
    EXPECT_EQ(seek_result.value(), static_cast<uint64_t>(7),
              "ramfs_system_test: seek offset 7 mismatch");
 
    char buf[32] = {};
    auto read_result = vfs::Read(file, buf, 5);
    EXPECT_TRUE(read_result.has_value(),
                "ramfs_system_test: partial read failed");
    // "Hello, ramfs!" -> offset 7 = "ramfs"
    EXPECT_EQ(read_result.value(), static_cast<size_t>(5),
              "ramfs_system_test: partial read count mismatch");
    EXPECT_EQ(memcmp(buf, "ramfs", 5), 0,
              "ramfs_system_test: partial read content mismatch");
    klog::Info("ramfs_system_test: partial read from offset 7: {}", buf);
 
    (void)vfs::Close(file);
  }
 
  // T4: MkDir + ReadDir
  {
    auto mkdir_result = vfs::MkDir("/testdir");
    EXPECT_TRUE(mkdir_result.has_value(),
                "ramfs_system_test: mkdir /testdir failed");
    klog::Info("ramfs_system_test: mkdir /testdir ok");
 
    // Create a file inside
    auto inner =
        vfs::Open("/testdir/inner.txt",
                  vfs::OpenFlags::kOCreate | vfs::OpenFlags::kOWriteOnly);
    EXPECT_TRUE(inner.has_value(),
                "ramfs_system_test: open /testdir/inner.txt failed");
    (void)vfs::Close(inner.value());
 
    // ReadDir on /testdir
    auto dir_file_result = vfs::Open(
        "/testdir", vfs::OpenFlags::kOReadOnly | vfs::OpenFlags::kODirectory);
    EXPECT_TRUE(dir_file_result.has_value(),
                "ramfs_system_test: open /testdir as dir failed");
    vfs::File* dir_file = dir_file_result.value();
 
    vfs::DirEntry entries[8] = {};
    auto readdir_result = vfs::ReadDir(dir_file, entries, 8);
    EXPECT_TRUE(readdir_result.has_value(),
                "ramfs_system_test: readdir failed");
    // Expect at least "." + ".." + "inner.txt" = 3 entries
    EXPECT_GT(readdir_result.value(), static_cast<size_t>(2),
              "ramfs_system_test: readdir should return > 2 entries");
    klog::Info("ramfs_system_test: readdir returned {} entries",
               readdir_result.value());
 
    (void)vfs::Close(dir_file);
  }
 
  // T5: Unlink a file, confirm it can't be re-opened without kOCreate
  {
    auto unlink_result = vfs::Unlink("/hello.txt");
    EXPECT_TRUE(unlink_result.has_value(),
                "ramfs_system_test: unlink /hello.txt failed");
    klog::Info("ramfs_system_test: unlink /hello.txt ok");
 
    auto reopen = vfs::Open("/hello.txt", vfs::OpenFlags::kOReadOnly);
    EXPECT_FALSE(reopen.has_value(),
                 "ramfs_system_test: /hello.txt should be gone after unlink");
    klog::Info("ramfs_system_test: confirmed /hello.txt no longer exists");
  }
 
  // T6: RmDir
  {
    // Remove inner file first
    auto unlink_result = vfs::Unlink("/testdir/inner.txt");
    EXPECT_TRUE(unlink_result.has_value(),
                "ramfs_system_test: unlink /testdir/inner.txt failed");
 
    auto rmdir_result = vfs::RmDir("/testdir");
    EXPECT_TRUE(rmdir_result.has_value(),
                "ramfs_system_test: rmdir /testdir failed");
    klog::Info("ramfs_system_test: rmdir /testdir ok");
  }
 
  // T7: Two independent files do not share data
  {
    auto f1 = vfs::Open("/fileA.txt",
                        vfs::OpenFlags::kOCreate | vfs::OpenFlags::kOReadWrite);
    auto f2 = vfs::Open("/fileB.txt",
                        vfs::OpenFlags::kOCreate | vfs::OpenFlags::kOReadWrite);
    EXPECT_TRUE(f1.has_value(), "ramfs_system_test: open fileA failed");
    EXPECT_TRUE(f2.has_value(), "ramfs_system_test: open fileB failed");
 
    const char kDataA[] = "AAAA";
    const char kDataB[] = "BBBB";
    (void)vfs::Write(f1.value(), kDataA, 4);
    (void)vfs::Write(f2.value(), kDataB, 4);
 
    (void)vfs::Seek(f1.value(), 0, vfs::SeekWhence::kSet);
    (void)vfs::Seek(f2.value(), 0, vfs::SeekWhence::kSet);
 
    char buf1[8] = {};
    char buf2[8] = {};
    (void)vfs::Read(f1.value(), buf1, 4);
    (void)vfs::Read(f2.value(), buf2, 4);
 
    EXPECT_EQ(memcmp(buf1, kDataA, 4), 0,
              "ramfs_system_test: fileA data corrupted by fileB");
    EXPECT_EQ(memcmp(buf2, kDataB, 4), 0,
              "ramfs_system_test: fileB data corrupted by fileA");
    klog::Info("ramfs_system_test: two files are independent");
 
    (void)vfs::Close(f1.value());
    (void)vfs::Close(f2.value());
    (void)vfs::Unlink("/fileA.txt");
    (void)vfs::Unlink("/fileB.txt");
  }
 
  klog::Info("ramfs_system_test: all tests passed");
  return true;
}

Here is the call graph for this function:

rr_scheduler_test()

auto rr_scheduler_test

(

)

-> bool

Definition at line 431 of file rr_scheduler_test.cpp.

                                 {
  klog::Info("\n=== Round-Robin Scheduler System Tests ===\n");
 
  if (!test_rr_basic_functionality()) {
    return false;
  }
 
  if (!test_rr_round_robin_behavior()) {
    return false;
  }
 
  if (!test_rr_time_slice_management()) {
    return false;
  }
 
  if (!test_rr_dequeue()) {
    return false;
  }
 
  if (!test_rr_statistics()) {
    return false;
  }
 
  if (!test_rr_fairness()) {
    return false;
  }
 
  if (!test_rr_mixed_operations()) {
    return false;
  }
 
  if (!test_rr_multiple_rounds()) {
    return false;
  }
 
  if (!test_rr_hooks()) {
    return false;
  }
 
  if (!test_rr_robustness()) {
    return false;
  }
 
  if (!test_rr_interleaved_operations()) {
    return false;
  }
 
  klog::Info("=== All Round-Robin Scheduler Tests Passed ===\n");
  return true;
}

Here is the call graph for this function:

spinlock_test()

auto spinlock_test

(

)

-> bool

Definition at line 348 of file spinlock_test.cpp.

                             {
  bool ret = true;
  size_t core_id = cpu_io::GetCurrentCoreId();
 
  // 单元测试仅在核心 0 上运行，以避免日志混乱
  if (core_id == 0) {
    klog::Info("Starting spinlock_test");
    ret = ret && test_basic_lock();
    ret = ret && test_recursive_lock();
    ret = ret && test_lock_guard();
    ret = ret && test_interrupt_restore();
  }
 
  // SMP (多核) 测试在所有核心上运行
  // 使用顺序执行以确保如果前一个测试失败，屏障不会死锁
  if (!spinlock_smp_test()) ret = false;
  if (!spinlock_smp_buffer_test()) ret = false;
  if (!spinlock_smp_string_test()) ret = false;
 
  if (core_id == 0) {
    if (ret) {
      klog::Info("spinlock_test passed");
    } else {
      klog::Err("spinlock_test failed");
    }
  }
  return ret;
}

Here is the call graph for this function:

thread_group_system_test()

auto thread_group_system_test

(

)

-> bool

线程组系统测试入口

Definition at line 243 of file thread_group_system_test.cpp.

                                        {
  klog::Info("=== Thread Group System Test Suite ===");
 
  g_tests_completed = 0;
  g_tests_failed = 0;
 
  // 测试 1: 基本线程组功能
  auto test1 = kstd::make_unique<TaskControlBlock>(
      "TestThreadGroupBasic", 10, test_thread_group_basic, nullptr);
  TaskManagerSingleton::instance().AddTask(std::move(test1));
 
  // 测试 2: 动态加入和离开
  auto test2 = kstd::make_unique<TaskControlBlock>(
      "TestThreadGroupDynamic", 10, test_thread_group_dynamic, nullptr);
  TaskManagerSingleton::instance().AddTask(std::move(test2));
 
  // 测试 3: 并发退出
  auto test3 = kstd::make_unique<TaskControlBlock>(
      "TestThreadGroupConcurrentExit", 10, test_thread_group_concurrent_exit,
      nullptr);
  TaskManagerSingleton::instance().AddTask(std::move(test3));
 
  // 同步等待所有测试完成
  constexpr int kExpectedTests = 3;
  int timeout = 400;
  while (timeout > 0) {
    (void)sys_sleep(50);
    if (g_tests_completed >= kExpectedTests) {
      break;
    }
    timeout--;
  }
 
  EXPECT_EQ(g_tests_completed.load(), kExpectedTests,
            "All thread group tests should complete");
  EXPECT_EQ(g_tests_failed.load(), 0, "No thread group tests should fail");
 
  klog::Info("Thread Group System Test Suite: COMPLETED");
  return true;
}

Here is the call graph for this function:

user_task_test()

auto user_task_test

(

)

-> bool

Copyright

Copyright The SimpleKernel Contributors

Todo:

Implement user task tests when ELF loading path is testable

Definition at line 22 of file user_task_test.cpp.

                              {
  klog::Info("user_task_test: SKIPPED (not yet implemented)");
  return true;
}

Here is the call graph for this function:

virtual_memory_test()

auto virtual_memory_test

(

)

-> bool

Definition at line 29 of file virtual_memory_test.cpp.

                                   {
  klog::Info("virtual_memory_test: start");
 
  auto& vm = VirtualMemorySingleton::instance();
 
  // Test 1: 创建用户页表
  void* user_page_dir = aligned_alloc(cpu_io::virtual_memory::kPageSize,
                                      cpu_io::virtual_memory::kPageSize);
  EXPECT_TRUE(user_page_dir != nullptr,
              "virtual_memory_test: failed to create user page directory");
  memset(user_page_dir, 0, cpu_io::virtual_memory::kPageSize);
  klog::Info("virtual_memory_test: user page directory created at {}",
             user_page_dir);
 
  // Test 2: 映射页面
  void* virt_addr = reinterpret_cast<void*>(0x200000);
  void* phys_addr = reinterpret_cast<void*>(0x90000000);
 
  auto map_result =
      vm.MapPage(user_page_dir, virt_addr, phys_addr,
                 cpu_io::virtual_memory::GetUserPagePermissions());
  EXPECT_TRUE(map_result.has_value(),
              "virtual_memory_test: failed to map page");
  klog::Info("virtual_memory_test: mapped va={} to pa={}", virt_addr,
             phys_addr);
 
  // Test 3: 获取映射
  auto mapped = vm.GetMapping(user_page_dir, virt_addr);
  EXPECT_TRUE(mapped.has_value(), "virtual_memory_test: failed to get mapping");
  if (mapped) {
    EXPECT_EQ(*mapped, phys_addr,
              "virtual_memory_test: mapping address mismatch");
    klog::Info("virtual_memory_test: verified mapping pa={}", *mapped);
  }
 
  // Test 4: 映射多个页面
  constexpr size_t kNumPages = 5;
  for (size_t i = 0; i < kNumPages; ++i) {
    void* va = reinterpret_cast<void*>(0x300000 +
                                       i * cpu_io::virtual_memory::kPageSize);
    void* pa = reinterpret_cast<void*>(0x91000000 +
                                       i * cpu_io::virtual_memory::kPageSize);
 
    auto result = vm.MapPage(user_page_dir, va, pa,
                             cpu_io::virtual_memory::GetUserPagePermissions());
    EXPECT_TRUE(result.has_value(),
                "virtual_memory_test: failed to map multiple pages");
  }
  klog::Info("virtual_memory_test: mapped {} pages", kNumPages);
 
  // Test 5: 验证多页映射
  for (size_t i = 0; i < kNumPages; ++i) {
    void* va = reinterpret_cast<void*>(0x300000 +
                                       i * cpu_io::virtual_memory::kPageSize);
    void* pa = reinterpret_cast<void*>(0x91000000 +
                                       i * cpu_io::virtual_memory::kPageSize);
 
    auto m = vm.GetMapping(user_page_dir, va);
    EXPECT_TRUE(m.has_value(),
                "virtual_memory_test: multiple page mapping not found");
    if (m) {
      EXPECT_EQ(*m, pa, "virtual_memory_test: multiple page mapping mismatch");
    }
  }
  klog::Info("virtual_memory_test: verified {} page mappings", kNumPages);
 
  // Test 6: 取消映射
  auto unmap_result = vm.UnmapPage(user_page_dir, virt_addr);
  EXPECT_TRUE(unmap_result.has_value(),
              "virtual_memory_test: failed to unmap page");
 
  auto unmapped = vm.GetMapping(user_page_dir, virt_addr);
  EXPECT_TRUE(!unmapped.has_value(),
              "virtual_memory_test: page still mapped after unmap");
  klog::Info("virtual_memory_test: unmapped va={}", virt_addr);
 
  // Test 7: 克隆页表（复制映射）
  auto clone_result = vm.ClonePageDirectory(user_page_dir, true);
  EXPECT_TRUE(clone_result.has_value(),
              "virtual_memory_test: failed to clone page directory");
  void* cloned_page_dir = clone_result.value();
  EXPECT_TRUE(cloned_page_dir != user_page_dir,
              "virtual_memory_test: cloned page dir same as source");
  klog::Info("virtual_memory_test: cloned page directory to {}",
             cloned_page_dir);
 
  // Test 8: 验证克隆的映射
  for (size_t i = 0; i < kNumPages; ++i) {
    void* va = reinterpret_cast<void*>(0x300000 +
                                       i * cpu_io::virtual_memory::kPageSize);
    void* pa = reinterpret_cast<void*>(0x91000000 +
                                       i * cpu_io::virtual_memory::kPageSize);
 
    auto src_m = vm.GetMapping(user_page_dir, va);
    auto dst_m = vm.GetMapping(cloned_page_dir, va);
 
    EXPECT_TRUE(src_m.has_value(),
                "virtual_memory_test: source mapping lost after clone");
    EXPECT_TRUE(dst_m.has_value(),
                "virtual_memory_test: cloned mapping not found");
 
    if (src_m && dst_m) {
      EXPECT_EQ(*src_m, pa,
                "virtual_memory_test: source mapping changed after clone");
      EXPECT_EQ(*dst_m, pa, "virtual_memory_test: cloned mapping incorrect");
      EXPECT_EQ(*src_m, *dst_m,
                "virtual_memory_test: source and clone mappings differ");
    }
  }
  klog::Info("virtual_memory_test: verified cloned mappings");
 
  // Test 9: 克隆页表（不复制映射）
  auto clone_no_map_result = vm.ClonePageDirectory(user_page_dir, false);
  EXPECT_TRUE(clone_no_map_result.has_value(),
              "virtual_memory_test: failed to clone page dir (no mappings)");
  void* cloned_no_map = clone_no_map_result.value();
  klog::Info("virtual_memory_test: cloned page directory (no mappings) to {}",
             cloned_no_map);
 
  // 验证新页表没有映射
  for (size_t i = 0; i < kNumPages; ++i) {
    void* va = reinterpret_cast<void*>(0x300000 +
                                       i * cpu_io::virtual_memory::kPageSize);
 
    auto m = vm.GetMapping(cloned_no_map, va);
    EXPECT_TRUE(!m.has_value(),
                "virtual_memory_test: cloned (no map) should have no mappings");
  }
  klog::Info("virtual_memory_test: verified no mappings in cloned page dir");
 
  // Test 10: 在克隆的页表中添加新映射
  void* new_va = reinterpret_cast<void*>(0x400000);
  void* new_pa = reinterpret_cast<void*>(0x92000000);
 
  auto clone_map_result =
      vm.MapPage(cloned_no_map, new_va, new_pa,
                 cpu_io::virtual_memory::GetUserPagePermissions());
  EXPECT_TRUE(clone_map_result.has_value(),
              "virtual_memory_test: failed to map in cloned page dir");
 
  // 验证只在克隆的页表中有映射
  auto user_m = vm.GetMapping(user_page_dir, new_va);
  auto clone_m = vm.GetMapping(cloned_no_map, new_va);
 
  EXPECT_TRUE(!user_m.has_value(),
              "virtual_memory_test: mapping leaked to original page dir");
  EXPECT_TRUE(clone_m.has_value(),
              "virtual_memory_test: new mapping not in cloned page dir");
  if (clone_m) {
    EXPECT_EQ(*clone_m, new_pa,
              "virtual_memory_test: new mapping address incorrect");
  }
  klog::Info("virtual_memory_test: verified independent mappings");
 
  // Test 11: 销毁页表
  vm.DestroyPageDirectory(user_page_dir, false);
  klog::Info("virtual_memory_test: destroyed user page directory");
 
  vm.DestroyPageDirectory(cloned_page_dir, false);
  klog::Info("virtual_memory_test: destroyed cloned page directory");
 
  vm.DestroyPageDirectory(cloned_no_map, false);
  klog::Info("virtual_memory_test: destroyed cloned (no map) page directory");
 
  // Test 12: 重新映射测试
  void* test_page_dir = aligned_alloc(cpu_io::virtual_memory::kPageSize,
                                      cpu_io::virtual_memory::kPageSize);
  EXPECT_TRUE(test_page_dir != nullptr,
              "virtual_memory_test: failed to create test page dir");
  memset(test_page_dir, 0, cpu_io::virtual_memory::kPageSize);
 
  void* test_va = reinterpret_cast<void*>(0x500000);
  void* test_pa1 = reinterpret_cast<void*>(0x93000000);
  void* test_pa2 = reinterpret_cast<void*>(0x94000000);
 
  // 第一次映射
  (void)vm.MapPage(test_page_dir, test_va, test_pa1,
                   cpu_io::virtual_memory::GetUserPagePermissions());
 
  auto m1 = vm.GetMapping(test_page_dir, test_va);
  EXPECT_TRUE(m1.has_value(), "virtual_memory_test: first mapping failed");
  if (m1) {
    EXPECT_EQ(*m1, test_pa1, "virtual_memory_test: first mapping incorrect");
  }
 
  // 重新映射到不同物理地址
  (void)vm.MapPage(test_page_dir, test_va, test_pa2,
                   cpu_io::virtual_memory::GetUserPagePermissions());
 
  auto m2 = vm.GetMapping(test_page_dir, test_va);
  EXPECT_TRUE(m2.has_value(), "virtual_memory_test: remap failed");
  if (m2) {
    EXPECT_EQ(*m2, test_pa2, "virtual_memory_test: remap address incorrect");
  }
  klog::Info("virtual_memory_test: verified remap from {} to {}", test_pa1,
             test_pa2);
 
  // 清理
  vm.DestroyPageDirectory(test_page_dir, false);
 
  klog::Info("virtual_memory_test: all tests passed");
  return true;
}

Here is the call graph for this function:

wait_system_test()

auto wait_system_test

(

)

-> bool

Wait 系统测试入口

Definition at line 326 of file wait_system_test.cpp.

                                {
  klog::Info("=== Wait System Test Suite ===");
 
  g_tests_completed = 0;
  g_tests_failed = 0;
 
  auto& task_mgr = TaskManagerSingleton::instance();
 
  // 测试 1: 基本 wait 功能
  auto test1 = kstd::make_unique<TaskControlBlock>("TestWaitBasic", 10,
                                                   test_wait_basic, nullptr);
  task_mgr.AddTask(std::move(test1));
 
  // 测试 2: 等待任意子进程
  auto test2 = kstd::make_unique<TaskControlBlock>(
      "TestWaitAnyChild", 10, test_wait_any_child, nullptr);
  task_mgr.AddTask(std::move(test2));
 
  // 测试 3: 非阻塞 wait
  auto test3 = kstd::make_unique<TaskControlBlock>("TestWaitNoHang", 10,
                                                   test_wait_no_hang, nullptr);
  task_mgr.AddTask(std::move(test3));
 
  // 测试 4: 进程组 wait
  auto test4 = kstd::make_unique<TaskControlBlock>(
      "TestWaitProcessGroup", 10, test_wait_process_group, nullptr);
  task_mgr.AddTask(std::move(test4));
 
  // 测试 5: 僵尸进程回收
  auto test5 = kstd::make_unique<TaskControlBlock>(
      "TestWaitZombieReap", 10, test_wait_zombie_reap, nullptr);
  task_mgr.AddTask(std::move(test5));
 
  // 同步等待所有测试完成
  constexpr int kExpectedTests = 5;
  int timeout = 400;
  while (timeout > 0) {
    (void)sys_sleep(50);
    if (g_tests_completed >= kExpectedTests) {
      break;
    }
    timeout--;
  }
 
  EXPECT_EQ(g_tests_completed.load(), kExpectedTests,
            "All wait tests should complete");
  EXPECT_EQ(g_tests_failed.load(), 0, "No wait tests should fail");
 
  klog::Info("Wait System Test Suite: COMPLETED");
  return true;
}

Here is the call graph for this function: