task_plan_2/tests/test_dispatch_monitor.cpp

#include <gtest/gtest.h>
#include "core/dispatch.hpp"
#include <string>
#include <vector>
#include <memory>
#include <chrono>

// 使用实际项目中的类型定义
namespace battlefield {
// 使用实际项目中的类型，通过已包含的头文件获取
// struct Plan;
// struct CmdPacket;
// struct MonitorStatus;
// struct DispatchLog;
// class DispatchMonitor;
} // namespace battlefield

// 测试夹具
class DispatchMonitorTest : public ::testing::Test {
protected:
    void SetUp() override {
        monitor_ = std::make_unique<battlefield::DispatchMonitor>();
    }
    void TearDown() override {
        monitor_.reset();
    }
    std::unique_ptr<battlefield::DispatchMonitor> monitor_;
};

// ==================== DispatchPlan 测试 ====================
TEST_F(DispatchMonitorTest, testDispatchPlanNormalInput) {
    // 正常输入：包含多个子任务的计划
    battlefield::Plan plan;
    plan.id = "P001";
    plan.name = "Attack Plan";
    plan.description = "Test description";
    plan.subTasks = {
        {"Task1", "P001", "Task1", "Description 1", 0, ""},
        {"Task2", "P001", "Task2", "Description 2", 1, ""},
        {"Task3", "P001", "Task3", "Description 3", 2, ""}
    };
    plan.score = 0.0;
    std::string target = "UnitAlpha";

    auto packet = monitor_->DispatchPlan(plan, target);

    // 验证返回值
    EXPECT_EQ(packet.packetId, "CMD-P001");
    EXPECT_EQ(packet.planId, "P001");
    EXPECT_EQ(packet.targetUnit, "UnitAlpha");
    EXPECT_TRUE(packet.payload.find("Attack Plan") != std::string::npos);
    EXPECT_TRUE(packet.payload.find("3") != std::string::npos);

    // 验证副作用：状态更新
    auto status = monitor_->GetMonitorStatus();
    EXPECT_EQ(status.totalTasks, 3);
    EXPECT_EQ(status.inProgressTasks, 3);
    EXPECT_EQ(status.completedTasks, 0);
}

TEST_F(DispatchMonitorTest, testDispatchPlanBoundaryZeroTasks) {
    // 边界值测试：空子任务列表
    battlefield::Plan plan;
    plan.id = "P002";
    plan.name = "Empty Plan";
    plan.description = "Test description";
    plan.subTasks = {};
    plan.score = 0.0;
    auto packet = monitor_->DispatchPlan(plan, "UnitBeta");

    EXPECT_EQ(packet.packetId, "CMD-P002");
    auto status = monitor_->GetMonitorStatus();
    EXPECT_EQ(status.totalTasks, 0);
    EXPECT_EQ(status.inProgressTasks, 0);
}

// ==================== GetMonitorStatus 测试 ====================
TEST_F(DispatchMonitorTest, testGetMonitorStatusInitialState) {
    // 正常输入：初始状态验证
    auto status = monitor_->GetMonitorStatus();
    EXPECT_EQ(status.totalTasks, 0);
    EXPECT_EQ(status.completedTasks, 0);
    EXPECT_EQ(status.inProgressTasks, 0);
    EXPECT_EQ(status.failedTasks, 0);
    EXPECT_DOUBLE_EQ(status.progressPercent, 0.0);
}

// ==================== GetDashboardData 测试 ====================
TEST_F(DispatchMonitorTest, testGetDashboardDataNormalFormat) {
    // 正常输入：执行部分操作后验证仪表盘格式
    battlefield::Plan plan;
    plan.id = "P003";
    plan.name = "Test Plan";
    plan.description = "Test description";
    plan.subTasks = {
        {"T1", "P003", "Task 1", "Description 1", 0, ""},
        {"T2", "P003", "Task 2", "Description 2", 1, ""}
    };
    plan.score = 0.0;
    monitor_->DispatchPlan(plan, "UnitGamma");
    monitor_->AdvanceProgress(1);

    std::string dashboard = monitor_->GetDashboardData();
    EXPECT_TRUE(dashboard.find("=== Dashboard ===") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Total Tasks: 2") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Completed: 1") != std::string::npos);
    EXPECT_TRUE(dashboard.find("In Progress: 1") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Progress: 50.0%") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Issued Packets: 1") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Log Entries: 1") != std::string::npos);
}

