From 6fd5a9955d9d90b84fafcc3c9b2c4c9ffd46a938 Mon Sep 17 00:00:00 2001 From: linianlin Date: Mon, 20 Apr 2026 15:18:13 +0800 Subject: [PATCH] =?UTF-8?q?AI=20=E8=87=AA=E5=8A=A8=E7=94=9F=E6=88=90?= =?UTF-8?q?=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests1/test_alert_manager.cpp | 231 ++++++++++++++++++++++++++++++++++ 1 file changed, 231 insertions(+) create mode 100644 tests1/test_alert_manager.cpp diff --git a/tests1/test_alert_manager.cpp b/tests1/test_alert_manager.cpp new file mode 100644 index 0000000..39c37f9 --- /dev/null +++ b/tests1/test_alert_manager.cpp @@ -0,0 +1,231 @@ +#include "gtest/gtest.h" +#include "alert_manager.hpp" +#include +#include + +// 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()); +} \ No newline at end of file