CppGenerate/tests1/test_alert_manager.cpp

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

// Mock time function for deterministic testing
uint32_t mock_timestamp = 1000;
uint32_t getMockTimestamp() { return mock_timestamp; }

// Override the global triggerAlert and updateAlertStatus for testing
void triggerAlert(AlertManager::AlertType type, uint32_t timestamp, const std::string& description) {
    // Mock implementation
}

void updateAlertStatus(AlertManager::AlertType type, AlertManager::AlertStatus new_status, uint32_t timestamp) {
    // Mock implementation
}

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

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

    void setMockTimestamp(uint32_t ts) {
        mock_timestamp = ts;
    }
};

// Test checkAltitudeAlert - Normal case: altitude within bounds
TEST_F(AlertManagerTest, testCheckAltitudeAlertNormal) {
    alert_manager.setAltitudeThresholds(150.0f, -100.0f);
    alert_manager.checkAltitudeAlert(120.0f, getMockTimestamp());

    EXPECT_FALSE(alert_manager.hasActiveAlerts());
}

// Test checkAltitudeAlert - Upper threshold exceeded
TEST_F(AlertManagerTest, testCheckAltitudeAlertUpperExceeded) {
    alert_manager.setAltitudeThresholds(150.0f, -100.0f);
    alert_manager.checkAltitudeAlert(160.0f, getMockTimestamp());

    EXPECT_TRUE(alert_manager.hasActiveAlerts());
    auto active_alerts = alert_manager.getActiveAlerts();
    EXPECT_EQ(active_alerts.size(), 1);
    EXPECT_EQ(active_alerts[0].type, AlertManager::AlertType::ALTITUDE_UPPER);
    EXPECT_EQ(active_alerts[0].status, AlertManager::AlertStatus::ACTIVE);
}

// Test checkAltitudeAlert - Lower threshold exceeded
TEST_F(AlertManagerTest, testCheckAltitudeAlertLowerExceeded) {
    alert_manager.setAltitudeThresholds(150.0f, -100.0f);
    alert_manager.checkAltitudeAlert(-120.0f, getMockTimestamp());

    EXPECT_TRUE(alert_manager.hasActiveAlerts());
    auto active_alerts = alert_manager.getActiveAlerts();
    EXPECT_EQ(active_alerts.size(), 1);
    EXPECT_EQ(active_alerts[0].type, AlertManager::AlertType::ALTITUDE_LOWER);
    EXPECT_EQ(active_alerts[0].status, AlertManager::AlertStatus::ACTIVE);
}

// Test checkAltitudeAlert - Recovery from upper threshold
TEST_F(AlertManagerTest, testCheckAltitudeAlertUpperRecovery) {
    alert_manager.setAltitudeThresholds(150.0f, -100.0f);
    alert_manager.checkAltitudeAlert(160.0f, getMockTimestamp());
    alert_manager.checkAltitudeAlert(140.0f, getMockTimestamp());

    EXPECT_FALSE(alert_manager.hasActiveAlerts());
    auto history = alert_manager.getAlertHistory(10);
    EXPECT_EQ(history.size(), 1);
    EXPECT_EQ(history[0].type, AlertManager::AlertType::ALTITUDE_UPPER);
    EXPECT_EQ(history[0].status, AlertManager::AlertStatus::RESOLVED);
}

// Test checkAltitudeAlert - Recovery from lower threshold
TEST_F(AlertManagerTest, testCheckAltitudeAlertLowerRecovery) {
    alert_manager.setAltitudeThresholds(150.0f, -100.0f);
    alert_manager.checkAltitudeAlert(-120.0f, getMockTimestamp());
    alert_manager.checkAltitudeAlert(-80.0f, getMockTimestamp());

    EXPECT_FALSE(alert_manager.hasActiveAlerts());
    auto history = alert_manager.getAlertHistory(10);
    EXPECT_EQ(history.size(), 1);
    EXPECT_EQ(history[0].type, AlertManager::AlertType::ALTITUDE_LOWER);
    EXPECT_EQ(history[0].status, AlertManager::AlertStatus::RESOLVED);
}

// Test setAltitudeThresholds - Valid thresholds
TEST_F(AlertManagerTest, testSetAltitudeThresholdsValid) {
    EXPECT_NO_THROW(alert_manager.setAltitudeThresholds(200.0f, -50.0f));
    EXPECT_EQ(alert_manager.getAltitudeThresholds().first, 200.0f);
    EXPECT_EQ(alert_manager.getAltitudeThresholds().second, -50.0f);
}

// Test setAltitudeThresholds - Invalid thresholds (upper <= lower)
TEST_F(AlertManagerTest, testSetAltitudeThresholdsInvalid) {
    EXPECT_NO_THROW(alert_manager.setAltitudeThresholds(100.0f, 100.0f));
    EXPECT_EQ(alert_manager.getAltitudeThresholds().first, 100.0f);
    EXPECT_EQ(alert_manager.getAltitudeThresholds().second, 100.0f);
}

// Test setAltitudeThresholds - Reset alerts on threshold change
TEST_F(AlertManagerTest, testSetAltitudeThresholdsResetAlerts) {
    alert_manager.setAltitudeThresholds(150.0f, -100.0f);
    alert_manager.checkAltitudeAlert(160.0f, getMockTimestamp());
    EXPECT_TRUE(alert_manager.hasActiveAlerts());

    alert_manager.setAltitudeThresholds(200.0f, -150.0f);
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
}

