rr_scheduler_test.cpp File Reference

#include "rr_scheduler.hpp"
#include <gtest/gtest.h>
#include "kstd_vector"
#include "task_control_block.hpp"

Include dependency graph for rr_scheduler_test.cpp:

Go to the source code of this file.

Functions
	TEST (RoundRobinSchedulerTest, BasicEnqueueDequeue)
	TEST (RoundRobinSchedulerTest, RoundRobinRotation)
	TEST (RoundRobinSchedulerTest, DequeueSpecificTask)
	TEST (RoundRobinSchedulerTest, NullPointerHandling)
	TEST (RoundRobinSchedulerTest, RepeatedEnqueueDequeue)
	TEST (RoundRobinSchedulerTest, InterleavedEnqueueDequeue)
	TEST (RoundRobinSchedulerTest, QueueSizeAndEmpty)
	TEST (RoundRobinSchedulerTest, TimeSliceReset)
	TEST (RoundRobinSchedulerTest, Statistics)
	TEST (RoundRobinSchedulerTest, FairnessWithManyTasks)
	TEST (RoundRobinSchedulerTest, MultipleRounds)
	TEST (RoundRobinSchedulerTest, SingleTask)
	TEST (RoundRobinSchedulerTest, DequeueNonExistentTask)

Function Documentation

TEST() [1/13]

TEST	(	RoundRobinSchedulerTest	,
		BasicEnqueueDequeue
	)

Copyright

Copyright The SimpleKernel Contributors

Definition at line 13 of file rr_scheduler_test.cpp.

                                                   {
  RoundRobinScheduler scheduler;
 
  // 创建测试任务
  TaskControlBlock task1("Task1", 1, nullptr, nullptr);
  task1.status = TaskStatus::kReady;
 
  TaskControlBlock task2("Task2", 2, nullptr, nullptr);
  task2.status = TaskStatus::kReady;
 
  // 测试空队列
  EXPECT_EQ(scheduler.PickNext(), nullptr);
 
  // 加入任务
  scheduler.Enqueue(&task1);
  scheduler.Enqueue(&task2);
 
  // 测试 FIFO 顺序
  EXPECT_EQ(scheduler.PickNext(), &task1);
  EXPECT_EQ(scheduler.PickNext(), &task2);
  EXPECT_EQ(scheduler.PickNext(), nullptr);
}

Here is the call graph for this function:

TEST() [2/13]

TEST	(	RoundRobinSchedulerTest	,
		DequeueNonExistentTask
	)

Definition at line 296 of file rr_scheduler_test.cpp.

                                                      {
  RoundRobinScheduler scheduler;
 
  TaskControlBlock task1("Task1", 1, nullptr, nullptr);
  TaskControlBlock task2("Task2", 2, nullptr, nullptr);
  TaskControlBlock task3("Task3", 3, nullptr, nullptr);
 
  scheduler.Enqueue(&task1);
  scheduler.Enqueue(&task2);
 
  // 尝试移除不在队列中的任务
  scheduler.Dequeue(&task3);
  EXPECT_EQ(scheduler.GetQueueSize(), 2);
 
  // 验证原有任务仍在队列中
  EXPECT_EQ(scheduler.PickNext(), &task1);
  EXPECT_EQ(scheduler.PickNext(), &task2);
  EXPECT_TRUE(scheduler.IsEmpty());
}

Here is the call graph for this function:

TEST() [3/13]

TEST	(	RoundRobinSchedulerTest	,
		DequeueSpecificTask
	)

Definition at line 66 of file rr_scheduler_test.cpp.

                                                   {
  RoundRobinScheduler scheduler;
 
  TaskControlBlock task1("Task1", 1, nullptr, nullptr);
  TaskControlBlock task2("Task2", 2, nullptr, nullptr);
  TaskControlBlock task3("Task3", 3, nullptr, nullptr);
 
  scheduler.Enqueue(&task1);
  scheduler.Enqueue(&task2);
  scheduler.Enqueue(&task3);
 
  // 移除中间的任务
  scheduler.Dequeue(&task2);
 
  // 验证只剩下 task1 和 task3
  EXPECT_EQ(scheduler.PickNext(), &task1);
  EXPECT_EQ(scheduler.PickNext(), &task3);
  EXPECT_EQ(scheduler.PickNext(), nullptr);
}

Here is the call graph for this function:

TEST() [4/13]

TEST	(	RoundRobinSchedulerTest	,
		FairnessWithManyTasks
	)

