From 711584f93d133586253eee2a5420b6fd517d1d89 Mon Sep 17 00:00:00 2001 From: pwx1285814 Date: Tue, 29 Jul 2025 10:11:02 +0800 Subject: [PATCH] =?UTF-8?q?=E8=A1=A5=E5=85=85UT=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: pwx1285814 Change-Id: I20ccc0a5d959117ce9d72816ac68731a79d61c92 Signed-off-by: pwx1285814 --- .../UTTest_discovery_manager.cpp | 34 ++- .../UTTest_dm_distributed_hardware_load.cpp | 144 ++++++++++-- test/unittest/UTTest_auth_manager.cpp | 160 +++++++++++++ test/unittest/UTTest_freeze_process.cpp | 30 +++ test/unittest/UTTest_json_str_handle.cpp | 217 ++++++++++++++++-- 5 files changed, 544 insertions(+), 41 deletions(-) diff --git a/test/commonunittest/UTTest_discovery_manager.cpp b/test/commonunittest/UTTest_discovery_manager.cpp index 1de0b1d66..64fd6de72 100644 --- a/test/commonunittest/UTTest_discovery_manager.cpp +++ b/test/commonunittest/UTTest_discovery_manager.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -370,6 +370,38 @@ HWTEST_F(DiscoveryManagerTest, CloseCommonDependencyObj_002, testing::ext::TestS bool ret = manager->CloseCommonDependencyObj(); EXPECT_EQ(ret, true); } + +/* * + * @tc.name: StopDiscoveringByInnerSubId_001 + * @tc.desc: Test StopDiscoveringByInnerSubId + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DiscoveryManagerTest, StopDiscoveringByInnerSubId_001, testing::ext::TestSize.Level0) +{ + std::string pkgName; + uint16_t subscribeId = 0; + int32_t ret = manager->StopDiscoveringByInnerSubId(pkgName, subscribeId); + EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +/* * + * @tc.name: StopDiscoveringByInnerSubId_002 + * @tc.desc: Test StopDiscoveringByInnerSubId + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DiscoveryManagerTest, StopDiscoveringByInnerSubId_002, testing::ext::TestSize.Level0) +{ + std::string pkgName = "pkgName"; + uint16_t subscribeId = 0; + manager->pkgNameSet_.insert(pkgName); + DiscoveryContext context; + manager->discoveryContextMap_.emplace(pkgName, context); + int32_t ret = manager->StopDiscoveringByInnerSubId(pkgName, subscribeId); + + EXPECT_EQ(checkSoftbusRes(ret), false); +} } // namespace } // namespace DistributedHardware } // namespace OHOS diff --git a/test/commonunittest/UTTest_dm_distributed_hardware_load.cpp b/test/commonunittest/UTTest_dm_distributed_hardware_load.cpp index 74d236d79..4b468c183 100644 --- a/test/commonunittest/UTTest_dm_distributed_hardware_load.cpp +++ b/test/commonunittest/UTTest_dm_distributed_hardware_load.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -22,21 +22,13 @@ namespace OHOS { namespace DistributedHardware { -void DmDistributedHardwareLoadTest::SetUp() -{ -} +void DmDistributedHardwareLoadTest::SetUp() {} -void DmDistributedHardwareLoadTest::TearDown() -{ -} +void DmDistributedHardwareLoadTest::TearDown() {} -void DmDistributedHardwareLoadTest::SetUpTestCase() -{ -} +void DmDistributedHardwareLoadTest::SetUpTestCase() {} -void DmDistributedHardwareLoadTest::TearDownTestCase() -{ -} +void DmDistributedHardwareLoadTest::TearDownTestCase() {} HWTEST_F(DmDistributedHardwareLoadTest, LoadDistributedHardwareFwk_001, testing::ext::TestSize.Level0) { @@ -109,12 +101,132 @@ HWTEST_F(DmDistributedHardwareLoadTest, GetGroupIdHash_001, testing::ext::TestSi EXPECT_EQ(str.empty(), false); } +/** + * @tc.name: ConvertHexStringToBytes_001 + * @tc.desc: Test ConvertHexStringToBytes + * @tc.type: FUNC + * @tc.require: + */ HWTEST_F(DmDistributedHardwareLoadTest, ConvertHexStringToBytes_001, testing::ext::TestSize.Level0) { + uint32_t inLen = 2; + uint32_t outBufLen = 0; + const char *inBuf = "12"; unsigned char *outBuf = nullptr; + auto ret = Crypto::ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +/** + * @tc.name: ConvertHexStringToBytes_002 + * @tc.desc: Test ConvertHexStringToBytes + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DmDistributedHardwareLoadTest, ConvertHexStringToBytes_002, testing::ext::TestSize.Level0) +{ + uint32_t inLen = 0; + uint32_t outBufLen = 1; const char *inBuf = nullptr; - auto ret = Crypto::ConvertHexStringToBytes(outBuf, 0, inBuf, 0); + unsigned char outBuf[1] = {0}; + auto ret = Crypto::ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +/** + * @tc.name: ConvertHexStringToBytes_003 + * @tc.desc: Test ConvertHexStringToBytes + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DmDistributedHardwareLoadTest, ConvertHexStringToBytes_003, testing::ext::TestSize.Level0) +{ + uint32_t inLen = 1; + uint32_t outBufLen = 1; + const char *inBuf = "1"; + unsigned char outBuf[1] = {0}; + auto ret = Crypto::ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +/** + * @tc.name: ConvertHexStringToBytes_004 + * @tc.desc: Test ConvertHexStringToBytes + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DmDistributedHardwareLoadTest, ConvertHexStringToBytes_004, testing::ext::TestSize.Level0) +{ + uint32_t inLen = 2; + uint32_t outBufLen = 2; + const char *inBuf = "1G"; + unsigned char outBuf[2] = {0}; + auto ret = Crypto::ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen); EXPECT_EQ(ret, ERR_DM_FAILED); } -} // namespace DistributedHardware -} // namespace OHOS + +/** + * @tc.name: ConvertHexStringToBytes_005 + * @tc.desc: Test ConvertHexStringToBytes + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DmDistributedHardwareLoadTest, ConvertHexStringToBytes_005, testing::ext::TestSize.Level0) +{ + uint32_t inLen = 2; + uint32_t outBufLen = 2; + const char *inBuf = "G1"; + unsigned char outBuf[2] = {0}; + auto ret = Crypto::ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +/** + * @tc.name: ConvertHexStringToBytes_006 + * @tc.desc: Test ConvertHexStringToBytes + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DmDistributedHardwareLoadTest, ConvertHexStringToBytes_006, testing::ext::TestSize.Level0) +{ + uint32_t inLen = 2; + uint32_t outBufLen = 2; + const char *inBuf = "a1"; + unsigned char outBuf[2] = {0}; + auto ret = Crypto::ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: ConvertHexStringToBytes_007 + * @tc.desc: Test ConvertHexStringToBytes + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DmDistributedHardwareLoadTest, ConvertHexStringToBytes_007, testing::ext::TestSize.Level0) +{ + uint32_t inLen = 2; + uint32_t outBufLen = 2; + const char *inBuf = "Aa"; + unsigned char outBuf[2] = {0}; + auto ret = Crypto::ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: ConvertHexStringToBytes_008 + * @tc.desc: Test ConvertHexStringToBytes + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DmDistributedHardwareLoadTest, ConvertHexStringToBytes_008, testing::ext::TestSize.Level0) +{ + uint32_t inLen = 2; + uint32_t outBufLen = 2; + const char *inBuf = "AA"; + unsigned char outBuf[2] = {0}; + auto ret = Crypto::ConvertHexStringToBytes(outBuf, outBufLen, inBuf, inLen); + EXPECT_EQ(ret, DM_OK); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/test/unittest/UTTest_auth_manager.cpp b/test/unittest/UTTest_auth_manager.cpp index 882891ed0..e6f477205 100644 --- a/test/unittest/UTTest_auth_manager.cpp +++ b/test/unittest/UTTest_auth_manager.cpp @@ -196,5 +196,165 @@ HWTEST_F(AuthManagerTest, OnUserOperation_007, testing::ext::TestSize.Level1) EXPECT_EQ(ret, DM_OK); } + +/* * + * @tc.name: RegisterUiStateCallback_001 + * @tc.desc: Test RegisterUiStateCallback + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AuthManagerTest, RegisterUiStateCallback_001, testing::ext::TestSize.Level1) +{ + std::string pkgName = "ohos_test"; + authManager->context_->authUiStateMgr = nullptr; + int32_t ret = authManager->RegisterUiStateCallback(pkgName); + ASSERT_EQ(ret, ERR_DM_FAILED); +} + +/* * + * @tc.name: RegisterUiStateCallback_002 + * @tc.desc: Test RegisterUiStateCallback + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AuthManagerTest, RegisterUiStateCallback_002, testing::ext::TestSize.Level1) +{ + std::string pkgName = "ohos_test"; + std::shared_ptr listener = std::make_shared(); + authManager->context_->authUiStateMgr = std::make_shared(listener); + int32_t ret = authManager->RegisterUiStateCallback(pkgName); + ASSERT_EQ(ret, DM_OK); +} + +/* * + * @tc.name: UnRegisterUiStateCallback_001 + * @tc.desc: Test UnRegisterUiStateCallback + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AuthManagerTest, UnRegisterUiStateCallback_001, testing::ext::TestSize.Level1) +{ + std::string pkgName = "ohos_test"; + authManager->context_->authUiStateMgr = nullptr; + int32_t ret = authManager->UnRegisterUiStateCallback(pkgName); + ASSERT_EQ(ret, ERR_DM_FAILED); +} + +/* * + * @tc.name: UnRegisterUiStateCallback_002 + * @tc.desc: Test UnRegisterUiStateCallback + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AuthManagerTest, UnRegisterUiStateCallback_002, testing::ext::TestSize.Level1) +{ + std::string pkgName = "ohos_test"; + std::shared_ptr listener = std::make_shared(); + authManager->context_->authUiStateMgr = std::make_shared(listener); + int32_t ret = authManager->UnRegisterUiStateCallback(pkgName); + ASSERT_EQ(ret, DM_OK); +} + +/* * + * @tc.name: ImportAuthCode_001 + * @tc.desc: Test ImportAuthCode + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AuthManagerTest, ImportAuthCode_001, testing::ext::TestSize.Level1) +{ + std::string authCode = ""; + std::string pkgName = "pkgName"; + int32_t ret = authManager->ImportAuthCode(authCode, pkgName); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +/* * + * @tc.name: ImportAuthCode_002 + * @tc.desc: Test ImportAuthCode + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AuthManagerTest, ImportAuthCode_002, testing::ext::TestSize.Level1) +{ + std::string authCode = "123456"; + std::string pkgName = ""; + int32_t ret = authManager->ImportAuthCode(authCode, pkgName); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +/* * + * @tc.name: ImportAuthCode_003 + * @tc.desc: Test ImportAuthCode + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AuthManagerTest, ImportAuthCode_003, testing::ext::TestSize.Level1) +{ + std::string authCode = "123456"; + std::string pkgName = "pkgName"; + int32_t ret = authManager->ImportAuthCode(authCode, pkgName); + ASSERT_EQ(ret, DM_OK); +} + +/* * + * @tc.name: IsAuthCodeReady_001 + * @tc.desc: Test IsAuthCodeReady + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AuthManagerTest, IsAuthCodeReady_001, testing::ext::TestSize.Level1) +{ + std::string pkgName; + authManager->context_->importAuthCode = ""; + authManager->context_->importPkgName = "importPkgName"; + bool ret = authManager->IsAuthCodeReady(pkgName); + ASSERT_EQ(ret, false); +} + +/* * + * @tc.name: IsAuthCodeReady_002 + * @tc.desc: Test IsAuthCodeReady + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AuthManagerTest, IsAuthCodeReady_002, testing::ext::TestSize.Level1) +{ + std::string pkgName; + authManager->context_->importAuthCode = "importAuthCode"; + authManager->context_->importPkgName = ""; + bool ret = authManager->IsAuthCodeReady(pkgName); + ASSERT_EQ(ret, false); +} + +/* * + * @tc.name: IsAuthCodeReady_003 + * @tc.desc: Test IsAuthCodeReady + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AuthManagerTest, IsAuthCodeReady_003, testing::ext::TestSize.Level1) +{ + std::string pkgName = "pkgName"; + authManager->context_->importAuthCode = "importAuthCode"; + authManager->context_->importPkgName = "importPkgName"; + bool ret = authManager->IsAuthCodeReady(pkgName); + ASSERT_EQ(ret, false); +} + +/* * + * @tc.name: IsAuthCodeReady_004 + * @tc.desc: Test IsAuthCodeReady + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AuthManagerTest, IsAuthCodeReady_004, testing::ext::TestSize.Level1) +{ + std::string pkgName = "ohos_test"; + authManager->context_->importAuthCode = "importAuthCode"; + authManager->context_->importPkgName = "ohos_test"; + bool ret = authManager->IsAuthCodeReady(pkgName); + ASSERT_EQ(ret, true); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/UTTest_freeze_process.cpp b/test/unittest/UTTest_freeze_process.cpp index 22de14052..93a55a5a2 100644 --- a/test/unittest/UTTest_freeze_process.cpp +++ b/test/unittest/UTTest_freeze_process.cpp @@ -160,5 +160,35 @@ HWTEST_F(FreezeProcessTest, ConvertJsonToDeviceFreezeState_WhenAllExist, testing EXPECT_EQ(freezeStateObj.startFreezeTimeStamp, 1234567890); EXPECT_EQ(freezeStateObj.stopFreezeTimeStamp, 9876543210); } + +/* * + * @tc.name: CleanBindFailedEvents_001 + * @tc.desc: Test CleanBindFailedEvents + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(FreezeProcessTest, CleanBindFailedEvents_001, testing::ext::TestSize.Level0) +{ + int64_t reservedDataTimeStamp = 12; + FreezeProcess freezeProcess; + int32_t result = freezeProcess.CleanBindFailedEvents(reservedDataTimeStamp); + + EXPECT_EQ(result, DM_OK); +} + +/* * + * @tc.name: CleanFreezeState_001 + * @tc.desc: Test CleanFreezeState + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(FreezeProcessTest, CleanFreezeState_001, testing::ext::TestSize.Level0) +{ + int64_t reservedDataTimeStamp = 12; + FreezeProcess freezeProcess; + int32_t result = freezeProcess.CleanFreezeState(reservedDataTimeStamp); + + EXPECT_EQ(result, DM_OK); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/UTTest_json_str_handle.cpp b/test/unittest/UTTest_json_str_handle.cpp index 7bc13c2cb..6819007b7 100644 --- a/test/unittest/UTTest_json_str_handle.cpp +++ b/test/unittest/UTTest_json_str_handle.cpp @@ -21,23 +21,21 @@ namespace OHOS { namespace DistributedHardware { -void JsonStrHandleTest::SetUp() -{ -} -void JsonStrHandleTest::TearDown() -{ -} +namespace { +const std::string TAG_PEER_BUNDLE_NAME = "peerBundleName"; +const std::string TAG_PEER_TOKENID = "peerTokenId"; +const std::string TAG_PROXY = "proxy"; +} // namespace -void JsonStrHandleTest::SetUpTestCase() -{ -} +void JsonStrHandleTest::SetUp() {} -void JsonStrHandleTest::TearDownTestCase() -{ -} +void JsonStrHandleTest::TearDown() {} + +void JsonStrHandleTest::SetUpTestCase() {} + +void JsonStrHandleTest::TearDownTestCase() {} -namespace { /** * @tc.name: GetPeerAppInfoParseExtra_001 * @tc.desc: GetPeerAppInfoParseExtra @@ -56,24 +54,195 @@ HWTEST_F(JsonStrHandleTest, GetPeerAppInfoParseExtra_001, testing::ext::TestSize peerBundleName = "peerBundleName"; JsonStrHandle::GetInstance().GetPeerAppInfoParseExtra(extra, peerTokenId, peerBundleName); std::string extraInfo = "extraInfo"; - std::vector tokenIdVec = - JsonStrHandle::GetInstance().GetProxyTokenIdByExtra(extraInfo); + std::vector tokenIdVec = JsonStrHandle::GetInstance().GetProxyTokenIdByExtra(extraInfo); EXPECT_EQ(tokenIdVec.empty(), true); } +/** + * @tc.name: GetPeerAppInfoParseExtra_002 + * @tc.desc: Test GetPeerAppInfoParseExtra + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(JsonStrHandleTest, GetPeerAppInfoParseExtra_002, testing::ext::TestSize.Level1) +{ + std::string extra = "{\"" + TAG_PEER_TOKENID + "\": 12345}"; + uint64_t peerTokenId = 0; + std::string peerBundleName = ""; + std::shared_ptr handle = std::make_shared(); + handle->GetPeerAppInfoParseExtra(extra, peerTokenId, peerBundleName); + EXPECT_EQ(peerBundleName, ""); +} + +/** + * @tc.name: GetPeerAppInfoParseExtra_003 + * @tc.desc: Test GetPeerAppInfoParseExtra + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(JsonStrHandleTest, GetPeerAppInfoParseExtra_003, testing::ext::TestSize.Level1) +{ + std::string extra = "{\"" + TAG_PEER_BUNDLE_NAME + "\": \"testBundle\"}"; + uint64_t peerTokenId = 0; + std::string peerBundleName = ""; + std::shared_ptr handle = std::make_shared(); + handle->GetPeerAppInfoParseExtra(extra, peerTokenId, peerBundleName); + EXPECT_EQ(peerTokenId, 0); +} + +/** + * @tc.name: GetPeerAppInfoParseExtra_004 + * @tc.desc: Test GetPeerAppInfoParseExtra + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(JsonStrHandleTest, GetPeerAppInfoParseExtra_004, testing::ext::TestSize.Level1) +{ + std::string extra = "{\"" + TAG_PEER_BUNDLE_NAME + "\": 123, \"" + TAG_PEER_TOKENID + "\": 456}"; + uint64_t peerTokenId = 0; + std::string peerBundleName = ""; + std::shared_ptr handle = std::make_shared(); + handle->GetPeerAppInfoParseExtra(extra, peerTokenId, peerBundleName); + EXPECT_EQ(peerBundleName, ""); +} + +/** + * @tc.name: GetPeerAppInfoParseExtra_005 + * @tc.desc: Test GetPeerAppInfoParseExtra + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(JsonStrHandleTest, GetPeerAppInfoParseExtra_005, testing::ext::TestSize.Level1) +{ + std::string extra = "{\"" + TAG_PEER_BUNDLE_NAME + "\": \"testBundle\", \"" + TAG_PEER_TOKENID + "\": \"123\"}"; + uint64_t peerTokenId = 0; + std::string peerBundleName = ""; + std::shared_ptr handle = std::make_shared(); + handle->GetPeerAppInfoParseExtra(extra, peerTokenId, peerBundleName); + EXPECT_EQ(peerTokenId, 0); +} + +/** + * @tc.name: GetPeerAppInfoParseExtra_006 + * @tc.desc: Test GetPeerAppInfoParseExtra + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(JsonStrHandleTest, GetPeerAppInfoParseExtra_006, testing::ext::TestSize.Level1) +{ + std::string extra = "{\"" + TAG_PEER_BUNDLE_NAME + "\": \"testBundle\", \"" + TAG_PEER_TOKENID + "\": 12345}"; + uint64_t peerTokenId = 0; + std::string peerBundleName = ""; + std::shared_ptr handle = std::make_shared(); + handle->GetPeerAppInfoParseExtra(extra, peerTokenId, peerBundleName); + EXPECT_EQ(peerTokenId, 12345); + EXPECT_EQ(peerBundleName, "testBundle"); +} + /** * @tc.name: GetProxyTokenIdByExtra_001 - * @tc.desc: GetProxyTokenIdByExtra + * @tc.desc: Test GetProxyTokenIdByExtra with empty extraInfo * @tc.type: FUNC - * @tc.require: AR000GHSJK + * @tc.require: AR00000000 */ HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_001, testing::ext::TestSize.Level1) { - std::string extraInfo = ""; - std::vector tokenIdVec = - JsonStrHandle::GetInstance().GetProxyTokenIdByExtra(extraInfo); - EXPECT_EQ(tokenIdVec.empty(), true); + std::shared_ptr handle = std::make_shared(); + std::string emptyExtra; + std::vector result = handle->GetProxyTokenIdByExtra(emptyExtra); + EXPECT_TRUE(result.empty()); +} + +/** + * @tc.name: GetProxyTokenIdByExtra_002 + * @tc.desc: Test GetProxyTokenIdByExtra with invalid JSON string + * @tc.type: FUNC + * @tc.require: AR00000000 + */ +HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_002, testing::ext::TestSize.Level1) +{ + std::shared_ptr handle = std::make_shared(); + std::string invalidJson = "{invalid}"; + std::vector result = handle->GetProxyTokenIdByExtra(invalidJson); + EXPECT_TRUE(result.empty()); +} + +/** + * @tc.name: GetProxyTokenIdByExtra_003 + * @tc.desc: Test GetProxyTokenIdByExtra with JSON missing proxy tag + * @tc.type: FUNC + * @tc.require: AR00000000 + */ +HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_003, testing::ext::TestSize.Level1) +{ + std::shared_ptr handle = std::make_shared(); + std::string noProxyTag = "{\"other\": \"value\"}"; + std::vector result = handle->GetProxyTokenIdByExtra(noProxyTag); + EXPECT_TRUE(result.empty()); +} + +/** + * @tc.name: GetProxyTokenIdByExtra_004 + * @tc.desc: Test GetProxyTokenIdByExtra with invalid proxy list string + * @tc.type: FUNC + * @tc.require: AR00000000 + */ +HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_004, testing::ext::TestSize.Level1) +{ + std::shared_ptr handle = std::make_shared(); + std::string invalidProxyList = "{\"" + TAG_PROXY + "\": \"not_a_valid_json_array\"}"; + std::vector result = handle->GetProxyTokenIdByExtra(invalidProxyList); + EXPECT_TRUE(result.empty()); +} + +/** + * @tc.name: GetProxyTokenIdByExtra_005 + * @tc.desc: Test GetProxyTokenIdByExtra with empty proxy list + * @tc.type: FUNC + * @tc.require: AR00000000 + */ +HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_005, testing::ext::TestSize.Level1) +{ + std::shared_ptr handle = std::make_shared(); + std::string emptyProxyList = "{\"" + TAG_PROXY + "\": \"[]\"}"; + std::vector result = handle->GetProxyTokenIdByExtra(emptyProxyList); + EXPECT_TRUE(result.empty()); +} + +/** + * @tc.name: GetProxyTokenIdByExtra_006 + * @tc.desc: Test GetProxyTokenIdByExtra with valid number list + * @tc.type: FUNC + * @tc.require: AR00000000 + */ +HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_006, testing::ext::TestSize.Level1) +{ + std::shared_ptr handle = std::make_shared(); + std::string validProxyList = "{\"" + TAG_PROXY + "\": \"[123, 456, 789]\"}"; + std::vector result = handle->GetProxyTokenIdByExtra(validProxyList); + + ASSERT_EQ(result.size(), 3); + EXPECT_EQ(result[0], 123); + EXPECT_EQ(result[1], 456); + EXPECT_EQ(result[2], 789); +} + +/** + * @tc.name: GetProxyTokenIdByExtra_007 + * @tc.desc: Test GetProxyTokenIdByExtra with mixed type list + * @tc.type: FUNC + * @tc.require: AR00000000 + */ +HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_007, testing::ext::TestSize.Level1) +{ + std::shared_ptr handle = std::make_shared(); + std::string mixedProxyList = "{\"" + TAG_PROXY + "\": \"[123, 456, null, 789]\"}"; + std::vector result = handle->GetProxyTokenIdByExtra(mixedProxyList); + + ASSERT_EQ(result.size(), 3); + EXPECT_EQ(result[0], 123); + EXPECT_EQ(result[1], 456); + EXPECT_EQ(result[2], 789); } -} // namespace -} // namespace DistributedHardware -} // namespace OHOS \ No newline at end of file +} // namespace DistributedHardware +} // namespace OHOS -- Gitee