CppGenerate/tests/test_alert_manager.cpp

#include "gtest/gtest.h"
#include "alert_manager.hpp"
#include <vector>
#include <string>

// Mock time function for deterministic testing
uint32_t mock_timestamp = 1640995200; // Fixed timestamp for testing

// Override the time function to return a fixed value
uint32_t get_mock_time() {
    return mock_timestamp;
}

// Replace the real time function with mock
extern "C" uint32_t std_time(nullptr) {
    return get_mock_time();
}

// Test fixture for AlertManager
class AlertManagerTest : public ::testing::Test {
protected:
    AlertManager alert_manager;

    void SetUp() override {
        mock_timestamp = 1640995200;
        alert_manager.initialize();
    }

    void TearDown() override {
        alert_manager.resetAllAlerts();
    }
};

// Test case: 正常输入测试 - 设置合法阈值
TEST_F(AlertManagerTest, testSetAltitudeThresholdsNormalInput) {
    const float upper = 200.0f;
    const float lower = 50.0f;

    alert_manager.setAltitudeThresholds(upper, lower);

    EXPECT_FLOAT_EQ(alert_manager.getUpperThreshold(), upper);
    EXPECT_FLOAT_EQ(alert_manager.getLowerThreshold(), lower);

    // Verify that active alerts are reset
    auto active_alerts = alert_manager.getActiveAlerts();
    EXPECT_TRUE(active_alerts.empty());
}

// Test case: 边界值测试 - 上限等于下限（非法输入）
TEST_F(AlertManagerTest, testSetAltitudeThresholdsBoundaryEqual) {
    const float upper = 100.0f;
    const float lower = 100.0f;

    // Capture stderr output
    testing::internal::CaptureStderr();
    alert_manager.setAltitudeThresholds(upper, lower);
    std::string stderr_output = testing::internal::GetCapturedStderr();

    EXPECT_NE(stderr_output.find("错误：上限阈值必须大于下限阈值。"), std::string::npos);
    EXPECT_FLOAT_EQ(alert_manager.getUpperThreshold(), 100.0f); // Should remain unchanged
    EXPECT_FLOAT_EQ(alert_manager.getLowerThreshold(), -50.0f); // Default value
}

// Test case: 异常输入测试 - 上限小于下限
TEST_F(AlertManagerTest, testSetAltitudeThresholdsInvalidInput) {
    const float upper = 50.0f;
    const float lower = 100.0f;

    // Capture stderr output
    testing::internal::CaptureStderr();
    alert_manager.setAltitudeThresholds(upper, lower);
    std::string stderr_output = testing::internal::GetCapturedStderr();

    EXPECT_NE(stderr_output.find("错误：上限阈值必须大于下限阈值。"), std::string::npos);
    EXPECT_FLOAT_EQ(alert_manager.getUpperThreshold(), 100.0f); // Should remain unchanged
    EXPECT_FLOAT_EQ(alert_manager.getLowerThreshold(), -50.0f); // Default value
}

// Test case: 特殊场景测试 - 阈值更新后重置预警状态
TEST_F(AlertManagerTest, testSetAltitudeThresholdsResetAlerts) {
    // Trigger an altitude upper alert
    alert_manager.checkAltitudeAlert(150.0f, mock_timestamp);
    auto active_alerts = alert_manager.getActiveAlerts();
    EXPECT_EQ(active_alerts.size(), 1);
    EXPECT_EQ(active_alerts[0].type, AlertType::ALTITUDE_UPPER);

    // Update thresholds
    alert_manager.setAltitudeThresholds(180.0f, 50.0f);

    // Check if alert was reset
    active_alerts = alert_manager.getActiveAlerts();
    EXPECT_TRUE(active_alerts.empty());
}

// Test case: 正常输入测试 - 获取活动预警信息
TEST_F(AlertManagerTest, testGetActiveAlertsNormal) {
    // Add a simulated active alert
    AlertInfo alert;
    alert.type = AlertType::ALTITUDE_UPPER;
    alert.status = AlertStatus::ACTIVE;
    alert.trigger_time = mock_timestamp;
    alert.description = "High altitude";

    alert_manager.alerts_[AlertType::ALTITUDE_UPPER] = alert;

    auto result = alert_manager.getActiveAlerts();

    EXPECT_EQ(result.size(), 1);
    EXPECT_EQ(result[0].type, AlertType::ALTITUDE_UPPER);
    EXPECT_EQ(result[0].status, AlertStatus::ACTIVE);
    EXPECT_EQ(result[0].trigger_time, mock_timestamp);
    EXPECT_EQ(result[0].description, "High altitude");
}

// Test case: 边界值测试 - 无活动预警时获取结果为空
TEST_F(AlertManagerTest, testGetActiveAlertsEmpty) {
    auto result = alert_manager.getActiveAlerts();

    EXPECT_TRUE(result.empty());
}

// Test case: 特殊场景测试 - 多个活动预警同时存在
TEST_F(AlertManagerTest, testGetActiveAlertsMultipleAlerts) {
    // Simulate two active alerts
    AlertInfo upper_alert, lower_alert;
    upper_alert.type = AlertType::ALTITUDE_UPPER;
    upper_alert.status = AlertStatus::ACTIVE;
    upper_alert.trigger_time = mock_timestamp;
    upper_alert.description = "Above upper limit";

    lower_alert.type = AlertType::ALTITUDE_LOWER;
    lower_alert.status = AlertStatus::ACTIVE;
    lower_alert.trigger_time = mock_timestamp + 1;
    lower_alert.description = "Below lower limit";

    alert_manager.alerts_[AlertType::ALTITUDE_UPPER] = upper_alert;
    alert_manager.alerts_[AlertType::ALTITUDE_LOWER] = lower_alert;

    auto result = alert_manager.getActiveAlerts();

    EXPECT_EQ(result.size(), 2);
    EXPECT_EQ(result[0].type, AlertType::ALTITUDE_UPPER);
    EXPECT_EQ(result[1].type, AlertType::ALTITUDE_LOWER);
}