From 9204310e6bc5a9ea455de9bb4e53118a9c150b5b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=90=B4=E6=99=8B=E9=B9=8F?= Date: Mon, 11 Aug 2025 20:05:10 +0800 Subject: [PATCH] modify UT file directory MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 吴晋鹏 --- .../src/test/anr_manager_test.cpp | 513 ++++++++++++++++++ 1 file changed, 513 insertions(+) create mode 100644 service/event_handler/src/test/anr_manager_test.cpp diff --git a/service/event_handler/src/test/anr_manager_test.cpp b/service/event_handler/src/test/anr_manager_test.cpp new file mode 100644 index 0000000000..48afdc1bdd --- /dev/null +++ b/service/event_handler/src/test/anr_manager_test.cpp @@ -0,0 +1,513 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "anr_manager.h" +#include "dfx_hisysevent.h" +#include "input_event_handler.h" +#include "i_input_windows_manager.h" +#include "mmi_log.h" +#include "napi_constants.h" +#include "proto.h" +#include "timer_manager.h" +#include "window_manager.h" + +namespace OHOS { +namespace MMI { +namespace { +using namespace testing::ext; +const std::string PROGRAM_NAME { "uds_session_test" }; +constexpr int32_t MODULE_TYPE { 1 }; +constexpr int32_t UDS_FD { 1 }; +constexpr int32_t UDS_UID { 100 }; +constexpr int32_t UDS_PID { 100 }; +constexpr int64_t INPUT_UI_TIMEOUT_TIME { 5 * 1000000 }; +constexpr int32_t TIME_CONVERT_RATIO { 1000 }; +} // namespace + +class AnrManagerTest : public testing::Test { +public: + static void SetUpTestCase(void) {} + static void TearDownTestCase(void) {} +}; + +/** + * @tc.name: AnrManagerTest_MarkProcessed_001 + * @tc.desc: Features of the mark processed function + * @tc.type: FUNC + * @tc.require:SR000HQ0RR + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_MarkProcessed_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + UDSServer udsServer; + ANRManager anrMgr; + ASSERT_NO_FATAL_FAILURE(ANRMgr->Init(udsServer)); + int32_t pid = 123; + int32_t eventType = 1; + int32_t eventId = 456; + int64_t time = 123456789; + SessionPtr sess = std::shared_ptr(); + ANRMgr->TriggerANR(eventType, time, sess); + + ASSERT_NO_FATAL_FAILURE(ANRMgr->MarkProcessed(pid, eventType, eventId)); +} + +/** + * @tc.name: AnrManagerTest_MarkProcessed_003 + * @tc.desc: Features of the mark processed function + * @tc.type: FUNC + * @tc.require:SR000HQ0RR + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_MarkProcessed_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + UDSServer udsServer; + ANRManager anrMgr; + ASSERT_NO_FATAL_FAILURE(ANRMgr->Init(udsServer)); + int32_t pid = 123; + int32_t eventType = 1; + int32_t eventId = 456; + int64_t time = 123456789; + SessionPtr sess = std::shared_ptr(); + ANRMgr->TriggerANR(eventType, time, sess); + ASSERT_NO_FATAL_FAILURE(ANRMgr->MarkProcessed(pid, eventType, eventId)); + + ASSERT_NO_FATAL_FAILURE(ANRMgr->Init(udsServer)); + pid = 124; + eventType = 1; + eventId = 457; + time = 123456789; + ANRMgr->TriggerANR(eventType, time, sess); + ASSERT_NO_FATAL_FAILURE(ANRMgr->MarkProcessed(pid, eventType, eventId)); + + ASSERT_NO_FATAL_FAILURE(ANRMgr->Init(udsServer)); + pid = 124; + eventType = 1; + eventId = 457; + time = 1000; + ANRMgr->TriggerANR(eventType, time, sess); + ASSERT_NO_FATAL_FAILURE(ANRMgr->MarkProcessed(pid, eventType, eventId)); + + ASSERT_NO_FATAL_FAILURE(ANRMgr->Init(udsServer)); + pid = 124; + eventType = 1; + eventId = 457; + time = 1000; + ANRMgr->TriggerANR(eventType, time, sess); + ASSERT_NO_FATAL_FAILURE(ANRMgr->MarkProcessed(pid, eventType, eventId)); +} + +/** + * @tc.name: AnrManagerTest_RemoveTimers_001 + * @tc.desc: Features of the remove timers function + * @tc.type: FUNC + * @tc.require:SR000HQ0RR + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_RemoveTimers_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + UDSServer udsServer; + ASSERT_NO_FATAL_FAILURE(ANRMgr->Init(udsServer)); + SessionPtr sess; + ASSERT_NO_FATAL_FAILURE(ANRMgr->RemoveTimers(sess)); +} + +/** + * @tc.name: AnrManagerTest_RemoveTimersByType_001 + * @tc.desc: Remove timers by type abnormal + * @tc.type: FUNC + * @tc.require:SR000HQ0RR + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_RemoveTimersByType_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + UDSServer udsServer; + ASSERT_NO_FATAL_FAILURE(ANRMgr->Init(udsServer)); + SessionPtr session; + int32_t dispatchType = -1; + ASSERT_NO_FATAL_FAILURE(ANRMgr->RemoveTimersByType(session, dispatchType)); +} + +/** + * @tc.name: AnrManagerTest_RemoveTimersByType_002 + * @tc.desc: Remove timers by type abnormal + * @tc.type: FUNC + * @tc.require:SR000HQ0RR + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_RemoveTimersByType_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + UDSServer udsServer; + ASSERT_NO_FATAL_FAILURE(ANRMgr->Init(udsServer)); + SessionPtr session; + int32_t monitorType = 0; + ASSERT_NO_FATAL_FAILURE(ANRMgr->RemoveTimersByType(session, monitorType)); +} + +/** + * @tc.name: AnrManagerTest_RemoveTimersByType_003 + * @tc.desc: Remove timers by type normal + * @tc.type: FUNC + * @tc.require:SR000HQ0RR + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_RemoveTimersByType_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + UDSServer udsServer; + ASSERT_NO_FATAL_FAILURE(ANRMgr->Init(udsServer)); + SessionPtr session; + int32_t illegalType = 123; + ASSERT_NO_FATAL_FAILURE(ANRMgr->RemoveTimersByType(session, illegalType)); +} + +/** + * @tc.name: AnrManagerTest_SetANRNoticedPid_001 + * @tc.desc: Set noticed pid normal + * @tc.type: FUNC + * @tc.require:SR000HQ0RR + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_SetANRNoticedPid_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + UDSServer udsServer; + ASSERT_NO_FATAL_FAILURE(ANRMgr->Init(udsServer)); + int32_t pid = 1234; + int32_t ret = ANRMgr->SetANRNoticedPid(pid); + ASSERT_EQ(ret, RET_OK); +} + +/** + * @tc.name: AnrManagerTest_SetANRNoticedPid_002 + * @tc.desc: Set noticed pid abnormal + * @tc.type: FUNC + * @tc.require:SR000HQ0RR + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_SetANRNoticedPid_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + UDSServer udsServer; + ASSERT_NO_FATAL_FAILURE(ANRMgr->Init(udsServer)); + int32_t pid = -1; + int32_t ret = ANRMgr->SetANRNoticedPid(pid); + ASSERT_EQ(ret, RET_OK); +} + +/** + * @tc.name: AnrManagerTest_AddTimer_001 + * @tc.desc: Add timer function normal + * @tc.type: FUNC + * @tc.require:SR000HQ0RR + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_AddTimer_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + ANRManager anrMgr; + int32_t type = 1; + int32_t id = 1001; + int64_t currentTime = 123456789; + SessionPtr sess = std::shared_ptr(); + ASSERT_NO_FATAL_FAILURE(ANRMgr->AddTimer(type, id, currentTime, sess)); +} + +/** + * @tc.name: AnrManagerTest_AddTimer_002 + * @tc.desc: Add timer function abnormal + * @tc.type: FUNC + * @tc.require:SR000HQ0RR + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_AddTimer_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + ANRManager anrMgr; + int32_t type = -1; + int32_t id = -2; + int64_t currentTime = 123456789; + SessionPtr sess = std::shared_ptr(); + ASSERT_NO_FATAL_FAILURE(ANRMgr->AddTimer(type, id, currentTime, sess)); +} + +/** + * @tc.name: AnrManagerTest_TriggerANR_001 + * @tc.desc: Trigger function normal + * @tc.type: FUNC + * @tc.require:SR000HQ0RR + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_TriggerANR_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + int32_t type = 1; + int64_t time = 123456789; + SessionPtr sess = std::shared_ptr(); + bool result = ANRMgr->TriggerANR(type, time, sess); + EXPECT_FALSE(result); +} + +/** + * @tc.name: AnrManagerTest_MarkProcessed_002 + * @tc.desc: Cover the else branch of the if (pid_ != pid) + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_MarkProcessed_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + ANRManager anrMgr; + UDSServer udsServer; + int32_t pid = 10; + int32_t eventType = 1; + int32_t eventId = 100; + udsServer.pid_ = 20; + anrMgr.pid_ = 10; + anrMgr.udsServer_ = &udsServer; + ASSERT_EQ(anrMgr.MarkProcessed(pid, eventType, eventId), RET_ERR); +} + +/** + * @tc.name: AnrManagerTest_AddTimer_003 + * @tc.desc: Cover the else branch of the + *
if (sess->GetTokenType() != TokenType::TOKEN_HAP || sess->GetProgramName() == FOUNDATION) + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_AddTimer_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + ANRManager anrMgr; + int32_t type = ANR_MONITOR; + int32_t id = 1; + int64_t currentTime = 100; + std::string programName = "foundation"; + SessionPtr sess = std::make_shared(programName, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); + sess->SetTokenType(TokenType::TOKEN_NATIVE); + ASSERT_NO_FATAL_FAILURE(anrMgr.AddTimer(type, id, currentTime, sess)); + + sess->SetTokenType(TokenType::TOKEN_HAP); + ASSERT_NO_FATAL_FAILURE(anrMgr.AddTimer(type, id, currentTime, sess)); +} + +/** + * @tc.name: AnrManagerTest_AddTimer_004 + * @tc.desc:Cover the else branch of the if (anrTimerCount_ >= MAX_TIMER_COUNT) + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_AddTimer_004, TestSize.Level1) +{ + CALL_TEST_DEBUG; + ANRManager anrMgr; + int32_t type = ANR_MONITOR; + int32_t id = 1; + int64_t currentTime = 100; + SessionPtr sess = std::make_shared(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); + sess->SetTokenType(TokenType::TOKEN_HAP); + anrMgr.anrTimerCount_ = 51; + ASSERT_NO_FATAL_FAILURE(anrMgr.AddTimer(type, id, currentTime, sess)); + + anrMgr.anrTimerCount_ = 49; + ASSERT_NO_FATAL_FAILURE(anrMgr.AddTimer(type, id, currentTime, sess)); +} + +/** + * @tc.name: AnrManagerTest_RemoveTimers_002 + * @tc.desc: Cover the RemoveTimers function branch + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_RemoveTimers_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + ANRManager anrMgr; + SessionPtr sess = std::make_shared(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); + std::vector events { { 0, 0, -1 }, { 1, 1, 10 } }; + sess->events_[ANR_DISPATCH] = events; + sess->events_[ANR_MONITOR] = events; + ASSERT_NO_FATAL_FAILURE(anrMgr.RemoveTimers(sess)); +} + +/** + * @tc.name: AnrManagerTest_RemoveTimersByType_004 + * @tc.desc: Cover the RemoveTimersByType function branch + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_RemoveTimersByType_004, TestSize.Level1) +{ + CALL_TEST_DEBUG; + ANRManager anrMgr; + SessionPtr sess = std::make_shared(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); + int32_t type = 5; + ASSERT_NO_FATAL_FAILURE(anrMgr.RemoveTimersByType(sess, type)); + + type = ANR_DISPATCH; + std::vector events { { 0, 0, -1 }, { 1, 1, 10 } }; + sess->events_[ANR_MONITOR] = events; + ASSERT_NO_FATAL_FAILURE(anrMgr.RemoveTimersByType(sess, type)); +} + +/** + * @tc.name: AnrManagerTest_TriggerANR_002 + * @tc.desc: Cover the TriggerANR function branch + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_TriggerANR_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + ANRManager anrMgr; + int32_t type = ANR_MONITOR; + int64_t time = 1; + std::string programName = "foundation"; + SessionPtr sess = std::make_shared(programName, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); + UDSServer udsServer; + anrMgr.udsServer_ = &udsServer; + sess->SetTokenType(TokenType::TOKEN_NATIVE); + EXPECT_FALSE(anrMgr.TriggerANR(type, time, sess)); + + sess->SetTokenType(TokenType::TOKEN_HAP); + EXPECT_FALSE(anrMgr.TriggerANR(type, time, sess)); + + bool status = true; + SessionPtr session = std::make_shared(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); + session->SetTokenType(TokenType::TOKEN_HAP); + session->SetAnrStatus(type, status); + EXPECT_TRUE(anrMgr.TriggerANR(type, time, session)); + + type = ANR_DISPATCH; + status = false; + EXPECT_FALSE(anrMgr.TriggerANR(type, time, session)); +} + +/** + * @tc.name: AnrManagerTest_OnSessionLost + * @tc.desc: Cover the OnSessionLost function branch + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AnrManagerTest, AnrManagerTest_OnSessionLost, TestSize.Level1) +{ + CALL_TEST_DEBUG; + ANRManager anrMgr; + SessionPtr sess = std::make_shared(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); + anrMgr.anrNoticedPid_ = UDS_PID; + ASSERT_NO_FATAL_FAILURE(anrMgr.OnSessionLost(sess)); + + anrMgr.anrNoticedPid_ = 200; + ASSERT_NO_FATAL_FAILURE(anrMgr.OnSessionLost(sess)); +} + +/** +* @tc.name : AnrManagerTest_HandleAnrState_001 +* @tc.desc : Test without timeout event. +* @tc.type: FUNC +* @tc.require: +*/ +HWTEST_F(AnrManagerTest, AnrManagerTest_HandleAnrState_001, TestSize.Level1) +{ + SessionPtr sess = std::make_shared(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); + int32_t type = ANR_DISPATCH; + int64_t currentTime = 1000; + + ANRMgr->HandleAnrState(sess, type, currentTime); + + EXPECT_TRUE(sess->GetEventsByType(type).empty()); +} + +/** +* @tc.name : AnrManagerTest_HandleAnrState_002 +* @tc.desc : Test when there are multiple timeout event. +* @tc.type: FUNC +* @tc.require: +*/ +HWTEST_F(AnrManagerTest, AnrManagerTest_HandleAnrState_002, TestSize.Level1) +{ + SessionPtr sess = std::make_shared(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); + int32_t type = ANR_DISPATCH; + int64_t currentTime = 10000; + + std::vector event { {1, 1000, 1}, {2, 2000, 2}, {3, 3000, 3} }; + sess->events_[ANR_DISPATCH] = event; + + ANRMgr->HandleAnrState(sess, type, currentTime); + + auto events = sess->GetEventsByType(type); + EXPECT_EQ(events.size(), 1); + EXPECT_EQ(events[0].id, 3); +} + +/** +* @tc.name : AnrManagerTest_HandleAnrState_003 +* @tc.desc : Test when there is only one timeout event. +* @tc.type: FUNC +* @tc.require: +*/ +HWTEST_F(AnrManagerTest, AnrManagerTest_HandleAnrState_003, TestSize.Level1) +{ + SessionPtr sess = std::make_shared(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); + int32_t type = ANR_DISPATCH; + int64_t currentTime = 10000; + std::vector event { {1, 1000, 1} }; + sess->events_[ANR_DISPATCH] = event; + ANRMgr->HandleAnrState(sess, type, currentTime); + + auto events = sess->GetEventsByType(type); + EXPECT_EQ(events.size(), 1); + EXPECT_EQ(events[0].id, 1); +} + +/** +* @tc.name : AnrManagerTest_HandleAnrState_004 +* @tc.desc : Test when the event exists but there are no timeout events. +* @tc.type: FUNC +* @tc.require: +*/ +HWTEST_F(AnrManagerTest, AnrManagerTest_HandleAnrState_004, TestSize.Level1) +{ + SessionPtr sess = std::make_shared(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); + int32_t type = ANR_DISPATCH; + int64_t currentTime = 1500; + std::vector events { {1, 1000, 1} }; + sess->events_[type] = events; + ANRMgr->HandleAnrState(sess, type, currentTime); + auto resultEvents = sess->GetEventsByType(type); + EXPECT_EQ(resultEvents.size(), 1); + EXPECT_EQ(resultEvents[0].id, 1); +} + +/** +* @tc.name : AnrManagerTest_HandleAnrState_005 +* @tc.desc : Test multiple events with partial timeouts. +* @tc.type: FUNC +* @tc.require: +*/ +HWTEST_F(AnrManagerTest, AnrManagerTest_HandleAnrState_005, TestSize.Level1) +{ + SessionPtr sess = std::make_shared(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); + int32_t type = ANR_DISPATCH; + int64_t currentTime = 10000; + const int64_t timeoutThreshold = INPUT_UI_TIMEOUT_TIME / TIME_CONVERT_RATIO; + std::vector events { + {1, currentTime - timeoutThreshold - 100, 1}, + {2, currentTime - timeoutThreshold + 100, 2}, + {3, currentTime - timeoutThreshold - 200, 3} }; + sess->events_[type] = events; + ANRMgr->HandleAnrState(sess, type, currentTime); + auto resultEvents = sess->GetEventsByType(type); + ASSERT_EQ(resultEvents.size(), 0); +} +} // namespace MMI +} // namespace OHOS \ No newline at end of file -- Gitee