From 6c1c145965b3066e3867960f768f9cfa1f03fd0f Mon Sep 17 00:00:00 2001 From: lids <1713278948@qq.com> Date: Sat, 9 May 2026 16:51:04 +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 --- tests/test_alert_manager.cpp | 660 ++++++++++++++++++++++------------- 1 file changed, 426 insertions(+), 234 deletions(-) diff --git a/tests/test_alert_manager.cpp b/tests/test_alert_manager.cpp index 5bc247a..1013c67 100644 --- a/tests/test_alert_manager.cpp +++ b/tests/test_alert_manager.cpp @@ -1,267 +1,459 @@ -#include "gtest/gtest.h" +#include +#include #include "alert_manager.hpp" -#include -#include +#include +#include -// Mock for time to ensure deterministic tests -static uint32_t mock_timestamp = 1640995200; // 2022-01-01 00:00:00 UTC - -class MockTime { +// 辅助类：用于捕获标准输出和标准错误输出 +class StreamCapture { public: - static uint32_t getTimestamp() { return mock_timestamp; } - static void setTimestamp(uint32_t t) { mock_timestamp = t; } + StreamCapture() { + old_cout_buf_ = std::cout.rdbuf(cout_buffer_.rdbuf()); + old_cerr_buf_ = std::cerr.rdbuf(cerr_buffer_.rdbuf()); + } + + ~StreamCapture() { + std::cout.rdbuf(old_cout_buf_); + std::cerr.rdbuf(old_cerr_buf_); + } + + std::string getCout() const { return cout_buffer_.str(); } + std::string getCerr() const { return cerr_buffer_.str(); } + +private: + std::stringstream cout_buffer_; + std::stringstream cerr_buffer_; + std::streambuf* old_cout_buf_; + std::streambuf* old_cerr_buf_; }; -// Helper function to compare AlertInfo -bool operator==(const AlertInfo& a, const AlertInfo& b) { - return a.type == b.type && - a.status == b.status && - a.trigger_time == b.trigger_time && - a.acknowledge_time == b.acknowledge_time && - a.resolve_time == b.resolve_time && - a.description == b.description; -} - -// Test fixture +// 测试夹具类 class AlertManagerTest : public ::testing::Test { protected: - AlertManager manager; - void SetUp() override { - mock_timestamp = 1640995200; manager.initialize(); } void TearDown() override { - manager.clearHistory(); + manager.resetAllAlerts(); } + + AlertManager manager; }; -TEST_F(AlertManagerTest, testAlertManagerDefaultInitialization) { - EXPECT_FLOAT_EQ(manager.getAltitudeThresholds().first, 100.0f); - EXPECT_FLOAT_EQ(manager.getAltitudeThresholds().second, -50.0f); - EXPECT_TRUE(manager.getActiveAlerts().empty()); - EXPECT_TRUE(manager.getAlertHistory(10).empty()); -} +// ==================== checkAltitudeAlert 测试 ==================== -TEST_F(AlertManagerTest, testInitialize) { - // No direct output assertion, but verify initialization logic - // This is tested implicitly via constructor - EXPECT_NO_FATAL_FAILURE(manager.initialize()); -} - -TEST_F(AlertManagerTest, testCheckAltitudeAlertNormal) { - mock_timestamp = 1640995200; - manager.checkAltitudeAlert(105.0f, mock_timestamp); - auto alerts = manager.getActiveAlerts(); - EXPECT_EQ(alerts.size(), 1); - EXPECT_EQ(alerts[0].type, AlertType::ALTITUDE_UPPER); - EXPECT_EQ(alerts[0].status, AlertStatus::ACTIVE); - EXPECT_EQ(alerts[0].trigger_time, mock_timestamp); -} - -TEST_F(AlertManagerTest, testCheckAltitudeAlertBelowLower) { - mock_timestamp = 1640995200; - manager.checkAltitudeAlert(-55.0f, mock_timestamp); - auto alerts = manager.getActiveAlerts(); - EXPECT_EQ(alerts.size(), 1); - EXPECT_EQ(alerts[0].type, AlertType::ALTITUDE_LOWER); - EXPECT_EQ(alerts[0].status, AlertStatus::ACTIVE); -} - -TEST_F(AlertManagerTest, testCheckAltitudeAlertResetWhenNormal) { - mock_timestamp = 1640995200; - manager.checkAltitudeAlert(105.0f, mock_timestamp); // Trigger upper - mock_timestamp = 1640995201; - manager.checkAltitudeAlert(90.0f, mock_timestamp); // Reset - auto alerts = manager.getActiveAlerts(); - EXPECT_TRUE(alerts.empty()); -} - -TEST_F(AlertManagerTest, testSetAltitudeThresholdsValid) { - manager.setAltitudeThresholds(200.0f, -100.0f); - auto thresholds = manager.getAltitudeThresholds(); - EXPECT_FLOAT_EQ(thresholds.first, 200.0f); - EXPECT_FLOAT_EQ(thresholds.second, -100.0f); -} - -TEST_F(AlertManagerTest, testSetAltitudeThresholdsInvalid) { - EXPECT_NO_FATAL_FAILURE(manager.setAltitudeThresholds(50.0f, 100.0f)); - // Should print error, but no crash - EXPECT_FLOAT_EQ(manager.getAltitudeThresholds().first, 100.0f); - EXPECT_FLOAT_EQ(manager.getAltitudeThresholds().second, -50.0f); -} - -TEST_F(AlertManagerTest, testTriggerSensorFailure) { - mock_timestamp = 1640995200; - manager.triggerSensorFailure(mock_timestamp); - auto alerts = manager.getActiveAlerts(); - EXPECT_EQ(alerts.size(), 1); - EXPECT_EQ(alerts[0].type, AlertType::SENSOR_FAILURE); - EXPECT_EQ(alerts[0].status, AlertStatus::ACTIVE); - EXPECT_EQ(alerts[0].trigger_time, mock_timestamp); -} - -TEST_F(AlertManagerTest, testTriggerLowBattery) { - mock_timestamp = 1640995200; - manager.triggerLowBattery(mock_timestamp, 15.0f); - auto alerts = manager.getActiveAlerts(); - EXPECT_EQ(alerts.size(), 1); - EXPECT_EQ(alerts[0].type, AlertType::LOW_BATTERY); - EXPECT_EQ(alerts[0].status, AlertStatus::ACTIVE); - EXPECT_NE(alerts[0].description.find("15.0%"), std::string::npos); -} - -TEST_F(AlertManagerTest, testTriggerCommunicationError) { - mock_timestamp = 1640995200; - manager.triggerCommunicationError(mock_timestamp); - auto alerts = manager.getActiveAlerts(); - EXPECT_EQ(alerts.size(), 1); - EXPECT_EQ(alerts[0].type, AlertType::COMMUNICATION_ERROR); - EXPECT_EQ(alerts[0].status, AlertStatus::ACTIVE); -} - -TEST_F(AlertManagerTest, testAcknowledgeAllAlerts) { - mock_timestamp = 1640995200; - manager.triggerSensorFailure(mock_timestamp); - manager.triggerLowBattery(mock_timestamp + 1, 10.0f); - mock_timestamp = 1640995202; - manager.acknowledgeAllAlerts(mock_timestamp); - auto alerts = manager.getActiveAlerts(); - EXPECT_TRUE(alerts.empty()); - EXPECT_EQ(alerts.size(), 0); -} - -TEST_F(AlertManagerTest, testAcknowledgeAlert) { - mock_timestamp = 1640995200; - manager.triggerSensorFailure(mock_timestamp); - mock_timestamp = 1640995201; - manager.acknowledgeAlert(AlertType::SENSOR_FAILURE, mock_timestamp); - auto alerts = manager.getActiveAlerts(); - EXPECT_TRUE(alerts.empty()); -} - -TEST_F(AlertManagerTest, testResetAlert) { - mock_timestamp = 1640995200; - manager.triggerSensorFailure(mock_timestamp); - manager.resetAlert(AlertType::SENSOR_FAILURE); - auto alerts = manager.getActiveAlerts(); - EXPECT_TRUE(alerts.empty()); -} - -TEST_F(AlertManagerTest, testResetAllAlerts) { - mock_timestamp = 1640995200; - manager.triggerSensorFailure(mock_timestamp); - manager.triggerLowBattery(mock_timestamp + 1, 10.0f); - manager.resetAllAlerts(); - auto alerts = manager.getActiveAlerts(); - EXPECT_TRUE(alerts.empty()); -} - -TEST_F(AlertManagerTest, testHasActiveAlerts) { +// 正常输入测试：高度在阈值范围内，不应触发任何预警 +TEST_F(AlertManagerTest, testCheckAltitudeAlertNormalRange) { + StreamCapture capture; + + // 默认阈值：上限100.0，下限-50.0 + manager.checkAltitudeAlert(50.0f, 1000); + EXPECT_FALSE(manager.hasActiveAlerts()); - mock_timestamp = 1640995200; - manager.triggerSensorFailure(mock_timestamp); + EXPECT_FALSE(manager.hasUnacknowledgedAlerts()); + + // 验证没有预警相关的输出 + std::string cout_output = capture.getCout(); + EXPECT_EQ(cout_output.find("[预警]"), std::string::npos); +} + +// 正常输入测试：高度超过上限，应触发上限预警 +TEST_F(AlertManagerTest, testCheckAltitudeAlertUpperThresholdExceeded) { + StreamCapture capture; + + manager.checkAltitudeAlert(150.0f, 2000); + + EXPECT_TRUE(manager.hasActiveAlerts()); + EXPECT_TRUE(manager.hasUnacknowledgedAlerts()); + + auto active_alerts = manager.getActiveAlerts(); + ASSERT_EQ(active_alerts.size(), 1); + EXPECT_EQ(active_alerts[0].type, AlertType::ALTITUDE_UPPER); + EXPECT_EQ(active_alerts[0].status, AlertStatus::ACTIVE); + EXPECT_EQ(active_alerts[0].trigger_time, 2000); + + // 验证输出包含预警信息 + std::string cout_output = capture.getCout(); + EXPECT_NE(cout_output.find("高度上限预警"), std::string::npos); + EXPECT_NE(cout_output.find("150"), std::string::npos); +} + +// 正常输入测试：高度低于下限，应触发下限预警 +TEST_F(AlertManagerTest, testCheckAltitudeAlertLowerThresholdExceeded) { + StreamCapture capture; + + manager.checkAltitudeAlert(-100.0f, 3000); + + EXPECT_TRUE(manager.hasActiveAlerts()); + EXPECT_TRUE(manager.hasUnacknowledgedAlerts()); + + auto active_alerts = manager.getActiveAlerts(); + ASSERT_EQ(active_alerts.size(), 1); + EXPECT_EQ(active_alerts[0].type, AlertType::ALTITUDE_LOWER); + EXPECT_EQ(active_alerts[0].status, AlertStatus::ACTIVE); + EXPECT_EQ(active_alerts[0].trigger_time, 3000); + + // 验证输出包含预警信息 + std::string cout_output = capture.getCout(); + EXPECT_NE(cout_output.find("高度下限预警"), std::string::npos); + EXPECT_NE(cout_output.find("-100"), std::string::npos); +} + +// 边界值测试：高度恰好等于上限阈值，不应触发预警 +TEST_F(AlertManagerTest, testCheckAltitudeAlertAtUpperBoundary) { + StreamCapture capture; + + manager.checkAltitudeAlert(100.0f, 4000); + + EXPECT_FALSE(manager.hasActiveAlerts()); + EXPECT_FALSE(manager.hasUnacknowledgedAlerts()); + + std::string cout_output = capture.getCout(); + EXPECT_EQ(cout_output.find("[预警]"), std::string::npos); +} + +// 边界值测试：高度恰好等于下限阈值，不应触发预警 +TEST_F(AlertManagerTest, testCheckAltitudeAlertAtLowerBoundary) { + StreamCapture capture; + + manager.checkAltitudeAlert(-50.0f, 5000); + + EXPECT_FALSE(manager.hasActiveAlerts()); + EXPECT_FALSE(manager.hasUnacknowledgedAlerts()); + + std::string cout_output = capture.getCout(); + EXPECT_EQ(cout_output.find("[预警]"), std::string::npos); +} + +// 边界值测试：高度略高于上限阈值（浮点数精度边界） +TEST_F(AlertManagerTest, testCheckAltitudeAlertJustAboveUpperBoundary) { + StreamCapture capture; + + manager.checkAltitudeAlert(100.0001f, 6000); + + EXPECT_TRUE(manager.hasActiveAlerts()); + + auto active_alerts = manager.getActiveAlerts(); + ASSERT_EQ(active_alerts.size(), 1); + EXPECT_EQ(active_alerts[0].type, AlertType::ALTITUDE_UPPER); +} + +// 边界值测试：高度略低于下限阈值（浮点数精度边界） +TEST_F(AlertManagerTest, testCheckAltitudeAlertJustBelowLowerBoundary) { + StreamCapture capture; + + manager.checkAltitudeAlert(-50.0001f, 7000); + + EXPECT_TRUE(manager.hasActiveAlerts()); + + auto active_alerts = manager.getActiveAlerts(); + ASSERT_EQ(active_alerts.size(), 1); + EXPECT_EQ(active_alerts[0].type, AlertType::ALTITUDE_LOWER); +} + +// 特殊场景测试：高度从超出上限恢复到正常范围，应解除预警 +TEST_F(AlertManagerTest, testCheckAltitudeAlertRecoverFromUpperAlert) { + StreamCapture capture; + + // 先触发上限预警 + manager.checkAltitudeAlert(150.0f, 8000); + EXPECT_TRUE(manager.hasActiveAlerts()); + + // 高度恢复正常 + manager.checkAltitudeAlert(50.0f, 9000); + + EXPECT_FALSE(manager.hasActiveAlerts()); + EXPECT_FALSE(manager.hasUnacknowledgedAlerts()); + + // 验证预警已解决 + auto history = manager.getAlertHistory(10); + bool found_resolved = false; + for (const auto& alert : history) { + if (alert.type == AlertType::ALTITUDE_UPPER && + alert.status == AlertStatus::RESOLVED) { + found_resolved = true; + break; + } + } + EXPECT_TRUE(found_resolved); +} + +// 特殊场景测试：高度从低于下限恢复到正常范围，应解除预警 +TEST_F(AlertManagerTest, testCheckAltitudeAlertRecoverFromLowerAlert) { + StreamCapture capture; + + // 先触发下限预警 + manager.checkAltitudeAlert(-100.0f, 10000); + EXPECT_TRUE(manager.hasActiveAlerts()); + + // 高度恢复正常 + manager.checkAltitudeAlert(0.0f, 11000); + + EXPECT_FALSE(manager.hasActiveAlerts()); + EXPECT_FALSE(manager.hasUnacknowledgedAlerts()); + + // 验证预警已解决 + auto history = manager.getAlertHistory(10); + bool found_resolved = false; + for (const auto& alert : history) { + if (alert.type == AlertType::ALTITUDE_LOWER && + alert.status == AlertStatus::RESOLVED) { + found_resolved = true; + break; + } + } + EXPECT_TRUE(found_resolved); +} + +// 特殊场景测试：同时触发上限和下限预警（理论上不可能，但测试边界情况） +TEST_F(AlertManagerTest, testCheckAltitudeAlertBothThresholdsExceeded) { + StreamCapture capture; + + // 修改阈值为较小范围，使高度同时超出上下限（不可能，但测试代码健壮性） + manager.setAltitudeThresholds(10.0f, 20.0f); + + // 高度30同时超出上下限（下限20，上限10），实际只应触发上限预警 + manager.checkAltitudeAlert(30.0f, 12000); + + auto active_alerts = manager.getActiveAlerts(); + EXPECT_EQ(active_alerts.size(), 1); + EXPECT_EQ(active_alerts[0].type, AlertType::ALTITUDE_UPPER); +} + +// 异常输入测试：高度为极大值 +TEST_F(AlertManagerTest, testCheckAltitudeAlertExtremeHighValue) { + StreamCapture capture; + + manager.checkAltitudeAlert(1e10f, 13000); + + EXPECT_TRUE(manager.hasActiveAlerts()); + auto active_alerts = manager.getActiveAlerts(); + ASSERT_EQ(active_alerts.size(), 1); + EXPECT_EQ(active_alerts[0].type, AlertType::ALTITUDE_UPPER); +} + +// 异常输入测试：高度为极小值 +TEST_F(AlertManagerTest, testCheckAltitudeAlertExtremeLowValue) { + StreamCapture capture; + + manager.checkAltitudeAlert(-1e10f, 14000); + + EXPECT_TRUE(manager.hasActiveAlerts()); + auto active_alerts = manager.getActiveAlerts(); + ASSERT_EQ(active_alerts.size(), 1); + EXPECT_EQ(active_alerts[0].type, AlertType::ALTITUDE_LOWER); +} + +// 异常输入测试：时间戳为0 +TEST_F(AlertManagerTest, testCheckAltitudeAlertZeroTimestamp) { + StreamCapture capture; + + manager.checkAltitudeAlert(150.0f, 0); + + EXPECT_TRUE(manager.hasActiveAlerts()); + auto active_alerts = manager.getActiveAlerts(); + ASSERT_EQ(active_alerts.size(), 1); + EXPECT_EQ(active_alerts[0].trigger_time, 0); +} + +// 异常输入测试：时间戳为最大值 +TEST_F(AlertManagerTest, testCheckAltitudeAlertMaxTimestamp) { + StreamCapture capture; + + manager.checkAltitudeAlert(150.0f, UINT32_MAX); + + EXPECT_TRUE(manager.hasActiveAlerts()); + auto active_alerts = manager.getActiveAlerts(); + ASSERT_EQ(active_alerts.size(), 1); + EXPECT_EQ(active_alerts[0].trigger_time, UINT32_MAX); +} + +// ==================== setAltitudeThresholds 测试 ==================== + +// 正常输入测试：设置有效的上下限阈值 +TEST_F(AlertManagerTest, testSetAltitudeThresholdsValidValues) { + StreamCapture capture; + + manager.setAltitudeThresholds(200.0f, 0.0f); + + // 验证新阈值生效 + manager.checkAltitudeAlert(150.0f, 15000); + EXPECT_FALSE(manager.hasActiveAlerts()); + + manager.checkAltitudeAlert(250.0f, 16000); + EXPECT_TRUE(manager.hasActiveAlerts()); + + // 验证输出信息 + std::string cout_output = capture.getCout(); + EXPECT_NE(cout_output.find("预警阈值已更新"), std::string::npos); + EXPECT_NE(cout_output.find("200"), std::string::npos); + EXPECT_NE(cout_output.find("0"), std::string::npos); +} + +// 正常输入测试：设置阈值后，之前的预警应被重置 +TEST_F(AlertManagerTest, testSetAltitudeThresholdsResetsAlerts) { + StreamCapture capture; + + // 先触发预警 + manager.checkAltitudeAlert(150.0f, 17000); + EXPECT_TRUE(manager.hasActiveAlerts()); + + // 修改阈值 + manager.setAltitudeThresholds(200.0f, 0.0f); + + // 预警应被重置 + EXPECT_FALSE(manager.hasActiveAlerts()); +} + +// 异常输入测试：上限小于下限，应输出错误信息且不修改阈值 +TEST_F(AlertManagerTest, testSetAltitudeThresholdsUpperLessThanLower) { + StreamCapture capture; + + float original_upper = 100.0f; + float original_lower = -50.0f; + + manager.setAltitudeThresholds(10.0f, 20.0f); + + // 验证阈值未改变 + manager.checkAltitudeAlert(50.0f, 18000); + EXPECT_FALSE(manager.hasActiveAlerts()); + + // 验证错误输出 + std::string cerr_output = capture.getCerr(); + EXPECT_NE(cerr_output.find("上限阈值必须大于下限阈值"), std::string::npos); +} + +// 边界值测试：上限等于下限，应视为非法输入 +TEST_F(AlertManagerTest, testSetAltitudeThresholdsUpperEqualToLower) { + StreamCapture capture; + + manager.setAltitudeThresholds(50.0f, 50.0f); + + // 验证阈值未改变 + manager.checkAltitudeAlert(50.0f, 19000); + EXPECT_FALSE(manager.hasActiveAlerts()); + + // 验证错误输出 + std::string cerr_output = capture.getCerr(); + EXPECT_NE(cerr_output.find("上限阈值必须大于下限阈值"), std::string::npos); +} + +// 边界值测试：设置非常大的阈值范围 +TEST_F(AlertManagerTest, testSetAltitudeThresholdsLargeRange) { + StreamCapture capture; + + manager.setAltitudeThresholds(10000.0f, -10000.0f); + + // 验证新阈值生效 + manager.checkAltitudeAlert(5000.0f, 20000); + EXPECT_FALSE(manager.hasActiveAlerts()); + + manager.checkAltitudeAlert(15000.0f, 21000); EXPECT_TRUE(manager.hasActiveAlerts()); } -TEST_F(AlertManagerTest, testHasUnacknowledgedAlerts) { - EXPECT_FALSE(manager.hasUnacknowledgedAlerts()); - mock_timestamp = 1640995200; - manager.triggerSensorFailure(mock_timestamp); - EXPECT_TRUE(manager.hasUnacknowledgedAlerts()); - manager.acknowledgeAllAlerts(mock_timestamp + 1); - EXPECT_FALSE(manager.hasUnacknowledgedAlerts()); +// 边界值测试：设置非常小的阈值范围 +TEST_F(AlertManagerTest, testSetAltitudeThresholdsSmallRange) { + StreamCapture capture; + + manager.setAltitudeThresholds(1.0f, 0.0f); + + // 验证新阈值生效 + manager.checkAltitudeAlert(0.5f, 22000); + EXPECT_FALSE(manager.hasActiveAlerts()); + + manager.checkAltitudeAlert(1.5f, 23000); + EXPECT_TRUE(manager.hasActiveAlerts()); + + manager.checkAltitudeAlert(-0.5f, 24000); + EXPECT_TRUE(manager.hasActiveAlerts()); } -TEST_F(AlertManagerTest, testGetActiveAlerts) { - mock_timestamp = 1640995200; - manager.triggerSensorFailure(mock_timestamp); - auto alerts = manager.getActiveAlerts(); - EXPECT_EQ(alerts.size(), 1); - EXPECT_EQ(alerts[0].type, AlertType::SENSOR_FAILURE); +// 异常输入测试：设置负数的上限和下限 +TEST_F(AlertManagerTest, testSetAltitudeThresholdsNegativeValues) { + StreamCapture capture; + + manager.setAltitudeThresholds(-10.0f, -100.0f); + + // 验证新阈值生效 + manager.checkAltitudeAlert(-50.0f, 25000); + EXPECT_FALSE(manager.hasActiveAlerts()); + + manager.checkAltitudeAlert(-5.0f, 26000); + EXPECT_TRUE(manager.hasActiveAlerts()); } -TEST_F(AlertManagerTest, testGetAlertHistoryMaxCount) { - mock_timestamp = 1640995200; - for (int i = 0; i < 15; ++i) { - manager.triggerSensorFailure(mock_timestamp + i); - } - auto history = manager.getAlertHistory(10); - EXPECT_EQ(history.size(), 10); +// 异常输入测试：设置浮点数精度极限值 +TEST_F(AlertManagerTest, testSetAltitudeThresholdsFloatPrecision) { + StreamCapture capture; + + manager.setAltitudeThresholds(100.000001f, 0.000001f); + + // 验证新阈值生效 + manager.checkAltitudeAlert(50.0f, 27000); + EXPECT_FALSE(manager.hasActiveAlerts()); + + manager.checkAltitudeAlert(100.00001f, 28000); + EXPECT_TRUE(manager.hasActiveAlerts()); } -TEST_F(AlertManagerTest, testGetStatusDescriptionNoAlerts) { - std::string desc = manager.getStatusDescription(); - EXPECT_EQ(desc, "系统状态：正常"); +// 特殊场景测试：多次设置阈值，验证最后一次生效 +TEST_F(AlertManagerTest, testSetAltitudeThresholdsMultipleCalls) { + StreamCapture capture; + + manager.setAltitudeThresholds(200.0f, 100.0f); + manager.setAltitudeThresholds(300.0f, 200.0f); + manager.setAltitudeThresholds(400.0f, 300.0f); + + // 验证最后一次设置生效 + manager.checkAltitudeAlert(350.0f, 29000); + EXPECT_FALSE(manager.hasActiveAlerts()); + + manager.checkAltitudeAlert(450.0f, 30000); + EXPECT_TRUE(manager.hasActiveAlerts()); } -TEST_F(AlertManagerTest, testGetStatusDescriptionWithAlerts) { - mock_timestamp = 1640995200; - manager.triggerSensorFailure(mock_timestamp); - std::string desc = manager.getStatusDescription(); - EXPECT_NE(desc.find("有1个活动预警"), std::string::npos); - EXPECT_NE(desc.find("传感器故障"), std::string::npos); +// 特殊场景测试：设置阈值后立即检查高度，验证阈值更新及时 +TEST_F(AlertManagerTest, testSetAltitudeThresholdsImmediateEffect) { + StreamCapture capture; + + // 当前高度50，默认阈值下正常 + manager.checkAltitudeAlert(50.0f, 31000); + EXPECT_FALSE(manager.hasActiveAlerts()); + + // 修改阈值为[30, 60] + manager.setAltitudeThresholds(60.0f, 30.0f); + + // 高度50仍在范围内 + manager.checkAltitudeAlert(50.0f, 32000); + EXPECT_FALSE(manager.hasActiveAlerts()); + + // 修改阈值为[40, 45] + manager.setAltitudeThresholds(45.0f, 40.0f); + + // 高度50超出上限 + manager.checkAltitudeAlert(50.0f, 33000); + EXPECT_TRUE(manager.hasActiveAlerts()); } -TEST_F(AlertManagerTest, testClearHistory) { - mock_timestamp = 1640995200; - manager.triggerSensorFailure(mock_timestamp); - manager.clearHistory(); - EXPECT_TRUE(manager.getAlertHistory(10).empty()); +// 特殊场景测试：设置阈值后，之前已解决的预警不应再次触发 +TEST_F(AlertManagerTest, testSetAltitudeThresholdsDoesNotReTriggerResolvedAlerts) { + StreamCapture capture; + + // 触发并解决预警 + manager.checkAltitudeAlert(150.0f, 34000); + manager.checkAltitudeAlert(50.0f, 35000); + EXPECT_FALSE(manager.hasActiveAlerts()); + + // 修改阈值 + manager.setAltitudeThresholds(200.0f, 0.0f); + + // 不应有活动预警 + EXPECT_FALSE(manager.hasActiveAlerts()); } -TEST_F(AlertManagerTest, testAddToHistoryLimit) { - mock_timestamp = 1640995200; - for (int i = 0; i < 100; ++i) { - manager.triggerSensorFailure(mock_timestamp + i); - } - auto history = manager.getAlertHistory(10); - EXPECT_EQ(history.size(), 10); +int main(int argc, char **argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } - -TEST_F(AlertManagerTest, testTriggerAlert) { - mock_timestamp = 1640995200; - manager.triggerAlert(AlertType::SENSOR_FAILURE, mock_timestamp, "Test alert"); - auto alerts = manager.getActiveAlerts(); - EXPECT_EQ(alerts.size(), 1); - EXPECT_EQ(alerts[0].description, "Test alert"); -} - -TEST_F(AlertManagerTest, testUpdateAlertStatusAcknowledged) { - mock_timestamp = 1640995200; - manager.triggerSensorFailure(mock_timestamp); - mock_timestamp = 1640995201; - manager.updateAlertStatus(AlertType::SENSOR_FAILURE, AlertStatus::ACKNOWLEDGED, mock_timestamp); - auto alerts = manager.getActiveAlerts(); - EXPECT_TRUE(alerts.empty()); -} - -TEST_F(AlertManagerTest, testUpdateAlertStatusResolved) { - mock_timestamp = 1640995200; - manager.triggerSensorFailure(mock_timestamp); - mock_timestamp = 1640995201; - manager.updateAlertStatus(AlertType::SENSOR_FAILURE, AlertStatus::RESOLVED, mock_timestamp); - auto alerts = manager.getActiveAlerts(); - EXPECT_TRUE(alerts.empty()); -} - -TEST_F(AlertManagerTest, testGetAlertTypeName) { - EXPECT_EQ(manager.getAlertTypeName(AlertType::ALTITUDE_UPPER), "高度上限预警"); - EXPECT_EQ(manager.getAlertTypeName(AlertType::NONE), "无"); - EXPECT_EQ(manager.getAlertTypeName(static_cast(99)), "未知预警"); -} - -TEST_F(AlertManagerTest, testGetAlertStatusName) { - EXPECT_EQ(manager.getAlertStatusName(AlertStatus::ACTIVE), "预警中"); - EXPECT_EQ(manager.getAlertStatusName(AlertStatus::INACTIVE), "未激活"); - EXPECT_EQ(manager.getAlertStatusName(static_cast(99)), "未知状态"); -} - -TEST_F(AlertManagerTest, testDestructorDoesNotCrash) { - // Verify destructor doesn't throw or crash - EXPECT_NO_FATAL_FAILURE({ - AlertManager* mgr = new AlertManager(); - delete mgr; - }); -} \ No newline at end of file