TEST_F(DispatchMonitorTest, testGetDashboardDataEmptyState) {
    // 边界值测试：空状态下的仪表盘输出
    std::string dashboard = monitor_->GetDashboardData();
    EXPECT_TRUE(dashboard.find("Total Tasks: 0") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Progress: 0.0%") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Issued Packets: 0") != std::string::npos);
}

// ==================== LogDispatch 测试 ====================
TEST_F(DispatchMonitorTest, testLogDispatchNormalSuccess) {
    // 正常输入：记录成功日志
    monitor_->LogDispatch("P004", "START", true);
    std::string dash = monitor_->GetDashboardData();
    EXPECT_TRUE(dash.find("Log Entries: 1") != std::string::npos);
}

TEST_F(DispatchMonitorTest, testLogDispatchBoundaryEmptyStrings) {
    // 边界值测试：空字符串参数
    monitor_->LogDispatch("", "", false);
    std::string dash = monitor_->GetDashboardData();
    EXPECT_TRUE(dash.find("Log Entries: 1") != std::string::npos);
    // 验证日志ID自增逻辑正常
    monitor_->LogDispatch("P005", "END", true);
    dash = monitor_->GetDashboardData();
    EXPECT_TRUE(dash.find("Log Entries: 2") != std::string::npos);
}

// ==================== AdvanceProgress 测试 ====================
TEST_F(DispatchMonitorTest, testAdvanceProgressNormal) {
    // 正常输入：正常推进进度
    battlefield::Plan plan;
    plan.id = "P005";
    plan.name = "Progress Plan";
    plan.description = "Test description";
    plan.subTasks = {
        {"A", "P005", "Task A", "Description A", 0, ""},
        {"B", "P005", "Task B", "Description B", 1, ""},
        {"C", "P005", "Task C", "Description C", 2, ""},
        {"D", "P005", "Task D", "Description D", 3, ""}
    };
    plan.score = 0.0;
    monitor_->DispatchPlan(plan, "UnitDelta");
    monitor_->AdvanceProgress(2);

    auto status = monitor_->GetMonitorStatus();
    EXPECT_EQ(status.completedTasks, 2);
    EXPECT_EQ(status.inProgressTasks, 2);
    EXPECT_DOUBLE_EQ(status.progressPercent, 50.0);
}

TEST_F(DispatchMonitorTest, testAdvanceProgressBoundaryClamping) {
    // 边界值测试：完成数大于进行中任务数（触发截断）
    battlefield::Plan plan;
    plan.id = "P006";
    plan.name = "Clamp Plan";
    plan.description = "Test description";
    plan.subTasks = {
        {"X", "P006", "Task X", "Description X", 0, ""},
        {"Y", "P006", "Task Y", "Description Y", 1, ""}
    };
    plan.score = 0.0;
    monitor_->DispatchPlan(plan, "UnitEpsilon");
    monitor_->AdvanceProgress(10); // 10 > 2

    auto status = monitor_->GetMonitorStatus();
    EXPECT_EQ(status.completedTasks, 2);
    EXPECT_EQ(status.inProgressTasks, 0);
    EXPECT_DOUBLE_EQ(status.progressPercent, 100.0);
}

TEST_F(DispatchMonitorTest, testAdvanceProgressSpecialZeroTotal) {
    // 特殊场景测试：总任务数为0时避免除零异常
    monitor_->AdvanceProgress(5);
    auto status = monitor_->GetMonitorStatus();
    // inProgressTasks 初始为0，min(5, 0) = 0，故 completedTasks 不变
    EXPECT_EQ(status.completedTasks, 0);
    EXPECT_DOUBLE_EQ(status.progressPercent, 0.0);
}