Definition at line 230 of file rr_scheduler_test.cpp.

                                                     {
  RoundRobinScheduler scheduler;
  constexpr size_t kTaskCount = 100;
 
  // 创建任务数组（使用动态分配）
  kstd::vector<TaskControlBlock*> tasks;
  for (size_t i = 0; i < kTaskCount; ++i) {
    auto* task = new TaskControlBlock("Task", 10, nullptr, nullptr);
    task->status = TaskStatus::kReady;
    tasks.push_back(task);
    scheduler.Enqueue(task);
  }
 
  EXPECT_EQ(scheduler.GetQueueSize(), kTaskCount);
 
  // 验证所有任务按顺序被选中
  for (size_t i = 0; i < kTaskCount; ++i) {
    auto* picked = scheduler.PickNext();
    ASSERT_NE(picked, nullptr);
    EXPECT_EQ(picked, tasks[i]);
  }
 
  EXPECT_TRUE(scheduler.IsEmpty());
 
  // 清理内存
  for (auto* task : tasks) {
    delete task;
  }
}

Here is the call graph for this function:

TEST() [5/13]

TEST	(	RoundRobinSchedulerTest	,
		InterleavedEnqueueDequeue
	)

Definition at line 114 of file rr_scheduler_test.cpp.

                                                         {
  RoundRobinScheduler scheduler;
 
  TaskControlBlock task1("Task1", 1, nullptr, nullptr);
  TaskControlBlock task2("Task2", 2, nullptr, nullptr);
 
  scheduler.Enqueue(&task1);
  EXPECT_EQ(scheduler.PickNext(), &task1);
 
  scheduler.Enqueue(&task2);
  EXPECT_EQ(scheduler.PickNext(), &task2);
 
  scheduler.Enqueue(&task1);
  scheduler.Enqueue(&task2);
  EXPECT_EQ(scheduler.PickNext(), &task1);
  EXPECT_EQ(scheduler.PickNext(), &task2);
}

Here is the call graph for this function:

TEST() [6/13]

TEST	(	RoundRobinSchedulerTest	,
		MultipleRounds
	)

Definition at line 261 of file rr_scheduler_test.cpp.

                                              {
  RoundRobinScheduler scheduler;
 
  TaskControlBlock task1("Task1", 1, nullptr, nullptr);
  TaskControlBlock task2("Task2", 2, nullptr, nullptr);
  TaskControlBlock task3("Task3", 3, nullptr, nullptr);
 
  // 进行 5 轮轮转
  for (int round = 0; round < 5; ++round) {
    scheduler.Enqueue(&task1);
    scheduler.Enqueue(&task2);
    scheduler.Enqueue(&task3);
 
    EXPECT_EQ(scheduler.PickNext(), &task1);
    EXPECT_EQ(scheduler.PickNext(), &task2);
    EXPECT_EQ(scheduler.PickNext(), &task3);
    EXPECT_TRUE(scheduler.IsEmpty());
  }
}

Here is the call graph for this function:

TEST() [7/13]

TEST	(	RoundRobinSchedulerTest	,
		NullPointerHandling
	)

Definition at line 87 of file rr_scheduler_test.cpp.

                                                   {
  RoundRobinScheduler scheduler;
 
  // Enqueue 空指针应该不崩溃
  scheduler.Enqueue(nullptr);
  EXPECT_EQ(scheduler.PickNext(), nullptr);
 
  // Dequeue 空指针应该不崩溃
  scheduler.Dequeue(nullptr);
}

Here is the call graph for this function:

TEST() [8/13]

TEST	(	RoundRobinSchedulerTest	,
		QueueSizeAndEmpty
	)

Definition at line 133 of file rr_scheduler_test.cpp.

                                                 {
  RoundRobinScheduler scheduler;
 
  TaskControlBlock task1("Task1", 1, nullptr, nullptr);
  TaskControlBlock task2("Task2", 2, nullptr, nullptr);
  TaskControlBlock task3("Task3", 3, nullptr, nullptr);
 
  // 初始状态
  EXPECT_TRUE(scheduler.IsEmpty());
  EXPECT_EQ(scheduler.GetQueueSize(), 0);
 
  // 加入任务
  scheduler.Enqueue(&task1);
  EXPECT_FALSE(scheduler.IsEmpty());
  EXPECT_EQ(scheduler.GetQueueSize(), 1);
 
  scheduler.Enqueue(&task2);
  scheduler.Enqueue(&task3);
  EXPECT_EQ(scheduler.GetQueueSize(), 3);
 
  // 取出任务
  scheduler.PickNext();
  EXPECT_EQ(scheduler.GetQueueSize(), 2);
 
  scheduler.PickNext();
  scheduler.PickNext();
  EXPECT_TRUE(scheduler.IsEmpty());
  EXPECT_EQ(scheduler.GetQueueSize(), 0);
}

Here is the call graph for this function:

TEST() [9/13]

TEST	(	RoundRobinSchedulerTest	,
		RepeatedEnqueueDequeue
	)

Definition at line 99 of file rr_scheduler_test.cpp.

                                                      {
  RoundRobinScheduler scheduler;
 
  TaskControlBlock task1("Task1", 1, nullptr, nullptr);
 
  // 重复入队和出队
  for (int i = 0; i < 10; ++i) {
    scheduler.Enqueue(&task1);
    EXPECT_EQ(scheduler.PickNext(), &task1);
  }
 
  EXPECT_EQ(scheduler.PickNext(), nullptr);
}

