Star591
735
代码
代码
Issues44
Pull Requests156
Actions
项目讨论
Wiki
分析
Star591
735
已合并
test: 重构 TSD 单元测试并提升测试有效性(#800) #4085
DevLeev创建于 8月7日
test: 重构 TSD 单元测试并提升测试有效性(#800) #4085
已合并
DevLeev创建于 8月7日
从LiWei79/runtimeut_split合入到cann/runtimemaster
共 66 个文件变更+8537-7486
Rtests/ut/tsd/tsdclient/test/capability_manager_utest.cpp→tests/ut/tsd/basic_component/capability/capability_manager_utest.cpp+156-100
@@ -30,18 +30,78 @@ static const int deviceId = 0;
30 30 
31struct StubDeviceComm : public DeviceComm {31struct StubDeviceComm : public DeviceComm {
32 explicit StubDeviceComm(uint32_t devId) : DeviceComm(devId, DeviceCommType::HDC) {}32 explicit StubDeviceComm(uint32_t devId) : DeviceComm(devId, DeviceCommType::HDC) {}
33+ TSD_StatusT CommInit(const uint32_t, const bool) override { return TSD_OK; }
34+ TSD_StatusT CommCreateSession(uint32_t& sessionId) override
35+ {
36+ sessionId = 1U;
37+ return TSD_OK;
38+ }
39+ void CommDestroy() override {}
40+ TSD_StatusT CommRecvData(const uint32_t, const bool, const uint32_t timeout) override
41+ {
42+ ++recvCount;
43+ receivedTimeout = timeout;
44+ return recvResult;
45+ }
46+ TSD_StatusT CommGetConctStatus(int32_t& status) override
47+ {
48+ status = 0;
49+ return TSD_OK;
50+ }
51+ TSD_StatusT CommSendMsg(const uint32_t, const HDCMessage& msg) override
52+ {
53+ ++sendCount;
54+ sentType = msg.type();
55+ return sendResult;
56+ }
57+ TSD_StatusT CommGetVersionVerify(const uint32_t, std::shared_ptr<VersionVerify>& inspector) override
58+ {
59+ inspector = std::make_shared<VersionVerify>();
60+ return TSD_OK;
61+ }
62+ TSD_StatusT recvResult = TSD_OK;
63+ TSD_StatusT sendResult = TSD_OK;
64+ uint32_t recvCount = 0U;
65+ uint32_t sendCount = 0U;
66+ uint32_t receivedTimeout = 0U;
67+ HDCMessage::MsgType sentType = HDCMessage::INIT;
33};68};
69+ 
70+std::shared_ptr<StubDeviceComm> InjectStubComm(ProcessModeManager& manager, uint32_t devId)
71+{
72+ auto stub = std::make_shared<StubDeviceComm>(devId);
73+ manager.commAgent_.devCommClient_ = stub;
74+ return stub;
75+}
34} // namespace76} // namespace
35 77 
36class CapabilityManagerTest : public testing::Test {78class CapabilityManagerTest : public testing::Test {
37protected:79protected:
38- virtual void SetUp() { cout << "Before CapabilityManagerTest" << endl; }80+ virtual void SetUp()
81+ {
82+ cout << "Before CapabilityManagerTest" << endl;
83+ savedDeviceCommMap_ = *DeviceComm::DeviceCommMap();
84+ savedCreatorMap_ = *DeviceComm::CreatorMap();
85+ DeviceComm::DeviceCommMap()->clear();
86+ }
39 virtual void TearDown()87 virtual void TearDown()
40 {88 {
41 cout << "After CapabilityManagerTest" << endl;89 cout << "After CapabilityManagerTest" << endl;
42- GlobalMockObject::verify();90+ try {
91+ GlobalMockObject::verify();
92+ } catch (...) {
93+ GlobalMockObject::reset();
94+ *DeviceComm::DeviceCommMap() = savedDeviceCommMap_;
95+ *DeviceComm::CreatorMap() = savedCreatorMap_;
96+ throw;
97+ }
43 GlobalMockObject::reset();98 GlobalMockObject::reset();
99+ *DeviceComm::DeviceCommMap() = savedDeviceCommMap_;
100+ *DeviceComm::CreatorMap() = savedCreatorMap_;
44 }101 }
102+ 
103+ std::map<uint64_t, std::shared_ptr<DeviceComm>> savedDeviceCommMap_;
104+ std::unordered_map<uint32_t, DeviceComm::CreatorFunc> savedCreatorMap_;
45};105};
46 106 
47TEST_F(CapabilityManagerTest, IsOkToGetCapability_Level_True)107TEST_F(CapabilityManagerTest, IsOkToGetCapability_Level_True)
@@ -108,91 +168,6 @@ TEST_F(CapabilityManagerTest, IsOkToGetCapability_InvalidType_False)
108 EXPECT_FALSE(pm.capabilityMgr_.IsOkToGetCapability(TSD_CAPABILITY_BUT));168 EXPECT_FALSE(pm.capabilityMgr_.IsOkToGetCapability(TSD_CAPABILITY_BUT));
109}169}
110 170 
111-TEST_F(CapabilityManagerTest, BuildCapability_PidQos)
112-{
113- MessageContext ctx{};
114- ctx.logicDeviceId = static_cast<uint32_t>(deviceId);
115- ctx.capabilityType = TSD_CAPABILITY_PIDQOS;
116- HDCMessage msg;
117- EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);
118- EXPECT_EQ(msg.type(), HDCMessage::TSD_GET_PID_QOS);
119- EXPECT_EQ(msg.device_id(), deviceId % PER_OS_CHIP_NUM);
120- EXPECT_EQ(msg.real_device_id(), static_cast<uint32_t>(deviceId));
121-}
122- 
123-TEST_F(CapabilityManagerTest, BuildCapability_Level)
124-{
125- MessageContext ctx{};
126- ctx.logicDeviceId = static_cast<uint32_t>(deviceId);
127- ctx.capabilityType = TSD_CAPABILITY_LEVEL;
128- HDCMessage msg;
129- EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);
130- EXPECT_EQ(msg.type(), HDCMessage::TSD_GET_SUPPORT_CAPABILITY_LEVEL);
131- EXPECT_EQ(msg.device_id(), deviceId % PER_OS_CHIP_NUM);
132- EXPECT_EQ(msg.real_device_id(), static_cast<uint32_t>(deviceId));
133-}
134- 
135-TEST_F(CapabilityManagerTest, BuildCapability_BuiltinUdf)
136-{
137- MessageContext ctx{};
138- ctx.logicDeviceId = static_cast<uint32_t>(deviceId);
139- ctx.capabilityType = TSD_CAPABILITY_BUILTIN_UDF;
140- HDCMessage msg;
141- EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);
142- EXPECT_EQ(msg.type(), HDCMessage::TSD_GET_SUPPORT_CAPABILITY_LEVEL);
143-}
144- 
145-TEST_F(CapabilityManagerTest, BuildCapability_MultipleHccp)
146-{
147- MessageContext ctx{};
148- ctx.logicDeviceId = static_cast<uint32_t>(deviceId);
149- ctx.capabilityType = TSD_CAPABILITY_MUTIPLE_HCCP;
150- HDCMessage msg;
151- EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);
152- EXPECT_EQ(msg.type(), HDCMessage::TSD_GET_SUPPORT_CAPABILITY_LEVEL);
153-}
154- 
155-TEST_F(CapabilityManagerTest, BuildCapability_OmInnerDec)
156-{
157- MessageContext ctx{};
158- ctx.logicDeviceId = static_cast<uint32_t>(deviceId);
159- ctx.capabilityType = TSD_CAPABILITY_OM_INNER_DEC;
160- HDCMessage msg;
161- EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);
162- EXPECT_EQ(msg.type(), HDCMessage::TSD_SUPPORT_OM_INNER_DEC);
163-}
164- 
165-TEST_F(CapabilityManagerTest, BuildCapability_Adprof)
166-{
167- MessageContext ctx{};
168- ctx.logicDeviceId = static_cast<uint32_t>(deviceId);
169- ctx.capabilityType = TSD_CAPABILITY_ADPROF;
170- HDCMessage msg;
171- EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);
172- EXPECT_EQ(msg.type(), HDCMessage::TSD_GET_SUPPORT_ADPROF);
173-}
174- 
175-TEST_F(CapabilityManagerTest, BuildCapability_InvalidType)
176-{
177- MessageContext ctx{};
178- ctx.logicDeviceId = static_cast<uint32_t>(deviceId);
179- ctx.capabilityType = TSD_CAPABILITY_BUT;
180- HDCMessage msg;
181- EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);
182- EXPECT_EQ(msg.type(), HDCMessage::INIT);
183-}
184- 
185-TEST_F(CapabilityManagerTest, BuildCapability_ProcSignPid)
186-{
187- MessageContext ctx{};
188- ctx.logicDeviceId = static_cast<uint32_t>(deviceId);
189- ctx.capabilityType = TSD_CAPABILITY_LEVEL;
190- ctx.procSign.tgid = 4321;
191- HDCMessage msg;
192- EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);
193- EXPECT_EQ(msg.proc_sign_pid().proc_pid(), 4321U);
194-}
195- 
196TEST_F(CapabilityManagerTest, ConstructCapabilityMsg_SetsFields)171TEST_F(CapabilityManagerTest, ConstructCapabilityMsg_SetsFields)
197{172{
198 ProcessModeManager pm(deviceId, 0);173 ProcessModeManager pm(deviceId, 0);
@@ -348,7 +323,7 @@ TEST_F(CapabilityManagerTest, SaveCapabilityResult_OmInnerDec_NotSupported)
348{323{
349 ProcessModeManager pm(deviceId, 0);324 ProcessModeManager pm(deviceId, 0);
350 pm.capabilityMgr_.supportOmInnerDec_ = false;325 pm.capabilityMgr_.supportOmInnerDec_ = false;
351- uint64_t result = 0;326+ uint64_t result = 0xA5A5UL;
352 uint64_t ptr = reinterpret_cast<uint64_t>(&result);327 uint64_t ptr = reinterpret_cast<uint64_t>(&result);
353 EXPECT_EQ(pm.capabilityMgr_.SaveCapabilityResult(TSD_CAPABILITY_OM_INNER_DEC, ptr), TSD_OK);328 EXPECT_EQ(pm.capabilityMgr_.SaveCapabilityResult(TSD_CAPABILITY_OM_INNER_DEC, ptr), TSD_OK);
354 EXPECT_EQ(result, 0UL);329 EXPECT_EQ(result, 0UL);
@@ -392,7 +367,7 @@ TEST_F(CapabilityManagerTest, SaveCapabilityResult_InvalidType)
392 EXPECT_EQ(pm.capabilityMgr_.SaveCapabilityResult(TSD_CAPABILITY_BUT, ptr), TSD_CLT_OPEN_FAILED);367 EXPECT_EQ(pm.capabilityMgr_.SaveCapabilityResult(TSD_CAPABILITY_BUT, ptr), TSD_CLT_OPEN_FAILED);
393}368}
394 369 
395-TEST_F(CapabilityManagerTest, SaveCapabilityResult_DriverVersion_Fail)370+TEST_F(CapabilityManagerTest, SaveCapabilityResult_DriverVersion_ReturnsLogicError)
396{371{
397 ProcessModeManager pm(deviceId, 0);372 ProcessModeManager pm(deviceId, 0);
398 uint64_t result = 0;373 uint64_t result = 0;
@@ -409,7 +384,8 @@ TEST_F(CapabilityManagerTest, WaitCapabilityRsp_InvalidType_DefaultBehavior)
409 uint64_t ptr = reinterpret_cast<uint64_t>(&result);384 uint64_t ptr = reinterpret_cast<uint64_t>(&result);
410 // Unknown type uses timeout=0, ignoreFail=false.385 // Unknown type uses timeout=0, ignoreFail=false.
411 MOCKER_CPP(&CapabilityManager::WaitRspForCapability)386 MOCKER_CPP(&CapabilityManager::WaitRspForCapability)
412- .stubs()387+ .expects(exactly(1))
388+ .with(eq(0U), eq(false))
413 .will(returnValue(static_cast<uint32_t>(TSD_CLT_OPEN_FAILED)));389 .will(returnValue(static_cast<uint32_t>(TSD_CLT_OPEN_FAILED)));
414 EXPECT_EQ(pm.capabilityMgr_.WaitCapabilityRsp(TSD_CAPABILITY_BUT, ptr), TSD_CLT_OPEN_FAILED);390 EXPECT_EQ(pm.capabilityMgr_.WaitCapabilityRsp(TSD_CAPABILITY_BUT, ptr), TSD_CLT_OPEN_FAILED);
415 GlobalMockObject::verify();391 GlobalMockObject::verify();
@@ -426,7 +402,7 @@ TEST_F(CapabilityManagerTest, UpdateStateFromMsg_CapabilityLevelRsp)
426 EXPECT_EQ(pm.capabilityMgr_.tsdSupportLevel_, 7U);402 EXPECT_EQ(pm.capabilityMgr_.tsdSupportLevel_, 7U);
427}403}
428 404 
429-TEST_F(CapabilityManagerTest, UpdateStateFromMsg_CapabilityLevelRsp_RspCodeFail)405+TEST_F(CapabilityManagerTest, UpdateStateFromMsg_LevelResponseError_PreservesCachedLevel)
430{406{
431 ProcessModeManager pm(deviceId, 0);407 ProcessModeManager pm(deviceId, 0);
432 HDCMessage msg;408 HDCMessage msg;
@@ -448,7 +424,7 @@ TEST_F(CapabilityManagerTest, UpdateStateFromMsg_AdprofRsp)
448 EXPECT_TRUE(pm.capabilityMgr_.adprofSupport_);424 EXPECT_TRUE(pm.capabilityMgr_.adprofSupport_);
449}425}
450 426 
451-TEST_F(CapabilityManagerTest, UpdateStateFromMsg_OmInnerDecRsp_Success)427+TEST_F(CapabilityManagerTest, UpdateStateFromMsg_OmResponseOk_MarksSupported)
452{428{
453 ProcessModeManager pm(deviceId, 0);429 ProcessModeManager pm(deviceId, 0);
454 HDCMessage msg;430 HDCMessage msg;
@@ -458,7 +434,7 @@ TEST_F(CapabilityManagerTest, UpdateStateFromMsg_OmInnerDecRsp_Success)
458 EXPECT_TRUE(pm.capabilityMgr_.supportOmInnerDec_);434 EXPECT_TRUE(pm.capabilityMgr_.supportOmInnerDec_);
459}435}
460 436 
461-TEST_F(CapabilityManagerTest, UpdateStateFromMsg_OmInnerDecRsp_Fail)437+TEST_F(CapabilityManagerTest, UpdateStateFromMsg_OmResponseError_MarksUnsupported)
462{438{
463 ProcessModeManager pm(deviceId, 0);439 ProcessModeManager pm(deviceId, 0);
464 HDCMessage msg;440 HDCMessage msg;
@@ -534,7 +510,7 @@ TEST_F(CapabilityManagerTest, HandlePidQosRsp_NegativePidQos)
534TEST_F(CapabilityManagerTest, WaitCapabilityRsp_OmInnerDec_TimeoutReturnsOk)510TEST_F(CapabilityManagerTest, WaitCapabilityRsp_OmInnerDec_TimeoutReturnsOk)
535{511{
536 ProcessModeManager pm(deviceId, 0);512 ProcessModeManager pm(deviceId, 0);
537- uint64_t result = 0;513+ uint64_t result = 0xA5A5UL;
538 uint64_t ptr = reinterpret_cast<uint64_t>(&result);514 uint64_t ptr = reinterpret_cast<uint64_t>(&result);
539 MOCKER_CPP(&CapabilityManager::WaitRspForCapability).stubs().will(returnValue(static_cast<uint32_t>(1U)));515 MOCKER_CPP(&CapabilityManager::WaitRspForCapability).stubs().will(returnValue(static_cast<uint32_t>(1U)));
540 EXPECT_EQ(pm.capabilityMgr_.WaitCapabilityRsp(TSD_CAPABILITY_OM_INNER_DEC, ptr), TSD_OK);516 EXPECT_EQ(pm.capabilityMgr_.WaitCapabilityRsp(TSD_CAPABILITY_OM_INNER_DEC, ptr), TSD_OK);
@@ -552,7 +528,7 @@ TEST_F(CapabilityManagerTest, WaitCapabilityRsp_Level_TimeoutReturnsOk)
552 GlobalMockObject::verify();528 GlobalMockObject::verify();
553}529}
554 530 
555-TEST_F(CapabilityManagerTest, WaitCapabilityRsp_Success)531+TEST_F(CapabilityManagerTest, WaitCapabilityRsp_PidQosResponse_WritesResult)
556{532{
557 ProcessModeManager pm(deviceId, 0);533 ProcessModeManager pm(deviceId, 0);
558 uint64_t result = 0;534 uint64_t result = 0;
@@ -564,18 +540,22 @@ TEST_F(CapabilityManagerTest, WaitCapabilityRsp_Success)
564 GlobalMockObject::verify();540 GlobalMockObject::verify();
565}541}
566 542 
567-TEST_F(CapabilityManagerTest, CapabilityGet_NullPtr_Fail)543+TEST_F(CapabilityManagerTest, CapabilityGet_NullPtr_ReturnsOpenFailed)
568{544{
569 ProcessModeManager pm(deviceId, 0);545 ProcessModeManager pm(deviceId, 0);
570 EXPECT_EQ(pm.capabilityMgr_.CapabilityGet(TSD_CAPABILITY_LEVEL, 0UL), TSD_CLT_OPEN_FAILED);546 EXPECT_EQ(pm.capabilityMgr_.CapabilityGet(TSD_CAPABILITY_LEVEL, 0UL), TSD_CLT_OPEN_FAILED);
571}547}
572 548 
573-TEST_F(CapabilityManagerTest, CapabilityGet_PidQos_NotInit_ReturnsOk)549+TEST_F(CapabilityManagerTest, CapabilityGet_PidQosClientUninitialized_CurrentContractReturnsOkWithoutCommunication)
574{550{
575 ProcessModeManager pm(deviceId, 0);551 ProcessModeManager pm(deviceId, 0);
576- uint64_t result = 0;552+ uint64_t result = 0xA5A5UL;
577- uint64_t ptr = reinterpret_cast<uint64_t>(&result);553+ const uint64_t ptr = reinterpret_cast<uint64_t>(&result);
554+ MOCKER_CPP(&DeviceCommAgent::SendMsg).expects(never());
555+ MOCKER_CPP(&DeviceCommAgent::RecvData).expects(never());
556+ 
578 EXPECT_EQ(pm.capabilityMgr_.CapabilityGet(TSD_CAPABILITY_PIDQOS, ptr), TSD_OK);557 EXPECT_EQ(pm.capabilityMgr_.CapabilityGet(TSD_CAPABILITY_PIDQOS, ptr), TSD_OK);
558+ EXPECT_EQ(result, 0xA5A5UL);
579}559}
580 560 
581TEST_F(CapabilityManagerTest, CapabilityGet_Level_UseStored_ReturnsOk)561TEST_F(CapabilityManagerTest, CapabilityGet_Level_UseStored_ReturnsOk)
@@ -588,7 +568,7 @@ TEST_F(CapabilityManagerTest, CapabilityGet_Level_UseStored_ReturnsOk)
588 EXPECT_EQ(result, 1U);568 EXPECT_EQ(result, 1U);
589}569}
590 570 
591-TEST_F(CapabilityManagerTest, CapabilityGet_NotOkToGet_Fail)571+TEST_F(CapabilityManagerTest, CapabilityGet_PidQosWithoutStartCp_ReturnsOpenFailed)
592{572{
593 ProcessModeManager pm(deviceId, 0);573 ProcessModeManager pm(deviceId, 0);
594 pm.commAgent_.devCommClient_ = DeviceComm::GetInstance(deviceId, DeviceCommType::HDC);574 pm.commAgent_.devCommClient_ = DeviceComm::GetInstance(deviceId, DeviceCommType::HDC);
@@ -597,3 +577,79 @@ TEST_F(CapabilityManagerTest, CapabilityGet_NotOkToGet_Fail)
597 uint64_t ptr = reinterpret_cast<uint64_t>(&result);577 uint64_t ptr = reinterpret_cast<uint64_t>(&result);
598 EXPECT_EQ(pm.capabilityMgr_.CapabilityGet(TSD_CAPABILITY_PIDQOS, ptr), TSD_CLT_OPEN_FAILED);578 EXPECT_EQ(pm.capabilityMgr_.CapabilityGet(TSD_CAPABILITY_PIDQOS, ptr), TSD_CLT_OPEN_FAILED);
599}579}
580+ 
581+TEST_F(CapabilityManagerTest, IsSupportCommonInterface_EmptyCache_ReceivesZeroBitmap)
582+{
583+ ProcessModeManager processModeManager(deviceId, 0);
584+ auto comm = InjectStubComm(processModeManager, deviceId);
585+ 
586+ EXPECT_FALSE(processModeManager.capabilityMgr_.IsSupportCommonInterface(TSD_SUPPORT_HS_AISERVER_FEATURE_BIT));
587+ EXPECT_EQ(comm->sendCount, 1U);
588+ EXPECT_EQ(comm->sentType, HDCMessage::TSD_GET_SUPPORT_CAPABILITY_LEVEL);
589+ EXPECT_EQ(comm->recvCount, 1U);
590+ EXPECT_EQ(comm->receivedTimeout, 10000U);
591+}
592+ 
593+TEST_F(CapabilityManagerTest, IsSupportCommonInterface_CachedBitSet_SkipsCommunication)
594+{
595+ ProcessModeManager processModeManager(deviceId, 0);
596+ auto comm = InjectStubComm(processModeManager, deviceId);
597+ processModeManager.capabilityMgr_.tsdSupportLevel_ = 1U << TSD_SUPPORT_HS_AISERVER_FEATURE_BIT;
598+ 
599+ EXPECT_TRUE(processModeManager.capabilityMgr_.IsSupportCommonInterface(TSD_SUPPORT_HS_AISERVER_FEATURE_BIT));
600+ EXPECT_EQ(comm->sendCount, 0U);
601+ EXPECT_EQ(comm->recvCount, 0U);
602+}
603+ 
604+TEST_F(CapabilityManagerTest, IsSupportCommonInterface_ReceiveFails_ReturnsFalse)
605+{
606+ ProcessModeManager processModeManager(deviceId, 0);
607+ auto comm = InjectStubComm(processModeManager, deviceId);
608+ comm->recvResult = TSD_HDC_RECV_MSG_ERROR;
609+ 
610+ EXPECT_FALSE(processModeManager.capabilityMgr_.IsSupportCommonInterface(TSD_SUPPORT_HS_AISERVER_FEATURE_BIT));
611+ EXPECT_EQ(comm->sendCount, 1U);
612+ EXPECT_EQ(comm->recvCount, 1U);
613+}
614+ 
615+TEST_F(CapabilityManagerTest, IsSupportCommonSink_EmptyHostPathAndInterfaceUnsupported_ReturnsFalse)
616+{
617+ ProcessModeManager processModeManager(deviceId, 0);
618+ std::string emptyPath = "";
619+ MOCKER(tsd::GetHostSoPath).stubs().will(returnValue(emptyPath));
620+ MOCKER_CPP(&CapabilityManager::IsSupportCommonInterface).stubs().will(returnValue(false));
621+ 
622+ EXPECT_FALSE(processModeManager.capabilityMgr_.IsSupportCommonSink());
623+}
624+ 
625+TEST_F(CapabilityManagerTest, IsSupportCommonSink_No_With_hostSoPathInvalid)
626+{
627+ ProcessModeManager processModeManager(deviceId, 0);
628+ std::string hostSoPath = "/usr/local/ascend/driver/";
629+ MOCKER(tsd::GetHostSoPath).stubs().will(returnValue(hostSoPath));
630+ MOCKER(CheckRealPath).stubs().will(returnValue(false));
631+ MOCKER_CPP(&CapabilityManager::IsSupportCommonInterface).stubs().will(returnValue(false));
632+ 
633+ EXPECT_FALSE(processModeManager.capabilityMgr_.IsSupportCommonSink());
634+}
635+ 
636+TEST_F(CapabilityManagerTest, IsSupportCommonSink_Yes_With_hostSoPathValid)
637+{
638+ ProcessModeManager processModeManager(deviceId, 0);
639+ std::string hostSoPath = "/usr/local/ascend/driver/";
640+ MOCKER(tsd::GetHostSoPath).stubs().will(returnValue(hostSoPath));
641+ MOCKER(CheckRealPath).stubs().will(returnValue(true));
642+ MOCKER_CPP(&CapabilityManager::IsSupportCommonInterface).stubs().will(returnValue(false));
643+ 
644+ EXPECT_TRUE(processModeManager.capabilityMgr_.IsSupportCommonSink());
645+}
646+ 
647+TEST_F(CapabilityManagerTest, IsSupportCommonSink_EmptyHostPathAndInterfaceSupported_ReturnsTrue)
648+{
649+ ProcessModeManager processModeManager(deviceId, 0);
650+ std::string emptyPath = "";
651+ MOCKER(tsd::GetHostSoPath).stubs().will(returnValue(emptyPath));
652+ MOCKER_CPP(&CapabilityManager::IsSupportCommonInterface).stubs().will(returnValue(true));
653+ 
654+ EXPECT_TRUE(processModeManager.capabilityMgr_.IsSupportCommonSink());
655+}
Atests/ut/tsd/basic_component/device_comm/device_comm_agent_utest.cpp+258-0
@@ -0,0 +1,258 @@
1+/**
2+ * Copyright (c) 2026 Huawei Technologies Co., Ltd.
3+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4+ * CANN Open Software License Agreement Version 2.0 (the "License").
5+ * Please refer to the License for details. You may not use this file except in compliance with the License.
6+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8+ * See LICENSE in the root of the software repository for the full text of the License.
9+ */
10+ 
11+#include "gtest/gtest.h"
12+#include "mockcpp/mockcpp.hpp"
13+#define private public
14+#define protected public
15+#include "device_comm_agent.h"
16+#undef protected
17+#undef private
18+#include "error_code.h"
19+#include "tsd_util_func.h"
20+ 
21+using namespace tsd;
22+ 
23+namespace {
24+class ConfigurableDeviceComm final : public DeviceComm {
25+public:
26+ explicit ConfigurableDeviceComm(uint32_t deviceId) : DeviceComm(deviceId, DeviceCommType::HDC) {}
27+ 
28+ TSD_StatusT CommInit(uint32_t clientPid, bool isAdcEnv) override
29+ {
30+ ++initCount;
31+ receivedPid = clientPid;
32+ receivedAdcEnv = isAdcEnv;
33+ return initResult;
34+ }
35+ 
36+ TSD_StatusT CommCreateSession(uint32_t& sessionId) override
37+ {
38+ ++createSessionCount;
39+ sessionId = configuredSessionId;
40+ return createSessionResult;
41+ }
42+ 
43+ void CommDestroy() override { ++destroyCount; }
44+ 
45+ TSD_StatusT CommRecvData(uint32_t sessionId, bool ignoreRecvErr, uint32_t timeout) override
46+ {
47+ ++recvCount;
48+ receivedSessionId = sessionId;
49+ receivedIgnoreRecvErr = ignoreRecvErr;
50+ receivedTimeout = timeout;
51+ return recvResult;
52+ }
53+ 
54+ TSD_StatusT CommGetConctStatus(int32_t& sessStat) override
55+ {
56+ ++statusCount;
57+ sessStat = configuredStatus;
58+ return statusResult;
59+ }
60+ 
61+ TSD_StatusT CommSendMsg(uint32_t sessionId, const HDCMessage&) override
62+ {
63+ ++sendCount;
64+ receivedSessionId = sessionId;
65+ return sendResult;
66+ }
67+ 
68+ TSD_StatusT CommGetVersionVerify(uint32_t sessionId, std::shared_ptr<VersionVerify>& inspector) override
69+ {
70+ ++versionCount;
71+ receivedSessionId = sessionId;
72+ inspector = configuredInspector;
73+ return versionResult;
74+ }
75+ 
76+ TSD_StatusT initResult = TSD_OK;
77+ TSD_StatusT createSessionResult = TSD_OK;
78+ TSD_StatusT recvResult = TSD_OK;
79+ TSD_StatusT statusResult = TSD_OK;
80+ TSD_StatusT sendResult = TSD_OK;
81+ TSD_StatusT versionResult = TSD_OK;
82+ uint32_t configuredSessionId = 73U;
83+ int32_t configuredStatus = 9;
84+ std::shared_ptr<VersionVerify> configuredInspector = std::make_shared<VersionVerify>();
85+ uint32_t receivedPid = 0U;
86+ uint32_t receivedSessionId = 0U;
87+ uint32_t receivedTimeout = 0U;
88+ bool receivedAdcEnv = false;
89+ bool receivedIgnoreRecvErr = false;
90+ uint32_t initCount = 0U;
91+ uint32_t createSessionCount = 0U;
92+ uint32_t destroyCount = 0U;
93+ uint32_t recvCount = 0U;
94+ uint32_t statusCount = 0U;
95+ uint32_t sendCount = 0U;
96+ uint32_t versionCount = 0U;
97+};
98+ 
99+drvError_t GetProcessSignFailed(process_sign*) { return DRV_ERROR_INVALID_VALUE; }
100+} // namespace
101+ 
102+class DeviceCommAgentBehaviorUTest : public testing::Test {
103+protected:
104+ void SetUp() override
105+ {
106+ originalDeviceCommMap_ = *DeviceComm::DeviceCommMap();
107+ originalCreatorMap_ = *DeviceComm::CreatorMap();
108+ }
109+ 
110+ void TearDown() override
111+ {
112+ try {
113+ GlobalMockObject::verify();
114+ } catch (...) {
115+ GlobalMockObject::reset();
116+ *DeviceComm::DeviceCommMap() = originalDeviceCommMap_;
117+ *DeviceComm::CreatorMap() = originalCreatorMap_;
118+ throw;
119+ }
120+ GlobalMockObject::reset();
121+ *DeviceComm::DeviceCommMap() = originalDeviceCommMap_;
122+ *DeviceComm::CreatorMap() = originalCreatorMap_;
123+ }
124+ 
125+ std::shared_ptr<ConfigurableDeviceComm> InstallComm(DeviceCommAgent& agent, uint32_t deviceId)
126+ {
127+ auto comm = std::make_shared<ConfigurableDeviceComm>(deviceId);
128+ agent.devCommClient_ = comm;
129+ return comm;
130+ }
131+ 
132+ std::shared_ptr<ConfigurableDeviceComm> RegisterComm(uint32_t deviceId)
133+ {
134+ auto comm = std::make_shared<ConfigurableDeviceComm>(deviceId);
135+ (*DeviceComm::DeviceCommMap())[KeyCompose(deviceId, DeviceCommType::HDC)] = comm;
136+ return comm;
137+ }
138+ 
139+ std::map<uint64_t, std::shared_ptr<DeviceComm>> originalDeviceCommMap_;
140+ std::unordered_map<uint32_t, DeviceComm::CreatorFunc> originalCreatorMap_;
141+};
142+ 
143+TEST_F(DeviceCommAgentBehaviorUTest, InitTsdClient_AlreadyInitialized_SkipsInitialization)
144+{
145+ DeviceCommAgent agent(41U);
146+ auto comm = InstallComm(agent, 41U);
147+ 
148+ EXPECT_EQ(agent.InitTsdClient(true), TSD_OK);
149+ EXPECT_EQ(comm->initCount, 0U);
150+}
151+ 
152+TEST_F(DeviceCommAgentBehaviorUTest, InitTsdClient_ProcessSignFails_ReturnsOpenFailed)
153+{
154+ DeviceCommAgent agent(42U);
155+ MOCKER(drvGetProcessSign).stubs().will(invoke(GetProcessSignFailed));
156+ 
157+ EXPECT_EQ(agent.InitTsdClient(false), TSD_CLT_OPEN_FAILED);
158+ EXPECT_FALSE(agent.IsInit());
159+}
160+ 
161+TEST_F(DeviceCommAgentBehaviorUTest, InitTsdClientRejectsDeviceIdAtUpperBoundary)
162+{
163+ DeviceCommAgent agent(MAX_DEVNUM_PER_HOST);
164+ 
165+ EXPECT_EQ(agent.InitTsdClient(false), TSD_DEVICEID_ERROR);
166+ EXPECT_FALSE(agent.IsInit());
167+}
168+ 
169+TEST_F(DeviceCommAgentBehaviorUTest, InitTsdClient_CommInitFails_ReleasesComm)
170+{
171+ constexpr uint32_t deviceId = 43U;
172+ DeviceCommAgent agent(deviceId);
173+ auto comm = RegisterComm(deviceId);
174+ comm->initResult = TSD_HDC_CLIENT_INIT_ERROR;
175+ 
176+ EXPECT_EQ(agent.InitTsdClient(true), TSD_HDC_CLIENT_INIT_ERROR);
177+ EXPECT_EQ(comm->initCount, 1U);
178+ EXPECT_TRUE(comm->receivedAdcEnv);
179+ EXPECT_EQ(comm->destroyCount, 1U);
180+ EXPECT_FALSE(agent.IsInit());
181+}
182+ 
183+TEST_F(DeviceCommAgentBehaviorUTest, InitTsdClient_ValidComm_CreatesSession)
184+{
185+ constexpr uint32_t deviceId = 44U;
186+ DeviceCommAgent agent(deviceId);
187+ auto comm = RegisterComm(deviceId);
188+ 
189+ EXPECT_EQ(agent.InitTsdClient(false), TSD_OK);
190+ EXPECT_EQ(comm->initCount, 1U);
191+ EXPECT_EQ(comm->createSessionCount, 1U);
192+ EXPECT_EQ(agent.GetSessionId(), comm->configuredSessionId);
193+}
194+ 
195+TEST_F(DeviceCommAgentBehaviorUTest, OperationsRejectMissingClient)
196+{
197+ DeviceCommAgent agent(45U);
198+ HDCMessage msg;
199+ std::shared_ptr<VersionVerify> inspector;
200+ 
201+ EXPECT_EQ(agent.SendMsg(msg), TSD_INSTANCE_NOT_INITIALED);
202+ EXPECT_EQ(agent.RecvData(), TSD_INSTANCE_NOT_INITIALED);
203+ EXPECT_EQ(agent.GetVersionVerify(inspector), TSD_INSTANCE_NOT_INITIALED);
204+}
205+ 
206+TEST_F(DeviceCommAgentBehaviorUTest, OperationsDelegateSessionAndArguments)
207+{
208+ DeviceCommAgent agent(46U);
209+ auto comm = InstallComm(agent, 46U);
210+ agent.tsdSessionId_ = 85U;
211+ HDCMessage msg;
212+ std::shared_ptr<VersionVerify> inspector;
213+ 
214+ EXPECT_EQ(agent.SendMsg(msg), TSD_OK);
215+ EXPECT_EQ(agent.RecvData(true, 300U), TSD_OK);
216+ EXPECT_EQ(agent.GetVersionVerify(inspector), TSD_OK);
217+ EXPECT_EQ(comm->sendCount, 1U);
218+ EXPECT_EQ(comm->recvCount, 1U);
219+ EXPECT_EQ(comm->versionCount, 1U);
220+ EXPECT_EQ(comm->receivedSessionId, 85U);
221+ EXPECT_TRUE(comm->receivedIgnoreRecvErr);
222+ EXPECT_EQ(comm->receivedTimeout, 300U);
223+ EXPECT_EQ(inspector, comm->configuredInspector);
224+}
225+ 
226+TEST_F(DeviceCommAgentBehaviorUTest, GetHdcConctStatusUsesEnvironmentWithoutClient)
227+{
228+ DeviceCommAgent agent(47U);
229+ int32_t status = -1;
230+ 
231+ EXPECT_EQ(agent.GetHdcConctStatus(status, true), TSD_OK);
232+ EXPECT_EQ(status, HDC_SESSION_STATUS_CONNECT);
233+ EXPECT_EQ(agent.GetHdcConctStatus(status, false), TSD_OK);
234+ EXPECT_EQ(status, HDC_SESSION_STATUS_CLOSE);
235+}
236+ 
237+TEST_F(DeviceCommAgentBehaviorUTest, GetHdcConctStatusDelegatesToClient)
238+{
239+ DeviceCommAgent agent(48U);
240+ auto comm = InstallComm(agent, 48U);
241+ int32_t status = -1;
242+ 
243+ EXPECT_EQ(agent.GetHdcConctStatus(status, false), TSD_OK);
244+ EXPECT_EQ(status, comm->configuredStatus);
245+ EXPECT_EQ(comm->statusCount, 1U);
246+}
247+ 
248+TEST_F(DeviceCommAgentBehaviorUTest, ReleaseDeviceConnectionIsIdempotent)
249+{
250+ DeviceCommAgent agent(49U);
251+ auto comm = InstallComm(agent, 49U);
252+ 
253+ agent.ReleaseDeviceConnection();
254+ agent.ReleaseDeviceConnection();
255+ 
256+ EXPECT_EQ(comm->destroyCount, 1U);
257+ EXPECT_FALSE(agent.IsInit());
258+}
Rtests/ut/tsd/tsdclient/test/device_comm_utest.cpp→tests/ut/tsd/basic_component/device_comm/device_comm_utest.cpp+33-37
@@ -23,14 +23,36 @@ using namespace std;
23 23 
24class DeviceCommTest : public testing::Test {24class DeviceCommTest : public testing::Test {
25protected:25protected:
26- virtual void SetUp() { cout << "Before DeviceCommTest()" << endl; }26+ virtual void SetUp()
27+ {
28+ cout << "Before DeviceCommTest()" << endl;
29+ savedDeviceCommMap_ = *DeviceComm::DeviceCommMap();
30+ savedCreatorMap_ = *DeviceComm::CreatorMap();
31+ DeviceComm::DeviceCommMap()->clear();
32+ DeviceComm::CreatorMap()->clear();
33+ (void)DeviceComm::Register(DeviceCommType::HDC, [](uint32_t devId) -> std::shared_ptr<DeviceComm> {
34+ return std::make_shared<HdcClient>(devId);
35+ });
36+ }
27 37 
28 virtual void TearDown()38 virtual void TearDown()
29 {39 {
30 cout << "After DeviceCommTest" << endl;40 cout << "After DeviceCommTest" << endl;
31- GlobalMockObject::verify();41+ try {
42+ GlobalMockObject::verify();
43+ } catch (...) {
44+ GlobalMockObject::reset();
45+ *DeviceComm::DeviceCommMap() = savedDeviceCommMap_;
46+ *DeviceComm::CreatorMap() = savedCreatorMap_;
47+ throw;
48+ }
32 GlobalMockObject::reset();49 GlobalMockObject::reset();
50+ *DeviceComm::DeviceCommMap() = savedDeviceCommMap_;
51+ *DeviceComm::CreatorMap() = savedCreatorMap_;
33 }52 }
53+ 
54+ std::map<uint64_t, std::shared_ptr<DeviceComm>> savedDeviceCommMap_;
55+ std::unordered_map<uint32_t, DeviceComm::CreatorFunc> savedCreatorMap_;
34};56};
35 57 
36TEST_F(DeviceCommTest, GetInstance_DevIdOutOfRange_ReturnNull)58TEST_F(DeviceCommTest, GetInstance_DevIdOutOfRange_ReturnNull)
@@ -39,19 +61,13 @@ TEST_F(DeviceCommTest, GetInstance_DevIdOutOfRange_ReturnNull)
39 EXPECT_EQ(comm, nullptr);61 EXPECT_EQ(comm, nullptr);
40}62}
41 63 
42-TEST_F(DeviceCommTest, GetInstance_DevIdMaxRange_ReturnNull)
43-{
44- auto comm = DeviceComm::GetInstance(200, DeviceCommType::HDC);
45- EXPECT_EQ(comm, nullptr);
46-}
47- 
48TEST_F(DeviceCommTest, GetInstance_InvalidCommType_ReturnNull)64TEST_F(DeviceCommTest, GetInstance_InvalidCommType_ReturnNull)
49{65{
50 auto comm = DeviceComm::GetInstance(0, DeviceCommType::DEVICE_COMM_TYPE_TOTAL_NUM);66 auto comm = DeviceComm::GetInstance(0, DeviceCommType::DEVICE_COMM_TYPE_TOTAL_NUM);
51 EXPECT_EQ(comm, nullptr);67 EXPECT_EQ(comm, nullptr);
52}68}
53 69 
54-TEST_F(DeviceCommTest, GetInstance_HdcType_Success)70+TEST_F(DeviceCommTest, GetInstance_HdcType_ReturnsHdcClient)
55{71{
56 auto comm = DeviceComm::GetInstance(0, DeviceCommType::HDC);72 auto comm = DeviceComm::GetInstance(0, DeviceCommType::HDC);
57 EXPECT_NE(comm, nullptr);73 EXPECT_NE(comm, nullptr);
@@ -76,22 +92,6 @@ TEST_F(DeviceCommTest, GetInstance_DiffDev_ReturnDifferent)
76 EXPECT_NE(comm1, comm2);92 EXPECT_NE(comm1, comm2);
77}93}
78 94 
79-TEST_F(DeviceCommTest, GetInstance_InsertIntoMap_Success)
80-{
81- auto comm = DeviceComm::GetInstance(2, DeviceCommType::HDC);
82- EXPECT_NE(comm, nullptr);
83- auto commAgain = DeviceComm::GetInstance(2, DeviceCommType::HDC);
84- EXPECT_EQ(comm, commAgain);
85-}
86- 
87-TEST_F(DeviceCommTest, GetInstance_NonZeroDev_InsertIntoMap_Success)
88-{
89- auto comm = DeviceComm::GetInstance(5, DeviceCommType::HDC);
90- EXPECT_NE(comm, nullptr);
91- auto commAgain = DeviceComm::GetInstance(5, DeviceCommType::HDC);
92- EXPECT_EQ(comm, commAgain);
93-}
94- 
95TEST_F(DeviceCommTest, Constructor_DerivedClassFieldsSet)95TEST_F(DeviceCommTest, Constructor_DerivedClassFieldsSet)
96{96{
97 HdcClient client(5U);97 HdcClient client(5U);
@@ -135,7 +135,7 @@ TEST_F(DeviceCommTest, Register_CreatorAddedToCreatorMap)
135 EXPECT_EQ(hdcClient->deviceId_, 98U);135 EXPECT_EQ(hdcClient->deviceId_, 98U);
136}136}
137 137 
138-TEST_F(DeviceCommTest, Register_CustomType_GetInstanceSuccess)138+TEST_F(DeviceCommTest, Register_CustomType_GetInstanceReturnsClient)
139{139{
140 // 注册自定义类型后，GetInstance 可通过注册表创建实例140 // 注册自定义类型后，GetInstance 可通过注册表创建实例
141 DeviceComm::Register(static_cast<DeviceCommType>(97U), [](uint32_t devId) -> std::shared_ptr<DeviceComm> {141 DeviceComm::Register(static_cast<DeviceCommType>(97U), [](uint32_t devId) -> std::shared_ptr<DeviceComm> {
@@ -154,7 +154,7 @@ TEST_F(DeviceCommTest, Register_CreatorReturnsNull_GetInstanceReturnNull)
154 EXPECT_EQ(comm, nullptr);154 EXPECT_EQ(comm, nullptr);
155}155}
156 156 
157-TEST_F(DeviceCommTest, GetInstance_BoundaryDevId127_Success)157+TEST_F(DeviceCommTest, GetInstance_BoundaryDevId127_ReturnsHdcClient)
158{158{
159 // devId=127 是合法上界，应能正常创建实例159 // devId=127 是合法上界，应能正常创建实例
160 auto comm = DeviceComm::GetInstance(127U, DeviceCommType::HDC);160 auto comm = DeviceComm::GetInstance(127U, DeviceCommType::HDC);
@@ -164,18 +164,14 @@ TEST_F(DeviceCommTest, GetInstance_BoundaryDevId127_Success)
164 EXPECT_EQ(hdcClient->deviceId_, 127U);164 EXPECT_EQ(hdcClient->deviceId_, 127U);
165}165}
166 166 
167-TEST_F(DeviceCommTest, KeyCompose_DifferentDevIdProduceDifferentKey)167+TEST_F(DeviceCommTest, KeyCompose_DeviceAndType_UsesExactBitLayout)
168{168{
169- // KeyCompose 对不同 devId 应产生不同 key169+ EXPECT_EQ(KeyCompose(5U, DeviceCommType::HDC), 5UL << 32U);
170- uint64_t key0 = KeyCompose(0U, DeviceCommType::HDC);
171- uint64_t key1 = KeyCompose(1U, DeviceCommType::HDC);
172- EXPECT_NE(key0, key1);
173}170}
174 171 
175-TEST_F(DeviceCommTest, KeyCompose_SameDevIdSameTypeSameKey)172+TEST_F(DeviceCommTest, KeyCompose_DifferentTypes_UseDistinctLowBits)
176{173{
177- // 相同输入下 KeyCompose 结果一致174+ const auto customType = static_cast<DeviceCommType>(7U);
178- uint64_t keyA = KeyCompose(5U, DeviceCommType::HDC);175+ EXPECT_EQ(KeyCompose(5U, customType), (5UL << 32U) | 7UL);
179- uint64_t keyB = KeyCompose(5U, DeviceCommType::HDC);176+ EXPECT_NE(KeyCompose(5U, customType), KeyCompose(5U, DeviceCommType::HDC));
180- EXPECT_EQ(keyA, keyB);
181}177}
Rtests/ut/tsd/tsdclient/test/hdc_client_utest.cpp→tests/ut/tsd/basic_component/device_comm/hdc_client_utest.cpp+132-73
@@ -28,6 +28,9 @@ using namespace tsd;
28using namespace std;28using namespace std;
29 29 
30namespace {30namespace {
31+uint32_t g_typeMismatchReplyCount = 0U;
32+HDCMessage::MsgType g_typeMismatchRequestType = HDCMessage::INIT;
33+ 
31drvError_t HalHdcGetSessionAttrCloseStub(HDC_SESSION session, int attr, int* value)34drvError_t HalHdcGetSessionAttrCloseStub(HDC_SESSION session, int attr, int* value)
32{35{
33 (void)session;36 (void)session;
@@ -38,11 +41,19 @@ drvError_t HalHdcGetSessionAttrCloseStub(HDC_SESSION session, int attr, int* val
38 return DRV_ERROR_NONE;41 return DRV_ERROR_NONE;
39}42}
40 43 
41-uint32_t GetNextTestDeviceId()44+void TypeMismatchReply(struct drvHdcMsg* msg, HdcBufferInfo* buf, const HDCMessage& request)
42{45{
43- static uint32_t nextDeviceId = 0U;46+ ++g_typeMismatchReplyCount;
44- return nextDeviceId++;47+ g_typeMismatchRequestType = request.type();
48+ StubServerMsgImpl::DefaultStartProcMsgProc(msg, buf, request);
45}49}
50+ 
51+hdcError_t DrvHdcSessionConnectWithHandle(int, int, HDC_CLIENT, HDC_SESSION* session)
52+{
53+ *session = reinterpret_cast<HDC_SESSION>(0x1234);
54+ return DRV_ERROR_NONE;
55+}
56+ 
46} // namespace57} // namespace
47 58 
48class HdcClientTest : public testing::Test {59class HdcClientTest : public testing::Test {
@@ -50,17 +61,34 @@ protected:
50 virtual void SetUp()61 virtual void SetUp()
51 {62 {
52 cout << "Before HdcClientTest()" << endl;63 cout << "Before HdcClientTest()" << endl;
53- devId_ = GetNextTestDeviceId();64+ serverReplyState_ = StubServerReply::GetInstance()->SaveState();
65+ StubServerReply::GetInstance()->ResetServerReply();
66+ savedDeviceCommMap_ = *DeviceComm::DeviceCommMap();
67+ DeviceComm::DeviceCommMap()->clear();
68+ g_typeMismatchReplyCount = 0U;
69+ g_typeMismatchRequestType = HDCMessage::INIT;
54 }70 }
55 71 
56 virtual void TearDown()72 virtual void TearDown()
57 {73 {
58 cout << "After HdcClientTest" << endl;74 cout << "After HdcClientTest" << endl;
59- GlobalMockObject::verify();75+ try {
76+ GlobalMockObject::verify();
77+ } catch (...) {
78+ GlobalMockObject::reset();
79+ *DeviceComm::DeviceCommMap() = savedDeviceCommMap_;
80+ StubServerReply::GetInstance()->RestoreState(serverReplyState_);
81+ throw;
82+ }
60 GlobalMockObject::reset();83 GlobalMockObject::reset();
84+ DeviceComm::DeviceCommMap()->clear();
85+ *DeviceComm::DeviceCommMap() = savedDeviceCommMap_;
86+ StubServerReply::GetInstance()->RestoreState(serverReplyState_);
61 }87 }
62 88 
63- uint32_t devId_ = 0U;89+ static constexpr uint32_t devId_ = 17U;
90+ StubServerReply::State serverReplyState_;
91+ std::map<uint64_t, std::shared_ptr<DeviceComm>> savedDeviceCommMap_;
64};92};
65 93 
66TEST_F(HdcClientTest, GetInstance_DevIdOutOfRange_ReturnNull)94TEST_F(HdcClientTest, GetInstance_DevIdOutOfRange_ReturnNull)
@@ -69,7 +97,7 @@ TEST_F(HdcClientTest, GetInstance_DevIdOutOfRange_ReturnNull)
69 EXPECT_EQ(client, nullptr);97 EXPECT_EQ(client, nullptr);
70}98}
71 99 
72-TEST_F(HdcClientTest, GetInstance_Success)100+TEST_F(HdcClientTest, GetInstance_ValidDevice_ReturnsClient)
73{101{
74 auto client = DeviceComm::GetInstance(devId_, DeviceCommType::HDC);102 auto client = DeviceComm::GetInstance(devId_, DeviceCommType::HDC);
75 EXPECT_NE(client, nullptr);103 EXPECT_NE(client, nullptr);
@@ -82,7 +110,7 @@ TEST_F(HdcClientTest, GetInstance_Twice_ReturnSame)
82 EXPECT_EQ(client1, client2);110 EXPECT_EQ(client1, client2);
83}111}
84 112 
85-TEST_F(HdcClientTest, Constructor_Success)113+TEST_F(HdcClientTest, Constructor_NewClient_InitializesClosedStateAndSessionIds)
86{114{
87 HdcClient client(devId_);115 HdcClient client(devId_);
88 EXPECT_EQ(client.deviceId_, devId_);116 EXPECT_EQ(client.deviceId_, devId_);
@@ -90,13 +118,13 @@ TEST_F(HdcClientTest, Constructor_Success)
90 EXPECT_EQ(client.sessionIdNumVec_.size(), 96U);118 EXPECT_EQ(client.sessionIdNumVec_.size(), 96U);
91}119}
92 120 
93-TEST_F(HdcClientTest, GetDeviceId_Success)121+TEST_F(HdcClientTest, GetDeviceId_ConstructedClient_ReturnsConfiguredId)
94{122{
95 HdcClient client(devId_);123 HdcClient client(devId_);
96 EXPECT_EQ(client.GetDeviceId(), devId_);124 EXPECT_EQ(client.GetDeviceId(), devId_);
97}125}
98 126 
99-TEST_F(HdcClientTest, InitPre_Success)127+TEST_F(HdcClientTest, InitPre_ClosedClient_OpensClient)
100{128{
101 HdcClient client(devId_);129 HdcClient client(devId_);
102 TSD_StatusT ret = client.InitPre();130 TSD_StatusT ret = client.InitPre();
@@ -104,7 +132,7 @@ TEST_F(HdcClientTest, InitPre_Success)
104 EXPECT_EQ(client.isClientClose_, false);132 EXPECT_EQ(client.isClientClose_, false);
105}133}
106 134 
107-TEST_F(HdcClientTest, Init_Success)135+TEST_F(HdcClientTest, CommInit_ValidPid_StoresHostPid)
108{136{
109 HdcClient client(devId_);137 HdcClient client(devId_);
110 TSD_StatusT ret = client.CommInit(1000, false);138 TSD_StatusT ret = client.CommInit(1000, false);
@@ -112,7 +140,7 @@ TEST_F(HdcClientTest, Init_Success)
112 EXPECT_EQ(client.hostPid_, 1000U);140 EXPECT_EQ(client.hostPid_, 1000U);
113}141}
114 142 
115-TEST_F(HdcClientTest, CreateHdcSession_ClientClosed_Fail)143+TEST_F(HdcClientTest, CommCreateSession_ClientClosed_ReturnsClientClosed)
116{144{
117 HdcClient client(devId_);145 HdcClient client(devId_);
118 uint32_t sessionId = 0;146 uint32_t sessionId = 0;
@@ -120,7 +148,7 @@ TEST_F(HdcClientTest, CreateHdcSession_ClientClosed_Fail)
120 EXPECT_EQ(ret, TSD_HDC_CLIENT_CLOSED);148 EXPECT_EQ(ret, TSD_HDC_CLIENT_CLOSED);
121}149}
122 150 
123-TEST_F(HdcClientTest, CreateHdcSession_Success)151+TEST_F(HdcClientTest, CommCreateSession_HandshakeSucceeds_ReturnsSessionId)
124{152{
125 HdcClient client(devId_);153 HdcClient client(devId_);
126 client.InitPre();154 client.InitPre();
@@ -132,7 +160,7 @@ TEST_F(HdcClientTest, CreateHdcSession_Success)
132 EXPECT_NE(sessionId, 0U);160 EXPECT_NE(sessionId, 0U);
133}161}
134 162 
135-TEST_F(HdcClientTest, GetHdcSession_SessionNotExist_Fail)163+TEST_F(HdcClientTest, GetHdcSession_SessionMissing_ReturnsNotExist)
136{164{
137 HdcClient client(devId_);165 HdcClient client(devId_);
138 HDC_SESSION session = nullptr;166 HDC_SESSION session = nullptr;
@@ -140,10 +168,11 @@ TEST_F(HdcClientTest, GetHdcSession_SessionNotExist_Fail)
140 EXPECT_EQ(ret, TSD_HDC_SESSION_DO_NOT_EXIST);168 EXPECT_EQ(ret, TSD_HDC_SESSION_DO_NOT_EXIST);
141}169}
142 170 
143-TEST_F(HdcClientTest, GetHdcSession_Success)171+TEST_F(HdcClientTest, GetHdcSession_SessionExists_ReturnsHandle)
144{172{
145 HdcClient client(devId_);173 HdcClient client(devId_);
146 client.InitPre();174 client.InitPre();
175+ MOCKER(&drvHdcSessionConnect).expects(exactly(1)).will(invoke(DrvHdcSessionConnectWithHandle));
147 StubServerReply::GetInstance()->RegisterCallBack(176 StubServerReply::GetInstance()->RegisterCallBack(
148 HDCMessage::TEST_HDC_SEND, StubServerMsgImpl::DefaultVersionNegotiateMsgProc);177 HDCMessage::TEST_HDC_SEND, StubServerMsgImpl::DefaultVersionNegotiateMsgProc);
149 uint32_t sessionId = 0;178 uint32_t sessionId = 0;
@@ -152,6 +181,9 @@ TEST_F(HdcClientTest, GetHdcSession_Success)
152 HDC_SESSION session = nullptr;181 HDC_SESSION session = nullptr;
153 TSD_StatusT ret = client.GetHdcSession(sessionId, session);182 TSD_StatusT ret = client.GetHdcSession(sessionId, session);
154 EXPECT_EQ(ret, TSD_OK);183 EXPECT_EQ(ret, TSD_OK);
184+ ASSERT_NE(session, nullptr);
185+ EXPECT_EQ(session, reinterpret_cast<HDC_SESSION>(0x1234));
186+ EXPECT_EQ(session, client.hdcClientSessionMap_.at(sessionId));
155}187}
156 188 
157TEST_F(HdcClientTest, GetHdcSession_DefaultSessionIdZero_ReturnFirstSession)189TEST_F(HdcClientTest, GetHdcSession_DefaultSessionIdZero_ReturnFirstSession)
@@ -170,7 +202,7 @@ TEST_F(HdcClientTest, GetHdcSession_DefaultSessionIdZero_ReturnFirstSession)
170 EXPECT_EQ(session, client.hdcClientSessionMap_.begin()->second);202 EXPECT_EQ(session, client.hdcClientSessionMap_.begin()->second);
171}203}
172 204 
173-TEST_F(HdcClientTest, GetVersionVerify_Success)205+TEST_F(HdcClientTest, CommGetVersionVerify_SessionExists_ReturnsInspector)
174{206{
175 HdcClient client(devId_);207 HdcClient client(devId_);
176 client.InitPre();208 client.InitPre();
@@ -200,7 +232,7 @@ TEST_F(HdcClientTest, GetVersionVerify_DefaultSessionIdZero_ReturnFirstInspector
200 EXPECT_NE(inspector, nullptr);232 EXPECT_NE(inspector, nullptr);
201}233}
202 234 
203-TEST_F(HdcClientTest, GetHdcConctStatus_Success)235+TEST_F(HdcClientTest, CommGetConctStatus_OpenSession_ReturnsConnected)
204{236{
205 auto client = std::dynamic_pointer_cast<HdcClient>(DeviceComm::GetInstance(0, DeviceCommType::HDC));237 auto client = std::dynamic_pointer_cast<HdcClient>(DeviceComm::GetInstance(0, DeviceCommType::HDC));
206 client->InitPre();238 client->InitPre();
@@ -209,12 +241,13 @@ TEST_F(HdcClientTest, GetHdcConctStatus_Success)
209 uint32_t sessionId = 0;241 uint32_t sessionId = 0;
210 client->CommCreateSession(sessionId);242 client->CommCreateSession(sessionId);
211 243 
212- int32_t hdcSessStat = 0;244+ int32_t hdcSessStat = -1;
213 TSD_StatusT ret = client->CommGetConctStatus(hdcSessStat);245 TSD_StatusT ret = client->CommGetConctStatus(hdcSessStat);
214 EXPECT_EQ(ret, TSD_OK);246 EXPECT_EQ(ret, TSD_OK);
247+ EXPECT_EQ(hdcSessStat, HDC_SESSION_STATUS_CONNECT);
215}248}
216 249 
217-TEST_F(HdcClientTest, SendMsg_SessionNotExist_Fail)250+TEST_F(HdcClientTest, CommSendMsg_SessionMissing_ReturnsSendError)
218{251{
219 auto client = std::dynamic_pointer_cast<HdcClient>(DeviceComm::GetInstance(devId_, DeviceCommType::HDC));252 auto client = std::dynamic_pointer_cast<HdcClient>(DeviceComm::GetInstance(devId_, DeviceCommType::HDC));
220 HDCMessage msg;253 HDCMessage msg;
@@ -222,7 +255,7 @@ TEST_F(HdcClientTest, SendMsg_SessionNotExist_Fail)
222 EXPECT_EQ(ret, TSD_HDC_SEND_MSG_ERROR);255 EXPECT_EQ(ret, TSD_HDC_SEND_MSG_ERROR);
223}256}
224 257 
225-TEST_F(HdcClientTest, RecvMsg_SessionNotExist_Fail)258+TEST_F(HdcClientTest, RecvMsg_SessionMissing_ReturnsRecvError)
226{259{
227 HdcClient client(devId_);260 HdcClient client(devId_);
228 HDCMessage msg;261 HDCMessage msg;
@@ -230,7 +263,7 @@ TEST_F(HdcClientTest, RecvMsg_SessionNotExist_Fail)
230 EXPECT_EQ(ret, TSD_HDC_RECV_MSG_ERROR);263 EXPECT_EQ(ret, TSD_HDC_RECV_MSG_ERROR);
231}264}
232 265 
233-TEST_F(HdcClientTest, Destroy_Success)266+TEST_F(HdcClientTest, CommDestroy_OpenClient_MarksClientClosed)
234{267{
235 auto client = std::dynamic_pointer_cast<HdcClient>(DeviceComm::GetInstance(devId_, DeviceCommType::HDC));268 auto client = std::dynamic_pointer_cast<HdcClient>(DeviceComm::GetInstance(devId_, DeviceCommType::HDC));
236 client->InitPre();269 client->InitPre();
@@ -243,7 +276,7 @@ TEST_F(HdcClientTest, Destroy_Success)
243 EXPECT_EQ(client->isClientClose_, true);276 EXPECT_EQ(client->isClientClose_, true);
244}277}
245 278 
246-TEST_F(HdcClientTest, ClearAllSession_Success)279+TEST_F(HdcClientTest, ClearAllSession_OpenSession_ClearsSessionMap)
247{280{
248 HdcClient client(devId_);281 HdcClient client(devId_);
249 client.InitPre();282 client.InitPre();
@@ -256,7 +289,7 @@ TEST_F(HdcClientTest, ClearAllSession_Success)
256 EXPECT_EQ(client.hdcClientSessionMap_.empty(), true);289 EXPECT_EQ(client.hdcClientSessionMap_.empty(), true);
257}290}
258 291 
259-TEST_F(HdcClientTest, ClearClientPtr_Success)292+TEST_F(HdcClientTest, ClearClientPtr_ClientCached_RemovesCachedInstance)
260{293{
261 auto client = std::dynamic_pointer_cast<HdcClient>(DeviceComm::GetInstance(devId_, DeviceCommType::HDC));294 auto client = std::dynamic_pointer_cast<HdcClient>(DeviceComm::GetInstance(devId_, DeviceCommType::HDC));
262 client->InitPre();295 client->InitPre();
@@ -268,7 +301,7 @@ TEST_F(HdcClientTest, ClearClientPtr_Success)
268 EXPECT_NE(newClient.get(), oldPtr);301 EXPECT_NE(newClient.get(), oldPtr);
269}302}
270 303 
271-TEST_F(HdcClientTest, CommDestroy_ClearDeviceCommMap_Success)304+TEST_F(HdcClientTest, CommDestroy_OpenCachedClient_RemovesCachedInstance)
272{305{
273 auto client = std::dynamic_pointer_cast<HdcClient>(DeviceComm::GetInstance(devId_, DeviceCommType::HDC));306 auto client = std::dynamic_pointer_cast<HdcClient>(DeviceComm::GetInstance(devId_, DeviceCommType::HDC));
274 client->InitPre();307 client->InitPre();
@@ -292,7 +325,7 @@ TEST_F(HdcClientTest, CommDestroy_ClientAlreadyClosed_KeepDeviceCommMap)
292 EXPECT_EQ(sameClient.get(), client.get());325 EXPECT_EQ(sameClient.get(), client.get());
293}326}
294 327 
295-TEST_F(HdcClientTest, TsdRecvData_Success)328+TEST_F(HdcClientTest, CommRecvData_ServerResponds_ReturnsOk)
296{329{
297 HdcClient client(devId_);330 HdcClient client(devId_);
298 client.InitPre();331 client.InitPre();
@@ -323,26 +356,30 @@ TEST_F(HdcClientTest, TsdRecvData_IgnoreRecvErr_ReturnRecvError)
323// 异常分支补充用例 - 增加 device_comm/hdc_client.cpp 的覆盖率356// 异常分支补充用例 - 增加 device_comm/hdc_client.cpp 的覆盖率
324// =====================================================================357// =====================================================================
325 358 
326-TEST_F(HdcClientTest, InitPre_DrvHdcClientCreate_AllRetryFail)359+TEST_F(HdcClientTest, InitPre_ElevenCreateAttemptsFail_ReturnsInitError)
327{360{
328 HdcClient client(devId_);361 HdcClient client(devId_);
329- MOCKER(&drvHdcClientCreate).stubs().will(returnValue(DRV_ERROR_INNER_ERR));362+ MOCKER(&drvHdcClientCreate).expects(exactly(11)).will(returnValue(DRV_ERROR_INNER_ERR));
330- MOCKER(&mmSleep).stubs().will(returnValue(0));363+ MOCKER(&mmSleep).expects(exactly(10)).will(returnValue(0));
331 TSD_StatusT ret = client.InitPre();364 TSD_StatusT ret = client.InitPre();
332 EXPECT_EQ(ret, TSD_HDC_CLIENT_INIT_ERROR);365 EXPECT_EQ(ret, TSD_HDC_CLIENT_INIT_ERROR);
366+ EXPECT_TRUE(client.isClientClose_);
333}367}
334 368 
335-TEST_F(HdcClientTest, InitPre_DrvHdcClientCreate_RetryThenSuccess)369+TEST_F(HdcClientTest, InitPre_SecondCreateAttemptSucceeds_OpensClient)
336{370{
337 HdcClient client(devId_);371 HdcClient client(devId_);
338- MOCKER(&drvHdcClientCreate).stubs().will(returnValue(DRV_ERROR_INNER_ERR)).then(returnValue(DRV_ERROR_NONE));372+ MOCKER(&drvHdcClientCreate)
339- MOCKER(&mmSleep).stubs().will(returnValue(0));373+ .expects(exactly(2))
374+ .will(returnValue(DRV_ERROR_INNER_ERR))
375+ .then(returnValue(DRV_ERROR_NONE));
376+ MOCKER(&mmSleep).expects(exactly(1)).will(returnValue(0));
340 TSD_StatusT ret = client.InitPre();377 TSD_StatusT ret = client.InitPre();
341 EXPECT_EQ(ret, TSD_OK);378 EXPECT_EQ(ret, TSD_OK);
342 EXPECT_EQ(client.isClientClose_, false);379 EXPECT_EQ(client.isClientClose_, false);
343}380}
344 381 
345-TEST_F(HdcClientTest, CommInit_InitMsgSizeFail)382+TEST_F(HdcClientTest, CommInit_MessageCapacityQueryFails_ReturnsInitError)
346{383{
347 HdcClient client(devId_);384 HdcClient client(devId_);
348 MOCKER(&drvHdcGetCapacity).stubs().will(returnValue(DRV_ERROR_NO_DEVICE));385 MOCKER(&drvHdcGetCapacity).stubs().will(returnValue(DRV_ERROR_NO_DEVICE));
@@ -350,7 +387,7 @@ TEST_F(HdcClientTest, CommInit_InitMsgSizeFail)
350 EXPECT_EQ(ret, TSD_HDC_CLIENT_INIT_ERROR);387 EXPECT_EQ(ret, TSD_HDC_CLIENT_INIT_ERROR);
351}388}
352 389 
353-TEST_F(HdcClientTest, CommCreateSession_SessionIdEmpty_Fail)390+TEST_F(HdcClientTest, CommCreateSession_NoAvailableSessionId_ReturnsNotAvailable)
354{391{
355 HdcClient client(devId_);392 HdcClient client(devId_);
356 client.InitPre();393 client.InitPre();
@@ -380,7 +417,7 @@ TEST_F(HdcClientTest, CommCreateSession_SessionConnect_RemoteNotListen)
380 EXPECT_EQ(ret, DRV_ERROR_REMOTE_NOT_LISTEN);417 EXPECT_EQ(ret, DRV_ERROR_REMOTE_NOT_LISTEN);
381}418}
382 419 
383-TEST_F(HdcClientTest, CommCreateSession_SessionConnect_OtherFail)420+TEST_F(HdcClientTest, CommCreateSession_DriverConnectFails_ReturnsCreateError)
384{421{
385 HdcClient client(devId_);422 HdcClient client(devId_);
386 client.InitPre();423 client.InitPre();
@@ -390,50 +427,58 @@ TEST_F(HdcClientTest, CommCreateSession_SessionConnect_OtherFail)
390 EXPECT_EQ(ret, TSD_HDC_CREATE_SESSION_FAILED);427 EXPECT_EQ(ret, TSD_HDC_CREATE_SESSION_FAILED);
391}428}
392 429 
393-TEST_F(HdcClientTest, CommCreateSession_SetSessionReferenceFail)430+TEST_F(HdcClientTest, CommCreateSession_SetReferenceFails_ClosesSessionAndReturnsError)
394{431{
395 HdcClient client(devId_);432 HdcClient client(devId_);
396 client.InitPre();433 client.InitPre();
397- MOCKER(&drvHdcSetSessionReference).stubs().will(returnValue(DRV_ERROR_INNER_ERR));434+ MOCKER(&drvHdcSetSessionReference).expects(exactly(1)).will(returnValue(DRV_ERROR_INNER_ERR));
398- uint32_t sessionId = 0;435+ MOCKER(&drvHdcSessionClose).expects(exactly(1)).will(returnValue(DRV_ERROR_NONE));
436+ uint32_t sessionId = 77U;
399 TSD_StatusT ret = client.CommCreateSession(sessionId);437 TSD_StatusT ret = client.CommCreateSession(sessionId);
400 EXPECT_EQ(ret, TSD_SET_HDCSESSION_REFERENCE_FAILED);438 EXPECT_EQ(ret, TSD_SET_HDCSESSION_REFERENCE_FAILED);
439+ EXPECT_EQ(sessionId, 77U);
440+ EXPECT_TRUE(client.hdcClientSessionMap_.empty());
441+ EXPECT_EQ(client.sessionIdNumVec_.size(), 96U);
401}442}
402 443 
403-TEST_F(HdcClientTest, CommCreateSession_SetSessionReferenceFail_CloseFail)444+TEST_F(HdcClientTest, CommCreateSession_SetSessionReferenceAndCloseFail_ReturnsReferenceError)
404{445{
405 HdcClient client(devId_);446 HdcClient client(devId_);
406 client.InitPre();447 client.InitPre();
407- MOCKER(&drvHdcSetSessionReference).stubs().will(returnValue(DRV_ERROR_INNER_ERR));448+ MOCKER(&drvHdcSetSessionReference).expects(exactly(1)).will(returnValue(DRV_ERROR_INNER_ERR));
408- MOCKER(&drvHdcSessionClose).stubs().will(returnValue(DRV_ERROR_INNER_ERR));449+ MOCKER(&drvHdcSessionClose).expects(exactly(1)).will(returnValue(DRV_ERROR_INNER_ERR));
409- uint32_t sessionId = 0;450+ uint32_t sessionId = 77U;
410 TSD_StatusT ret = client.CommCreateSession(sessionId);451 TSD_StatusT ret = client.CommCreateSession(sessionId);
411 EXPECT_EQ(ret, TSD_SET_HDCSESSION_REFERENCE_FAILED);452 EXPECT_EQ(ret, TSD_SET_HDCSESSION_REFERENCE_FAILED);
453+ EXPECT_EQ(sessionId, 77U);
454+ EXPECT_TRUE(client.hdcClientSessionMap_.empty());
455+ EXPECT_EQ(client.sessionIdNumVec_.size(), 96U);
412}456}
413 457 
414-TEST_F(HdcClientTest, CommCreateSession_CheckHdcConnection_RecvFail)458+TEST_F(HdcClientTest, CommCreateSession_HandshakeReceiveFails_ReturnsRecvError)
415{459{
416 HdcClient client(devId_);460 HdcClient client(devId_);
417- client.InitPre();461+ ASSERT_EQ(client.InitPre(), TSD_OK);
418- // 不注册回调，halHdcRecv 默认返回 DRV_ERROR_INNER_ERR462+ MOCKER_CPP(&StubServerReply::ReplyToHost).expects(exactly(1)).will(returnValue(false));
419- StubServerReply::GetInstance()->ClearAllCallBack();463+ uint32_t sessionId = 0U;
420- uint32_t sessionId = 0;464+ 
421- TSD_StatusT ret = client.CommCreateSession(sessionId);465+ EXPECT_EQ(client.CommCreateSession(sessionId), TSD_HDC_RECV_MSG_ERROR);
422- EXPECT_EQ(ret, TSD_HDC_RECV_MSG_ERROR);
423}466}
424 467 
425-TEST_F(HdcClientTest, CommCreateSession_CheckHdcConnection_RspTypeMismatch)468+TEST_F(HdcClientTest, CommCreateSession_HandshakeResponseTypeMismatch_ReturnsRecvError)
426{469{
427 HdcClient client(devId_);470 HdcClient client(devId_);
428- client.InitPre();471+ ASSERT_EQ(client.InitPre(), TSD_OK);
429- StubServerReply::GetInstance()->RegisterCallBack(472+ StubServerReply::GetInstance()->RegisterCallBack(HDCMessage::TEST_HDC_SEND, TypeMismatchReply);
430- HDCMessage::TEST_HDC_SEND, StubServerMsgImpl::DefaultStartProcMsgProc);473+ MOCKER_CPP(&VersionVerify::PeerVersionCheck).expects(never());
431- uint32_t sessionId = 0;474+ uint32_t sessionId = 0U;
432- TSD_StatusT ret = client.CommCreateSession(sessionId);475+ 
433- EXPECT_EQ(ret, TSD_HDC_RECV_MSG_ERROR);476+ EXPECT_EQ(client.CommCreateSession(sessionId), TSD_HDC_RECV_MSG_ERROR);
477+ EXPECT_EQ(g_typeMismatchReplyCount, 1U);
478+ EXPECT_EQ(g_typeMismatchRequestType, HDCMessage::TEST_HDC_SEND);
434}479}
435 480 
436-TEST_F(HdcClientTest, CommGetVersionVerify_NotExist_Fail)481+TEST_F(HdcClientTest, CommGetVersionVerify_SessionMissing_ReturnsNotExist)
437{482{
438 HdcClient client(devId_);483 HdcClient client(devId_);
439 std::shared_ptr<VersionVerify> inspector = nullptr;484 std::shared_ptr<VersionVerify> inspector = nullptr;
@@ -441,16 +486,17 @@ TEST_F(HdcClientTest, CommGetVersionVerify_NotExist_Fail)
441 EXPECT_EQ(ret, TSD_HDC_SESSION_DO_NOT_EXIST);486 EXPECT_EQ(ret, TSD_HDC_SESSION_DO_NOT_EXIST);
442}487}
443 488 
444-TEST_F(HdcClientTest, CommGetConctStatus_HalGetAPIVersionFail)489+TEST_F(HdcClientTest, CommGetConctStatus_ApiVersionQueryFails_ReturnsStatusError)
445{490{
446 HdcClient client(devId_);491 HdcClient client(devId_);
447- MOCKER(&halGetAPIVersion).stubs().will(returnValue(DRV_ERROR_INNER_ERR));492+ MOCKER(&halGetAPIVersion).expects(exactly(1)).will(returnValue(DRV_ERROR_INNER_ERR));
448- int32_t hdcSessStat = 0;493+ int32_t hdcSessStat = 77;
449 TSD_StatusT ret = client.CommGetConctStatus(hdcSessStat);494 TSD_StatusT ret = client.CommGetConctStatus(hdcSessStat);
450 EXPECT_EQ(ret, TSD_HDC_SESSION_STATUS_GET_FAILED);495 EXPECT_EQ(ret, TSD_HDC_SESSION_STATUS_GET_FAILED);
496+ EXPECT_EQ(hdcSessStat, HDC_SESSION_STATUS_CONNECT);
451}497}
452 498 
453-TEST_F(HdcClientTest, CommGetConctStatus_GetSessionAttrFail)499+TEST_F(HdcClientTest, CommGetConctStatus_SessionStatusQueryFails_ReturnsStatusError)
454{500{
455 HdcClient client(devId_);501 HdcClient client(devId_);
456 client.InitPre();502 client.InitPre();
@@ -459,10 +505,11 @@ TEST_F(HdcClientTest, CommGetConctStatus_GetSessionAttrFail)
459 uint32_t sessionId = 0;505 uint32_t sessionId = 0;
460 client.CommCreateSession(sessionId);506 client.CommCreateSession(sessionId);
461 507 
462- MOCKER(&halHdcGetSessionAttr).stubs().will(returnValue(DRV_ERROR_INNER_ERR));508+ MOCKER(&halHdcGetSessionAttr).expects(exactly(1)).will(returnValue(DRV_ERROR_INNER_ERR));
463- int32_t hdcSessStat = 0;509+ int32_t hdcSessStat = 77;
464 TSD_StatusT ret = client.CommGetConctStatus(hdcSessStat);510 TSD_StatusT ret = client.CommGetConctStatus(hdcSessStat);
465 EXPECT_EQ(ret, TSD_HDC_SESSION_STATUS_GET_FAILED);511 EXPECT_EQ(ret, TSD_HDC_SESSION_STATUS_GET_FAILED);
512+ EXPECT_EQ(hdcSessStat, HDC_SESSION_STATUS_CONNECT);
466}513}
467 514 
468TEST_F(HdcClientTest, CommGetConctStatus_CloseSession_RecycleSessionId)515TEST_F(HdcClientTest, CommGetConctStatus_CloseSession_RecycleSessionId)
@@ -488,7 +535,7 @@ TEST_F(HdcClientTest, CommGetConctStatus_CloseSession_RecycleSessionId)
488 EXPECT_EQ(client.sessionIdNumVec_.size(), sessionIdCount + 1U);535 EXPECT_EQ(client.sessionIdNumVec_.size(), sessionIdCount + 1U);
489}536}
490 537 
491-TEST_F(HdcClientTest, ClearAllSession_SessionCloseFail)538+TEST_F(HdcClientTest, ClearAllSession_CloseFails_ClearsMapWithoutRecyclingId)
492{539{
493 HdcClient client(devId_);540 HdcClient client(devId_);
494 client.InitPre();541 client.InitPre();
@@ -497,27 +544,39 @@ TEST_F(HdcClientTest, ClearAllSession_SessionCloseFail)
497 uint32_t sessionId = 0;544 uint32_t sessionId = 0;
498 client.CommCreateSession(sessionId);545 client.CommCreateSession(sessionId);
499 546 
500- MOCKER(&drvHdcSessionClose).stubs().will(returnValue(DRV_ERROR_INNER_ERR));547+ const size_t sessionIdCount = client.sessionIdNumVec_.size();
548+ MOCKER(&drvHdcSessionClose).expects(exactly(1)).will(returnValue(DRV_ERROR_INNER_ERR));
501 client.ClearAllSession();549 client.ClearAllSession();
502- EXPECT_EQ(client.hdcClientSessionMap_.empty(), true);550+ EXPECT_TRUE(client.hdcClientSessionMap_.empty());
551+ EXPECT_EQ(client.sessionIdNumVec_.size(), sessionIdCount);
503}552}
504 553 
505TEST_F(HdcClientTest, ClearClientPtr_DeviceIdNotInMap)554TEST_F(HdcClientTest, ClearClientPtr_DeviceIdNotInMap)
506{555{
507- HdcClient client(99);556+ HdcClient client(devId_);
557+ const uint64_t key = KeyCompose(client.GetDeviceId(), DeviceCommType::HDC);
558+ (void)DeviceComm::DeviceCommMap()->erase(key);
559+ ASSERT_EQ(DeviceComm::DeviceCommMap()->count(key), 0U);
560+ const size_t mapSize = DeviceComm::DeviceCommMap()->size();
561+ 
508 client.ClearClientPtr();562 client.ClearClientPtr();
509- SUCCEED();563+ 
564+ EXPECT_EQ(DeviceComm::DeviceCommMap()->size(), mapSize);
565+ EXPECT_EQ(DeviceComm::DeviceCommMap()->count(key), 0U);
566+ EXPECT_TRUE(client.isClientClose_);
510}567}
511 568 
512-TEST_F(HdcClientTest, DestroyClient_DrvHdcClientDestroyFail)569+TEST_F(HdcClientTest, DestroyClient_DriverDestroyFails_StillMarksClientClosed)
513{570{
514 HdcClient client(devId_);571 HdcClient client(devId_);
515- MOCKER(&drvHdcClientDestroy).stubs().will(returnValue(DRV_ERROR_INNER_ERR));572+ client.hdcClient_ = reinterpret_cast<HDC_CLIENT>(0x1234);
573+ client.isClientClose_ = false;
574+ MOCKER(&drvHdcClientDestroy).expects(exactly(1)).will(returnValue(DRV_ERROR_INNER_ERR));
516 client.DestroyClient();575 client.DestroyClient();
517- EXPECT_EQ(client.isClientClose_, true);576+ EXPECT_TRUE(client.isClientClose_);
518}577}
519 578 
520-TEST_F(HdcClientTest, CommSendMsg_SpecialFeatureCheckFail)579+TEST_F(HdcClientTest, CommSendMsg_FeatureCheckFails_ReturnsRecvError)
521{580{
522 HdcClient client(devId_);581 HdcClient client(devId_);
523 client.InitPre();582 client.InitPre();
@@ -549,7 +608,7 @@ TEST_F(HdcClientTest, InitPre_ClientAlreadyOpen_SkipCreate)
549 EXPECT_EQ(client.isClientClose_, false);608 EXPECT_EQ(client.isClientClose_, false);
550}609}
551 610 
552-TEST_F(HdcClientTest, CommSendMsg_Success)611+TEST_F(HdcClientTest, CommSendMsg_CompatibleMessage_ReturnsOk)
553{612{
554 // CommSendMsg 全路径成功：session 存在、SpecialFeatureCheck 通过、halHdcSend 成功613 // CommSendMsg 全路径成功：session 存在、SpecialFeatureCheck 通过、halHdcSend 成功
555 HdcClient client(devId_);614 HdcClient client(devId_);
@@ -565,7 +624,7 @@ TEST_F(HdcClientTest, CommSendMsg_Success)
565 EXPECT_EQ(ret, TSD_OK);624 EXPECT_EQ(ret, TSD_OK);
566}625}
567 626 
568-TEST_F(HdcClientTest, CommRecvData_RecvFail_NotIgnoreErr_ReturnError)627+TEST_F(HdcClientTest, CommRecvData_ReceiveFailsWithoutIgnore_ReturnsRecvError)
569{628{
570 // recv 返回非 socket-closed 错误，ignoreRecvErr=false 时应返回该错误码629 // recv 返回非 socket-closed 错误，ignoreRecvErr=false 时应返回该错误码
571 HdcClient client(devId_);630 HdcClient client(devId_);
Rtests/ut/tsd/tsdclient/test/hdc_common_utest.cpp→tests/ut/tsd/basic_component/device_comm/hdc_common_utest.cpp+48-35
@@ -27,6 +27,9 @@ using namespace tsd;
27using namespace std;27using namespace std;
28 28 
29namespace {29namespace {
30+HDC_SESSION g_attrSession = nullptr;
31+int g_attrType = -1;
32+ 
30drvError_t HalHdcGetSessionAttrDfxFailNegativeStub(HDC_SESSION session, int attr, int* value)33drvError_t HalHdcGetSessionAttrDfxFailNegativeStub(HDC_SESSION session, int attr, int* value)
31{34{
32 (void)session;35 (void)session;
@@ -36,21 +39,39 @@ drvError_t HalHdcGetSessionAttrDfxFailNegativeStub(HDC_SESSION session, int attr
36 }39 }
37 return DRV_ERROR_INNER_ERR;40 return DRV_ERROR_INNER_ERR;
38}41}
42+ 
43+drvError_t HalHdcGetSessionAttrSuccessStub(HDC_SESSION session, int attr, int* value)
44+{
45+ g_attrSession = session;
46+ g_attrType = attr;
47+ *value = HDC_SESSION_STATUS_CLOSE;
48+ return DRV_ERROR_NONE;
49+}
39} // namespace50} // namespace
40 51 
41class HdcCommonTest : public testing::Test {52class HdcCommonTest : public testing::Test {
42protected:53protected:
43- virtual void SetUp() { cout << "Before HdcCommonTest()" << endl; }54+ virtual void SetUp()
55+ {
56+ cout << "Before HdcCommonTest()" << endl;
57+ g_attrSession = nullptr;
58+ g_attrType = -1;
59+ }
44 60 
45 virtual void TearDown()61 virtual void TearDown()
46 {62 {
47 cout << "After HdcCommonTest" << endl;63 cout << "After HdcCommonTest" << endl;
48- GlobalMockObject::verify();64+ try {
65+ GlobalMockObject::verify();
66+ } catch (...) {
67+ GlobalMockObject::reset();
68+ throw;
69+ }
49 GlobalMockObject::reset();70 GlobalMockObject::reset();
50 }71 }
51};72};
52 73 
53-TEST_F(HdcCommonTest, Constructor_Success)74+TEST_F(HdcCommonTest, Constructor_NewInstance_InitializesMessageSizes)
54{75{
55 HdcCommon hdcCommon;76 HdcCommon hdcCommon;
56 EXPECT_EQ(hdcCommon.isAdcEnv_, false);77 EXPECT_EQ(hdcCommon.isAdcEnv_, false);
@@ -59,7 +80,7 @@ TEST_F(HdcCommonTest, Constructor_Success)
59 EXPECT_EQ(hdcCommon.msgLongHeadDataMaxSize_, 0U);80 EXPECT_EQ(hdcCommon.msgLongHeadDataMaxSize_, 0U);
60}81}
61 82 
62-TEST_F(HdcCommonTest, InitMsgSize_Success)83+TEST_F(HdcCommonTest, InitMsgSize_DriverCapacityAvailable_SetsMaximumSize)
63{84{
64 HdcCommon hdcCommon;85 HdcCommon hdcCommon;
65 TSD_StatusT ret = hdcCommon.InitMsgSize();86 TSD_StatusT ret = hdcCommon.InitMsgSize();
@@ -67,7 +88,7 @@ TEST_F(HdcCommonTest, InitMsgSize_Success)
67 EXPECT_EQ(hdcCommon.msgMaxSize_, 1024 * 1024);88 EXPECT_EQ(hdcCommon.msgMaxSize_, 1024 * 1024);
68}89}
69 90 
70-TEST_F(HdcCommonTest, GetMsgMaxSize_Success)91+TEST_F(HdcCommonTest, GetMsgMaxSize_SizeConfigured_ReturnsConfiguredSize)
71{92{
72 HdcCommon hdcCommon;93 HdcCommon hdcCommon;
73 hdcCommon.msgMaxSize_ = 1024;94 hdcCommon.msgMaxSize_ = 1024;
@@ -75,14 +96,14 @@ TEST_F(HdcCommonTest, GetMsgMaxSize_Success)
75 EXPECT_EQ(size, 1024);96 EXPECT_EQ(size, 1024);
76}97}
77 98 
78-TEST_F(HdcCommonTest, MakeVersionVerifyNoThrow_Success)99+TEST_F(HdcCommonTest, MakeVersionVerifyNoThrow_AllocationSucceeds_ReturnsInspector)
79{100{
80 HdcCommon hdcCommon;101 HdcCommon hdcCommon;
81 auto versionVerify = hdcCommon.MakeVersionVerifyNoThrow();102 auto versionVerify = hdcCommon.MakeVersionVerifyNoThrow();
82 EXPECT_NE(versionVerify, nullptr);103 EXPECT_NE(versionVerify, nullptr);
83}104}
84 105 
85-TEST_F(HdcCommonTest, SendNormalMsg_Success)106+TEST_F(HdcCommonTest, SendNormalMsg_ValidMessage_ReturnsOk)
86{107{
87 HdcCommon hdcCommon;108 HdcCommon hdcCommon;
88 HDC_SESSION session = reinterpret_cast<HDC_SESSION>(0x1);109 HDC_SESSION session = reinterpret_cast<HDC_SESSION>(0x1);
@@ -93,17 +114,21 @@ TEST_F(HdcCommonTest, SendNormalMsg_Success)
93 EXPECT_EQ(ret, TSD_OK);114 EXPECT_EQ(ret, TSD_OK);
94}115}
95 116 
96-TEST_F(HdcCommonTest, GetHdcAttrStatus_Success)117+TEST_F(HdcCommonTest, GetHdcAttrStatus_DriverQuerySucceeds_ReturnsOk)
97{118{
98 HdcCommon hdcCommon;119 HdcCommon hdcCommon;
99 HDC_SESSION session = reinterpret_cast<HDC_SESSION>(0x1);120 HDC_SESSION session = reinterpret_cast<HDC_SESSION>(0x1);
100- int32_t hdcSessStat = 0;121+ int32_t hdcSessStat = -1;
122+ MOCKER(&halHdcGetSessionAttr).expects(exactly(1)).will(invoke(HalHdcGetSessionAttrSuccessStub));
101 123 
102 TSD_StatusT ret = hdcCommon.GetHdcAttrStatus(session, hdcSessStat);124 TSD_StatusT ret = hdcCommon.GetHdcAttrStatus(session, hdcSessStat);
103 EXPECT_EQ(ret, TSD_OK);125 EXPECT_EQ(ret, TSD_OK);
126+ EXPECT_EQ(g_attrSession, session);
127+ EXPECT_EQ(g_attrType, HDC_SESSION_ATTR_STATUS);
128+ EXPECT_EQ(hdcSessStat, HDC_SESSION_STATUS_CLOSE);
104}129}
105 130 
106-TEST_F(HdcCommonTest, SendNormalShortMsg_SizeZero_Fail)131+TEST_F(HdcCommonTest, SendNormalShortMsg_ZeroSize_ReturnsSendError)
107{132{
108 HdcCommon hdcCommon;133 HdcCommon hdcCommon;
109 HDC_SESSION session = reinterpret_cast<HDC_SESSION>(0x1);134 HDC_SESSION session = reinterpret_cast<HDC_SESSION>(0x1);
@@ -113,7 +138,7 @@ TEST_F(HdcCommonTest, SendNormalShortMsg_SizeZero_Fail)
113 EXPECT_EQ(ret, TSD_HDC_SEND_MSG_ERROR);138 EXPECT_EQ(ret, TSD_HDC_SEND_MSG_ERROR);
114}139}
115 140 
116-TEST_F(HdcCommonTest, SendNormalShortMsg_SizeTooLarge_Fail)141+TEST_F(HdcCommonTest, SendNormalShortMsg_SizeExceedsMaxHeapBuffByte_ReturnsReversedIntegerError)
117{142{
118 HdcCommon hdcCommon;143 HdcCommon hdcCommon;
119 HDC_SESSION session = reinterpret_cast<HDC_SESSION>(0x1);144 HDC_SESSION session = reinterpret_cast<HDC_SESSION>(0x1);
@@ -124,7 +149,7 @@ TEST_F(HdcCommonTest, SendNormalShortMsg_SizeTooLarge_Fail)
124 EXPECT_EQ(ret, TSD_INTERGER_REVERSED);149 EXPECT_EQ(ret, TSD_INTERGER_REVERSED);
125}150}
126 151 
127-TEST_F(HdcCommonTest, InitMsgSize_FailedByDrv)152+TEST_F(HdcCommonTest, InitMsgSize_DriverCapacityFails_LeavesSizeZero)
128{153{
129 HdcCommon hdcCommon;154 HdcCommon hdcCommon;
130 MOCKER(&drvHdcGetCapacity).stubs().will(returnValue(DRV_ERROR_NO_DEVICE));155 MOCKER(&drvHdcGetCapacity).stubs().will(returnValue(DRV_ERROR_NO_DEVICE));
@@ -181,35 +206,22 @@ TEST_F(HdcCommonTest, SendHdcDefaultMsg_HalHdcSendSocketClosed)
181 EXPECT_EQ(ret, TSD_HDC_SERVER_CLIENT_SOCKET_CLOSED);206 EXPECT_EQ(ret, TSD_HDC_SERVER_CLIENT_SOCKET_CLOSED);
182}207}
183 208 
184-TEST_F(HdcCommonTest, RecvHdcDefaultMsg_HalHdcRecvFailed)209+TEST_F(HdcCommonTest, RecvHdcDefaultMsg_RecvAndDfxQueriesFail_PreservesOutputs)
185{210{
186 HdcCommon hdcCommon;211 HdcCommon hdcCommon;
187 hdcCommon.InitMsgSize();212 hdcCommon.InitMsgSize();
188 HDC_SESSION session = reinterpret_cast<HDC_SESSION>(0x1);213 HDC_SESSION session = reinterpret_cast<HDC_SESSION>(0x1);
189 drvHdcMsg drvMsg;214 drvHdcMsg drvMsg;
190- char_t* buffer = nullptr;215+ char_t* buffer = reinterpret_cast<char_t*>(0x1234);
191- uint32_t bufferLengthOut = 0U;216+ uint32_t bufferLengthOut = 77U;
192 217 
193- MOCKER(&halHdcRecv).stubs().will(returnValue(DRV_ERROR_INNER_ERR));218+ MOCKER(&halHdcRecv).expects(exactly(1)).will(returnValue(DRV_ERROR_INNER_ERR));
194- 219+ MOCKER(&halHdcGetSessionAttr).expects(exactly(1)).will(invoke(HalHdcGetSessionAttrDfxFailNegativeStub));
195- TSD_StatusT ret = hdcCommon.RecvHdcDefaultMsg(session, &drvMsg, buffer, bufferLengthOut, 1000U);
196- EXPECT_EQ(ret, TSD_HDC_RECV_MSG_ERROR);
197-}
198- 
199-TEST_F(HdcCommonTest, RecvHdcDefaultMsg_HalHdcRecvFailed_DfxAttrCheckFailed)
200-{
201- HdcCommon hdcCommon;
202- hdcCommon.InitMsgSize();
203- HDC_SESSION session = reinterpret_cast<HDC_SESSION>(0x1);
204- drvHdcMsg drvMsg;
205- char_t* buffer = nullptr;
206- uint32_t bufferLengthOut = 0U;
207- 
208- MOCKER(&halHdcRecv).stubs().will(returnValue(DRV_ERROR_INNER_ERR));
209- MOCKER(&halHdcGetSessionAttr).stubs().will(invoke(HalHdcGetSessionAttrDfxFailNegativeStub));
210 220 
211 TSD_StatusT ret = hdcCommon.RecvHdcDefaultMsg(session, &drvMsg, buffer, bufferLengthOut, 1000U);221 TSD_StatusT ret = hdcCommon.RecvHdcDefaultMsg(session, &drvMsg, buffer, bufferLengthOut, 1000U);
212 EXPECT_EQ(ret, TSD_HDC_RECV_MSG_ERROR);222 EXPECT_EQ(ret, TSD_HDC_RECV_MSG_ERROR);
223+ EXPECT_EQ(buffer, reinterpret_cast<char_t*>(0x1234));
224+ EXPECT_EQ(bufferLengthOut, 77U);
213}225}
214 226 
215TEST_F(HdcCommonTest, RecvHdcDefaultMsg_HalHdcRecvSocketClosed)227TEST_F(HdcCommonTest, RecvHdcDefaultMsg_HalHdcRecvSocketClosed)
@@ -326,12 +338,13 @@ TEST_F(HdcCommonTest, RecvMsg_FreeMsgFailAfterRecv)
326 EXPECT_EQ(ret, TSD_HDC_RECV_MSG_ERROR);338 EXPECT_EQ(ret, TSD_HDC_RECV_MSG_ERROR);
327}339}
328 340 
329-TEST_F(HdcCommonTest, GetHdcAttrStatus_HalFail)341+TEST_F(HdcCommonTest, GetHdcAttrStatus_DriverQueryFails_PreservesOutput)
330{342{
331 HdcCommon hdcCommon;343 HdcCommon hdcCommon;
332 HDC_SESSION session = reinterpret_cast<HDC_SESSION>(0x1);344 HDC_SESSION session = reinterpret_cast<HDC_SESSION>(0x1);
333- int32_t hdcSessStat = 0;345+ int32_t hdcSessStat = 77;
334- MOCKER(&halHdcGetSessionAttr).stubs().will(returnValue(DRV_ERROR_INNER_ERR));346+ MOCKER(&halHdcGetSessionAttr).expects(exactly(1)).will(returnValue(DRV_ERROR_INNER_ERR));
335 TSD_StatusT ret = hdcCommon.GetHdcAttrStatus(session, hdcSessStat);347 TSD_StatusT ret = hdcCommon.GetHdcAttrStatus(session, hdcSessStat);
336 EXPECT_EQ(ret, TSD_HDC_SESSION_STATUS_GET_FAILED);348 EXPECT_EQ(ret, TSD_HDC_SESSION_STATUS_GET_FAILED);
349+ EXPECT_EQ(hdcSessStat, 77);
337}350}
Rtests/ut/tsd/tsdclient/test/version_verify_utest.cpp→tests/ut/tsd/basic_component/device_comm/version_verify_utest.cpp+29-14
@@ -32,7 +32,7 @@ protected:
32 }32 }
33};33};
34 34 
35-TEST_F(VersionVerifyTest, PeerVersionCheckFalse)35+TEST_F(VersionVerifyTest, PeerVersionCheck_ZeroVersion_ReturnsFalse)
36{36{
37 std::shared_ptr<VersionVerify> versionVerify = std::make_shared<VersionVerify>();37 std::shared_ptr<VersionVerify> versionVerify = std::make_shared<VersionVerify>();
38 HDCMessage::VersionInfo peer_version_info;38 HDCMessage::VersionInfo peer_version_info;
@@ -41,7 +41,7 @@ TEST_F(VersionVerifyTest, PeerVersionCheckFalse)
41 EXPECT_EQ(false, ret);41 EXPECT_EQ(false, ret);
42}42}
43 43 
44-TEST_F(VersionVerifyTest, SpecialFeatureCheck)44+TEST_F(VersionVerifyTest, SpecialFeatureCheck_FeatureListMismatch_ReturnsFalse)
45{45{
46 std::shared_ptr<VersionVerify> versionVerify = std::make_shared<VersionVerify>();46 std::shared_ptr<VersionVerify> versionVerify = std::make_shared<VersionVerify>();
47 versionVerify->peerFeatureList_[HDCMessage::TSD_START_PROC_MSG] = {"test1"};47 versionVerify->peerFeatureList_[HDCMessage::TSD_START_PROC_MSG] = {"test1"};
@@ -49,18 +49,25 @@ TEST_F(VersionVerifyTest, SpecialFeatureCheck)
49 EXPECT_EQ(false, ret);49 EXPECT_EQ(false, ret);
50}50}
51 51 
52-TEST_F(VersionVerifyTest, SetVersionInfo)52+TEST_F(VersionVerifyTest, SetVersionInfo_NewMessage_WritesExactCompatibilityContract)
53{53{
54 HDCMessage msg;54 HDCMessage msg;
55 std::shared_ptr<VersionVerify> versionVerify = std::make_shared<VersionVerify>();55 std::shared_ptr<VersionVerify> versionVerify = std::make_shared<VersionVerify>();
56 versionVerify->SetVersionInfo(msg);56 versionVerify->SetVersionInfo(msg);
57- uint32_t version = msg.mutable_version_info()->version();57+ const HDCMessage::VersionInfo& versionInfo = msg.version_info();
58- EXPECT_EQ(version, 1230);58+ EXPECT_EQ(versionInfo.version(), 1230U);
59- 59+ ASSERT_EQ(versionInfo.feature_list_size(), 3);
60- versionVerify->ParseVersionInfo(msg.version_info());60+ std::map<HDCMessage::MsgType, std::string> features;
61- EXPECT_EQ(versionVerify->peerFeatureList_.empty(), false);61+ for (const auto& featureList : versionInfo.feature_list()) {
62+ ASSERT_EQ(featureList.feature_size(), 1);
63+ features[featureList.msg_type()] = featureList.feature(0);
64+ }
65+ EXPECT_EQ(features.at(HDCMessage::TSD_CHECK_PACKAGE), "check before send aicpu package");
66+ EXPECT_EQ(features.at(HDCMessage::TSD_START_QS_MSG), "check before send open qs message");
67+ EXPECT_EQ(features.at(HDCMessage::TSD_CHECK_PACKAGE_RETRY), "get check code retry");
62}68}
63-TEST_F(VersionVerifyTest, PeerVersionCheckTrue)69+ 
70+TEST_F(VersionVerifyTest, PeerVersionCheck_MatchingVersion_ReturnsTrue)
64{71{
65 HDCMessage::VersionInfo peerVersionInfo;72 HDCMessage::VersionInfo peerVersionInfo;
66 peerVersionInfo.set_version(1230);73 peerVersionInfo.set_version(1230);
@@ -69,9 +76,8 @@ TEST_F(VersionVerifyTest, PeerVersionCheckTrue)
69 EXPECT_EQ(ret, true);76 EXPECT_EQ(ret, true);
70}77}
71 78 
72-TEST_F(VersionVerifyTest, SpecialFeatureCheck_fail_001)79+TEST_F(VersionVerifyTest, SpecialFeatureCheck_CachedUnsupportedType_ReturnsFalse)
73{80{
74- HDCMessage::VersionInfo peerVersionInfo;
75 const HDCMessage::MsgType msgType = HDCMessage::TSD_OPEN_SUB_PROC_RSP;81 const HDCMessage::MsgType msgType = HDCMessage::TSD_OPEN_SUB_PROC_RSP;
76 std::shared_ptr<VersionVerify> versionVerify = std::make_shared<VersionVerify>();82 std::shared_ptr<VersionVerify> versionVerify = std::make_shared<VersionVerify>();
77 versionVerify->alreadyCheckedList_.insert(std::make_pair(msgType, false));83 versionVerify->alreadyCheckedList_.insert(std::make_pair(msgType, false));
@@ -79,9 +85,8 @@ TEST_F(VersionVerifyTest, SpecialFeatureCheck_fail_001)
79 EXPECT_EQ(ret, false);85 EXPECT_EQ(ret, false);
80}86}
81 87 
82-TEST_F(VersionVerifyTest, SpecialFeatureCheck_fail_002)88+TEST_F(VersionVerifyTest, SpecialFeatureCheck_LegacyTypeAbsentFromBothLists_ReturnsTrue)
83{89{
84- HDCMessage::VersionInfo peerVersionInfo;
85 const HDCMessage::MsgType msgType = HDCMessage::TSD_OPEN_SUB_PROC_RSP;90 const HDCMessage::MsgType msgType = HDCMessage::TSD_OPEN_SUB_PROC_RSP;
86 std::shared_ptr<VersionVerify> versionVerify = std::make_shared<VersionVerify>();91 std::shared_ptr<VersionVerify> versionVerify = std::make_shared<VersionVerify>();
87 versionVerify->peerFeatureList_.clear();92 versionVerify->peerFeatureList_.clear();
@@ -89,7 +94,7 @@ TEST_F(VersionVerifyTest, SpecialFeatureCheck_fail_002)
89 EXPECT_EQ(ret, true);94 EXPECT_EQ(ret, true);
90}95}
91 96 
92-TEST_F(VersionVerifyTest, SpecialFeatureCheck_for_compatible_scenario)97+TEST_F(VersionVerifyTest, SpecialFeatureCheck_ExactAndMismatchedFeatureLists_ReturnsExpectedSupport)
93{98{
94 std::shared_ptr<VersionVerify> versionVerify = std::make_shared<VersionVerify>();99 std::shared_ptr<VersionVerify> versionVerify = std::make_shared<VersionVerify>();
95 // attention: 模拟老版驱动device侧支持的feature list，不可修改100 // attention: 模拟老版驱动device侧支持的feature list，不可修改
@@ -109,3 +114,13 @@ TEST_F(VersionVerifyTest, SpecialFeatureCheck_for_compatible_scenario)
109 versionVerify->peerFeatureList_[HDCMessage::TSD_CHECK_PACKAGE] = {"check before send aicpu package error msg"};114 versionVerify->peerFeatureList_[HDCMessage::TSD_CHECK_PACKAGE] = {"check before send aicpu package error msg"};
110 EXPECT_FALSE(versionVerify->SpecialFeatureCheck(HDCMessage::TSD_CHECK_PACKAGE));115 EXPECT_FALSE(versionVerify->SpecialFeatureCheck(HDCMessage::TSD_CHECK_PACKAGE));
111}116}
117+ 
118+TEST_F(VersionVerifyTest, PeerVersionCheck_NonzeroMismatchedVersion_ReturnsFalse)
119+{
120+ HDCMessage::VersionInfo peerVersionInfo;
121+ peerVersionInfo.set_version(1229U);
122+ VersionVerify versionVerify;
123+ 
124+ EXPECT_FALSE(versionVerify.PeerVersionCheck(peerVersionInfo));
125+ EXPECT_EQ(versionVerify.peerVersion_, 1229U);
126+}
Rtests/ut/tsd/tsdclient/test/hdc_message_builder_utest.cpp→tests/ut/tsd/basic_component/message_builder/hdc_message_builder_utest.cpp+48-22
@@ -74,7 +74,12 @@ protected:
74 {74 {
75 cout << "After HdcMessageBuilderTest" << endl;75 cout << "After HdcMessageBuilderTest" << endl;
76 g_mockAscendAicpuPath = nullptr;76 g_mockAscendAicpuPath = nullptr;
77- GlobalMockObject::verify();77+ try {
78+ GlobalMockObject::verify();
79+ } catch (...) {
80+ GlobalMockObject::reset();
81+ throw;
82+ }
78 GlobalMockObject::reset();83 GlobalMockObject::reset();
79 }84 }
80};85};
@@ -122,8 +127,10 @@ TEST_F(HdcMessageBuilderTest, BuildOpen_EmptyAicpuPathWhenEnvUnset)
122 127 
123 MessageContext ctx = MakeSeededContext();128 MessageContext ctx = MakeSeededContext();
124 HDCMessage msg;129 HDCMessage msg;
130+ msg.mutable_ascend_aicpu_path()->set_ascend_aicpu_path("stale-path");
125 EXPECT_EQ(HdcMessageBuilder::BuildOpen(msg, ctx), TSD_OK);131 EXPECT_EQ(HdcMessageBuilder::BuildOpen(msg, ctx), TSD_OK);
126 EXPECT_EQ(msg.ascend_aicpu_path().ascend_aicpu_path(), "");132 EXPECT_EQ(msg.ascend_aicpu_path().ascend_aicpu_path(), "");
133+ EXPECT_EQ(msg.type(), HDCMessage::TSD_START_PROC_MSG);
127}134}
128 135 
129TEST_F(HdcMessageBuilderTest, BuildOpen_StartFlagsBothTrue)136TEST_F(HdcMessageBuilderTest, BuildOpen_StartFlagsBothTrue)
@@ -143,6 +150,8 @@ TEST_F(HdcMessageBuilderTest, BuildOpen_StartFlagsBothFalse)
143 ctx.startHccp = false;150 ctx.startHccp = false;
144 ctx.startCp = false;151 ctx.startCp = false;
145 HDCMessage msg;152 HDCMessage msg;
153+ msg.set_start_hccp(true);
154+ msg.set_start_cp(true);
146 EXPECT_EQ(HdcMessageBuilder::BuildOpen(msg, ctx), TSD_OK);155 EXPECT_EQ(HdcMessageBuilder::BuildOpen(msg, ctx), TSD_OK);
147 EXPECT_FALSE(msg.start_hccp());156 EXPECT_FALSE(msg.start_hccp());
148 EXPECT_FALSE(msg.start_cp());157 EXPECT_FALSE(msg.start_cp());
@@ -213,8 +222,10 @@ TEST_F(HdcMessageBuilderTest, BuildOmFileDecompress_EmptyOmfileName)
213 MessageContext ctx = MakeSeededContext();222 MessageContext ctx = MakeSeededContext();
214 ctx.omfileName.clear();223 ctx.omfileName.clear();
215 HDCMessage msg;224 HDCMessage msg;
225+ msg.set_omfile_name("stale.om");
216 EXPECT_EQ(HdcMessageBuilder::BuildOmFileDecompress(msg, ctx), TSD_OK);226 EXPECT_EQ(HdcMessageBuilder::BuildOmFileDecompress(msg, ctx), TSD_OK);
217 EXPECT_EQ(msg.omfile_name(), "");227 EXPECT_EQ(msg.omfile_name(), "");
228+ EXPECT_EQ(msg.type(), HDCMessage::TSD_OM_PKG_DECOMPRESS_STATUS);
218}229}
219 230 
220// ===== BuildPackageCheckCode =====231// ===== BuildPackageCheckCode =====
@@ -242,8 +253,10 @@ TEST_F(HdcMessageBuilderTest, BuildPackageCheckCode_BeforeSendPkgFalse)
242 ctx.msgType = static_cast<uint32_t>(HDCMessage::TSD_CHECK_PACKAGE);253 ctx.msgType = static_cast<uint32_t>(HDCMessage::TSD_CHECK_PACKAGE);
243 ctx.beforeSendPkg = false;254 ctx.beforeSendPkg = false;
244 HDCMessage msg;255 HDCMessage msg;
256+ msg.set_before_send_pkg(true);
245 EXPECT_EQ(HdcMessageBuilder::BuildPackageCheckCode(msg, ctx), TSD_OK);257 EXPECT_EQ(HdcMessageBuilder::BuildPackageCheckCode(msg, ctx), TSD_OK);
246 EXPECT_FALSE(msg.before_send_pkg());258 EXPECT_FALSE(msg.before_send_pkg());
259+ EXPECT_EQ(msg.type(), HDCMessage::TSD_CHECK_PACKAGE);
247}260}
248 261 
249// ===== BuildCapability =====262// ===== BuildCapability =====
@@ -266,6 +279,30 @@ TEST_F(HdcMessageBuilderTest, BuildCapability_Level)
266 HDCMessage msg;279 HDCMessage msg;
267 EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);280 EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);
268 EXPECT_EQ(msg.type(), HDCMessage::TSD_GET_SUPPORT_CAPABILITY_LEVEL);281 EXPECT_EQ(msg.type(), HDCMessage::TSD_GET_SUPPORT_CAPABILITY_LEVEL);
282+ EXPECT_EQ(msg.device_id(), DEV_ID % PER_OS_CHIP_NUM);
283+ EXPECT_EQ(msg.real_device_id(), DEV_ID);
284+}
285+ 
286+TEST_F(HdcMessageBuilderTest, BuildCapability_BuiltinUdf)
287+{
288+ MessageContext ctx = MakeSeededContext();
289+ ctx.capabilityType = TSD_CAPABILITY_BUILTIN_UDF;
290+ HDCMessage msg;
291+ EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);
292+ EXPECT_EQ(msg.type(), HDCMessage::TSD_GET_SUPPORT_CAPABILITY_LEVEL);
293+ EXPECT_EQ(msg.device_id(), DEV_ID % PER_OS_CHIP_NUM);
294+ EXPECT_EQ(msg.real_device_id(), DEV_ID);
295+}
296+ 
297+TEST_F(HdcMessageBuilderTest, BuildCapability_MultipleHccp)
298+{
299+ MessageContext ctx = MakeSeededContext();
300+ ctx.capabilityType = TSD_CAPABILITY_MUTIPLE_HCCP;
301+ HDCMessage msg;
302+ EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);
303+ EXPECT_EQ(msg.type(), HDCMessage::TSD_GET_SUPPORT_CAPABILITY_LEVEL);
304+ EXPECT_EQ(msg.device_id(), DEV_ID % PER_OS_CHIP_NUM);
305+ EXPECT_EQ(msg.real_device_id(), DEV_ID);
269}306}
270 307 
271TEST_F(HdcMessageBuilderTest, BuildCapability_OmInnerDec)308TEST_F(HdcMessageBuilderTest, BuildCapability_OmInnerDec)
@@ -291,9 +328,10 @@ TEST_F(HdcMessageBuilderTest, BuildCapability_InvalidType_SpecIsNull)
291 MessageContext ctx = MakeSeededContext();328 MessageContext ctx = MakeSeededContext();
292 ctx.capabilityType = TSD_CAPABILITY_BUT; // 越界，FindCapabilitySpec 返回 nullptr329 ctx.capabilityType = TSD_CAPABILITY_BUT; // 越界，FindCapabilitySpec 返回 nullptr
293 HDCMessage msg;330 HDCMessage msg;
331+ msg.set_type(HDCMessage::TSD_CLOSE_PROC_MSG);
294 EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);332 EXPECT_EQ(HdcMessageBuilder::BuildCapability(msg, ctx), TSD_OK);
295- // spec == nullptr 分支：不调用 set_type，type 保持默认 INIT333+ // spec == nullptr 分支不覆盖已有消息类型。
296- EXPECT_EQ(msg.type(), HDCMessage::INIT);334+ EXPECT_EQ(msg.type(), HDCMessage::TSD_CLOSE_PROC_MSG);
297 EXPECT_EQ(msg.device_id(), DEV_ID % PER_OS_CHIP_NUM);335 EXPECT_EQ(msg.device_id(), DEV_ID % PER_OS_CHIP_NUM);
298 EXPECT_EQ(msg.real_device_id(), DEV_ID);336 EXPECT_EQ(msg.real_device_id(), DEV_ID);
299}337}
@@ -345,8 +383,10 @@ TEST_F(HdcMessageBuilderTest, BuildRemoveFile_EmptyPath)
345 MessageContext ctx = MakeSeededContext();383 MessageContext ctx = MakeSeededContext();
346 ctx.removeFilePath.clear();384 ctx.removeFilePath.clear();
347 HDCMessage msg;385 HDCMessage msg;
386+ msg.set_remove_file_path("stale-path");
348 EXPECT_EQ(HdcMessageBuilder::BuildRemoveFile(msg, ctx), TSD_OK);387 EXPECT_EQ(HdcMessageBuilder::BuildRemoveFile(msg, ctx), TSD_OK);
349 EXPECT_EQ(msg.remove_file_path(), "");388 EXPECT_EQ(msg.remove_file_path(), "");
389+ EXPECT_EQ(msg.type(), HDCMessage::TSD_REMOVE_FILE);
350}390}
351 391 
352// ===== BuildCannHsCheckCode =====392// ===== BuildCannHsCheckCode =====
@@ -379,6 +419,7 @@ TEST_F(HdcMessageBuilderTest, BuildCannHsCheckCode_EmptyNameAndHash)
379 ctx.hashCode.clear();419 ctx.hashCode.clear();
380 HDCMessage msg;420 HDCMessage msg;
381 EXPECT_EQ(HdcMessageBuilder::BuildCannHsCheckCode(msg, ctx), TSD_OK);421 EXPECT_EQ(HdcMessageBuilder::BuildCannHsCheckCode(msg, ctx), TSD_OK);
422+ EXPECT_EQ(msg.type(), HDCMessage::TSD_GET_DEVICE_CANN_HS_CHECKCODE);
382 ASSERT_EQ(msg.package_hash_code_list_size(), 1);423 ASSERT_EQ(msg.package_hash_code_list_size(), 1);
383 EXPECT_EQ(msg.package_hash_code_list(0).package_name(), "");424 EXPECT_EQ(msg.package_hash_code_list(0).package_name(), "");
384 EXPECT_EQ(msg.package_hash_code_list(0).hash_code(), "");425 EXPECT_EQ(msg.package_hash_code_list(0).hash_code(), "");
@@ -546,6 +587,7 @@ TEST_F(HdcMessageBuilderTest, BuildCommonOpen_NoOptionalFields)
546 ctx.subProcEnvList.clear();587 ctx.subProcEnvList.clear();
547 ctx.subProcExtParamList.clear();588 ctx.subProcExtParamList.clear();
548 HDCMessage msg;589 HDCMessage msg;
590+ msg.set_type(HDCMessage::TSD_CLOSE_PROC_MSG);
549 EXPECT_EQ(HdcMessageBuilder::BuildCommonOpen(msg, ctx), TSD_OK);591 EXPECT_EQ(HdcMessageBuilder::BuildCommonOpen(msg, ctx), TSD_OK);
550 592 
551 EXPECT_EQ(msg.type(), HDCMessage::TSD_OPEN_SUB_PROC);593 EXPECT_EQ(msg.type(), HDCMessage::TSD_OPEN_SUB_PROC);
@@ -639,33 +681,16 @@ TEST_F(HdcMessageBuilderTest, BuildCheckPackageRetry_WaitFlagFalse)
639 ctx.waitFlag = false;681 ctx.waitFlag = false;
640 ctx.checkCode = 0U;682 ctx.checkCode = 0U;
641 HDCMessage msg;683 HDCMessage msg;
684+ msg.set_wait_flag(true);
642 EXPECT_EQ(HdcMessageBuilder::BuildCheckPackageRetry(msg, ctx), TSD_OK);685 EXPECT_EQ(HdcMessageBuilder::BuildCheckPackageRetry(msg, ctx), TSD_OK);
643 EXPECT_FALSE(msg.wait_flag());686 EXPECT_FALSE(msg.wait_flag());
644 EXPECT_EQ(msg.check_code(), 0U);687 EXPECT_EQ(msg.check_code(), 0U);
688+ EXPECT_EQ(msg.type(), HDCMessage::TSD_CHECK_PACKAGE_RETRY);
645}689}
646 690 
647// ===== BuildCheckPackage =====691// ===== BuildCheckPackage =====
648// 该函数有 3 个独立 `!= 0U` 分支，逐个覆盖。692// 该函数有 3 个独立 `!= 0U` 分支，逐个覆盖。
649 693 
650-TEST_F(HdcMessageBuilderTest, BuildCheckPackage_AllCheckCodesZero)
651-{
652- MessageContext ctx = MakeSeededContext();
653- ctx.checkCode = 0U;
654- ctx.extendpkgCheckCode = 0U;
655- ctx.ascendcppCheckCode = 0U;
656- ctx.asan = false;
657- HDCMessage msg;
658- EXPECT_EQ(HdcMessageBuilder::BuildCheckPackage(msg, ctx), TSD_OK);
659- 
660- EXPECT_EQ(msg.real_device_id(), DEV_ID);
661- EXPECT_EQ(msg.type(), HDCMessage::TSD_CHECK_PACKAGE);
662- EXPECT_FALSE(msg.asan());
663- // 3 个分支均未进入，对应字段保持默认值 0
664- EXPECT_EQ(msg.check_code(), 0U);
665- EXPECT_EQ(msg.extendpkg_check_code(), 0U);
666- EXPECT_EQ(msg.ascendcpppkg_check_code(), 0U);
667-}
668- 
669TEST_F(HdcMessageBuilderTest, BuildCheckPackage_OnlyCheckCodeNonZero)694TEST_F(HdcMessageBuilderTest, BuildCheckPackage_OnlyCheckCodeNonZero)
670{695{
671 MessageContext ctx = MakeSeededContext();696 MessageContext ctx = MakeSeededContext();
@@ -847,6 +872,7 @@ TEST_F(HdcMessageBuilderTest, BuildNormalCheckCode_EmptyPackageNameAndHash)
847 ctx.hashCode.clear();872 ctx.hashCode.clear();
848 HDCMessage msg;873 HDCMessage msg;
849 EXPECT_EQ(HdcMessageBuilder::BuildNormalCheckCode(msg, ctx), TSD_OK);874 EXPECT_EQ(HdcMessageBuilder::BuildNormalCheckCode(msg, ctx), TSD_OK);
875+ EXPECT_EQ(msg.type(), HDCMessage::TSD_GET_DEVICE_PACKAGE_CHECKCODE_NORMAL);
850 ASSERT_EQ(msg.package_hash_code_list_size(), 1);876 ASSERT_EQ(msg.package_hash_code_list_size(), 1);
851 EXPECT_EQ(msg.package_hash_code_list(0).package_name(), "");877 EXPECT_EQ(msg.package_hash_code_list(0).package_name(), "");
852 EXPECT_EQ(msg.package_hash_code_list(0).hash_code(), "");878 EXPECT_EQ(msg.package_hash_code_list(0).hash_code(), "");
Rtests/ut/tsd/tsdclient/test/common_util_func.cpp→tests/ut/tsd/basic_component/message_rsp_handler/message_parse_client_utest.cpp+11-16
@@ -7,22 +7,17 @@
7 * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.7 * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8 * See LICENSE in the root of the software repository for the full text of the License.8 * See LICENSE in the root of the software repository for the full text of the License.
9 */9 */
10-#include "common_util_func.h"
11-#include <iostream>
12-#include <fstream>
13-namespace tsd {
14 10 
15-bool WriteTmpFile(const std::string& filePath, const std::string& fileName)11+#include "gtest/gtest.h"
12+#include "tsd_message_parse_client.h"
13+ 
14+using namespace tsd;
15+ 
16+TEST(MessageParseClientUTest, GetInstanceReturnsSingleton)
16{17{
17- // ut工程只运行在tmp目录下写小文件，用完之后要及时删除18+ MessageParseClient* first = MessageParseClient::GetInstance();
18- const std::string dstFile = "/tmp/" + filePath + "/" + fileName;19+ MessageParseClient* second = MessageParseClient::GetInstance();
19- std::ofstream outFile(dstFile);20+ 
20- if (!outFile) {21+ EXPECT_NE(first, nullptr);
21- std::cout << "Can not creat file " << dstFile << std::endl;22+ EXPECT_EQ(first, second);
22- return false;
23- }
24- outFile << "this is tmp file" << std::endl;
25- outFile.close();
26- return true;
27}23}
28-} // namespace tsd
Atests/ut/tsd/basic_component/message_rsp_handler/message_parse_interface_utest.cpp+113-0
@@ -0,0 +1,113 @@
1+/**
2+ * Copyright (c) 2026 Huawei Technologies Co., Ltd.
3+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4+ * CANN Open Software License Agreement Version 2.0 (the "License").
5+ * Please refer to the License for details. You may not use this file except in compliance with the License.
6+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8+ * See LICENSE in the root of the software repository for the full text of the License.
9+ */
10+ 
11+#include "gtest/gtest.h"
12+#include "tsd_message_parse_interface.h"
13+ 
14+using namespace tsd;
15+ 
16+namespace {
17+class TestMessageParseInterface final : public MessageParseInterface {
18+public:
19+ TestMessageParseInterface() = default;
20+};
21+ 
22+uint32_t g_firstCount = 0U;
23+uint32_t g_secondCount = 0U;
24+uint32_t g_sessionId = 0U;
25+HDCMessage::MsgType g_msgType = HDCMessage::INIT;
26+ 
27+void FirstParser(uint32_t sessionId, const HDCMessage& msg)
28+{
29+ ++g_firstCount;
30+ g_sessionId = sessionId;
31+ g_msgType = msg.type();
32+}
33+ 
34+void SecondParser(uint32_t, const HDCMessage&) { ++g_secondCount; }
35+} // namespace
36+ 
37+class MessageParseInterfaceBehaviorUTest : public testing::Test {
38+protected:
39+ void SetUp() override
40+ {
41+ g_firstCount = 0U;
42+ g_secondCount = 0U;
43+ g_sessionId = 0U;
44+ g_msgType = HDCMessage::INIT;
45+ }
46+};
47+ 
48+TEST_F(MessageParseInterfaceBehaviorUTest, FirstRegistrationDispatchesMatchingMessage)
49+{
50+ TestMessageParseInterface parser;
51+ parser.RegisterMsgProcess(HDCMessage::TEST_HDC_SEND, FirstParser);
52+ HDCMessage msg;
53+ msg.set_type(HDCMessage::TEST_HDC_SEND);
54+ 
55+ parser.ProcessMessage(123U, msg);
56+ 
57+ EXPECT_EQ(g_firstCount, 1U);
58+ EXPECT_EQ(g_sessionId, 123U);
59+ EXPECT_EQ(g_msgType, HDCMessage::TEST_HDC_SEND);
60+}
61+ 
62+TEST_F(MessageParseInterfaceBehaviorUTest, RegistrationForSameTypeReplacesParser)
63+{
64+ TestMessageParseInterface parser;
65+ parser.RegisterMsgProcess(HDCMessage::TEST_HDC_SEND, FirstParser);
66+ parser.RegisterMsgProcess(HDCMessage::TEST_HDC_SEND, SecondParser);
67+ HDCMessage msg;
68+ msg.set_type(HDCMessage::TEST_HDC_SEND);
69+ 
70+ parser.ProcessMessage(1U, msg);
71+ 
72+ EXPECT_EQ(g_firstCount, 0U);
73+ EXPECT_EQ(g_secondCount, 1U);
74+}
75+ 
76+TEST_F(MessageParseInterfaceBehaviorUTest, NullParserReplacesExistingParserWithoutDispatch)
77+{
78+ TestMessageParseInterface parser;
79+ parser.RegisterMsgProcess(HDCMessage::TEST_HDC_SEND, FirstParser);
80+ parser.RegisterMsgProcess(HDCMessage::TEST_HDC_SEND, nullptr);
81+ HDCMessage msg;
82+ msg.set_type(HDCMessage::TEST_HDC_SEND);
83+ 
84+ parser.ProcessMessage(1U, msg);
85+ 
86+ EXPECT_EQ(g_firstCount, 0U);
87+}
88+ 
89+TEST_F(MessageParseInterfaceBehaviorUTest, UnknownTypeDoesNotDispatch)
90+{
91+ TestMessageParseInterface parser;
92+ parser.RegisterMsgProcess(HDCMessage::TEST_HDC_SEND, FirstParser);
93+ HDCMessage msg;
94+ msg.set_type(HDCMessage::INIT);
95+ 
96+ parser.ProcessMessage(1U, msg);
97+ 
98+ EXPECT_EQ(g_firstCount, 0U);
99+}
100+ 
101+TEST_F(MessageParseInterfaceBehaviorUTest, MultipleTypesDispatchOnlyMatchingParser)
102+{
103+ TestMessageParseInterface parser;
104+ parser.RegisterMsgProcess(HDCMessage::TEST_HDC_SEND, FirstParser);
105+ parser.RegisterMsgProcess(HDCMessage::INIT, SecondParser);
106+ HDCMessage msg;
107+ msg.set_type(HDCMessage::INIT);
108+ 
109+ parser.ProcessMessage(1U, msg);
110+ 
111+ EXPECT_EQ(g_firstCount, 0U);
112+ EXPECT_EQ(g_secondCount, 1U);
113+}
Rtests/ut/tsd/tsdclient/test/aicpu_package_process_utest.cpp→tests/ut/tsd/basic_component/package_manager/aicpu_package_process_utest.cpp+47-74
@@ -45,37 +45,8 @@ char* RealpathFakeOpenFail(const char* path, char* resolvedPath)
45 return resolvedPath;45 return resolvedPath;
46}46}
47 47 
48-std::string GetDirName()
49-{
50- std::unique_ptr<char_t[]> path(new (std::nothrow) char_t[PATH_MAX]);
51- if (path == nullptr) {
52- std::cout << "Oom" << std::endl;
53- return "";
54- }
55- const int32_t eRet = memset_s(path.get(), PATH_MAX, 0, PATH_MAX);
56- if (eRet != EOK) {
57- std::cout << "memset failed" << std::endl;
58- return "";
59- }
60- 
61- const auto ret = getcwd(path.get(), PATH_MAX);
62- if (ret == nullptr) {
63- std::cout << "Get current work path failed" << std::endl;
64- return "";
65- }
66- 
67- std::string dirPath(path.get());
68- if (dirPath.back() != '/') {
69- dirPath.append("/");
70- }
71- dirPath.append(std::to_string(getpid())).append("versionFileDir/");
72- 
73- return dirPath;
74-}
75- 
76bool CreateVersionFile(const std::string& dirPath)48bool CreateVersionFile(const std::string& dirPath)
77{49{
78- (void)PackageWorkerUtils::MakeDirectory(dirPath);
79 std::string fileName = dirPath + "version.info";50 std::string fileName = dirPath + "version.info";
80 std::cout << fileName << std::endl;51 std::cout << fileName << std::endl;
81 52 
@@ -110,6 +81,9 @@ bool CreateVersionFile(const std::string& dirPath)
110 81 
111void ClearDir(const std::string& dirPath)82void ClearDir(const std::string& dirPath)
112{83{
84+ if (dirPath.empty()) {
85+ return;
86+ }
113 const std::string cmd = "rm -rf " + dirPath;87 const std::string cmd = "rm -rf " + dirPath;
114 PackSystem(cmd.c_str());88 PackSystem(cmd.c_str());
115}89}
@@ -117,24 +91,39 @@ void ClearDir(const std::string& dirPath)
117 91 
118class AicpuPackageProcessTest : public testing::Test {92class AicpuPackageProcessTest : public testing::Test {
119protected:93protected:
120- virtual void SetUp() {}94+ void SetUp() override
95+ {
96+ char dirTemplate[] = "/tmp/aicpu_package_process_ut_XXXXXX";
97+ char* dir = mkdtemp(dirTemplate);
98+ ASSERT_NE(dir, nullptr);
99+ soInstallPath_ = std::string(dir) + "/";
100+ }
121 101 
122- virtual void TearDown() { GlobalMockObject::verify(); }102+ void TearDown() override
103+ {
104+ try {
105+ GlobalMockObject::verify();
106+ } catch (...) {
107+ GlobalMockObject::reset();
108+ ClearDir(soInstallPath_);
109+ throw;
110+ }
111+ GlobalMockObject::reset();
112+ ClearDir(soInstallPath_);
113+ }
114+ 
115+ std::string soInstallPath_;
123};116};
124 117 
125-TEST_F(AicpuPackageProcessTest, CheckPackageNameSuccess)118+TEST_F(AicpuPackageProcessTest, CheckPackageName_SourceMatchesVersionFile_ReturnsOk)
126{119{
127- const std::string soInstallPath = GetDirName();120+ ASSERT_TRUE(CreateVersionFile(soInstallPath_));
128- if (!CreateVersionFile(soInstallPath)) {
129- return;
130- }
131 const std::string packageName = "/test/asd/Ascend910-aicpu_syskernels.tar.gz";121 const std::string packageName = "/test/asd/Ascend910-aicpu_syskernels.tar.gz";
132- const TSD_StatusT ret = AicpuPackageProcess::CheckPackageName(soInstallPath, packageName);122+ const TSD_StatusT ret = AicpuPackageProcess::CheckPackageName(soInstallPath_, packageName);
133- ClearDir(soInstallPath);
134 EXPECT_EQ(ret, TSD_OK);123 EXPECT_EQ(ret, TSD_OK);
135}124}
136 125 
137-TEST_F(AicpuPackageProcessTest, CheckPackageNameFail)126+TEST_F(AicpuPackageProcessTest, CheckPackageName_VersionFileMissing_ReturnsInternalError)
138{127{
139 const std::string soInstallPath = "/usr/lib64/aicpu_kernels/0";128 const std::string soInstallPath = "/usr/lib64/aicpu_kernels/0";
140 const std::string packageName = "/test/asd/Ascend_test_tsd.tar.gz";129 const std::string packageName = "/test/asd/Ascend_test_tsd.tar.gz";
@@ -142,7 +131,7 @@ TEST_F(AicpuPackageProcessTest, CheckPackageNameFail)
142 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);131 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);
143}132}
144 133 
145-TEST_F(AicpuPackageProcessTest, CheckPackageNameGetSrcPkgNameFail)134+TEST_F(AicpuPackageProcessTest, CheckPackageName_SourceNameContainsInvalidCharacter_ReturnsStartFail)
146{135{
147 const std::string soInstallPath = "/usr/lib64/aicpu_kernels/0";136 const std::string soInstallPath = "/usr/lib64/aicpu_kernels/0";
148 const std::string packageName = "/test/asd/_test?_tsd.tar.gz";137 const std::string packageName = "/test/asd/_test?_tsd.tar.gz";
@@ -150,66 +139,50 @@ TEST_F(AicpuPackageProcessTest, CheckPackageNameGetSrcPkgNameFail)
150 EXPECT_EQ(ret, TSD_START_FAIL);139 EXPECT_EQ(ret, TSD_START_FAIL);
151}140}
152 141 
153-TEST_F(AicpuPackageProcessTest, CheckPackageNamePackageNameEqualFail)142+TEST_F(AicpuPackageProcessTest, CheckPackageName_SourceDiffersFromVersionFile_ReturnsInternalError)
154{143{
155- const std::string soInstallPath = GetDirName();144+ ASSERT_TRUE(CreateVersionFile(soInstallPath_));
156- if (!CreateVersionFile(soInstallPath)) {
157- return;
158- }
159 const std::string packageName = "/test/asd/Ascend-ai_sys.tar.gz";145 const std::string packageName = "/test/asd/Ascend-ai_sys.tar.gz";
160- const TSD_StatusT ret = AicpuPackageProcess::CheckPackageName(soInstallPath, packageName);146+ const TSD_StatusT ret = AicpuPackageProcess::CheckPackageName(soInstallPath_, packageName);
161- ClearDir(soInstallPath);
162 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);147 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);
163}148}
164 149 
165-TEST_F(AicpuPackageProcessTest, MoveSoToSandBoxSuccess)150+TEST_F(AicpuPackageProcessTest, MoveSoToSandBox_VersionListsSandboxSo_ReturnsOk)
166{151{
167- const std::string soInstallPath = GetDirName();152+ ASSERT_TRUE(CreateVersionFile(soInstallPath_));
168- if (!CreateVersionFile(soInstallPath)) {
169- return;
170- }
171 MOCKER(rename).stubs().will(returnValue(0));153 MOCKER(rename).stubs().will(returnValue(0));
172- TSD_StatusT ret = AicpuPackageProcess::MoveSoToSandBox(soInstallPath);154+ TSD_StatusT ret = AicpuPackageProcess::MoveSoToSandBox(soInstallPath_);
173- ClearDir(soInstallPath);
174 EXPECT_EQ(ret, TSD_OK);155 EXPECT_EQ(ret, TSD_OK);
175}156}
176 157 
177-TEST_F(AicpuPackageProcessTest, MoveSoToSandBoxGetSandboxFail)158+TEST_F(AicpuPackageProcessTest, MoveSoToSandBox_VersionWalkFails_ReturnsInternalError)
178{159{
179- const std::string soInstallPath = GetDirName();160+ ASSERT_TRUE(CreateVersionFile(soInstallPath_));
180- if (!CreateVersionFile(soInstallPath)) {
181- return;
182- }
183 MOCKER(rename).stubs().will(returnValue(0));161 MOCKER(rename).stubs().will(returnValue(0));
184 MOCKER_CPP(&AicpuPackageProcess::WalkInVersionFile)162 MOCKER_CPP(&AicpuPackageProcess::WalkInVersionFile)
185 .stubs()163 .stubs()
186 .will(returnValue(static_cast<uint32_t>(TSD_INTERNAL_ERROR)));164 .will(returnValue(static_cast<uint32_t>(TSD_INTERNAL_ERROR)));
187- TSD_StatusT ret = AicpuPackageProcess::MoveSoToSandBox(soInstallPath);165+ TSD_StatusT ret = AicpuPackageProcess::MoveSoToSandBox(soInstallPath_);
188- ClearDir(soInstallPath);
189 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);166 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);
190}167}
191 168 
192-TEST_F(AicpuPackageProcessTest, MoveSoToSandBoxCreateDirFail)169+TEST_F(AicpuPackageProcessTest, MoveSoToSandBox_SandboxDirectoryCreationFails_ReturnsInternalError)
193{170{
194- const std::string soInstallPath = GetDirName();171+ ASSERT_TRUE(CreateVersionFile(soInstallPath_));
195- if (!CreateVersionFile(soInstallPath)) {
196- return;
197- }
198 MOCKER(rename).stubs().will(returnValue(0));172 MOCKER(rename).stubs().will(returnValue(0));
199 MOCKER_CPP(PackageWorkerUtils::MakeDirectory).stubs().will(returnValue(static_cast<uint32_t>(TSD_INTERNAL_ERROR)));173 MOCKER_CPP(PackageWorkerUtils::MakeDirectory).stubs().will(returnValue(static_cast<uint32_t>(TSD_INTERNAL_ERROR)));
200- TSD_StatusT ret = AicpuPackageProcess::MoveSoToSandBox(soInstallPath);174+ TSD_StatusT ret = AicpuPackageProcess::MoveSoToSandBox(soInstallPath_);
201- ClearDir(soInstallPath);
202 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);175 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);
203}176}
204 177 
205-TEST_F(AicpuPackageProcessTest, IsSoExistSuccess)178+TEST_F(AicpuPackageProcessTest, IsSoExist_PathMissingThenAccessible_ReturnsFalseThenTrue)
206{179{
207 EXPECT_EQ(AicpuPackageProcess::IsSoExist(0U), false);180 EXPECT_EQ(AicpuPackageProcess::IsSoExist(0U), false);
208 MOCKER(access).stubs().will(returnValue(0));181 MOCKER(access).stubs().will(returnValue(0));
209 EXPECT_EQ(AicpuPackageProcess::IsSoExist(0U), true);182 EXPECT_EQ(AicpuPackageProcess::IsSoExist(0U), true);
210}183}
211 184 
212-TEST_F(AicpuPackageProcessTest, CopyExtendSoToCommonSoPathSuccess)185+TEST_F(AicpuPackageProcessTest, CopyExtendSoToCommonSoPath_AsanAndNormalModes_HandleCommandResult)
213{186{
214 MOCKER(PackSystem).stubs().will(returnValue(0)).then(returnValue(1));187 MOCKER(PackSystem).stubs().will(returnValue(0)).then(returnValue(1));
215 const std::string soInstallPath = "/usr/lib64/aicpu_kernels/0";188 const std::string soInstallPath = "/usr/lib64/aicpu_kernels/0";
@@ -219,7 +192,7 @@ TEST_F(AicpuPackageProcessTest, CopyExtendSoToCommonSoPathSuccess)
219 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);192 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);
220}193}
221 194 
222-TEST_F(AicpuPackageProcessTest, CopyExtendSoToCommonSoPathAsanFail)195+TEST_F(AicpuPackageProcessTest, CopyExtendSoToCommonSoPath_AsanCommandFails_StillReturnsOk)
223{196{
224 MOCKER(PackSystem).stubs().will(returnValue(1));197 MOCKER(PackSystem).stubs().will(returnValue(1));
225 const std::string soInstallPath = "/usr/lib64/aicpu_kernels/0";198 const std::string soInstallPath = "/usr/lib64/aicpu_kernels/0";
@@ -227,7 +200,7 @@ TEST_F(AicpuPackageProcessTest, CopyExtendSoToCommonSoPathAsanFail)
227 EXPECT_EQ(ret, TSD_OK);200 EXPECT_EQ(ret, TSD_OK);
228}201}
229 202 
230-TEST_F(AicpuPackageProcessTest, WalkInVersionFileMemsetFail)203+TEST_F(AicpuPackageProcessTest, WalkInVersionFile_MemsetFails_ReturnsInternalError)
231{204{
232 const std::string soInstallPath = "";205 const std::string soInstallPath = "";
233 const auto handler = [](const std::string& line) -> bool { return true; };206 const auto handler = [](const std::string& line) -> bool { return true; };
@@ -236,7 +209,7 @@ TEST_F(AicpuPackageProcessTest, WalkInVersionFileMemsetFail)
236 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);209 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);
237}210}
238 211 
239-TEST_F(AicpuPackageProcessTest, WalkInVersionFileOpenFail)212+TEST_F(AicpuPackageProcessTest, WalkInVersionFile_FileOpenFails_ReturnsInternalError)
240{213{
241 const std::string soInstallPath = "/tmp/";214 const std::string soInstallPath = "/tmp/";
242 const auto handler = [](const std::string& line) -> bool {215 const auto handler = [](const std::string& line) -> bool {
@@ -247,4 +220,4 @@ TEST_F(AicpuPackageProcessTest, WalkInVersionFileOpenFail)
247 MOCKER(realpath).stubs().will(invoke(RealpathFakeOpenFail));220 MOCKER(realpath).stubs().will(invoke(RealpathFakeOpenFail));
248 const TSD_StatusT ret = AicpuPackageProcess::WalkInVersionFile(soInstallPath, handler);221 const TSD_StatusT ret = AicpuPackageProcess::WalkInVersionFile(soInstallPath, handler);
249 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);222 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);
250-}223+}
Rtests/ut/tsd/tsdclient/test/aicpu_thread_package_worker_utest.cpp→tests/ut/tsd/basic_component/package_manager/aicpu_thread_package_worker_utest.cpp+90-31
@@ -7,9 +7,9 @@
7 * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.7 * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8 * See LICENSE in the root of the software repository for the full text of the License.8 * See LICENSE in the root of the software repository for the full text of the License.
9 */9 */
10-#include <thread>
11#include "gtest/gtest.h"10#include "gtest/gtest.h"
12#include "mockcpp/mockcpp.hpp"11#include "mockcpp/mockcpp.hpp"
12+#include <vector>
13#include "package_worker_utils.h"13#include "package_worker_utils.h"
14#define private public14#define private public
15#define protected public15#define protected public
@@ -48,6 +48,13 @@ std::string GetDirName()
48 return dirPath;48 return dirPath;
49}49}
50std::string g_curWorkDir = "";50std::string g_curWorkDir = "";
51+std::vector<std::string> g_packCommands;
52+ 
53+int32_t CapturePackSystem(const char* command)
54+{
55+ g_packCommands.emplace_back(command == nullptr ? "" : command);
56+ return 0;
57+}
51} // namespace58} // namespace
52 59 
53class AicpuThreadPackageWorkerTest : public testing::Test {60class AicpuThreadPackageWorkerTest : public testing::Test {
@@ -55,6 +62,7 @@ protected:
55 virtual void SetUp()62 virtual void SetUp()
56 {63 {
57 g_curWorkDir = GetDirName();64 g_curWorkDir = GetDirName();
65+ g_packCommands.clear();
58 MOCKER(getenv).stubs().will(returnValue(const_cast<char*>(g_curWorkDir.c_str())));66 MOCKER(getenv).stubs().will(returnValue(const_cast<char*>(g_curWorkDir.c_str())));
59 }67 }
60 68 
@@ -65,28 +73,45 @@ protected:
65 (void)remove(extendFileName.c_str());73 (void)remove(extendFileName.c_str());
66 (void)remove(aicpuFileName.c_str());74 (void)remove(aicpuFileName.c_str());
67 g_curWorkDir = "";75 g_curWorkDir = "";
68- GlobalMockObject::verify();76+ try {
77+ GlobalMockObject::verify();
78+ } catch (...) {
79+ GlobalMockObject::reset();
80+ throw;
81+ }
82+ GlobalMockObject::reset();
69 }83 }
70};84};
71 85 
72-TEST_F(AicpuThreadPackageWorkerTest, LoadAndUnloadPackageSuccess)86+TEST_F(AicpuThreadPackageWorkerTest, LoadPackage_AllProcessingStepsSucceed_InvokesEachStepOnce)
73{87{
74 AicpuThreadPackageWorker inst({0U, 0U});88 AicpuThreadPackageWorker inst({0U, 0U});
75 const std::string path = "/home/test";89 const std::string path = "/home/test";
76 const std::string name = "Ascend-aicpu_syskernels.tar.gz";90 const std::string name = "Ascend-aicpu_syskernels.tar.gz";
77- MOCKER_CPP(&AicpuThreadPackageWorker::GetOriginPackageSize).stubs().will(returnValue(1U));91+ MOCKER_CPP(&AicpuThreadPackageWorker::GetOriginPackageSize).stubs().will(returnValue(static_cast<uint64_t>(1U)));
78- MOCKER_CPP(&PackageWorkerUtils::VerifyPackage).stubs().will(returnValue(TSD_OK));92+ const std::string decomDir = g_curWorkDir + "/";
79- MOCKER_CPP(&PackageWorkerUtils::MakeDirectory).stubs().will(returnValue(TSD_OK));93+ const std::string decomPackage = decomDir + name;
80- MOCKER_CPP(&AicpuPackageProcess::CheckPackageName).stubs().will(returnValue(TSD_OK));94+ const std::string installRoot = decomDir + "aicpu_kernels/0/";
81- MOCKER_CPP(&AicpuPackageProcess::MoveSoToSandBox).stubs().will(returnValue(TSD_OK));95+ const std::string installPath = installRoot + "aicpu_kernels_device/";
82- MOCKER(PackSystem).stubs().will(returnValue(0));96+ MOCKER_CPP(&PackageWorkerUtils::VerifyPackage).expects(once()).with(decomPackage).will(returnValue(TSD_OK));
83- auto ret = inst.LoadPackage(path, name);97+ MOCKER_CPP(&PackageWorkerUtils::MakeDirectory).expects(once()).with(decomDir).will(returnValue(TSD_OK));
84- EXPECT_EQ(ret, TSD_OK);98+ MOCKER_CPP(&AicpuPackageProcess::CheckPackageName)
85- ret = inst.UnloadPackage();99+ .expects(once())
86- EXPECT_EQ(ret, TSD_OK);100+ .with(installPath, name)
101+ .will(returnValue(TSD_OK));
102+ MOCKER_CPP(&AicpuPackageProcess::MoveSoToSandBox).expects(once()).with(installPath).will(returnValue(TSD_OK));
103+ MOCKER(PackSystem).expects(exactly(2)).will(invoke(CapturePackSystem));
104+ 
105+ EXPECT_EQ(inst.LoadPackage(path, name), TSD_OK);
106+ EXPECT_EQ(inst.GetPackageCheckCode(), 1U);
107+ ASSERT_EQ(g_packCommands.size(), 2U);
108+ EXPECT_EQ(g_packCommands[0], "cp '/home/test/Ascend-aicpu_syskernels.tar.gz' '" + decomPackage + "'");
109+ EXPECT_EQ(
110+ g_packCommands[1],
111+ "mkdir -p " + installRoot + " ; tar --no-same-owner -ozxf " + decomPackage + " -C " + installRoot);
87}112}
88 113 
89-TEST_F(AicpuThreadPackageWorkerTest, LoadAndUnloadExtendPackageESuccess)114+TEST_F(AicpuThreadPackageWorkerTest, LoadExtendPackage_AllStepsSucceed_ReturnsOk)
90{115{
91 ExtendThreadPackageWorker inst({0U, 0U});116 ExtendThreadPackageWorker inst({0U, 0U});
92 const std::string path = "/home/test";117 const std::string path = "/home/test";
@@ -103,7 +128,7 @@ TEST_F(AicpuThreadPackageWorkerTest, LoadAndUnloadExtendPackageESuccess)
103 EXPECT_EQ(ret, TSD_OK);128 EXPECT_EQ(ret, TSD_OK);
104}129}
105 130 
106-TEST_F(AicpuThreadPackageWorkerTest, LoadPackageSucc)131+TEST_F(AicpuThreadPackageWorkerTest, LoadPackage_NeedLoadAndPostProcessSucceeds_ReturnsOk)
107{132{
108 AicpuThreadPackageWorker inst({0U, 0U});133 AicpuThreadPackageWorker inst({0U, 0U});
109 inst.SetCheckCode(1);134 inst.SetCheckCode(1);
@@ -121,23 +146,57 @@ TEST_F(AicpuThreadPackageWorkerTest, LoadPackageSucc)
121 EXPECT_EQ(ret, TSD_OK);146 EXPECT_EQ(ret, TSD_OK);
122}147}
123 148 
124-TEST_F(AicpuThreadPackageWorkerTest, LoadPackageFail)149+TEST_F(AicpuThreadPackageWorkerTest, LoadPackage_MoveSucceedsAndVerifyFails_ReturnsVerifyError)
125{150{
126 AicpuThreadPackageWorker inst({0U, 0U});151 AicpuThreadPackageWorker inst({0U, 0U});
127- inst.SetCheckCode(1);
128 const std::string path = "/home/test";152 const std::string path = "/home/test";
129 const std::string name = "Ascend-aicpu_syskernels.tar.gz";153 const std::string name = "Ascend-aicpu_syskernels.tar.gz";
130- MOCKER_CPP_VIRTUAL(inst, &AicpuThreadPackageWorker::IsNeedLoadPackage).stubs().will(returnValue(true));154+ const std::string decomDir = g_curWorkDir + "/";
131- auto ret = inst.LoadPackage(path, name);155+ const std::string decomPackage = decomDir + name;
132- EXPECT_EQ(ret, TSD_VERIFY_OPP_FAIL);156+ MOCKER_CPP_VIRTUAL(inst, &AicpuThreadPackageWorker::IsNeedLoadPackage).expects(once()).will(returnValue(true));
157+ MOCKER_CPP(&PackageWorkerUtils::MakeDirectory).expects(once()).with(decomDir).will(returnValue(TSD_OK));
158+ MOCKER(PackSystem).expects(once()).will(invoke(CapturePackSystem));
159+ MOCKER_CPP(&PackageWorkerUtils::VerifyPackage)
160+ .expects(once())
161+ .with(decomPackage)
162+ .will(returnValue(static_cast<TSD_StatusT>(TSD_VERIFY_OPP_FAIL)));
163+ MOCKER_CPP_VIRTUAL(static_cast<BasePackageWorker&>(inst), &BasePackageWorker::DecompressPackage).expects(never());
164+ MOCKER_CPP_VIRTUAL(inst, &AicpuThreadPackageWorker::PostProcessPackage).expects(never());
133 165 
134- MOCKER_CPP(&PackageWorkerUtils::VerifyPackage).stubs().will(returnValue(TSD_OK));166+ const auto ret = inst.LoadPackage(path, name);
135- MOCKER(PackSystem).stubs().will(returnValue(0));167+ 
136- ret = inst.LoadPackage(path, name);168+ EXPECT_EQ(ret, TSD_VERIFY_OPP_FAIL);
137- EXPECT_EQ(ret, TSD_INTERNAL_ERROR);169+ ASSERT_EQ(g_packCommands.size(), 1U);
170+ EXPECT_EQ(g_packCommands[0], "cp '/home/test/Ascend-aicpu_syskernels.tar.gz' '" + decomPackage + "'");
138}171}
139 172 
140-TEST_F(AicpuThreadPackageWorkerTest, LoadPackage)173+TEST_F(AicpuThreadPackageWorkerTest, LoadPackage_VerifyAndDecompressSucceedButPostProcessFails_ReturnsInternalError)
174+{
175+ AicpuThreadPackageWorker inst({0U, 0U});
176+ const std::string path = "/home/test";
177+ const std::string name = "Ascend-aicpu_syskernels.tar.gz";
178+ const std::string decomDir = g_curWorkDir + "/";
179+ const std::string decomPackage = decomDir + name;
180+ const std::string installRoot = decomDir + "aicpu_kernels/0/";
181+ MOCKER_CPP_VIRTUAL(inst, &AicpuThreadPackageWorker::IsNeedLoadPackage).expects(once()).will(returnValue(true));
182+ MOCKER_CPP(&PackageWorkerUtils::MakeDirectory).expects(once()).with(decomDir).will(returnValue(TSD_OK));
183+ MOCKER(PackSystem).expects(exactly(2)).will(invoke(CapturePackSystem));
184+ MOCKER_CPP(&PackageWorkerUtils::VerifyPackage).expects(once()).with(decomPackage).will(returnValue(TSD_OK));
185+ MOCKER_CPP_VIRTUAL(inst, &AicpuThreadPackageWorker::PostProcessPackage)
186+ .expects(once())
187+ .will(returnValue(static_cast<TSD_StatusT>(TSD_INTERNAL_ERROR)));
188+ 
189+ const auto ret = inst.LoadPackage(path, name);
190+ 
191+ EXPECT_EQ(ret, TSD_INTERNAL_ERROR);
192+ ASSERT_EQ(g_packCommands.size(), 2U);
193+ EXPECT_EQ(g_packCommands[0], "cp '/home/test/Ascend-aicpu_syskernels.tar.gz' '" + decomPackage + "'");
194+ EXPECT_EQ(
195+ g_packCommands[1],
196+ "mkdir -p " + installRoot + " ; tar --no-same-owner -ozxf " + decomPackage + " -C " + installRoot);
197+}
198+ 
199+TEST_F(AicpuThreadPackageWorkerTest, IsNeedLoadPackage_VerifyFileClosed_ReturnsFalse)
141{200{
142 AicpuThreadPackageWorker inst({0U, 0U});201 AicpuThreadPackageWorker inst({0U, 0U});
143 inst.SetCheckCode(1);202 inst.SetCheckCode(1);
@@ -150,7 +209,7 @@ TEST_F(AicpuThreadPackageWorkerTest, LoadPackage)
150 inst.GetDecompressPackageCmd();209 inst.GetDecompressPackageCmd();
151}210}
152 211 
153-TEST_F(AicpuThreadPackageWorkerTest, LoadPackageNoNeedLoad)212+TEST_F(AicpuThreadPackageWorkerTest, LoadPackage_RepeatedPackageSizeMatches_ReturnsOk)
154{213{
155 AicpuThreadPackageWorker inst({0U, 0U});214 AicpuThreadPackageWorker inst({0U, 0U});
156 inst.SetCheckCode(1);215 inst.SetCheckCode(1);
@@ -167,7 +226,7 @@ TEST_F(AicpuThreadPackageWorkerTest, LoadPackageNoNeedLoad)
167 EXPECT_EQ(ret, TSD_OK);226 EXPECT_EQ(ret, TSD_OK);
168}227}
169 228 
170-TEST_F(AicpuThreadPackageWorkerTest, UnloadPackageSuccess)229+TEST_F(AicpuThreadPackageWorkerTest, UnloadPackage_Always_ReturnsOk)
171{230{
172 AicpuThreadPackageWorker inst({0U, 0U});231 AicpuThreadPackageWorker inst({0U, 0U});
173 MOCKER(PackSystem).stubs().will(returnValue(0));232 MOCKER(PackSystem).stubs().will(returnValue(0));
@@ -175,7 +234,7 @@ TEST_F(AicpuThreadPackageWorkerTest, UnloadPackageSuccess)
175 EXPECT_EQ(ret, TSD_OK);234 EXPECT_EQ(ret, TSD_OK);
176}235}
177 236 
178-TEST_F(AicpuThreadPackageWorkerTest, PostProcessPackageMoveSoFail)237+TEST_F(AicpuThreadPackageWorkerTest, PostProcessPackage_MoveToSandboxFails_StillReturnsOk)
179{238{
180 AicpuThreadPackageWorker inst({0U, 0U});239 AicpuThreadPackageWorker inst({0U, 0U});
181 MOCKER_CPP(&AicpuPackageProcess::CheckPackageName).stubs().will(returnValue(TSD_OK));240 MOCKER_CPP(&AicpuPackageProcess::CheckPackageName).stubs().will(returnValue(TSD_OK));
@@ -186,7 +245,7 @@ TEST_F(AicpuThreadPackageWorkerTest, PostProcessPackageMoveSoFail)
186 EXPECT_EQ(ret, TSD_OK);245 EXPECT_EQ(ret, TSD_OK);
187}246}
188 247 
189-TEST_F(AicpuThreadPackageWorkerTest, ExtendPostProcessSucc)248+TEST_F(AicpuThreadPackageWorkerTest, ExtendPostProcess_CopySucceeds_ReturnsOk)
190{249{
191 ExtendThreadPackageWorker inst({0U, 0U});250 ExtendThreadPackageWorker inst({0U, 0U});
192 251 
@@ -197,7 +256,7 @@ TEST_F(AicpuThreadPackageWorkerTest, ExtendPostProcessSucc)
197 EXPECT_EQ(ret, TSD_OK);256 EXPECT_EQ(ret, TSD_OK);
198}257}
199 258 
200-TEST_F(AicpuThreadPackageWorkerTest, ExtendPostProcessFail)259+TEST_F(AicpuThreadPackageWorkerTest, ExtendPostProcess_CopyFails_PropagatesError)
201{260{
202 ExtendThreadPackageWorker inst({0U, 0U});261 ExtendThreadPackageWorker inst({0U, 0U});
203 262 
@@ -206,4 +265,4 @@ TEST_F(AicpuThreadPackageWorkerTest, ExtendPostProcessFail)
206 .will(returnValue(static_cast<uint32_t>(TSD_INTERNAL_ERROR)));265 .will(returnValue(static_cast<uint32_t>(TSD_INTERNAL_ERROR)));
207 const TSD_StatusT ret = inst.PostProcessPackage();266 const TSD_StatusT ret = inst.PostProcessPackage();
208 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);267 EXPECT_EQ(ret, TSD_INTERNAL_ERROR);
209-}268+}
Atests/ut/tsd/basic_component/package_manager/base_package_worker_utest.cpp+84-0
@@ -0,0 +1,84 @@
1+/**
2+ * Copyright (c) 2026 Huawei Technologies Co., Ltd.
3+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4+ * CANN Open Software License Agreement Version 2.0 (the "License").
5+ * Please refer to the License for details. You may not use this file except in compliance with the License.
6+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8+ * See LICENSE in the root of the software repository for the full text of the License.
9+ */
10+ 
11+#include "package_manager_test_common.h"
12+#include "package_worker_utils.h"
13+#define private public
14+#define protected public
15+#include "package_worker_factory.h"
16+#undef private
17+#undef protected
18+ 
19+using namespace tsd;
20+using namespace tsdtest;
21+using namespace std;
22+ 
23+namespace {
24+class ObservableBasePackageWorker : public BasePackageWorker {
25+public:
26+ ObservableBasePackageWorker() : BasePackageWorker({0U, 0U}) {}
27+ TSD_StatusT LoadPackage(const std::string&, const std::string&) override { return TSD_OK; }
28+ TSD_StatusT UnloadPackage() override { return TSD_OK; }
29+ void SetDecompressPackagePath() override
30+ {
31+ decomPackagePath_ = PackagePath("/decompress", originPackagePath_.name);
32+ }
33+ std::string GetMovePackageToDecompressDirCmd() const override { return "move"; }
34+ std::string GetDecompressPackageCmd() const override { return "decompress"; }
35+};
36+} // namespace
37+ 
38+class BasePackageWorkerComponentTest : public PackageManagerComponentTest {};
39+ 
40+TEST_F(BasePackageWorkerComponentTest, GetPackageCheckCode_NewWorker_ReturnsZero)
41+{
42+ PackageWorkerParas paras;
43+ auto worker =
44+ PackageWorkerFactory::GetInstance().CreatePackageWorker(PackageWorkerType::PACKAGE_WORKER_AICPU_THREAD, paras);
45+ EXPECT_EQ(worker->GetPackageCheckCode(), 0UL);
46+}
47+ 
48+TEST_F(BasePackageWorkerComponentTest, IsNeedLoadPackage_CodeMatchesSize_ReturnsFalse)
49+{
50+ ObservableBasePackageWorker worker;
51+ worker.SetOriginPackageSize(4096U);
52+ worker.SetCheckCode(4096U);
53+ EXPECT_FALSE(worker.IsNeedLoadPackage());
54+ 
55+ worker.SetCheckCode(4095U);
56+ EXPECT_TRUE(worker.IsNeedLoadPackage());
57+}
58+ 
59+TEST_F(BasePackageWorkerComponentTest, IsNeedUnloadPackage_ZeroCode_ReturnsFalse)
60+{
61+ PackageWorkerParas paras;
62+ auto worker =
63+ PackageWorkerFactory::GetInstance().CreatePackageWorker(PackageWorkerType::PACKAGE_WORKER_AICPU_THREAD, paras);
64+ EXPECT_FALSE(worker->IsNeedUnloadPackage());
65+}
66+ 
67+TEST_F(BasePackageWorkerComponentTest, PreProcessPackage_ValidInput_SetsPathsAndSize)
68+{
69+ ObservableBasePackageWorker worker;
70+ const std::string expectedOriginPath = "/origin/pkg.tar.gz";
71+ MOCKER_CPP(&PackageWorkerUtils::GetFileSize)
72+ .expects(once())
73+ .with(expectedOriginPath)
74+ .will(returnValue(static_cast<uint64_t>(8192U)));
75+ 
76+ worker.PreProcessPackage("/origin", "pkg.tar.gz");
77+ 
78+ EXPECT_EQ(worker.originPackagePath_.path, "/origin/");
79+ EXPECT_EQ(worker.originPackagePath_.name, "pkg.tar.gz");
80+ EXPECT_EQ(worker.originPackagePath_.realPath, "/origin/pkg.tar.gz");
81+ EXPECT_EQ(worker.decomPackagePath_.path, "/decompress/");
82+ EXPECT_EQ(worker.decomPackagePath_.realPath, "/decompress/pkg.tar.gz");
83+ EXPECT_EQ(worker.GetOriginPackageSize(), 8192U);
84+}
Atests/ut/tsd/basic_component/package_manager/package_check_code_service_utest.cpp+365-0
@@ -0,0 +1,365 @@
1+/**
2+ * Copyright (c) 2026 Huawei Technologies Co., Ltd.
3+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4+ * CANN Open Software License Agreement Version 2.0 (the "License").
5+ * Please refer to the License for details. You may not use this file except in compliance with the License.
6+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8+ * See LICENSE in the root of the software repository for the full text of the License.
9+ */
10+ 
11+#include "package_manager_test_common.h"
12+#include "env_internal_api.h"
13+ 
14+using namespace tsd;
15+using namespace tsdtest;
16+using namespace std;
17+ 
18+namespace {
19+HDCMessage g_retryRequest;
20+ 
21+void CaptureRetryRequest(HDCMessage msg) { g_retryRequest = std::move(msg); }
22+} // namespace
23+ 
24+class PackageCheckCodeServiceComponentTest : public PackageManagerComponentTest {};
25+ 
26+TEST_F(PackageCheckCodeServiceComponentTest, GetDeviceCheckCode_PackageAlreadyExists_ReturnsExisted)
27+{
28+ ProcessModeManager processModeManager(deviceId, 0);
29+ processModeManager.GetPackageManager().ctx_.aicpuPackageExistInDevice = true;
30+ tsd::TSD_StatusT ret = processModeManager.GetPackageManager().checkCodeSvc_.GetDeviceCheckCode();
31+ EXPECT_EQ(ret, tsd::TSD_AICPUPACKAGE_EXISTED);
32+}
33+ 
34+TEST_F(PackageCheckCodeServiceComponentTest, GetDeviceCheckCodeRetrySupport_FeatureSupported_SetsTrue)
35+{
36+ ProcessModeManager processModeManager(deviceId, 0);
37+ (void)InjectPackageStubComm(processModeManager, deviceId);
38+ processModeManager.GetPackageManager().ctx_.getCheckCodeRetrySupport = false;
39+ MOCKER_CPP(&VersionVerify::SpecialFeatureCheck).stubs().will(returnValue(true));
40+ 
41+ processModeManager.GetPackageManager().checkCodeSvc_.GetDeviceCheckCodeRetrySupport();
42+ 
43+ EXPECT_TRUE(processModeManager.GetPackageManager().ctx_.getCheckCodeRetrySupport);
44+}
45+ 
46+TEST_F(PackageCheckCodeServiceComponentTest, GetDeviceCheckCodeRetrySupport_FeatureUnsupported_SetsFalse)
47+{
48+ ProcessModeManager processModeManager(deviceId, 0);
49+ (void)InjectPackageStubComm(processModeManager, deviceId);
50+ processModeManager.GetPackageManager().ctx_.getCheckCodeRetrySupport = true;
51+ MOCKER_CPP(&VersionVerify::SpecialFeatureCheck).stubs().will(returnValue(false));
52+ 
53+ processModeManager.GetPackageManager().checkCodeSvc_.GetDeviceCheckCodeRetrySupport();
54+ 
55+ EXPECT_FALSE(processModeManager.GetPackageManager().ctx_.getCheckCodeRetrySupport);
56+}
57+ 
58+TEST_F(PackageCheckCodeServiceComponentTest, GetDeviceCheckCodeRetrySupport_VersionUnavailable_PreservesState)
59+{
60+ ProcessModeManager processModeManager(deviceId, 0);
61+ auto stub = InjectPackageStubComm(processModeManager, deviceId);
62+ stub->inspector_.reset();
63+ processModeManager.GetPackageManager().ctx_.getCheckCodeRetrySupport = true;
64+ 
65+ processModeManager.GetPackageManager().checkCodeSvc_.GetDeviceCheckCodeRetrySupport();
66+ 
67+ EXPECT_TRUE(processModeManager.GetPackageManager().ctx_.getCheckCodeRetrySupport);
68+ EXPECT_EQ(stub->commGetVersionVerifyRet_, TSD_OK);
69+}
70+ 
71+TEST_F(PackageCheckCodeServiceComponentTest, GetDeviceCheckCodeRetry_DeviceCommMissing_ReturnsNotFound)
72+{
73+ ProcessModeManager processModeManager(deviceId, 0);
74+ MOCKER_CPP(&PackageCheckCodeService::InitTsdClient).stubs().will(returnValue(tsd::TSD_OK));
75+ HDCMessage msg;
76+ msg.set_real_device_id(0);
77+ msg.set_type(HDCMessage::TSD_CHECK_PACKAGE_RETRY);
78+ msg.set_check_code(0);
79+ msg.set_wait_flag(true);
80+ auto ret = processModeManager.GetPackageManager().checkCodeSvc_.GetDeviceCheckCodeRetry(msg);
81+ GlobalMockObject::verify();
82+ EXPECT_EQ(ret, TSD_INSTANCE_NOT_FOUND);
83+}
84+ 
85+TEST_F(PackageCheckCodeServiceComponentTest, GetDeviceCheckCodeRetry_SendError_PreservesRequestAndReturnsInternalError)
86+{
87+ ProcessModeManager processModeManager(deviceId, 0);
88+ (void)InjectPackageStubComm(processModeManager, deviceId);
89+ g_retryRequest.Clear();
90+ MOCKER_CPP(&PackageCheckCodeService::InitTsdClient).expects(once()).will(returnValue(tsd::TSD_OK));
91+ HDCMessage msg;
92+ msg.set_real_device_id(0);
93+ msg.set_type(HDCMessage::TSD_CHECK_PACKAGE_RETRY);
94+ msg.set_check_code(2026U);
95+ msg.set_package_type(static_cast<uint32_t>(TsdLoadPackageType::TSD_PKG_TYPE_AICPU_KERNEL));
96+ msg.set_wait_flag(true);
97+ MOCKER_CPP(&PackageCheckCodeService::GetDeviceCheckCodeOnce)
98+ .expects(once())
99+ .with(processWith(CaptureRetryRequest))
100+ .will(returnValue(static_cast<TSD_StatusT>(TSD_HDC_SEND_MSG_ERROR)));
101+ 
102+ auto ret = processModeManager.GetPackageManager().checkCodeSvc_.GetDeviceCheckCodeRetry(msg);
103+ GlobalMockObject::verify();
104+ 
105+ EXPECT_EQ(ret, TSD_INTERNAL_ERROR);
106+ EXPECT_EQ(g_retryRequest.real_device_id(), msg.real_device_id());
107+ EXPECT_EQ(g_retryRequest.type(), msg.type());
108+ EXPECT_EQ(g_retryRequest.check_code(), msg.check_code());
109+ EXPECT_EQ(g_retryRequest.package_type(), msg.package_type());
110+ EXPECT_EQ(g_retryRequest.wait_flag(), msg.wait_flag());
111+}
112+ 
113+TEST_F(PackageCheckCodeServiceComponentTest, GetDeviceCheckCodeRetry_InitFails_PropagatesError)
114+{
115+ ProcessModeManager processModeManager(deviceId, 0);
116+ processModeManager.commAgent_.devCommClient_ = DeviceComm::GetInstance(deviceId, DeviceCommType::HDC);
117+ MOCKER_CPP(&PackageCheckCodeService::InitTsdClient).stubs().will(returnValue(100U));
118+ HDCMessage msg;
119+ msg.set_real_device_id(0);
120+ msg.set_type(HDCMessage::TSD_CHECK_PACKAGE_RETRY);
121+ msg.set_check_code(0);
122+ msg.set_wait_flag(true);
123+ auto ret = processModeManager.GetPackageManager().checkCodeSvc_.GetDeviceCheckCodeRetry(msg);
124+ GlobalMockObject::verify();
125+ EXPECT_EQ(ret, 100U);
126+}
127+ 
128+TEST_F(PackageCheckCodeServiceComponentTest, GetDeviceCheckCode_ExtendPackageConfiguredAndReceiveFails_ReturnsOk)
129+{
130+ ProcessModeManager processModeManager(deviceId, 0);
131+ processModeManager.GetPackageManager().ctx_.aicpuPackageExistInDevice = false;
132+ processModeManager.commAgent_.tsdSessionId_ = 0U;
133+ processModeManager.commAgent_.devCommClient_ = DeviceComm::GetInstance(deviceId, DeviceCommType::HDC);
134+ HDC_SESSION session = nullptr;
135+ std::dynamic_pointer_cast<HdcClient>(processModeManager.commAgent_.devCommClient_)->hdcClientSessionMap_[0U] =
136+ session;
137+ std::dynamic_pointer_cast<HdcClient>(processModeManager.commAgent_.devCommClient_)->hdcClientVerifyMap_[0U] =
138+ std::make_shared<VersionVerify>();
139+ processModeManager.GetPackageManager().envInfo_.GetPackageNameRef(1) = "Ascend-aicpu_extend_syskernels.tar.gz";
140+ MOCKER_CPP(&TsdProcessController::InitTsdClient).stubs().will(returnValue(tsd::TSD_OK));
141+ MOCKER_CPP(&TsdProcessController::InitTsdClient).stubs().will(returnValue(tsd::TSD_OK));
142+ MOCKER_CPP(&VersionVerify::SpecialFeatureCheck).stubs().will(returnValue(true));
143+ MOCKER_CPP(&HdcCommon::SendNormalMsg).stubs().will(returnValue(tsd::TSD_OK));
144+ MOCKER_CPP(&HdcCommon::RecvMsg).stubs().will(returnValue(1U));
145+ 
146+ tsd::TSD_StatusT ret = processModeManager.GetPackageManager().checkCodeSvc_.GetDeviceCheckCode();
147+ EXPECT_EQ(ret, tsd::TSD_OK);
148+}
149+ 
150+TEST_F(PackageCheckCodeServiceComponentTest, SaveDeviceCheckCode_AicpuResponse_StoresBaseExtendAndCapabilityValues)
151+{
152+ HDCMessage msg;
153+ msg.set_type(HDCMessage::TSD_CHECK_PACKAGE_RSP);
154+ msg.set_check_code(1U);
155+ msg.set_extendpkg_check_code(2U);
156+ msg.set_capability_level(5U);
157+ ProcessModeManager processModeManager(deviceId, 0);
158+ processModeManager.GetPackageManager().SaveDeviceCheckCode(msg);
159+ EXPECT_EQ(
160+ processModeManager.GetPackageManager()
161+ .ctx_.peerCheckCode[static_cast<uint32_t>(TsdLoadPackageType::TSD_PKG_TYPE_AICPU_KERNEL)],
162+ 1U);
163+ EXPECT_EQ(
164+ processModeManager.GetPackageManager()
165+ .ctx_.peerCheckCode[static_cast<uint32_t>(TsdLoadPackageType::TSD_PKG_TYPE_AICPU_EXTEND_KERNEL)],
166+ 2U);
167+ EXPECT_EQ(processModeManager.capabilityMgr_.tsdSupportLevel_, 5U);
168+}
169+ 
170+TEST_F(PackageCheckCodeServiceComponentTest, SaveDeviceCheckCode_DshapeResponse_StoresCodeAndSuccessStatus)
171+{
172+ HDCMessage msg;
173+ msg.set_type(HDCMessage::TSD_GET_DEVICE_DSHAPE_CHECKCODE_RSP);
174+ msg.set_check_code(1);
175+ msg.set_tsd_rsp_code(0);
176+ ProcessModeManager processModeManager(deviceId, 0);
177+ processModeManager.GetPackageManager().SaveDeviceCheckCode(msg);
178+ EXPECT_EQ(
179+ processModeManager.GetPackageManager()
180+ .ctx_.peerCheckCode[static_cast<uint32_t>(TsdLoadPackageType::TSD_PKG_TYPE_DSHAPE)],
181+ 1);
182+ EXPECT_EQ(static_cast<uint32_t>(processModeManager.GetPackageManager().ctx_.pkgRspCode), 0);
183+}
184+ 
185+TEST_F(PackageCheckCodeServiceComponentTest, SaveDeviceCheckCode_RuntimeResponse_StoresCodeAndSuccessStatus)
186+{
187+ HDCMessage msg;
188+ msg.set_type(HDCMessage::TSD_GET_DEVICE_RUNTIME_CHECKCODE_RSP);
189+ msg.set_check_code(1);
190+ msg.set_tsd_rsp_code(0);
191+ ProcessModeManager processModeManager(deviceId, 0);
192+ processModeManager.GetPackageManager().SaveDeviceCheckCode(msg);
193+ EXPECT_EQ(
194+ processModeManager.GetPackageManager()
195+ .ctx_.peerCheckCode[static_cast<uint32_t>(TsdLoadPackageType::TSD_PKG_TYPE_RUNTIME)],
196+ 1);
197+ EXPECT_EQ(static_cast<uint32_t>(processModeManager.GetPackageManager().ctx_.pkgRspCode), 0);
198+}
199+ 
200+TEST_F(PackageCheckCodeServiceComponentTest, GetDeviceHsPkgCheckCode_ClientInitializationFails_ReturnsInternalError)
201+{
202+ ProcessModeManager processModeManager(deviceId, PROCESS_MODE);
203+ processModeManager.commAgent_.devCommClient_ = DeviceComm::GetInstance(deviceId, DeviceCommType::HDC);
204+ MOCKER_CPP(&TsdProcessController::InitTsdClient)
205+ .stubs()
206+ .will(returnValue(static_cast<uint32_t>(TSD_INTERNAL_ERROR)));
207+ const auto ret = processModeManager.GetPackageManager().checkCodeSvc_.GetDeviceHsPkgCheckCode(
208+ 0U, HDCMessage::INIT, false, processModeManager.GetTsdController().BuildBaseMessageContext());
209+ EXPECT_EQ(ret, TSD_INTERNAL_ERROR);
210+}
211+ 
212+TEST_F(PackageCheckCodeServiceComponentTest, GetCannHsPkgCheckCode_ValidPackageAndHash_SendsRequestAndReturnsOk)
213+{
214+ ProcessModeManager processModeManager(deviceId, PROCESS_MODE);
215+ auto stub = InjectPackageStubComm(processModeManager, deviceId);
216+ const std::string packageName = "cann-custom-kernels.tar.gz";
217+ const std::string hostHash = "0123456789abcdef";
218+ processModeManager.GetPackageManager().ctx_.pkgRspCode = ResponseCode::SUCCESS;
219+ 
220+ const auto ret = processModeManager.GetPackageManager().checkCodeSvc_.GetCannHsPkgCheckCode(
221+ packageName, hostHash, processModeManager.GetTsdController().BuildBaseMessageContext());
222+ 
223+ EXPECT_EQ(ret, TSD_OK);
224+ EXPECT_EQ(stub->sendCount_, 1);
225+ EXPECT_EQ(stub->recvCount_, 1);
226+ EXPECT_EQ(stub->lastMsg_.type(), HDCMessage::TSD_GET_DEVICE_CANN_HS_CHECKCODE);
227+ ASSERT_EQ(stub->lastMsg_.package_hash_code_list_size(), 1);
228+ EXPECT_EQ(stub->lastMsg_.package_hash_code_list(0).package_name(), packageName);
229+ EXPECT_EQ(stub->lastMsg_.package_hash_code_list(0).hash_code(), hostHash);
230+ EXPECT_EQ(
231+ stub->lastMsg_.package_worker_type(), static_cast<uint32_t>(PackageWorkerType::PACKAGE_WORKER_COMMON_SINK));
232+ EXPECT_EQ(stub->lastMsg_.package_type(), static_cast<uint32_t>(TsdLoadPackageType::TSD_PKG_TYPE_COMMON_SINK));
233+}
234+ 
235+TEST_F(PackageCheckCodeServiceComponentTest, SaveDeviceCheckCode_NormalPackageResponse_StoresCodeStatusAndIdleFlag)
236+{
237+ HDCMessage msg;
238+ msg.set_type(HDCMessage::TSD_GET_DEVICE_PACKAGE_CHECKCODE_NORMAL_RSP);
239+ msg.set_check_code(1);
240+ msg.set_tsd_rsp_code(0);
241+ msg.set_package_type(static_cast<uint32_t>(TsdLoadPackageType::TSD_PKG_TYPE_DRIVER_EXTEND));
242+ msg.set_device_idle(true);
243+ ProcessModeManager processModeManager(deviceId, 0);
244+ processModeManager.GetPackageManager().SaveDeviceCheckCode(msg);
245+ EXPECT_EQ(
246+ processModeManager.GetPackageManager()
247+ .ctx_.peerCheckCode[static_cast<uint32_t>(TsdLoadPackageType::TSD_PKG_TYPE_DRIVER_EXTEND)],
248+ 1);
249+ EXPECT_EQ(static_cast<uint32_t>(processModeManager.GetPackageManager().ctx_.pkgRspCode), 0);
250+ EXPECT_EQ(processModeManager.GetPackageManager().ctx_.deviceIdle, true);
251+}
252+ 
253+TEST_F(PackageCheckCodeServiceComponentTest, SaveDeviceCheckCode_NormalPackageTypeInvalid_PreservesIdleFalse)
254+{
255+ HDCMessage msg;
256+ msg.set_type(HDCMessage::TSD_GET_DEVICE_PACKAGE_CHECKCODE_NORMAL_RSP);
257+ msg.set_check_code(1);
258+ msg.set_tsd_rsp_code(0);
259+ msg.set_package_type(0xff);
260+ msg.set_device_idle(true);
261+ ProcessModeManager processModeManager(deviceId, 0);
262+ processModeManager.GetPackageManager().SaveDeviceCheckCode(msg);
263+ EXPECT_EQ(static_cast<uint32_t>(processModeManager.sharedCtx_.rspCode), 1);
264+ EXPECT_EQ(processModeManager.GetPackageManager().ctx_.deviceIdle, false);
265+}
266+ 
267+TEST_F(PackageCheckCodeServiceComponentTest, GetDeviceCheckCodeRetry_CallsReleaseDeviceConnection)
268+{
269+ ProcessModeManager processModeManager(deviceId, 0);
270+ auto stub = InjectPackageStubComm(processModeManager, deviceId);
271+ 
272+ MOCKER_CPP(&PackageCheckCodeService::InitTsdClient).stubs().will(returnValue(tsd::TSD_OK));
273+ MOCKER_CPP(&PackageCheckCodeService::GetDeviceCheckCodeOnce).stubs().will(returnValue(0U));
274+ 
275+ HDCMessage msg;
276+ msg.set_real_device_id(deviceId);
277+ msg.set_type(HDCMessage::TSD_CHECK_PACKAGE_RETRY);
278+ 
279+ auto ret = processModeManager.GetPackageManager().checkCodeSvc_.GetDeviceCheckCodeRetry(msg);
280+ EXPECT_EQ(ret, TSD_OK);
281+ EXPECT_EQ(processModeManager.commAgent_.devCommClient_, nullptr);
282+ EXPECT_FALSE(processModeManager.commAgent_.IsInit());
283+ EXPECT_EQ(stub->destroyCount_, 1);
284+ GlobalMockObject::verify();
285+}
286+ 
287+TEST_F(PackageCheckCodeServiceComponentTest, GetDeviceCheckCode_SupportedFeature_SendsReceivesAndReleasesConnection)
288+{
289+ ProcessModeManager processModeManager(deviceId, 0);
290+ auto stub = InjectPackageStubComm(processModeManager, deviceId);
291+ auto& packageManager = processModeManager.GetPackageManager();
292+ packageManager.ctx_.aicpuPackageExistInDevice = false;
293+ packageManager.ctx_.hostCheckCode[static_cast<uint32_t>(TsdLoadPackageType::TSD_PKG_TYPE_AICPU_KERNEL)] = 101U;
294+ packageManager.ctx_.hostCheckCode[static_cast<uint32_t>(TsdLoadPackageType::TSD_PKG_TYPE_AICPU_EXTEND_KERNEL)] =
295+ 202U;
296+ packageManager.ctx_.hostCheckCode[static_cast<uint32_t>(TsdLoadPackageType::TSD_PKG_TYPE_ASCENDCPP)] = 303U;
297+ MOCKER_CPP(&VersionVerify::SpecialFeatureCheck).expects(exactly(2)).will(returnValue(true));
298+ MOCKER(IsAsanMmSysEnv).stubs().will(returnValue(false));
299+ 
300+ EXPECT_EQ(packageManager.checkCodeSvc_.GetDeviceCheckCode(), TSD_OK);
301+ EXPECT_TRUE(packageManager.ctx_.aicpuPackageExistInDevice);
302+ EXPECT_EQ(stub->sendCount_, 1);
303+ EXPECT_EQ(stub->recvCount_, 1);
304+ EXPECT_EQ(stub->lastMsg_.type(), HDCMessage::TSD_CHECK_PACKAGE);
305+ EXPECT_EQ(stub->lastMsg_.check_code(), 101U);
306+ EXPECT_EQ(stub->lastMsg_.extendpkg_check_code(), 202U);
307+ EXPECT_EQ(stub->lastMsg_.ascendcpppkg_check_code(), 303U);
308+ EXPECT_EQ(processModeManager.commAgent_.devCommClient_, nullptr);
309+ EXPECT_FALSE(processModeManager.commAgent_.IsInit());
310+ EXPECT_EQ(stub->destroyCount_, 1);
311+ GlobalMockObject::verify();
312+}
313+ 
314+TEST_F(
315+ PackageCheckCodeServiceComponentTest, GetDeviceCheckCode_WhenSpecialFeatureCheckFalse_CallsReleaseDeviceConnection)
316+{
317+ ProcessModeManager processModeManager(deviceId, 0);
318+ auto stub = InjectPackageStubComm(processModeManager, deviceId);
319+ processModeManager.GetPackageManager().ctx_.aicpuPackageExistInDevice = false;
320+ 
321+ MOCKER_CPP(&TsdProcessController::InitTsdClient).stubs().will(returnValue(tsd::TSD_OK));
322+ MOCKER_CPP(&VersionVerify::SpecialFeatureCheck).stubs().will(returnValue(false));
323+ 
324+ auto ret = processModeManager.GetPackageManager().checkCodeSvc_.GetDeviceCheckCode();
325+ EXPECT_EQ(ret, TSD_OK);
326+ EXPECT_EQ(processModeManager.commAgent_.devCommClient_, nullptr);
327+ EXPECT_FALSE(processModeManager.commAgent_.IsInit());
328+ EXPECT_EQ(stub->destroyCount_, 1);
329+ GlobalMockObject::verify();
330+}
331+ 
332+TEST_F(PackageCheckCodeServiceComponentTest, GetDeviceCheckCode_WhenGetOnceFails_CallsReleaseDeviceConnection)
333+{
334+ ProcessModeManager processModeManager(deviceId, 0);
335+ auto stub = InjectPackageStubComm(processModeManager, deviceId);
336+ processModeManager.GetPackageManager().ctx_.aicpuPackageExistInDevice = false;
337+ 
338+ MOCKER_CPP(&TsdProcessController::InitTsdClient).stubs().will(returnValue(tsd::TSD_OK));
339+ MOCKER_CPP(&VersionVerify::SpecialFeatureCheck).stubs().will(returnValue(true));
340+ MOCKER_CPP(&PackageCheckCodeService::GetDeviceCheckCodeOnce).stubs().will(returnValue(1U));
341+ 
342+ auto ret = processModeManager.GetPackageManager().checkCodeSvc_.GetDeviceCheckCode();
343+ EXPECT_EQ(ret, TSD_INTERNAL_ERROR);
344+ EXPECT_EQ(processModeManager.commAgent_.devCommClient_, nullptr);
345+ EXPECT_FALSE(processModeManager.commAgent_.IsInit());
346+ EXPECT_EQ(stub->destroyCount_, 1);
347+ GlobalMockObject::verify();
348+}
349+ 
350+TEST_F(PackageCheckCodeServiceComponentTest, GetDeviceHsPkgCheckCode_SendFail_ResetsInitFlag)
351+{
352+ // SendMsg 失败时重置 commAgent_.IsInit()，保持与原代码行为一致
353+ ProcessModeManager processModeManager(deviceId, 0);
354+ auto stub = InjectPackageStubComm(processModeManager, deviceId);
355+ stub->commSendMsgRet_ = tsd::TSD_INTERNAL_ERROR;
356+ 
357+ MOCKER_CPP(&TsdProcessController::InitTsdClient).stubs().will(returnValue(tsd::TSD_OK));
358+ 
359+ auto ret = processModeManager.GetPackageManager().checkCodeSvc_.GetDeviceHsPkgCheckCode(
360+ 0U, HDCMessage::INIT, false, processModeManager.GetTsdController().BuildBaseMessageContext());
361+ EXPECT_EQ(ret, TSD_INTERNAL_ERROR);
362+ // 验证 SendFail 后 commAgent_.IsInit() 被重置为 false，与原代码行为一致
363+ EXPECT_FALSE(processModeManager.commAgent_.IsInit());
364+ GlobalMockObject::verify();
365+}
Atests/ut/tsd/basic_component/package_manager/package_env_info_utest.cpp+251-0
@@ -0,0 +1,251 @@
1+/**
2+ * Copyright (c) 2026 Huawei Technologies Co., Ltd.
3+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4+ * CANN Open Software License Agreement Version 2.0 (the "License").
5+ * Please refer to the License for details. You may not use this file except in compliance with the License.
6+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8+ * See LICENSE in the root of the software repository for the full text of the License.
9+ */
10+ 
11+#include "package_manager_test_common.h"
12+ 
13+using namespace tsd;
14+using namespace tsdtest;
15+using namespace std;
16+ 
17+namespace {
18+mmDirent2** g_packageDirList = nullptr;
19+std::string g_platformLabel;
20+std::string g_platformKey;
21+ 
22+bool CaptureShortSocVersion(fe::PlatFormInfos*, const std::string& label, const std::string& key, std::string& value)
23+{
24+ g_platformLabel = label;
25+ g_platformKey = key;
26+ value = "Ascend910B";
27+ return true;
28+}
29+ 
30+drvError_t halGetSocVersionStub(uint32_t, char* socVersion, uint32_t len)
31+{
32+ return strcpy_s(socVersion, len, "Ascend910B1") == EOK ? DRV_ERROR_NONE : DRV_ERROR_INVALID_VALUE;
33+}
34+ 
35+int32_t mmScandir2_invoke(const char*, mmDirent2*** entryList, mmFilter2, mmSort2)
36+{
37+ g_packageDirList = static_cast<mmDirent2**>(malloc(sizeof(mmDirent2*)));
38+ g_packageDirList[0] = static_cast<mmDirent2*>(malloc(sizeof(mmDirent2)));
39+ (void)strcpy_s(
40+ g_packageDirList[0]->d_name, sizeof(g_packageDirList[0]->d_name), "Ascend310-aicpu_syskernels.tar.gz");
41+ *entryList = g_packageDirList;
42+ return 1;
43+}
44+ 
45+void mmScandirFree2_invoke(mmDirent2**, int32_t)
46+{
47+ free(g_packageDirList[0]);
48+ free(g_packageDirList);
49+ g_packageDirList = nullptr;
50+}
51+ 
52+int32_t mmScandir2_invokeExtend(const char*, mmDirent2*** entryList, mmFilter2, mmSort2)
53+{
54+ g_packageDirList = static_cast<mmDirent2**>(malloc(sizeof(mmDirent2*) * 2U));
55+ g_packageDirList[0] = static_cast<mmDirent2*>(malloc(sizeof(mmDirent2)));
56+ g_packageDirList[1] = static_cast<mmDirent2*>(malloc(sizeof(mmDirent2)));
57+ (void)strcpy_s(
58+ g_packageDirList[0]->d_name, sizeof(g_packageDirList[0]->d_name), "Ascend-aicpu_extend_syskernels.tar.gz");
59+ (void)strcpy_s(g_packageDirList[1]->d_name, sizeof(g_packageDirList[1]->d_name), "Ascend-aicpu_syskernels.tar.gz");
60+ *entryList = g_packageDirList;
61+ return 2;
62+}
63+ 
64+void mmScandirFree2_invokeExtend(mmDirent2**, int32_t)
65+{
66+ free(g_packageDirList[0]);
67+ free(g_packageDirList[1]);
68+ free(g_packageDirList);
69+ g_packageDirList = nullptr;
70+}
71+} // namespace
72+ 
73+class PackageEnvInfoComponentTest : public PackageManagerComponentTest {};
74+ 
75+TEST_F(PackageEnvInfoComponentTest, GetAscendLatestIntallPath_LatestPathEnvSet_ReturnsEnvValue)
76+{
77+ char env[] = "/usr/local/Asend/lastest";
78+ MOCKER(&mmSysGetEnv).stubs().will(returnValue(&env[0U]));
79+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_MINI);
80+ std::string pkgBasePath;
81+ envInfo.GetAscendLatestIntallPath(pkgBasePath);
82+ EXPECT_EQ(pkgBasePath, "/usr/local/Asend/lastest");
83+}
84+ 
85+TEST_F(PackageEnvInfoComponentTest, GetCurHostMutexFile_LegacyAndV2DriverResults_ReturnExpectedNames)
86+{
87+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_MINI);
88+ 
89+ EXPECT_EQ(envInfo.GetCurHostMutexFile(false), "libqueue_schedule.so");
90+ 
91+ MOCKER(halGetDeviceInfo).stubs().will(returnValue(DRV_ERROR_INVALID_VALUE)).then(returnValue(DRV_ERROR_NONE));
92+ EXPECT_EQ(envInfo.GetCurHostMutexFile(true), "libqueue_schedule.so");
93+ 
94+ EXPECT_EQ(envInfo.GetCurHostMutexFile(true), "sink_file_mutex_0.cfg");
95+}
96+ 
97+TEST_F(PackageEnvInfoComponentTest, GetCurHostMutexFile_PhysicalIdLookupFails_ReturnsLegacyMutexName)
98+{
99+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_MINI);
100+ EXPECT_EQ(envInfo.GetCurHostMutexFile(false), "libqueue_schedule.so");
101+ MOCKER(halGetDeviceInfo).stubs().will(returnValue(DRV_ERROR_INVALID_VALUE));
102+ MOCKER(drvDeviceGetPhyIdByIndex).stubs().will(returnValue(DRV_ERROR_INVALID_VALUE));
103+ EXPECT_EQ(envInfo.GetCurHostMutexFile(true), "libqueue_schedule.so");
104+}
105+ 
106+TEST_F(PackageEnvInfoComponentTest, GetCurHostMutexFile_MasterIdAvailable_ReturnsDeviceMutexName)
107+{
108+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_MINI);
109+ EXPECT_EQ(envInfo.GetCurHostMutexFile(false), "libqueue_schedule.so");
110+ EXPECT_EQ(envInfo.GetCurHostMutexFile(true), "sink_file_mutex_0.cfg");
111+}
112+ 
113+TEST_F(PackageEnvInfoComponentTest, GetShortSocVersion_PlatformResourceAvailable_ReturnsExactShortVersion)
114+{
115+ MOCKER(halGetSocVersion).stubs().will(invoke(halGetSocVersionStub));
116+ using GetPlatformResFnT = bool (fe::PlatFormInfos::*)(const std::string&, const std::string&, std::string&);
117+ const std::string expectedShortVersion = "Ascend910B";
118+ g_platformLabel.clear();
119+ g_platformKey.clear();
120+ MOCKER_CPP(static_cast<GetPlatformResFnT>(&fe::PlatFormInfos::GetPlatformRes))
121+ .expects(once())
122+ .will(invoke(CaptureShortSocVersion));
123+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_MINI);
124+ std::string shortSocVersion = "sentinel";
125+ const auto ret = envInfo.GetShortSocVersion(shortSocVersion);
126+ EXPECT_TRUE(ret);
127+ EXPECT_EQ(g_platformLabel, "version");
128+ EXPECT_EQ(g_platformKey, "Short_SoC_version");
129+ EXPECT_EQ(shortSocVersion, expectedShortVersion);
130+}
131+ 
132+TEST_F(PackageEnvInfoComponentTest, GetShortSocVersion_HalLookupFails_ReturnsFalse)
133+{
134+ MOCKER(halGetSocVersion).stubs().will(returnValue(1));
135+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_MINI);
136+ std::string shortSocVersion;
137+ const auto ret = envInfo.GetShortSocVersion(shortSocVersion);
138+ EXPECT_EQ(ret, false);
139+}
140+ 
141+TEST_F(PackageEnvInfoComponentTest, GetShortSocVersion_PlatformResourceMissing_ReturnsFalse)
142+{
143+ MOCKER(halGetSocVersion).stubs().will(invoke(halGetSocVersionStub));
144+ MOCKER_CPP(
145+ &fe::PlatFormInfos::GetPlatformRes,
146+ bool(fe::PlatFormInfos::*)(const std::string& label, const std::string& key, std::string& val))
147+ .stubs()
148+ .will(returnValue(false));
149+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_MINI);
150+ std::string shortSocVersion;
151+ const auto ret = envInfo.GetShortSocVersion(shortSocVersion);
152+ EXPECT_EQ(ret, false);
153+}
154+ 
155+TEST_F(PackageEnvInfoComponentTest, CheckPackageExists_NoDirectoryEntryMatches_ReturnsFalse)
156+{
157+ MOCKER(mmAccess).stubs().will(returnValue(0));
158+ MOCKER(mmIsDir).stubs().will(returnValue(0));
159+ // MOCKER(mmScandir2).stubs().will(returnValue(0));
160+ // MOCKER(mmScandirFree2).stubs().will(returnValue(0));
161+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_MINI);
162+ const bool ret = envInfo.CheckPackageExists();
163+ EXPECT_EQ(ret, false);
164+}
165+ 
166+TEST_F(PackageEnvInfoComponentTest, CheckPackageExists_ScanFails_ReturnsFalse)
167+{
168+ MOCKER(mmAccess).stubs().will(returnValue(0));
169+ MOCKER(mmIsDir).stubs().will(returnValue(0));
170+ MOCKER(mmScandir2).stubs().will(returnValue(-1));
171+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_MINI);
172+ const bool ret = envInfo.CheckPackageExists();
173+ EXPECT_EQ(ret, false);
174+}
175+ 
176+TEST_F(PackageEnvInfoComponentTest, CheckPackageExists_AicpuPackageEntryMatches_ReturnsTrue)
177+{
178+ MOCKER(mmAccess).stubs().will(returnValue(0));
179+ MOCKER(mmIsDir).stubs().will(returnValue(0));
180+ MOCKER(mmScandir2).stubs().will(invoke(mmScandir2_invoke));
181+ MOCKER(mmScandirFree2).stubs().will(invoke(mmScandirFree2_invoke));
182+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_MINI);
183+ const bool ret = envInfo.CheckPackageExists();
184+ EXPECT_EQ(ret, true);
185+}
186+ 
187+TEST_F(PackageEnvInfoComponentTest, GetPackagePath_AicpuEnvSet_ReturnsChipSpecificPath)
188+{
189+ char envpath[] = "/home";
190+ MOCKER(mmSysGetEnv).stubs().will(returnValue(&envpath[0U]));
191+ setenv("ASCEND_AICPU_PATH", "/home", 1);
192+ std::string env = "";
193+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_MINI);
194+ envInfo.GetPackagePath(env, 0U);
195+ EXPECT_EQ(env, "/home/opp/Ascend310/aicpu/");
196+}
197+ 
198+TEST_F(PackageEnvInfoComponentTest, GetPackageTitle_Ascend910B_ReturnsAscend)
199+{
200+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_ASCEND_910B);
201+ std::string pkgTitle;
202+ envInfo.GetPackageTitle(pkgTitle);
203+ EXPECT_EQ(pkgTitle, "Ascend");
204+}
205+ 
206+TEST_F(PackageEnvInfoComponentTest, CheckPackageExists_ExtendPackageEntryMatches_ReturnsTrue)
207+{
208+ MOCKER(mmAccess).stubs().will(returnValue(0));
209+ MOCKER(mmIsDir).stubs().will(returnValue(0));
210+ MOCKER(mmScandir2).stubs().will(invoke(mmScandir2_invokeExtend));
211+ MOCKER(mmScandirFree2).stubs().will(invoke(mmScandirFree2_invokeExtend));
212+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_ASCEND_910B);
213+ const bool ret = envInfo.CheckPackageExists();
214+ EXPECT_EQ(ret, true);
215+}
216+ 
217+TEST_F(PackageEnvInfoComponentTest, CheckPackageExists_PackagePathResolutionFails_ReturnsFalse)
218+{
219+ using GetPackagePathSig = bool (PackageEnvInfo::*)(std::string&, const uint32_t) const;
220+ MOCKER_CPP(static_cast<GetPackagePathSig>(&PackageEnvInfo::GetPackagePath)).stubs().will(returnValue(false));
221+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_MINI);
222+ const bool ret = envInfo.CheckPackageExists();
223+ EXPECT_EQ(ret, false);
224+}
225+ 
226+TEST_F(PackageEnvInfoComponentTest, GetPackagePath_PackageTitleUnavailable_ReturnsFalse)
227+{
228+ MOCKER_CPP(&PackageEnvInfo::GetPackageTitle).stubs().will(returnValue(false));
229+ std::string kernelPath;
230+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_MINI);
231+ const bool ret = envInfo.GetPackagePath(kernelPath, 0U);
232+ EXPECT_EQ(ret, false);
233+}
234+ 
235+TEST_F(PackageEnvInfoComponentTest, GetPackageTitle_UnknownChip_ReturnsFalseAndEmptyTitle)
236+{
237+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_END);
238+ std::string pkgTitle;
239+ const bool ret = envInfo.GetPackageTitle(pkgTitle);
240+ EXPECT_EQ(ret, false);
241+ EXPECT_STREQ(pkgTitle.c_str(), "");
242+}
243+ 
244+TEST_F(PackageEnvInfoComponentTest, GetPackageTitle_Ascend910A_ReturnsAscend910)
245+{
246+ PackageEnvInfo envInfo(deviceId, static_cast<uint32_t>(ModeType::ONLINE), false, CHIP_ASCEND_910A);
247+ std::string pkgTitle;
248+ const bool ret = envInfo.GetPackageTitle(pkgTitle);
249+ EXPECT_EQ(ret, true);
250+ EXPECT_STREQ(pkgTitle.c_str(), "Ascend910");
251+}
Atests/ut/tsd/basic_component/package_manager/package_hash_store_utest.cpp+110-0
@@ -0,0 +1,110 @@
1+/**
2+ * Copyright (c) 2026 Huawei Technologies Co., Ltd.
3+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4+ * CANN Open Software License Agreement Version 2.0 (the "License").
5+ * Please refer to the License for details. You may not use this file except in compliance with the License.
6+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8+ * See LICENSE in the root of the software repository for the full text of the License.
9+ */
10+ 
11+#include "package_manager_test_common.h"
12+ 
13+using namespace tsd;
14+using namespace tsdtest;
15+ 
16+class PackageHashStoreComponentTest : public PackageManagerComponentTest {};
17+ 
18+TEST_F(PackageHashStoreComponentTest, MissingHostHashReturnsEmpty)
19+{
20+ PackageHashStore store;
21+ EXPECT_TRUE(store.GetHostCommonSinkPackHashValue("missing").empty());
22+}
23+ 
24+TEST_F(PackageHashStoreComponentTest, MissingDeviceHashReturnsEmpty)
25+{
26+ PackageHashStore store;
27+ EXPECT_TRUE(store.GetDeviceCommonSinkPackHashValue("missing").empty());
28+}
29+ 
30+TEST_F(PackageHashStoreComponentTest, SetAndGetHostHash)
31+{
32+ PackageHashStore store;
33+ store.SetHostCommonSinkPackHashValue("pkg", "host");
34+ EXPECT_EQ(store.GetHostCommonSinkPackHashValue("pkg"), "host");
35+}
36+ 
37+TEST_F(PackageHashStoreComponentTest, SetAndGetDeviceHash)
38+{
39+ PackageHashStore store;
40+ store.SetDeviceCommonSinkPackHashValue("pkg", "device");
41+ EXPECT_EQ(store.GetDeviceCommonSinkPackHashValue("pkg"), "device");
42+}
43+ 
44+TEST_F(PackageHashStoreComponentTest, SameHashReturnsTrue)
45+{
46+ PackageHashStore store;
47+ store.SetHostCommonSinkPackHashValue("pkg", "same");
48+ store.SetDeviceCommonSinkPackHashValue("pkg", "same");
49+ EXPECT_TRUE(store.IsCommonSinkHostAndDevicePkgSame("pkg"));
50+}
51+ 
52+TEST_F(PackageHashStoreComponentTest, DifferentHashReturnsFalse)
53+{
54+ PackageHashStore store;
55+ store.SetHostCommonSinkPackHashValue("pkg", "host");
56+ store.SetDeviceCommonSinkPackHashValue("pkg", "device");
57+ EXPECT_FALSE(store.IsCommonSinkHostAndDevicePkgSame("pkg"));
58+}
59+ 
60+TEST_F(PackageHashStoreComponentTest, EmptyHashesAreNotSame)
61+{
62+ PackageHashStore store;
63+ EXPECT_FALSE(store.IsCommonSinkHostAndDevicePkgSame("pkg"));
64+}
65+ 
66+TEST_F(PackageHashStoreComponentTest, ClearRemovesHostAndDeviceHashes)
67+{
68+ PackageHashStore store;
69+ store.SetHostCommonSinkPackHashValue("pkg", "host");
70+ store.SetDeviceCommonSinkPackHashValue("pkg", "device");
71+ store.Clear();
72+ EXPECT_TRUE(store.GetHostCommonSinkPackHashValue("pkg").empty());
73+ EXPECT_TRUE(store.GetDeviceCommonSinkPackHashValue("pkg").empty());
74+}
75+ 
76+TEST_F(PackageHashStoreComponentTest, StoreAllAcceptsConfigResponse)
77+{
78+ PackageHashStore store;
79+ HDCMessage msg;
80+ msg.set_type(HDCMessage::TSD_UPDATE_PACKAGE_PROCESS_CONFIG_RSP);
81+ auto* info = msg.add_package_hash_code_list();
82+ info->set_package_name("pkg");
83+ info->set_hash_code("hash");
84+ store.StoreAllPkgHashValue(msg);
85+ EXPECT_EQ(store.GetDeviceCommonSinkPackHashValue("pkg"), "hash");
86+}
87+ 
88+TEST_F(PackageHashStoreComponentTest, StoreAllAcceptsNormalCheckCodeResponse)
89+{
90+ PackageHashStore store;
91+ HDCMessage msg;
92+ msg.set_type(HDCMessage::TSD_GET_DEVICE_PACKAGE_CHECKCODE_NORMAL_RSP);
93+ auto* info = msg.add_package_hash_code_list();
94+ info->set_package_name("pkg");
95+ info->set_hash_code("hash");
96+ store.StoreAllPkgHashValue(msg);
97+ EXPECT_EQ(store.GetDeviceCommonSinkPackHashValue("pkg"), "hash");
98+}
99+ 
100+TEST_F(PackageHashStoreComponentTest, StoreAllIgnoresUnrelatedResponse)
101+{
102+ PackageHashStore store;
103+ HDCMessage msg;
104+ msg.set_type(HDCMessage::TSD_START_PROC_MSG);
105+ auto* info = msg.add_package_hash_code_list();
106+ info->set_package_name("pkg");
107+ info->set_hash_code("hash");
108+ store.StoreAllPkgHashValue(msg);
109+ EXPECT_TRUE(store.GetDeviceCommonSinkPackHashValue("pkg").empty());
110+}
Atests/ut/tsd/basic_component/package_manager/package_manager_test_common.h+154-0
@@ -0,0 +1,154 @@
1+/**
2+ * Copyright (c) 2026 Huawei Technologies Co., Ltd.
3+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4+ * CANN Open Software License Agreement Version 2.0 (the "License").
5+ * Please refer to the License for details. You may not use this file except in compliance with the License.
6+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8+ * See LICENSE in the root of the software repository for the full text of the License.
9+ */
10+ 
11+#ifndef TSD_PACKAGE_MANAGER_TEST_COMMON_H
12+#define TSD_PACKAGE_MANAGER_TEST_COMMON_H
13+ 
14+#include "gtest/gtest.h"
15+#include "mockcpp/mockcpp.hpp"
16+#include "tsd/status.h"
17+ 
18+#define private public
19+#define protected public
20+#include "inc/process_mode_manager.h"
21+#include "package_manager.h"
22+#include "package_process_config.h"
23+#include "plugin_pkg_version.h"
24+#include "platform_manager_v2.h"
25+#include "tsd_hdc_client.h"
26+#include "weak_ascend_hal.h"
27+#include "common_util_func.h"
28+#undef private
29+#undef protected
30+ 
31+namespace tsdtest {
32+ 
33+constexpr int deviceId = 0;
34+constexpr int32_t PROCESS_MODE = 0;
35+ 
36+class PackageManagerComponentTest : public testing::Test {
37+protected:
38+ void SetUp() override
39+ {
40+ savedRunningMode_ = tsd::ClientManager::g_runningMode;
41+ ascendAicpuPathEnv_ = std::make_unique<tsd::ScopedEnvVar>("ASCEND_AICPU_PATH");
42+ packageProcessConfig_ = tsd::PackageProcessConfig::GetInstance();
43+ savedConfigMap_ = packageProcessConfig_->configMap_;
44+ savedHostPluginVersions_ = packageProcessConfig_->hostPluginVersions_;
45+ savedHashCode_ = packageProcessConfig_->hashCode_;
46+ savedFinishParse_ = packageProcessConfig_->finishParse_;
47+ ClearPackageProcessConfig();
48+ 
49+ std::string mode("PROCESS_MODE");
50+ tsd::ClientManager::SetRunMode(mode);
51+ MOCKER_CPP(&tsd::ClientManager::IsSupportSetVisibleDevices).stubs().will(returnValue(false));
52+ }
53+ 
54+ void TearDown() override
55+ {
56+ try {
57+ GlobalMockObject::verify();
58+ } catch (...) {
59+ GlobalMockObject::reset();
60+ RestoreSharedState();
61+ throw;
62+ }
63+ GlobalMockObject::reset();
64+ RestoreSharedState();
65+ }
66+ 
67+private:
68+ void ClearPackageProcessConfig()
69+ {
70+ packageProcessConfig_->configMap_.clear();
71+ packageProcessConfig_->hostPluginVersions_.clear();
72+ packageProcessConfig_->hashCode_.clear();
73+ packageProcessConfig_->finishParse_ = false;
74+ }
75+ 
76+ void RestoreSharedState()
77+ {
78+ packageProcessConfig_->configMap_ = savedConfigMap_;
79+ packageProcessConfig_->hostPluginVersions_ = savedHostPluginVersions_;
80+ packageProcessConfig_->hashCode_ = savedHashCode_;
81+ packageProcessConfig_->finishParse_ = savedFinishParse_;
82+ tsd::ClientManager::g_runningMode = savedRunningMode_;
83+ ascendAicpuPathEnv_.reset();
84+ }
85+ 
86+ tsd::RunningMode savedRunningMode_ = tsd::RunningMode::UNSET_MODE;
87+ tsd::PackageProcessConfig* packageProcessConfig_ = nullptr;
88+ std::map<std::string, tsd::PackConfDetail> savedConfigMap_;
89+ std::map<std::string, tsd::PluginPkgVersion> savedHostPluginVersions_;
90+ std::string savedHashCode_;
91+ bool savedFinishParse_ = false;
92+ std::unique_ptr<tsd::ScopedEnvVar> ascendAicpuPathEnv_;
93+};
94+ 
95+class StubPackageDeviceComm : public tsd::DeviceComm {
96+public:
97+ explicit StubPackageDeviceComm(uint32_t devId)
98+ : tsd::DeviceComm(devId, tsd::DeviceCommType::HDC), inspector_(std::make_shared<tsd::VersionVerify>())
99+ {}
100+ 
101+ tsd::TSD_StatusT CommInit(const uint32_t, const bool) override { return commInitRet_; }
102+ tsd::TSD_StatusT CommCreateSession(uint32_t& sid) override
103+ {
104+ sid = sessionIdStub_;
105+ return commCreateSessionRet_;
106+ }
107+ void CommDestroy() override { ++destroyCount_; }
108+ tsd::TSD_StatusT CommRecvData(const uint32_t, const bool, const uint32_t) override
109+ {
110+ ++recvCount_;
111+ return commRecvDataRet_;
112+ }
113+ tsd::TSD_StatusT CommGetConctStatus(int32_t& status) override
114+ {
115+ status = sessStat_;
116+ return commGetConctStatusRet_;
117+ }
118+ tsd::TSD_StatusT CommSendMsg(const uint32_t, const tsd::HDCMessage& msg) override
119+ {
120+ ++sendCount_;
121+ lastMsg_ = msg;
122+ return commSendMsgRet_;
123+ }
124+ tsd::TSD_StatusT CommGetVersionVerify(const uint32_t, std::shared_ptr<tsd::VersionVerify>& verify) override
125+ {
126+ verify = inspector_;
127+ return commGetVersionVerifyRet_;
128+ }
129+ 
130+ tsd::TSD_StatusT commInitRet_ = tsd::TSD_OK;
131+ tsd::TSD_StatusT commCreateSessionRet_ = tsd::TSD_OK;
132+ tsd::TSD_StatusT commRecvDataRet_ = tsd::TSD_OK;
133+ tsd::TSD_StatusT commGetConctStatusRet_ = tsd::TSD_OK;
134+ tsd::TSD_StatusT commSendMsgRet_ = tsd::TSD_OK;
135+ tsd::TSD_StatusT commGetVersionVerifyRet_ = tsd::TSD_OK;
136+ uint32_t sessionIdStub_ = 1U;
137+ int32_t sessStat_ = 0;
138+ int destroyCount_ = 0;
139+ int sendCount_ = 0;
140+ int recvCount_ = 0;
141+ tsd::HDCMessage lastMsg_;
142+ std::shared_ptr<tsd::VersionVerify> inspector_;
143+};
144+ 
145+inline std::shared_ptr<StubPackageDeviceComm> InjectPackageStubComm(tsd::ProcessModeManager& manager, uint32_t devId)
146+{
147+ auto stub = std::make_shared<StubPackageDeviceComm>(devId);
148+ manager.commAgent_.devCommClient_ = stub;
149+ return stub;
150+}
151+ 
152+} // namespace tsdtest
153+ 
154+#endif // TSD_PACKAGE_MANAGER_TEST_COMMON_H
Rtests/ut/tsd/tsdclient/test/message_parse_client_utest.cpp→tests/ut/tsd/basic_component/package_manager/package_manager_utest.cpp+25-38
@@ -8,55 +8,42 @@
8 * See LICENSE in the root of the software repository for the full text of the License.8 * See LICENSE in the root of the software repository for the full text of the License.
9 */9 */
10 10 
11-#include "gtest/gtest.h"11+#include "package_manager_test_common.h"
12-#define private public
13-#include "tsd_message_parse_client.h"
14-#undef private
15 12 
16using namespace tsd;13using namespace tsd;
14+using namespace tsdtest;
17 15 
18-namespace {16+class PackageManagerFacadeTest : public PackageManagerComponentTest {};
19-uint32_t g_sessionId = 0U;
20-HDCMessage::MsgType g_msgType = HDCMessage::INIT;
21 17 
22-void TestParseFunc(const uint32_t sessionId, const HDCMessage& msg)18+TEST_F(PackageManagerFacadeTest, ResetOnCloseClearsSendConfigState)
23{19{
24- g_sessionId = sessionId;20+ ProcessModeManager manager(deviceId, PROCESS_MODE);
25- g_msgType = msg.type();21+ manager.GetPackageManager().loader_.hasSendConfigFile_ = true;
26-}
27-} // namespace
28 22 
29-class MessageParseClientUTest : public testing::Test {23+ manager.GetPackageManager().ResetOnClose();
30-protected:
31- void SetUp() override
32- {
33- g_sessionId = 0U;
34- g_msgType = HDCMessage::INIT;
35- }
36 24 
37- void TearDown() override { MessageParseClient::GetInstance()->parseFuncMap_.erase(HDCMessage::TEST_HDC_SEND); }25+ EXPECT_FALSE(manager.GetPackageManager().loader_.hasSendConfigFile_);
38-};
39- 
40-TEST_F(MessageParseClientUTest, GetInstanceReturnsSingleton)
41-{
42- MessageParseClient* first = MessageParseClient::GetInstance();
43- MessageParseClient* second = MessageParseClient::GetInstance();
44- 
45- EXPECT_NE(first, nullptr);
46- EXPECT_EQ(first, second);
47}26}
48 27 
49-TEST_F(MessageParseClientUTest, GetInstanceSupportsRegisteredParser)28+TEST_F(PackageManagerFacadeTest, GetHostCheckCodeReturnsServiceState)
50{29{
51- constexpr uint32_t sessionId = 123U;30+ ProcessModeManager manager(deviceId, PROCESS_MODE);
52- MessageParseClient* client = MessageParseClient::GetInstance();31+ manager.GetPackageManager().checkCodeSvc_.SetHostCheckCodeByIndex(
53- ASSERT_NE(client, nullptr);32+ static_cast<uint32_t>(TsdLoadPackageType::TSD_PKG_TYPE_AICPU_KERNEL), 42U);
54 33 
55- client->RegisterMsgProcess(HDCMessage::TEST_HDC_SEND, TestParseFunc);34+ EXPECT_EQ(manager.GetPackageManager().GetHostCheckCode(TsdLoadPackageType::TSD_PKG_TYPE_AICPU_KERNEL), 42U);
35+}
36+ 
37+TEST_F(PackageManagerFacadeTest, StoreAllPkgHashValueForwardsToHashStore)
38+{
39+ ProcessModeManager manager(deviceId, PROCESS_MODE);
56 HDCMessage msg;40 HDCMessage msg;
57- msg.set_type(HDCMessage::TEST_HDC_SEND);41+ msg.set_type(HDCMessage::TSD_GET_DEVICE_PACKAGE_CHECKCODE_NORMAL_RSP);
58- client->ProcessMessage(sessionId, msg);42+ auto* info = msg.add_package_hash_code_list();
43+ info->set_package_name("pkg");
44+ info->set_hash_code("hash");
59 45 
60- EXPECT_EQ(g_sessionId, sessionId);46+ manager.GetPackageManager().StoreAllPkgHashValue(msg);
61- EXPECT_EQ(g_msgType, HDCMessage::TEST_HDC_SEND);47+ 
48+ EXPECT_EQ(manager.GetPackageManager().hashStore_.GetDeviceCommonSinkPackHashValue("pkg"), "hash");
62}49}
Rtests/ut/tsd/tsdclient/test/package_process_config_utest.cpp→tests/ut/tsd/basic_component/package_manager/package_process_config_utest.cpp+159-89
@@ -24,9 +24,57 @@ using namespace tsd;
24 24 
25class PackageProcessConfigTest : public testing::Test {25class PackageProcessConfigTest : public testing::Test {
26protected:26protected:
27- virtual void SetUp() {}27+ void SetUp() override
28+ {
29+ char dirTemplate[] = "/tmp/package_process_config_ut_XXXXXX";
30+ char* dir = mkdtemp(dirTemplate);
31+ ASSERT_NE(dir, nullptr);
32+ tempDir_ = dir;
33+ configFile_ = tempDir_ + "/ascend_package_load.ini";
28 34 
29- virtual void TearDown() { GlobalMockObject::verify(); }35+ config_ = PackageProcessConfig::GetInstance();
36+ savedConfigMap_ = config_->configMap_;
37+ savedHostPluginVersions_ = config_->hostPluginVersions_;
38+ savedHashCode_ = config_->hashCode_;
39+ savedFinishParse_ = config_->finishParse_;
40+ config_->configMap_.clear();
41+ config_->hostPluginVersions_.clear();
42+ config_->hashCode_.clear();
43+ config_->finishParse_ = false;
44+ }
45+ 
46+ void TearDown() override
47+ {
48+ try {
49+ GlobalMockObject::verify();
50+ } catch (...) {
51+ GlobalMockObject::reset();
52+ RestoreState();
53+ throw;
54+ }
55+ GlobalMockObject::reset();
56+ RestoreState();
57+ }
58+ 
59+ std::string configFile_;
60+ 
61+private:
62+ void RestoreState()
63+ {
64+ config_->configMap_ = savedConfigMap_;
65+ config_->hostPluginVersions_ = savedHostPluginVersions_;
66+ config_->hashCode_ = savedHashCode_;
67+ config_->finishParse_ = savedFinishParse_;
68+ (void)remove(configFile_.c_str());
69+ (void)remove(tempDir_.c_str());
70+ }
71+ 
72+ PackageProcessConfig* config_ = nullptr;
73+ std::string tempDir_;
74+ std::map<std::string, PackConfDetail> savedConfigMap_;
75+ std::map<std::string, PluginPkgVersion> savedHostPluginVersions_;
76+ std::string savedHashCode_;
77+ bool savedFinishParse_ = false;
30};78};
31namespace {79namespace {
32bool WriteConfigFile(const std::string fileName, const std::vector<std::string> itemVec)80bool WriteConfigFile(const std::string fileName, const std::vector<std::string> itemVec)
@@ -68,7 +116,7 @@ bool WriteConfigFile3(const std::string fileName)
68}116}
69} // namespace117} // namespace
70 118 
71-TEST_F(PackageProcessConfigTest, GetConfigDetailInfoSuccess)119+TEST_F(PackageProcessConfigTest, GetConfigDetailInfo_ExistingAndMissingNames_ReturnsStoredOrDefaultDetail)
72{120{
73 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();121 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();
74 PackConfDetail config = {};122 PackConfDetail config = {};
@@ -86,7 +134,7 @@ TEST_F(PackageProcessConfigTest, GetConfigDetailInfoSuccess)
86 EXPECT_EQ(res1.hostTruePath, "");134 EXPECT_EQ(res1.hostTruePath, "");
87}135}
88 136 
89-TEST_F(PackageProcessConfigTest, SetConfigDataOnServerSuccess)137+TEST_F(PackageProcessConfigTest, SetConfigDataOnServer_ValidPackageName_ReturnsTrue)
90{138{
91 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();139 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();
92 SinkPackageConfig hdcConfig;140 SinkPackageConfig hdcConfig;
@@ -95,7 +143,7 @@ TEST_F(PackageProcessConfigTest, SetConfigDataOnServerSuccess)
95 EXPECT_EQ(ret, true);143 EXPECT_EQ(ret, true);
96}144}
97 145 
98-TEST_F(PackageProcessConfigTest, ParseConfigDataFromProtoBufSuccess)146+TEST_F(PackageProcessConfigTest, ParseConfigDataFromProtoBuf_AllEntriesAccepted_ReturnsOk)
99{147{
100 HDCMessage msg;148 HDCMessage msg;
101 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();149 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();
@@ -112,7 +160,7 @@ TEST_F(PackageProcessConfigTest, ParseConfigDataFromProtoBufSuccess)
112 EXPECT_EQ(ret, TSD_OK);160 EXPECT_EQ(ret, TSD_OK);
113}161}
114 162 
115-TEST_F(PackageProcessConfigTest, ParseConfigDataFromProtoBufFailed)163+TEST_F(PackageProcessConfigTest, ParseConfigDataFromProtoBuf_EntryRejected_ReturnsStartFail)
116{164{
117 HDCMessage msg;165 HDCMessage msg;
118 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();166 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();
@@ -129,34 +177,30 @@ TEST_F(PackageProcessConfigTest, ParseConfigDataFromProtoBufFailed)
129 EXPECT_EQ(ret, TSD_START_FAIL);177 EXPECT_EQ(ret, TSD_START_FAIL);
130}178}
131 179 
132-TEST_F(PackageProcessConfigTest, GetHostFilePathSucc)180+TEST_F(PackageProcessConfigTest, GetHostFilePath_AccessiblePackage_ReturnsPackagePath)
133{181{
134 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();182 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();
135 std::string packagePath = "/tmp/";183 std::string packagePath = "/tmp/";
136 std::string packageName = "Ascend-aicpu_legacy.tar.gz";184 std::string packageName = "Ascend-aicpu_legacy.tar.gz";
137 MOCKER(access).stubs().will(returnValue(0));185 MOCKER(access).stubs().will(returnValue(0));
138 std::string path = pkgcfg->GetHostFilePath(packagePath, packageName);186 std::string path = pkgcfg->GetHostFilePath(packagePath, packageName);
187+ EXPECT_FALSE(path.empty());
188+ EXPECT_NE(path.find(packageName), std::string::npos);
139}189}
140 190 
141-TEST_F(PackageProcessConfigTest, ParseConfigDataFromFileSucc)191+TEST_F(PackageProcessConfigTest, ParseConfigDataFromFile_ValidConfig_SetsFinishFlag)
142{192{
143- std::string configFile = "/tmp/ascend_package_load.ini";
144 MOCKER(access).stubs().will(returnValue(0));193 MOCKER(access).stubs().will(returnValue(0));
145- if (WriteConfigFile2(configFile)) {194+ ASSERT_TRUE(WriteConfigFile2(configFile_));
146- PackageProcessConfig* pkgConf = PackageProcessConfig::GetInstance();195+ PackageProcessConfig* pkgConf = PackageProcessConfig::GetInstance();
147- MOCKER_CPP(&PackageProcessConfig::GetHostFilePath).stubs().will(returnValue(configFile));196+ MOCKER_CPP(&PackageProcessConfig::GetHostFilePath).stubs().will(returnValue(configFile_));
148- auto ret = pkgConf->ParseConfigDataFromFile("Ascend");197+ auto ret = pkgConf->ParseConfigDataFromFile("Ascend");
149- MOCKER_CPP(&PackageProcessConfig::SetConfigDataOnHost).stubs().will(returnValue(true));198+ EXPECT_EQ(ret, TSD_OK);
150- EXPECT_EQ(ret, TSD_OK);199+ EXPECT_EQ(pkgConf->finishParse_, true);
151- EXPECT_EQ(pkgConf->finishParse_, true);
152- pkgConf->configMap_.clear();
153- pkgConf->finishParse_ = false;
154- }
155}200}
156 201 
157-TEST_F(PackageProcessConfigTest, ParseConfigDataFromFile_EmptyPkgName_Failed)202+TEST_F(PackageProcessConfigTest, ParseConfigDataFromFile_EmptyPackageName_ReturnsStartFail)
158{203{
159- std::string configFile = "/tmp/ascend_package_load.ini";
160 MOCKER(access).stubs().will(returnValue(0));204 MOCKER(access).stubs().will(returnValue(0));
161 std::vector<std::string> itemVec{205 std::vector<std::string> itemVec{
162 "name:",206 "name:",
@@ -164,58 +208,52 @@ TEST_F(PackageProcessConfigTest, ParseConfigDataFromFile_EmptyPkgName_Failed)
164 "optional:true",208 "optional:true",
165 "package_path:opp",209 "package_path:opp",
166 };210 };
167- if (WriteConfigFile(configFile, itemVec)) {211+ ASSERT_TRUE(WriteConfigFile(configFile_, itemVec));
168- PackageProcessConfig* pkgConf = PackageProcessConfig::GetInstance();212+ PackageProcessConfig* pkgConf = PackageProcessConfig::GetInstance();
169- MOCKER_CPP(&PackageProcessConfig::GetHostFilePath).stubs().will(returnValue(configFile));213+ MOCKER_CPP(&PackageProcessConfig::GetHostFilePath).stubs().will(returnValue(configFile_));
170- auto ret = pkgConf->ParseConfigDataFromFile("Ascend");214+ auto ret = pkgConf->ParseConfigDataFromFile("Ascend");
171- EXPECT_EQ(ret, TSD_START_FAIL);215+ EXPECT_EQ(ret, TSD_START_FAIL);
172- }
173}216}
174 217 
175-TEST_F(PackageProcessConfigTest, ParseConfigDataFromFile_SetConfigDataOnHostFailed_Failed)218+TEST_F(PackageProcessConfigTest, ParseConfigDataFromFile_HostConfigStoreRejects_ReturnsStartFail)
176{219{
177- std::string configFile = "/tmp/ascend_package_load.ini";
178 MOCKER(access).stubs().will(returnValue(0));220 MOCKER(access).stubs().will(returnValue(0));
179- if (WriteConfigFile2(configFile)) {221+ ASSERT_TRUE(WriteConfigFile2(configFile_));
180- PackageProcessConfig* pkgConf = PackageProcessConfig::GetInstance();222+ PackageProcessConfig* pkgConf = PackageProcessConfig::GetInstance();
181- MOCKER_CPP(&PackageProcessConfig::GetHostFilePath).stubs().will(returnValue(configFile));223+ MOCKER_CPP(&PackageProcessConfig::GetHostFilePath).stubs().will(returnValue(configFile_));
182- MOCKER_CPP(&PackageProcessConfig::SetConfigDataOnHost).stubs().will(returnValue(false));224+ MOCKER_CPP(&PackageProcessConfig::SetConfigDataOnHost).stubs().will(returnValue(false));
183- auto ret = pkgConf->ParseConfigDataFromFile("Ascend");225+ auto ret = pkgConf->ParseConfigDataFromFile("Ascend");
184- EXPECT_EQ(ret, TSD_START_FAIL);226+ EXPECT_EQ(ret, TSD_START_FAIL);
185- }
186}227}
187 228 
188-TEST_F(PackageProcessConfigTest, SetConfigDataOnHostSucc)229+TEST_F(PackageProcessConfigTest, SetConfigDataOnHost_AllRequiredItemsPresent_ReturnsTrue)
189{230{
190- std::string configFile = "/tmp/ascend_package_load3.ini";
191 MOCKER(access).stubs().will(returnValue(0));231 MOCKER(access).stubs().will(returnValue(0));
192 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();232 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();
193- if (WriteConfigFile3(configFile)) {233+ ASSERT_TRUE(WriteConfigFile3(configFile_));
194- std::string fileName = "Ascend-aicpu_legacy.tar.gz";234+ std::string fileName = "Ascend-aicpu_legacy.tar.gz";
195- std::ifstream inFile(configFile);235+ std::ifstream inFile(configFile_);
196- MOCKER_CPP(&PackageProcessConfig::SetPkgHostTruePath).stubs().will(returnValue(true));236+ ASSERT_TRUE(inFile.is_open());
197- auto ret = pkgcfg->SetConfigDataOnHost(inFile, fileName, "Ascend");237+ MOCKER_CPP(&PackageProcessConfig::SetPkgHostTruePath).stubs().will(returnValue(true));
198- EXPECT_EQ(ret, true);238+ auto ret = pkgcfg->SetConfigDataOnHost(inFile, fileName, "Ascend");
199- }239+ EXPECT_EQ(ret, true);
200}240}
201 241 
202-TEST_F(PackageProcessConfigTest, SetConfigDataOnHost_ParseSingleParaFailed_Failed)242+TEST_F(PackageProcessConfigTest, SetConfigDataOnHost_ParameterParsingFails_ReturnsFalse)
203{243{
204- std::string configFile = "/tmp/ascend_package_load3.ini";
205 MOCKER(access).stubs().will(returnValue(0));244 MOCKER(access).stubs().will(returnValue(0));
206 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();245 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();
207- if (WriteConfigFile3(configFile)) {246+ ASSERT_TRUE(WriteConfigFile3(configFile_));
208- std::string fileName = "Ascend-aicpu_legacy.tar.gz";247+ std::string fileName = "Ascend-aicpu_legacy.tar.gz";
209- std::ifstream inFile(configFile);248+ std::ifstream inFile(configFile_);
210- MOCKER_CPP(&PackageProcessConfig::ParseSinglePara).stubs().will(returnValue(false));249+ ASSERT_TRUE(inFile.is_open());
211- auto ret = pkgcfg->SetConfigDataOnHost(inFile, fileName, "Ascend");250+ MOCKER_CPP(&PackageProcessConfig::ParseSinglePara).stubs().will(returnValue(false));
212- EXPECT_EQ(ret, false);251+ auto ret = pkgcfg->SetConfigDataOnHost(inFile, fileName, "Ascend");
213- }252+ EXPECT_EQ(ret, false);
214}253}
215 254 
216-TEST_F(PackageProcessConfigTest, SetConfigDataOnHost_NotAllItemParsed_Failed)255+TEST_F(PackageProcessConfigTest, SetConfigDataOnHost_RequiredItemMissing_ReturnsFalse)
217{256{
218- std::string configFile = "/tmp/ascend_package_load3.ini";
219 MOCKER(access).stubs().will(returnValue(0));257 MOCKER(access).stubs().will(returnValue(0));
220 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();258 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();
221 std::vector<std::string> itemVec{259 std::vector<std::string> itemVec{
@@ -223,29 +261,28 @@ TEST_F(PackageProcessConfigTest, SetConfigDataOnHost_NotAllItemParsed_Failed)
223 "optional:true",261 "optional:true",
224 "package_path:opp",262 "package_path:opp",
225 };263 };
226- if (WriteConfigFile(configFile, itemVec)) {264+ ASSERT_TRUE(WriteConfigFile(configFile_, itemVec));
227- std::string fileName = "Ascend-aicpu_legacy.tar.gz";265+ std::string fileName = "Ascend-aicpu_legacy.tar.gz";
228- std::ifstream inFile(configFile);266+ std::ifstream inFile(configFile_);
229- auto ret = pkgcfg->SetConfigDataOnHost(inFile, fileName, "Ascend");267+ ASSERT_TRUE(inFile.is_open());
230- EXPECT_EQ(ret, false);268+ auto ret = pkgcfg->SetConfigDataOnHost(inFile, fileName, "Ascend");
231- }269+ EXPECT_EQ(ret, false);
232}270}
233 271 
234-TEST_F(PackageProcessConfigTest, SetConfigDataOnHost_SetPkgHostTruePathFailed_Failed)272+TEST_F(PackageProcessConfigTest, SetConfigDataOnHost_HostPathResolutionFails_ReturnsFalse)
235{273{
236- std::string configFile = "/tmp/ascend_package_load3.ini";
237 MOCKER(access).stubs().will(returnValue(0));274 MOCKER(access).stubs().will(returnValue(0));
238 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();275 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();
239- if (WriteConfigFile3(configFile)) {276+ ASSERT_TRUE(WriteConfigFile3(configFile_));
240- std::string fileName = "Ascend-aicpu_legacy.tar.gz";277+ std::string fileName = "Ascend-aicpu_legacy.tar.gz";
241- std::ifstream inFile(configFile);278+ std::ifstream inFile(configFile_);
242- MOCKER_CPP(&PackageProcessConfig::SetPkgHostTruePath).stubs().will(returnValue(false));279+ ASSERT_TRUE(inFile.is_open());
243- auto ret = pkgcfg->SetConfigDataOnHost(inFile, fileName, "Ascend");280+ MOCKER_CPP(&PackageProcessConfig::SetPkgHostTruePath).stubs().will(returnValue(false));
244- EXPECT_EQ(ret, false);281+ auto ret = pkgcfg->SetConfigDataOnHost(inFile, fileName, "Ascend");
245- }282+ EXPECT_EQ(ret, false);
246}283}
247 284 
248-TEST_F(PackageProcessConfigTest, SetPkgHostTruePath_Success)285+TEST_F(PackageProcessConfigTest, SetPkgHostTruePath_LegacyPackageWithoutSoc_ReturnsTrue)
249{286{
250 PackConfDetail tempNode;287 PackConfDetail tempNode;
251 std::string pkgName = "-aicpu_legacy.tar.gz";288 std::string pkgName = "-aicpu_legacy.tar.gz";
@@ -255,7 +292,7 @@ TEST_F(PackageProcessConfigTest, SetPkgHostTruePath_Success)
255 EXPECT_EQ(ret, true);292 EXPECT_EQ(ret, true);
256}293}
257 294 
258-TEST_F(PackageProcessConfigTest, SetPkgHostTruePath_UseShortSocVersion_Success)295+TEST_F(PackageProcessConfigTest, SetPkgHostTruePath_SocVersionProvided_ReturnsTrue)
259{296{
260 PackConfDetail tempNode;297 PackConfDetail tempNode;
261 tempNode.loadAsPerSocFlag = true;298 tempNode.loadAsPerSocFlag = true;
@@ -266,7 +303,7 @@ TEST_F(PackageProcessConfigTest, SetPkgHostTruePath_UseShortSocVersion_Success)
266 EXPECT_EQ(ret, true);303 EXPECT_EQ(ret, true);
267}304}
268 305 
269-TEST_F(PackageProcessConfigTest, SetPkgHostTruePath_UseShortSocVersion_Failed)306+TEST_F(PackageProcessConfigTest, SetPkgHostTruePath_EmptySocVersion_ReturnsFalse)
270{307{
271 PackConfDetail tempNode;308 PackConfDetail tempNode;
272 tempNode.loadAsPerSocFlag = true;309 tempNode.loadAsPerSocFlag = true;
@@ -277,7 +314,7 @@ TEST_F(PackageProcessConfigTest, SetPkgHostTruePath_UseShortSocVersion_Failed)
277 EXPECT_EQ(ret, false);314 EXPECT_EQ(ret, false);
278}315}
279 316 
280-TEST_F(PackageProcessConfigTest, SetPkgHostTruePath_NoSocVersion_Failed)317+TEST_F(PackageProcessConfigTest, SetPkgHostTruePath_SocSeparatorMissing_ReturnsFalse)
281{318{
282 PackConfDetail tempNode;319 PackConfDetail tempNode;
283 tempNode.loadAsPerSocFlag = true;320 tempNode.loadAsPerSocFlag = true;
@@ -288,7 +325,7 @@ TEST_F(PackageProcessConfigTest, SetPkgHostTruePath_NoSocVersion_Failed)
288 EXPECT_EQ(ret, false);325 EXPECT_EQ(ret, false);
289}326}
290 327 
291-TEST_F(PackageProcessConfigTest, ParseSinglePara_Success)328+TEST_F(PackageProcessConfigTest, ParseSinglePara_ValidOptionalFlag_SetsFlagAndReturnsTrue)
292{329{
293 std::string inputLine = "optional:true";330 std::string inputLine = "optional:true";
294 PackConfDetail tempNode;331 PackConfDetail tempNode;
@@ -299,7 +336,7 @@ TEST_F(PackageProcessConfigTest, ParseSinglePara_Success)
299 EXPECT_EQ(ret, true);336 EXPECT_EQ(ret, true);
300}337}
301 338 
302-TEST_F(PackageProcessConfigTest, ParseSinglePara_ItemWithoutColon_Failed)339+TEST_F(PackageProcessConfigTest, ParseSinglePara_ColonMissing_ReturnsFalse)
303{340{
304 std::string inputLine = "optional";341 std::string inputLine = "optional";
305 PackConfDetail tempNode;342 PackConfDetail tempNode;
@@ -309,7 +346,7 @@ TEST_F(PackageProcessConfigTest, ParseSinglePara_ItemWithoutColon_Failed)
309 EXPECT_EQ(ret, false);346 EXPECT_EQ(ret, false);
310}347}
311 348 
312-TEST_F(PackageProcessConfigTest, ParseSinglePara_InvalidConfigItem_Failed)349+TEST_F(PackageProcessConfigTest, ParseSinglePara_ConfigKeyUnknown_ReturnsFalse)
313{350{
314 std::string inputLine = "invalidItem:123";351 std::string inputLine = "invalidItem:123";
315 PackConfDetail tempNode;352 PackConfDetail tempNode;
@@ -319,7 +356,7 @@ TEST_F(PackageProcessConfigTest, ParseSinglePara_InvalidConfigItem_Failed)
319 EXPECT_EQ(ret, false);356 EXPECT_EQ(ret, false);
320}357}
321 358 
322-TEST_F(PackageProcessConfigTest, ParseSinglePara_ParseItemFailed_Failed)359+TEST_F(PackageProcessConfigTest, ParseSinglePara_ConfigValueInvalid_ReturnsFalse)
323{360{
324 std::string inputLine = "optional:123";361 std::string inputLine = "optional:123";
325 PackConfDetail tempNode;362 PackConfDetail tempNode;
@@ -329,7 +366,7 @@ TEST_F(PackageProcessConfigTest, ParseSinglePara_ParseItemFailed_Failed)
329 EXPECT_EQ(ret, false);366 EXPECT_EQ(ret, false);
330}367}
331 368 
332-TEST_F(PackageProcessConfigTest, ParseInstallPath_Success)369+TEST_F(PackageProcessConfigTest, ParseInstallPath_ValidEnumValue_SetsDestination)
333{370{
334 std::string para = "0";371 std::string para = "0";
335 PackConfDetail tempNode;372 PackConfDetail tempNode;
@@ -339,7 +376,7 @@ TEST_F(PackageProcessConfigTest, ParseInstallPath_Success)
339 EXPECT_EQ(tempNode.decDstDir, static_cast<DeviceInstallPath>(0));376 EXPECT_EQ(tempNode.decDstDir, static_cast<DeviceInstallPath>(0));
340}377}
341 378 
342-TEST_F(PackageProcessConfigTest, ParseInstallPath_Failed)379+TEST_F(PackageProcessConfigTest, ParseInstallPath_NegativeValue_ReturnsFalse)
343{380{
344 std::string para = "-1";381 std::string para = "-1";
345 PackConfDetail tempNode;382 PackConfDetail tempNode;
@@ -348,7 +385,7 @@ TEST_F(PackageProcessConfigTest, ParseInstallPath_Failed)
348 EXPECT_EQ(ret, false);385 EXPECT_EQ(ret, false);
349}386}
350 387 
351-TEST_F(PackageProcessConfigTest, ParseOptionalFlag_Success)388+TEST_F(PackageProcessConfigTest, ParseOptionalFlag_TrueValue_SetsFlag)
352{389{
353 std::string para = "true";390 std::string para = "true";
354 PackConfDetail tempNode;391 PackConfDetail tempNode;
@@ -358,7 +395,7 @@ TEST_F(PackageProcessConfigTest, ParseOptionalFlag_Success)
358 EXPECT_EQ(tempNode.optionalFlag, true);395 EXPECT_EQ(tempNode.optionalFlag, true);
359}396}
360 397 
361-TEST_F(PackageProcessConfigTest, ParseOptionalFlag_Failed)398+TEST_F(PackageProcessConfigTest, ParseOptionalFlag_NonBooleanValue_ReturnsFalse)
362{399{
363 std::string para = "123";400 std::string para = "123";
364 PackConfDetail tempNode;401 PackConfDetail tempNode;
@@ -367,7 +404,7 @@ TEST_F(PackageProcessConfigTest, ParseOptionalFlag_Failed)
367 EXPECT_EQ(ret, false);404 EXPECT_EQ(ret, false);
368}405}
369 406 
370-TEST_F(PackageProcessConfigTest, ParsePackagePath_Success)407+TEST_F(PackageProcessConfigTest, ParsePackagePath_NonemptyValue_SetsFindPath)
371{408{
372 std::string para = "opp";409 std::string para = "opp";
373 PackConfDetail tempNode;410 PackConfDetail tempNode;
@@ -377,7 +414,7 @@ TEST_F(PackageProcessConfigTest, ParsePackagePath_Success)
377 EXPECT_EQ(tempNode.findPath, para);414 EXPECT_EQ(tempNode.findPath, para);
378}415}
379 416 
380-TEST_F(PackageProcessConfigTest, ParsePackagePath_Failed)417+TEST_F(PackageProcessConfigTest, ParsePackagePath_EmptyValue_ReturnsFalse)
381{418{
382 std::string para = "";419 std::string para = "";
383 PackConfDetail tempNode;420 PackConfDetail tempNode;
@@ -386,7 +423,7 @@ TEST_F(PackageProcessConfigTest, ParsePackagePath_Failed)
386 EXPECT_EQ(ret, false);423 EXPECT_EQ(ret, false);
387}424}
388 425 
389-TEST_F(PackageProcessConfigTest, ParseLoadAsPerSocFlag_Success)426+TEST_F(PackageProcessConfigTest, ParseLoadAsPerSocFlag_TrueValue_SetsFlag)
390{427{
391 std::string para = "true";428 std::string para = "true";
392 PackConfDetail tempNode;429 PackConfDetail tempNode;
@@ -396,7 +433,7 @@ TEST_F(PackageProcessConfigTest, ParseLoadAsPerSocFlag_Success)
396 EXPECT_EQ(tempNode.loadAsPerSocFlag, true);433 EXPECT_EQ(tempNode.loadAsPerSocFlag, true);
397}434}
398 435 
399-TEST_F(PackageProcessConfigTest, ParseLoadAsPerSocFlag_Failed)436+TEST_F(PackageProcessConfigTest, ParseLoadAsPerSocFlag_NonBooleanValue_ReturnsFalse)
400{437{
401 std::string para = "123";438 std::string para = "123";
402 PackConfDetail tempNode;439 PackConfDetail tempNode;
@@ -408,7 +445,7 @@ TEST_F(PackageProcessConfigTest, ParseLoadAsPerSocFlag_Failed)
408// 覆盖 RefreshHostPluginVersions 中加锁写 hostPluginVersions_ 的两条 lock_guard 分支：445// 覆盖 RefreshHostPluginVersions 中加锁写 hostPluginVersions_ 的两条 lock_guard 分支：
409// 1) compat 包 hostTruePath 为空 -> empty 分支加锁写入空版本446// 1) compat 包 hostTruePath 为空 -> empty 分支加锁写入空版本
410// 2) compat 包 hostTruePath 非空 -> 末尾加锁写入解析结果447// 2) compat 包 hostTruePath 非空 -> 末尾加锁写入解析结果
411-TEST_F(PackageProcessConfigTest, RefreshHostPluginVersions_LockBranches)448+TEST_F(PackageProcessConfigTest, RefreshHostPluginVersions_MissingCompatIni_StoresEmptyFallbackVersions)
412{449{
413 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();450 PackageProcessConfig* pkgcfg = PackageProcessConfig::GetInstance();
414 pkgcfg->configMap_.clear();451 pkgcfg->configMap_.clear();
@@ -436,4 +473,37 @@ TEST_F(PackageProcessConfigTest, RefreshHostPluginVersions_LockBranches)
436 473 
437 pkgcfg->configMap_.clear();474 pkgcfg->configMap_.clear();
438 pkgcfg->hostPluginVersions_.clear();475 pkgcfg->hostPluginVersions_.clear();
439-}476+}
477+ 
478+TEST_F(PackageProcessConfigTest, ConstructPkgConfigMsg_NormalAndCompatEntries_SetsVersionsCountAndExactHash)
479+{
480+ {
481+ std::ofstream configFile(configFile_, std::ios::binary | std::ios::trunc);
482+ ASSERT_TRUE(configFile.is_open());
483+ configFile << "abc";
484+ }
485+ PackageProcessConfig* config = PackageProcessConfig::GetInstance();
486+ PackConfDetail normal{};
487+ normal.decDstDir = DeviceInstallPath::RUNTIME_PATH;
488+ PackConfDetail compat{};
489+ compat.decDstDir = DeviceInstallPath::COMPAT_PLUGIN_PATH;
490+ config->configMap_["normal.tar.gz"] = normal;
491+ config->configMap_["compat.tar.gz"] = compat;
492+ config->hostPluginVersions_["compat.tar.gz"] = {"8.5.0", "20260806_120000000"};
493+ MOCKER_CPP(&PackageProcessConfig::GetHostFilePath).expects(once()).will(returnValue(configFile_));
494+ HDCMessage msg;
495+ 
496+ config->ConstructPkgConfigMsg(msg);
497+ 
498+ ASSERT_EQ(msg.sink_pkg_con_list_size(), 2);
499+ EXPECT_EQ(msg.sink_pkg_con_list(0).package_name(), "compat.tar.gz");
500+ EXPECT_EQ(
501+ msg.sink_pkg_con_list(0).file_dec_dst_dir(), static_cast<uint32_t>(DeviceInstallPath::COMPAT_PLUGIN_PATH));
502+ EXPECT_EQ(msg.sink_pkg_con_list(1).package_name(), "normal.tar.gz");
503+ EXPECT_EQ(msg.sink_pkg_con_list(1).file_dec_dst_dir(), static_cast<uint32_t>(DeviceInstallPath::RUNTIME_PATH));
504+ ASSERT_EQ(msg.host_plugin_versions_size(), 1);
505+ EXPECT_EQ(msg.host_plugin_versions(0).package_name(), "compat.tar.gz");
506+ EXPECT_EQ(msg.host_plugin_versions(0).version(), "8.5.0");
507+ EXPECT_EQ(msg.host_plugin_versions(0).timestamp(), "20260806_120000000");
508+ EXPECT_EQ(msg.package_config_hash_code(), "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
509+}
Rtests/ut/tsd/tsdclient/test/package_worker_factory_utest.cpp→tests/ut/tsd/basic_component/package_manager/package_worker_factory_utest.cpp+1-2
Rtests/ut/tsd/tsdclient/test/package_worker_utest.cpp→tests/ut/tsd/basic_component/package_manager/package_worker_utest.cpp+59-64
Rtests/ut/tsd/tsdclient/test/package_worker_utils_utest.cpp→tests/ut/tsd/basic_component/package_manager/package_worker_utils_utest.cpp+14-40
Rtests/ut/tsd/tsdclient/test/path_mgr_utest.cpp→tests/ut/tsd/basic_component/package_manager/tsd_path_mgr_utest.cpp+5-22
Rtests/ut/tsd/tsdclient/test/common_util_func.h→tests/ut/tsd/common/common_util_func.h+60-3
Rtests/ut/tsd/tsdclient/test/main.cpp→tests/ut/tsd/common/main.cpp+0-2
Rtests/ut/tsd/tsdclient/test/tsdclient_utest.cpp→tests/ut/tsd/interface/tsd_client_utest.cpp+202-252
Rtests/ut/tsd/tsdclient/test/env_internal_api_utest.cpp→tests/ut/tsd/pub_facility/env_manager/env_internal_api_utest.cpp+22-16
Rtests/ut/tsd/tsdclient/test/tsd_sha256_utest.cpp→tests/ut/tsd/pub_facility/util_func/tsd_sha256_utest.cpp+0-0
Rtests/ut/tsd/tsdclient/test/tsd_util_func_utest.cpp→tests/ut/tsd/pub_facility/util_func/tsd_util_func_utest.cpp+120-86
Rtests/ut/tsd/tsdclient/test/client_manager_utest.cpp→tests/ut/tsd/tsdclient/client_manager_utest.cpp+178-271
Rtests/ut/tsd/tsdclient/test/thread_manager_utest.cpp→tests/ut/tsd/tsdclient/thread_mode_manager_utest.cpp+305-127