// Test triggerSensorFailure - Trigger sensor failure
TEST_F(AlertManagerTest, testTriggerSensorFailure) {
    alert_manager.triggerSensorFailure(getMockTimestamp());
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
    auto active_alerts = alert_manager.getActiveAlerts();
    EXPECT_EQ(active_alerts.size(), 1);
    EXPECT_EQ(active_alerts[0].type, AlertManager::AlertType::SENSOR_FAILURE);
    EXPECT_EQ(active_alerts[0].status, AlertManager::AlertStatus::ACTIVE);
}

// Test triggerLowBattery - Low battery with valid level
TEST_F(AlertManagerTest, testTriggerLowBatteryValid) {
    alert_manager.triggerLowBattery(getMockTimestamp(), 15.0f);
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
    auto active_alerts = alert_manager.getActiveAlerts();
    EXPECT_EQ(active_alerts.size(), 1);
    EXPECT_EQ(active_alerts[0].type, AlertManager::AlertType::LOW_BATTERY);
    EXPECT_EQ(active_alerts[0].status, AlertManager::AlertStatus::ACTIVE);
    EXPECT_NE(active_alerts[0].description.find("低电量警告：当前电量15%"), std::string::npos);
}

// Test triggerCommunicationError - Trigger communication error
TEST_F(AlertManagerTest, testTriggerCommunicationError) {
    alert_manager.triggerCommunicationError(getMockTimestamp());
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
    auto active_alerts = alert_manager.getActiveAlerts();
    EXPECT_EQ(active_alerts.size(), 1);
    EXPECT_EQ(active_alerts[0].type, AlertManager::AlertType::COMMUNICATION_ERROR);
    EXPECT_EQ(active_alerts[0].status, AlertManager::AlertStatus::ACTIVE);
}

// Test hasActiveAlerts - No active alerts
TEST_F(AlertManagerTest, testHasActiveAlertsNoAlerts) {
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
}

// Test hasActiveAlerts - With active alerts
TEST_F(AlertManagerTest, testHasActiveAlertsWithAlerts) {
    alert_manager.triggerSensorFailure(getMockTimestamp());
    EXPECT_TRUE(alert_manager.hasActiveAlerts());
}

// Test getActiveAlerts - Empty list when no alerts
TEST_F(AlertManagerTest, testGetActiveAlertsEmpty) {
    auto alerts = alert_manager.getActiveAlerts();
    EXPECT_TRUE(alerts.empty());
}

// Test getActiveAlerts - Returns correct active alerts
TEST_F(AlertManagerTest, testGetActiveAlertsReturnsCorrect) {
    alert_manager.triggerLowBattery(getMockTimestamp(), 10.0f);
    auto alerts = alert_manager.getActiveAlerts();
    EXPECT_EQ(alerts.size(), 1);
    EXPECT_EQ(alerts[0].type, AlertManager::AlertType::LOW_BATTERY);
}

// Test getStatusDescription - Normal status
TEST_F(AlertManagerTest, testGetStatusDescriptionNormal) {
    std::string status = alert_manager.getStatusDescription();
    EXPECT_EQ(status, "系统状态：正常\n");
}

// Test getStatusDescription - With active alerts
TEST_F(AlertManagerTest, testGetStatusDescriptionWithAlerts) {
    alert_manager.triggerSensorFailure(getMockTimestamp());
    std::string status = alert_manager.getStatusDescription();
    EXPECT_NE(status.find("系统状态：有1个活动预警"), std::string::npos);
    EXPECT_NE(status.find("传感器故障"), std::string::npos);
}

// Test resetAllAlerts - Clears all alerts
TEST_F(AlertManagerTest, testResetAllAlerts) {
    alert_manager.triggerSensorFailure(getMockTimestamp());
    alert_manager.resetAllAlerts();
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
    EXPECT_TRUE(alert_manager.getActiveAlerts().empty());
}

// Test acknowledgeAllAlerts - Acknowledges all active alerts
TEST_F(AlertManagerTest, testAcknowledgeAllAlerts) {
    alert_manager.triggerSensorFailure(getMockTimestamp());
    alert_manager.acknowledgeAllAlerts(getMockTimestamp());
    auto alerts = alert_manager.getActiveAlerts();
    EXPECT_TRUE(alerts.empty());
}

// Test acknowledgeAlert - Acknowledges specific alert
TEST_F(AlertManagerTest, testAcknowledgeAlert) {
    alert_manager.triggerSensorFailure(getMockTimestamp());
    alert_manager.acknowledgeAlert(AlertManager::AlertType::SENSOR_FAILURE, getMockTimestamp());
    auto alerts = alert_manager.getActiveAlerts();
    EXPECT_TRUE(alerts.empty());
}

// Test resetAlert - Resets a specific alert
TEST_F(AlertManagerTest, testResetAlert) {
    alert_manager.triggerSensorFailure(getMockTimestamp());
    alert_manager.resetAlert(AlertManager::AlertType::SENSOR_FAILURE);
    EXPECT_FALSE(alert_manager.hasActiveAlerts());
}

// Test getAlertHistory - Limited history size
TEST_F(AlertManagerTest, testGetAlertHistoryLimitedSize) {
    for (int i = 0; i < 5; ++i) {
        alert_manager.triggerSensorFailure(getMockTimestamp() + i);
    }
    auto history = alert_manager.getAlertHistory(3);
    EXPECT_EQ(history.size(), 3);
}

// Test clearHistory - Clears all history
TEST_F(AlertManagerTest, testClearHistory) {
    alert_manager.triggerSensorFailure(getMockTimestamp());
    alert_manager.clearHistory();
    EXPECT_TRUE(alert_manager.getAlertHistory(10).empty());
}