1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <functional> 17 #include <gtest/gtest.h> 18 #include <string> 19 20 #include "dummy_negotiate_channel.h" 21 #include "net_conn_client.h" 22 #include "softbus_conn_interface.h" 23 #include "softbus_error_code.h" 24 #include "wifi_direct_manager.cpp" 25 #include "wifi_direct_manager.h" 26 #include "wifi_direct_mock.h" 27 28 using namespace testing::ext; 29 using testing::_; 30 using ::testing::Return; 31 32 namespace OHOS::SoftBus { 33 class WifiDirectManagerCppTest : public testing::Test { 34 public: SetUpTestCase()35 static void SetUpTestCase() { } TearDownTestCase()36 static void TearDownTestCase() { } SetUp()37 void SetUp() override { } TearDown()38 void TearDown() override { } 39 }; 40 41 /* 42 * @tc.name: AllocateListenerModuleIdTest 43 * @tc.desc: check AllocateListenerModuleId method 44 * @tc.type: FUNC 45 * @tc.require: 46 */ 47 HWTEST_F(WifiDirectManagerCppTest, AllocateListenerModuleIdTest, TestSize.Level1) 48 { 49 auto moduleId1 = GetWifiDirectManager()->allocateListenerModuleId(); 50 EXPECT_EQ(moduleId1, AUTH_ENHANCED_P2P_START); 51 52 auto moduleId2 = GetWifiDirectManager()->allocateListenerModuleId(); 53 EXPECT_EQ(moduleId2, AUTH_ENHANCED_P2P_START + 1); 54 GetWifiDirectManager()->freeListenerModuleId(moduleId1); 55 GetWifiDirectManager()->freeListenerModuleId(moduleId2); 56 } 57 58 /* 59 * @tc.name: SetElementTypeTest 60 * @tc.desc: check SetElementType method 61 * @tc.type: FUNC 62 * @tc.require: 63 */ 64 HWTEST_F(WifiDirectManagerCppTest, SetElementTypeTest, TestSize.Level1) 65 { 66 struct WifiDirectConnectInfo info = { 0 }; 67 ConnEventExtra extra = { 0 }; 68 info.connectType = WIFI_DIRECT_CONNECT_TYPE_AUTH_NEGO_P2P; 69 info.negoChannel.type = NEGO_CHANNEL_AUTH; 70 SetElementTypeExtra(&info, &extra); 71 EXPECT_EQ(info.dfxInfo.linkType, STATISTIC_P2P); 72 EXPECT_EQ(info.dfxInfo.bootLinkType, STATISTIC_NONE); 73 74 info.connectType = WIFI_DIRECT_CONNECT_TYPE_AUTH_NEGO_HML; 75 info.negoChannel.type = NEGO_CHANNEL_COC; 76 SetElementTypeExtra(&info, &extra); 77 EXPECT_EQ(info.dfxInfo.linkType, STATISTIC_HML); 78 EXPECT_EQ(info.dfxInfo.bootLinkType, STATISTIC_COC); 79 80 info.connectType = WIFI_DIRECT_CONNECT_TYPE_BLE_TRIGGER_HML; 81 info.negoChannel.type = NEGO_CHANNEL_NULL; 82 SetElementTypeExtra(&info, &extra); 83 EXPECT_EQ(info.dfxInfo.linkType, STATISTIC_TRIGGER_HML); 84 EXPECT_EQ(info.dfxInfo.bootLinkType, STATISTIC_NONE); 85 86 info.connectType = WIFI_DIRECT_CONNECT_TYPE_AUTH_TRIGGER_HML; 87 info.dfxInfo.linkType = STATISTIC_P2P; 88 SetElementTypeExtra(&info, &extra); 89 EXPECT_EQ(info.dfxInfo.linkType, STATISTIC_TRIGGER_HML); 90 } 91 92 /* 93 * @tc.name: SavePtkTest 94 * @tc.desc: check SavePtk method 95 * @tc.type: FUNC 96 * @tc.require: 97 */ 98 HWTEST_F(WifiDirectManagerCppTest, SavePtkTest, TestSize.Level1) 99 { 100 std::string remoteDeviceId("123"); 101 std::string ptk("ptk"); 102 auto ret = SavePtk(remoteDeviceId.c_str(), ptk.c_str()); 103 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT); 104 __anon90c335f50102(const char *remoteDeviceId, const char *ptk) 105 g_enhanceManager.savePTK = [](const char *remoteDeviceId, const char *ptk) -> int32_t { 106 return SOFTBUS_OK; 107 }; 108 ret = SavePtk(remoteDeviceId.c_str(), ptk.c_str()); 109 EXPECT_EQ(ret, SOFTBUS_OK); 110 } 111 112 /* 113 * @tc.name: SyncPtkTest 114 * @tc.desc: check SyncPtk method 115 * @tc.type: FUNC 116 * @tc.require: 117 */ 118 HWTEST_F(WifiDirectManagerCppTest, SyncPtkTest, TestSize.Level1) 119 { 120 std::string remoteDeviceId("123"); 121 auto ret = SyncPtk(remoteDeviceId.c_str()); 122 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT); 123 __anon90c335f50202(const char *remoteDeviceId) 124 g_enhanceManager.syncPTK = [](const char *remoteDeviceId) -> int32_t { 125 return SOFTBUS_OK; 126 }; 127 ret = SyncPtk(remoteDeviceId.c_str()); 128 EXPECT_EQ(ret, SOFTBUS_OK); 129 } 130 131 /* 132 * @tc.name: IsDeviceOnlineTest 133 * @tc.desc: check IsDeviceOnline method 134 * @tc.type: FUNC 135 * @tc.require: 136 */ 137 HWTEST_F(WifiDirectManagerCppTest, IsDeviceOnlineTest, TestSize.Level1) 138 { 139 std::string remoteMac("28:11:05:5e:ee:d3"); 140 auto ret = IsDeviceOnline(remoteMac.c_str()); 141 EXPECT_EQ(ret, false); 142 __anon90c335f50302(InnerLink &link) 143 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, "0123456789ABCDEF", [](InnerLink &link) { 144 link.SetRemoteBaseMac("28:11:05:5e:ee:d3"); 145 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 146 }); 147 ret = IsDeviceOnline(remoteMac.c_str()); 148 EXPECT_EQ(ret, true); 149 LinkManager::GetInstance().RemoveLink(remoteMac); 150 } 151 152 /* 153 * @tc.name: GetLocalIpByUuidTest 154 * @tc.desc: check GetLocalIpByUuid method 155 * @tc.type: FUNC 156 * @tc.require: 157 */ 158 HWTEST_F(WifiDirectManagerCppTest, GetLocalIpByUuidTest, TestSize.Level1) 159 { 160 std::string uuid("0123456789ABCDE9"); 161 std::string uuid2("11111111111"); 162 char myIp[IP_LEN] = { 0 }; 163 auto ret = GetLocalIpByUuid(uuid.c_str(), myIp, sizeof(myIp)); 164 EXPECT_EQ(ret, SOFTBUS_CONN_NOT_FOUND_FAILED); 165 __anon90c335f50402(InnerLink &link) 166 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, uuid, [](InnerLink &link) { 167 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 168 link.SetLocalIpv4("192.168.1.100"); 169 }); 170 __anon90c335f50502(InnerLink &link) 171 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, uuid2, [](InnerLink &link) { 172 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 173 link.SetLocalIpv4("192.168.1.100"); 174 }); 175 176 ret = GetLocalIpByUuid(uuid.c_str(), myIp, sizeof(myIp)); 177 EXPECT_EQ(ret, SOFTBUS_OK); 178 LinkManager::GetInstance().RemoveLinks(InnerLink::LinkType::HML); 179 } 180 181 /* 182 * @tc.name: GetLocalIpByRemoteIpOnceTest 183 * @tc.desc: check GetLocalIpByRemoteIpOnce method 184 * @tc.type: FUNC 185 * @tc.require: 186 */ 187 HWTEST_F(WifiDirectManagerCppTest, GetLocalIpByRemoteIpOnceTest, TestSize.Level1) 188 { 189 std::string uuid("0123456789ABCDE9"); 190 std::string uuid2("0123456789ABCDE8"); 191 std::string uuid3("0123456789ABCDE7"); 192 std::string remoteIp("172.30.1.2"); 193 std::string remoteIpv6("fe80::a446:b4ff:fec1:7323"); 194 char localIp[IP_LEN] = { 0 }; 195 auto ret = GetLocalIpByRemoteIpOnce(remoteIp.c_str(), localIp, sizeof(localIp)); 196 EXPECT_EQ(ret, SOFTBUS_CONN_NOT_FOUND_FAILED); 197 __anon90c335f50602(InnerLink &link) 198 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, uuid3, [](InnerLink &link) { 199 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 200 }); 201 ret = GetLocalIpByRemoteIpOnce(remoteIp.c_str(), localIp, sizeof(localIp)); 202 EXPECT_EQ(ret, SOFTBUS_CONN_NOT_FOUND_FAILED); 203 __anon90c335f50702(InnerLink &link) 204 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, uuid, [&remoteIp](InnerLink &link) { 205 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 206 link.SetLocalIpv4("170.30.1.1"); 207 link.SetRemoteIpv4(remoteIp); 208 }); 209 ret = GetLocalIpByRemoteIpOnce(remoteIp.c_str(), localIp, sizeof(localIp)); 210 EXPECT_EQ(ret, SOFTBUS_OK); 211 __anon90c335f50802(InnerLink &link) 212 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, uuid2, [&remoteIpv6](InnerLink &link) { 213 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 214 link.SetLocalIpv6("fe80::200:22ff:fe6b:262d"); 215 link.SetRemoteIpv6(remoteIpv6); 216 }); 217 ret = GetLocalIpByRemoteIpOnce(remoteIpv6.c_str(), localIp, sizeof(localIp)); 218 EXPECT_EQ(ret, SOFTBUS_OK); 219 LinkManager::GetInstance().RemoveLinks(InnerLink::LinkType::HML); 220 } 221 222 /* 223 * @tc.name: GetLocalIpByRemoteIpTest 224 * @tc.desc: check GetLocalIpByRemoteIp method 225 * @tc.type: FUNC 226 * @tc.require: 227 */ 228 HWTEST_F(WifiDirectManagerCppTest, GetLocalIpByRemoteIpTest, TestSize.Level1) 229 { 230 std::string uuid("0123456789ABCDE9"); 231 std::string remoteIp("172.30.1.2"); 232 char localIp[IP_LEN] = { 0 }; 233 auto ret = GetLocalIpByRemoteIp(remoteIp.c_str(), localIp, sizeof(localIp)); 234 EXPECT_EQ(ret, SOFTBUS_CONN_GET_LOCAL_IP_BY_REMOTE_IP_FAILED); 235 __anon90c335f50902(InnerLink &link) 236 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, uuid, [&remoteIp](InnerLink &link) { 237 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 238 link.SetLocalIpv4("170.30.1.1"); 239 link.SetRemoteIpv4(remoteIp); 240 }); 241 ret = GetLocalIpByRemoteIp(remoteIp.c_str(), localIp, sizeof(localIp)); 242 LinkManager::GetInstance().RemoveLinks(InnerLink::LinkType::HML); 243 EXPECT_EQ(ret, SOFTBUS_OK); 244 } 245 246 /* 247 * @tc.name: GetRemoteUuidByIpTest 248 * @tc.desc: check GetRemoteUuidByIp method 249 * @tc.type: FUNC 250 * @tc.require: 251 */ 252 HWTEST_F(WifiDirectManagerCppTest, GetRemoteUuidByIpTest, TestSize.Level1) 253 { 254 std::string uuid("0123456789ABCDE9"); 255 std::string uuid2("0123456789ABCDE8"); 256 std::string remoteIp("172.30.1.2"); 257 char localIp[IP_LEN] = { 0 }; 258 __anon90c335f50a02(InnerLink &link) 259 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, uuid2, [](InnerLink &link) { 260 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 261 }); 262 263 auto ret = GetRemoteUuidByIp(remoteIp.c_str(), localIp, sizeof(localIp)); 264 EXPECT_EQ(ret, SOFTBUS_CONN_NOT_FOUND_FAILED); 265 __anon90c335f50b02(InnerLink &link) 266 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, uuid, [&remoteIp](InnerLink &link) { 267 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 268 link.SetLocalIpv4("170.30.1.1"); 269 link.SetRemoteIpv4(remoteIp); 270 }); 271 ret = GetRemoteUuidByIp(remoteIp.c_str(), localIp, sizeof(localIp)); 272 EXPECT_EQ(ret, SOFTBUS_OK); 273 LinkManager::GetInstance().RemoveLinks(InnerLink::LinkType::HML); 274 } 275 276 /* 277 * @tc.name: GetLocalAndRemoteMacByLocalIpTest 278 * @tc.desc: check GetLocalAndRemoteMacByLocalIp method 279 * @tc.type: FUNC 280 * @tc.require: 281 */ 282 HWTEST_F(WifiDirectManagerCppTest, GetLocalAndRemoteMacByLocalIpTest, TestSize.Level1) 283 { 284 std::string uuid("0123456789ABCDE9"); 285 std::string uuid2("0123456789ABCDE8"); 286 std::string localIp("172.30.1.2"); 287 int macLen = 18; 288 char localMac[macLen]; 289 char remoteMac[macLen]; 290 __anon90c335f50c02(InnerLink &link) 291 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, uuid, [](InnerLink &link) { 292 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 293 }); 294 295 auto ret = GetLocalAndRemoteMacByLocalIp(localIp.c_str(), localMac, macLen, remoteMac, macLen); 296 EXPECT_EQ(ret, SOFTBUS_CONN_NOT_FOUND_FAILED); 297 __anon90c335f50d02(InnerLink &link) 298 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, uuid2, [&localIp](InnerLink &link) { 299 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 300 link.SetLocalIpv4(localIp); 301 }); 302 ret = GetLocalAndRemoteMacByLocalIp(localIp.c_str(), localMac, macLen, remoteMac, macLen); 303 EXPECT_EQ(ret, SOFTBUS_OK); 304 LinkManager::GetInstance().RemoveLinks(InnerLink::LinkType::HML); 305 } 306 307 /* 308 * @tc.name: WifiDirectStatusListenerTest 309 * @tc.desc: check NotifyOnline,NotifyOffline,NotifyRoleChange,NotifyConnectedForSink, NotifyDisconnectedForSink, method 310 * @tc.type: FUNC 311 * @tc.require: 312 */ 313 HWTEST_F(WifiDirectManagerCppTest, WifiDirectStatusListenerTest, TestSize.Level1) 314 { 315 std::string remoteMac("10:dc:b6:90:84:82"); 316 std::string remoteIp("170.30.1.2"); 317 std::string remoteUuid("0123456789ABCDEF"); 318 bool isSource = true; 319 std::string localIp("170.30.1.1"); 320 struct WifiDirectSinkLink sinkLink { }; 321 struct WifiDirectStatusListener listener1 = { 0 }; 322 g_listeners.push_back(listener1); 323 EXPECT_NO_FATAL_FAILURE(NotifyOnline(remoteMac.c_str(), remoteIp.c_str(), remoteUuid.c_str(), isSource)); 324 325 EXPECT_NO_FATAL_FAILURE(NotifyOffline(remoteMac.c_str(), remoteIp.c_str(), remoteUuid.c_str(), localIp.c_str())); 326 327 EXPECT_NO_FATAL_FAILURE(NotifyRoleChange(WIFI_DIRECT_ROLE_GO, WIFI_DIRECT_ROLE_GC)); 328 329 EXPECT_NO_FATAL_FAILURE(NotifyConnectedForSink(&sinkLink)); 330 331 EXPECT_NO_FATAL_FAILURE(NotifyDisconnectedForSink(&sinkLink)); 332 333 struct WifiDirectStatusListener listener2 = { __anon90c335f50e02(const char *remoteMac, const char *remoteIp, const char *remoteUuid, bool isSource) 334 .onDeviceOnLine = [](const char *remoteMac, const char *remoteIp, const char *remoteUuid, bool isSource) {}, 335 .onDeviceOffLine = [](const char *remoteMac, const char *remoteIp, const char *remoteUuid, __anon90c335f50f02(const char *remoteMac, const char *remoteIp, const char *remoteUuid, const char *localIp) 336 const char *localIp) {}, __anon90c335f51002(enum WifiDirectRole oldRole, enum WifiDirectRole newRole) 337 .onLocalRoleChange = [](enum WifiDirectRole oldRole, enum WifiDirectRole newRole) {}, __anon90c335f51102(const struct WifiDirectSinkLink *link) 338 .onConnectedForSink = [](const struct WifiDirectSinkLink *link) {}, __anon90c335f51202(const struct WifiDirectSinkLink *link) 339 .onDisconnectedForSink = [](const struct WifiDirectSinkLink *link) {}, 340 }; 341 g_listeners.push_back(listener2); 342 EXPECT_NO_FATAL_FAILURE(NotifyOnline(remoteMac.c_str(), remoteIp.c_str(), remoteUuid.c_str(), isSource)); 343 344 EXPECT_NO_FATAL_FAILURE(NotifyOffline(remoteMac.c_str(), remoteIp.c_str(), remoteUuid.c_str(), localIp.c_str())); 345 346 EXPECT_NO_FATAL_FAILURE(NotifyRoleChange(WIFI_DIRECT_ROLE_GO, WIFI_DIRECT_ROLE_GC)); 347 348 EXPECT_NO_FATAL_FAILURE(NotifyConnectedForSink(&sinkLink)); 349 350 EXPECT_NO_FATAL_FAILURE(NotifyDisconnectedForSink(&sinkLink)); 351 } 352 353 /* 354 * @tc.name: IsNegotiateChannelNeededTest 355 * @tc.desc: check IsNegotiateChannelNeeded method 356 * @tc.type: FUNC 357 * @tc.require: 358 */ 359 HWTEST_F(WifiDirectManagerCppTest, IsNegotiateChannelNeededTest, TestSize.Level1) 360 { 361 std::string remoteNetworkId("1234567890"); 362 std::string remoteMac("10:dc:b6:90:84:82"); 363 char uuid[UUID_BUF_LEN] = "0123456789ABCDEF"; 364 WifiDirectInterfaceMock mock; 365 EXPECT_CALL(mock, LnnGetRemoteStrInfo(_, _, _, _)) __anon90c335f51302(const std::string &netWorkId, InfoKey key, char *info, uint32_t len) 366 .WillRepeatedly([&uuid](const std::string &netWorkId, InfoKey key, char *info, uint32_t len) { 367 if (strcpy_s(info, UUID_BUF_LEN, uuid) != EOK) { 368 return SOFTBUS_STRCPY_ERR; 369 } 370 return SOFTBUS_OK; 371 }); 372 auto ret = IsNegotiateChannelNeeded(remoteNetworkId.c_str(), WIFI_DIRECT_LINK_TYPE_HML); 373 EXPECT_EQ(ret, true); 374 __anon90c335f51402(InnerLink &link) 375 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, uuid, [&remoteMac](InnerLink &link) { 376 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 377 link.SetRemoteBaseMac(remoteMac); 378 }); 379 ret = IsNegotiateChannelNeeded(remoteNetworkId.c_str(), WIFI_DIRECT_LINK_TYPE_HML); 380 EXPECT_EQ(ret, true); 381 __anon90c335f51502(InnerLink &link) 382 LinkManager::GetInstance().ProcessIfPresent(remoteMac.c_str(), [&remoteMac](InnerLink &link) { 383 link.SetNegotiateChannel(std::make_shared<DummyNegotiateChannel>()); 384 }); 385 ret = IsNegotiateChannelNeeded(remoteNetworkId.c_str(), WIFI_DIRECT_LINK_TYPE_HML); 386 EXPECT_EQ(ret, false); 387 } 388 389 /* 390 * @tc.name: NotifyPtkSyncResultTest 391 * @tc.desc: check NotifyPtkSyncResult method 392 * @tc.type: FUNC 393 * @tc.require: 394 */ 395 HWTEST_F(WifiDirectManagerCppTest, NotifyPtkSyncResultTest, TestSize.Level1) 396 { 397 std::string remoteUuid("0123456789ABCDEF"); 398 int result = 0; 399 EXPECT_NO_FATAL_FAILURE(NotifyPtkSyncResult(remoteUuid.c_str(), result)); 400 __anon90c335f51602(const char *remoteDeviceId, int result) 401 g_syncPtkListener = [](const char *remoteDeviceId, int result) {}; 402 EXPECT_NO_FATAL_FAILURE(NotifyPtkSyncResult(remoteUuid.c_str(), result)); 403 } 404 405 /* 406 * @tc.name: RefreshRelationShipTest001 407 * @tc.desc: check RefreshRelationShip method 408 * @tc.type: FUNC 409 * @tc.require: 410 */ 411 HWTEST_F(WifiDirectManagerCppTest, RefreshRelationShipTest001, TestSize.Level1) 412 { 413 CONN_LOGI(CONN_WIFI_DIRECT, "RefreshRelationShipTest001 enter"); 414 std::string remoteUuid("0123456789ABCDEF"); 415 std::string remoteMac("11:11:11:11:11:11"); 416 LinkManager::GetInstance().RemoveLinks(InnerLink::LinkType::HML); 417 __anon90c335f51702(InnerLink &link) 418 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, remoteMac, [&remoteMac](InnerLink &link) { 419 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 420 link.SetRemoteBaseMac(remoteMac); 421 }); 422 423 RefreshRelationShip(remoteUuid.c_str(), remoteMac.c_str()); 424 auto link = LinkManager::GetInstance().GetReuseLink(WIFI_DIRECT_LINK_TYPE_HML, remoteMac); 425 426 EXPECT_EQ(link, nullptr); 427 CONN_LOGI(CONN_WIFI_DIRECT, "RefreshRelationShipTest001 exit"); 428 LinkManager::GetInstance().RemoveLinks(InnerLink::LinkType::HML); 429 } 430 431 /* 432 * @tc.name: RefreshRelationShipTest002 433 * @tc.desc: check RefreshRelationShip method 434 * @tc.type: FUNC 435 * @tc.require: 436 */ 437 HWTEST_F(WifiDirectManagerCppTest, RefreshRelationShipTest002, TestSize.Level1) 438 { 439 CONN_LOGI(CONN_WIFI_DIRECT, "RefreshRelationShipTest002 enter"); 440 std::string remoteUuid("0123456789ABCDEF"); 441 std::string remoteMac("11:11:11:11:11:11"); 442 LinkManager::GetInstance().RemoveLinks(InnerLink::LinkType::HML); 443 444 LinkManager::GetInstance().ProcessIfAbsent( __anon90c335f51802(InnerLink &link) 445 InnerLink::LinkType::HML, remoteMac, [&remoteMac, &remoteUuid](InnerLink &link) { 446 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTED); 447 link.SetRemoteBaseMac(remoteMac); 448 link.SetRemoteDeviceId(remoteUuid); 449 }); 450 __anon90c335f51902(InnerLink &link) 451 LinkManager::GetInstance().ProcessIfAbsent(InnerLink::LinkType::HML, remoteUuid, [&remoteMac](InnerLink &link) { 452 link.SetState(OHOS::SoftBus::InnerLink::LinkState::CONNECTING); 453 link.SetRemoteBaseMac(remoteMac); 454 }); 455 456 RefreshRelationShip(remoteUuid.c_str(), remoteMac.c_str()); 457 auto link = LinkManager::GetInstance().GetReuseLink(WIFI_DIRECT_LINK_TYPE_HML, remoteMac); 458 459 EXPECT_NE(link, nullptr); 460 CONN_LOGI(CONN_WIFI_DIRECT, "RefreshRelationShipTest002 exit"); 461 LinkManager::GetInstance().RemoveLinks(InnerLink::LinkType::HML); 462 } 463 464 /* 465 * @tc.name: ForceDisconnectDeviceSync001 466 * @tc.desc: check ForceDisconnectDeviceSync001 method 467 * @tc.type: FUNC 468 * @tc.require: 469 */ 470 HWTEST_F(WifiDirectManagerCppTest, ForceDisconnectDeviceSync001, TestSize.Level1) 471 { 472 CONN_LOGI(CONN_WIFI_DIRECT, "RefreshRelationShipTest001 enter"); 473 LinkManager::GetInstance().RemoveLinks(InnerLink::LinkType::HML); 474 auto result = ForceDisconnectDeviceSync(WIFI_DIRECT_LINK_TYPE_HML); 475 EXPECT_EQ(result, SOFTBUS_OK); 476 CONN_LOGI(CONN_WIFI_DIRECT, "RefreshRelationShipTest001 exit"); 477 } 478 479 } // namespace OHOS::SoftBus