Here is the call graph for this function:

TEST() [10/13]

TEST	(	RoundRobinSchedulerTest	,
		RoundRobinRotation
	)

Definition at line 37 of file rr_scheduler_test.cpp.

                                                  {
  RoundRobinScheduler scheduler;
 
  TaskControlBlock task1("Task1", 1, nullptr, nullptr);
  TaskControlBlock task2("Task2", 2, nullptr, nullptr);
  TaskControlBlock task3("Task3", 3, nullptr, nullptr);
 
  // 加入三个任务
  scheduler.Enqueue(&task1);
  scheduler.Enqueue(&task2);
  scheduler.Enqueue(&task3);
 
  // 第一轮
  EXPECT_EQ(scheduler.PickNext(), &task1);
  EXPECT_EQ(scheduler.PickNext(), &task2);
  EXPECT_EQ(scheduler.PickNext(), &task3);
 
  // 模拟时间片用完，任务重新入队
  scheduler.Enqueue(&task1);
  scheduler.Enqueue(&task2);
  scheduler.Enqueue(&task3);
 
  // 第二轮 - 应该保持相同的顺序
  EXPECT_EQ(scheduler.PickNext(), &task1);
  EXPECT_EQ(scheduler.PickNext(), &task2);
  EXPECT_EQ(scheduler.PickNext(), &task3);
}

Here is the call graph for this function:

TEST() [11/13]

TEST	(	RoundRobinSchedulerTest	,
		SingleTask
	)

Definition at line 282 of file rr_scheduler_test.cpp.

                                          {
  RoundRobinScheduler scheduler;
 
  TaskControlBlock task1("Task1", 1, nullptr, nullptr);
 
  scheduler.Enqueue(&task1);
  EXPECT_EQ(scheduler.GetQueueSize(), 1);
 
  auto* picked = scheduler.PickNext();
  EXPECT_EQ(picked, &task1);
  EXPECT_TRUE(scheduler.IsEmpty());
}

Here is the call graph for this function:

TEST() [12/13]

TEST	(	RoundRobinSchedulerTest	,
		Statistics
	)

Definition at line 183 of file rr_scheduler_test.cpp.

                                          {
  RoundRobinScheduler scheduler;
 
  TaskControlBlock task1("Task1", 1, nullptr, nullptr);
  TaskControlBlock task2("Task2", 2, nullptr, nullptr);
 
  // 初始统计
  auto stats = scheduler.GetStats();
  EXPECT_EQ(stats.total_enqueues, 0);
  EXPECT_EQ(stats.total_dequeues, 0);
  EXPECT_EQ(stats.total_picks, 0);
  EXPECT_EQ(stats.total_preemptions, 0);
 
  // 测试入队统计
  scheduler.Enqueue(&task1);
  scheduler.Enqueue(&task2);
  stats = scheduler.GetStats();
  EXPECT_EQ(stats.total_enqueues, 2);
 
  // 测试选择统计
  scheduler.PickNext();
  scheduler.PickNext();
  stats = scheduler.GetStats();
  EXPECT_EQ(stats.total_picks, 2);
 
  // 测试出队统计
  scheduler.Enqueue(&task1);
  scheduler.Dequeue(&task1);
  stats = scheduler.GetStats();
  EXPECT_EQ(stats.total_dequeues, 1);
 
  // 测试抢占统计
  scheduler.OnPreempted(&task1);
  scheduler.OnPreempted(&task2);
  stats = scheduler.GetStats();
  EXPECT_EQ(stats.total_preemptions, 2);
 
  // 重置统计
  scheduler.ResetStats();
  stats = scheduler.GetStats();
  EXPECT_EQ(stats.total_enqueues, 0);
  EXPECT_EQ(stats.total_dequeues, 0);
  EXPECT_EQ(stats.total_picks, 0);
  EXPECT_EQ(stats.total_preemptions, 0);
}

Here is the call graph for this function:

TEST() [13/13]

TEST	(	RoundRobinSchedulerTest	,
		TimeSliceReset
	)

Definition at line 164 of file rr_scheduler_test.cpp.

                                              {
  RoundRobinScheduler scheduler;
 
  TaskControlBlock task1("Task1", 1, nullptr, nullptr);
  task1.sched_info.time_slice_default = 20;
  task1.sched_info.time_slice_remaining = 5;  // 时间片快用完了
 
  // 入队应该重置时间片
  scheduler.Enqueue(&task1);
  EXPECT_EQ(task1.sched_info.time_slice_remaining, 20);
 
  // 模拟时间片耗尽
  task1.sched_info.time_slice_remaining = 0;
  bool should_reenqueue = scheduler.OnTimeSliceExpired(&task1);
  EXPECT_TRUE(should_reenqueue);
  EXPECT_EQ(task1.sched_info.time_slice_remaining, 20);
}

Here is the call graph for this function: