1 /* 2 * Copyright (c) 2022 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 "device_networking_collect_test.h" 17 18 #include "device_status_collect_manager.h" 19 #include "sa_profiles.h" 20 #include "string_ex.h" 21 #include "test_log.h" 22 23 #define private public 24 #include "device_networking_collect.h" 25 #include "event_handler.h" 26 27 using namespace std; 28 using namespace testing; 29 using namespace testing::ext; 30 using namespace OHOS; 31 32 namespace OHOS { 33 namespace { 34 constexpr uint32_t DM_DIED_EVENT = 11; 35 constexpr int32_t MAX_WAIT_TIME = 1000; 36 } 37 38 bool DeviceNetworkingCollectTest::isCaseDone_ = false; 39 std::mutex DeviceNetworkingCollectTest::caseDoneLock_; 40 std::condition_variable DeviceNetworkingCollectTest::caseDoneCondition_; 41 std::shared_ptr<AppExecFwk::EventHandler> collectHandler_ = nullptr; 42 SetUpTestCase()43 void DeviceNetworkingCollectTest::SetUpTestCase() 44 { 45 auto runner = AppExecFwk::EventRunner::Create("collect_test2"); 46 collectHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner); 47 DTEST_LOG << "SetUpTestCase" << std::endl; 48 } 49 TearDownTestCase()50 void DeviceNetworkingCollectTest::TearDownTestCase() 51 { 52 DTEST_LOG << "TearDownTestCase" << std::endl; 53 } 54 SetUp()55 void DeviceNetworkingCollectTest::SetUp() 56 { 57 DTEST_LOG << "SetUp" << std::endl; 58 } 59 TearDown()60 void DeviceNetworkingCollectTest::TearDown() 61 { 62 DTEST_LOG << "TearDown" << std::endl; 63 } 64 65 /** 66 * @tc.name: OnStart001 67 * @tc.desc: test onStart 68 * @tc.type: FUNC 69 */ 70 HWTEST_F(DeviceNetworkingCollectTest, OnStart001, TestSize.Level3) 71 { 72 DTEST_LOG << " OnStart001 BEGIN" << std::endl; 73 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(nullptr); 74 networkingCollect->OnStart(); __anon9a5d7fab0202() 75 auto callback = [networkingCollect] () { 76 networkingCollect->OnStart(); 77 }; 78 collectHandler_->PostTask(callback); __anon9a5d7fab0302() 79 auto initDoneTask = []() { 80 std::lock_guard<std::mutex> autoLock(caseDoneLock_); 81 isCaseDone_ = true; 82 caseDoneCondition_.notify_all(); 83 }; 84 collectHandler_->PostTask(initDoneTask); 85 std::unique_lock<std::mutex> lock(caseDoneLock_); 86 caseDoneCondition_.wait_for(lock, std::chrono::milliseconds(MAX_WAIT_TIME), __anon9a5d7fab0402() 87 [&] () { return isCaseDone_; }); 88 isCaseDone_ = false; 89 OnDemandEvent event; 90 networkingCollect->ReportEvent(event); 91 networkingCollect->UpdateDeviceOnlineSet("deviceId"); 92 networkingCollect->IsOnline(); 93 networkingCollect->ClearDeviceOnlineSet(); 94 networkingCollect->stateCallback_ = nullptr; 95 networkingCollect->ReportEvent(event); 96 networkingCollect->UpdateDeviceOnlineSet("deviceId"); 97 networkingCollect->IsOnline(); 98 networkingCollect->ClearDeviceOnlineSet(); 99 networkingCollect->AddDeviceChangeListener(); 100 EXPECT_EQ(true, networkingCollect->initCallback_ != nullptr); 101 networkingCollect->initCallback_ = nullptr; 102 int32_t ret = networkingCollect->AddDeviceChangeListener(); 103 EXPECT_EQ(true, networkingCollect->initCallback_ == nullptr); 104 EXPECT_EQ(false, ret); 105 DTEST_LOG << " OnStart001 END" << std::endl; 106 } 107 108 /** 109 * @tc.name: OnStart002 110 * @tc.desc: test onStart 111 * @tc.type: FUNC 112 */ 113 HWTEST_F(DeviceNetworkingCollectTest, OnStart002, TestSize.Level3) 114 { 115 DTEST_LOG << " OnStart002 BEGIN" << std::endl; 116 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 117 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); __anon9a5d7fab0502() 118 auto callback = [networkingCollect] () { 119 networkingCollect->OnStart(); 120 }; 121 collectHandler_->PostTask(callback); __anon9a5d7fab0602() 122 auto initDoneTask = []() { 123 std::lock_guard<std::mutex> autoLock(caseDoneLock_); 124 isCaseDone_ = true; 125 caseDoneCondition_.notify_all(); 126 }; 127 collectHandler_->PostTask(initDoneTask); 128 std::unique_lock<std::mutex> lock(caseDoneLock_); 129 caseDoneCondition_.wait_for(lock, std::chrono::milliseconds(MAX_WAIT_TIME), __anon9a5d7fab0702() 130 [&] () { return isCaseDone_; }); 131 isCaseDone_ = false; 132 OnDemandEvent event; 133 networkingCollect->ReportEvent(event); 134 EXPECT_EQ(true, networkingCollect->initCallback_ != nullptr); 135 networkingCollect->workHandler_ = nullptr; 136 networkingCollect->OnStop(); 137 DTEST_LOG << " OnStart002 END" << std::endl; 138 } 139 140 /** 141 * @tc.name: OnRemoteDied001 142 * @tc.desc: test when dm is died 143 * @tc.type: FUNC 144 */ 145 HWTEST_F(DeviceNetworkingCollectTest, OnRemoteDied001, TestSize.Level3) 146 { 147 DTEST_LOG << " OnRemoteDied001 BEGIN" << std::endl; 148 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 149 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); __anon9a5d7fab0802() 150 auto callback = [networkingCollect] () { 151 networkingCollect->OnStart(); 152 }; 153 collectHandler_->PostTask(callback); __anon9a5d7fab0902() 154 auto initDoneTask = []() { 155 std::lock_guard<std::mutex> autoLock(caseDoneLock_); 156 isCaseDone_ = true; 157 caseDoneCondition_.notify_all(); 158 }; 159 collectHandler_->PostTask(initDoneTask); 160 std::unique_lock<std::mutex> lock(caseDoneLock_); 161 caseDoneCondition_.wait_for(lock, std::chrono::milliseconds(MAX_WAIT_TIME), __anon9a5d7fab0a02() 162 [&] () { return isCaseDone_; }); 163 isCaseDone_ = false; 164 auto initCallback = std::static_pointer_cast<DeviceInitCallBack>(networkingCollect->initCallback_); 165 initCallback->OnRemoteDied(); 166 initCallback->handler_ = nullptr; 167 initCallback->OnRemoteDied(); 168 EXPECT_EQ(true, initCallback != nullptr); 169 EXPECT_EQ(true, initCallback->handler_ == nullptr); 170 networkingCollect->OnStop(); 171 DTEST_LOG << " OnRemoteDied001 END" << std::endl; 172 } 173 174 /** 175 * @tc.name: OnDeviceOnline001 176 * @tc.desc: test OnDeviceOnline 177 * @tc.type: FUNC 178 */ 179 HWTEST_F(DeviceNetworkingCollectTest, OnDeviceOnline001, TestSize.Level3) 180 { 181 DTEST_LOG << " OnDeviceOnline001 BEGIN" << std::endl; 182 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 183 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); __anon9a5d7fab0b02() 184 auto callback = [networkingCollect] () { 185 networkingCollect->OnStart(); 186 }; 187 collectHandler_->PostTask(callback); __anon9a5d7fab0c02() 188 auto initDoneTask = []() { 189 std::lock_guard<std::mutex> autoLock(caseDoneLock_); 190 isCaseDone_ = true; 191 caseDoneCondition_.notify_all(); 192 }; 193 collectHandler_->PostTask(initDoneTask); 194 std::unique_lock<std::mutex> lock(caseDoneLock_); 195 caseDoneCondition_.wait_for(lock, std::chrono::milliseconds(MAX_WAIT_TIME), __anon9a5d7fab0d02() 196 [&] () { return isCaseDone_; }); 197 isCaseDone_ = false; 198 DistributedHardware::DmDeviceInfo dmDeviceInfo = { 199 .deviceId = "asdad", 200 .deviceName = "asda", 201 .deviceTypeId = 1, 202 }; 203 networkingCollect->stateCallback_->OnDeviceOnline(dmDeviceInfo); 204 EXPECT_EQ(true, networkingCollect->IsOnline()); 205 networkingCollect->stateCallback_->OnDeviceOnline(dmDeviceInfo); 206 networkingCollect->stateCallback_->collect_ = nullptr; 207 networkingCollect->ClearDeviceOnlineSet(); 208 networkingCollect->stateCallback_->OnDeviceOnline(dmDeviceInfo); 209 EXPECT_EQ(true, networkingCollect->IsOnline()); 210 DTEST_LOG << " OnDeviceOnline001 END" << std::endl; 211 } 212 213 /** 214 * @tc.name: OnDeviceOffline001 215 * @tc.desc: test OnDeviceOffline 216 * @tc.type: FUNC 217 */ 218 HWTEST_F(DeviceNetworkingCollectTest, OnDeviceOffline001, TestSize.Level3) 219 { 220 DTEST_LOG << " OnDeviceOffline001 BEGIN" << std::endl; 221 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 222 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); __anon9a5d7fab0e02() 223 auto callback = [networkingCollect] () { 224 networkingCollect->OnStart(); 225 }; 226 collectHandler_->PostTask(callback); __anon9a5d7fab0f02() 227 auto initDoneTask = []() { 228 std::lock_guard<std::mutex> autoLock(caseDoneLock_); 229 isCaseDone_ = true; 230 caseDoneCondition_.notify_all(); 231 }; 232 collectHandler_->PostTask(initDoneTask); 233 std::unique_lock<std::mutex> lock(caseDoneLock_); 234 caseDoneCondition_.wait_for(lock, std::chrono::milliseconds(MAX_WAIT_TIME), __anon9a5d7fab1002() 235 [&] () { return isCaseDone_; }); 236 isCaseDone_ = false; 237 DistributedHardware::DmDeviceInfo dmDeviceInfo = { 238 .deviceId = "asdad", 239 .deviceName = "asda", 240 .deviceTypeId = 1, 241 }; 242 networkingCollect->stateCallback_->OnDeviceOffline(dmDeviceInfo); 243 networkingCollect->stateCallback_->collect_ = nullptr; 244 networkingCollect->stateCallback_->OnDeviceOffline(dmDeviceInfo); 245 EXPECT_EQ(true, !networkingCollect->IsOnline()); 246 DTEST_LOG << " OnDeviceOffline001 END" << std::endl; 247 } 248 249 /** 250 * @tc.name: OnDeviceOffline002 251 * @tc.desc: test OnDeviceOffline, device is online 252 * @tc.type: FUNC 253 * @tc.require: I6OU0A 254 */ 255 HWTEST_F(DeviceNetworkingCollectTest, OnDeviceOffline002, TestSize.Level3) 256 { 257 DTEST_LOG << " OnDeviceOffline002 BEGIN" << std::endl; 258 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 259 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); __anon9a5d7fab1102() 260 auto callback = [networkingCollect] () { 261 networkingCollect->OnStart(); 262 }; 263 collectHandler_->PostTask(callback); __anon9a5d7fab1202() 264 auto initDoneTask = []() { 265 std::lock_guard<std::mutex> autoLock(caseDoneLock_); 266 isCaseDone_ = true; 267 caseDoneCondition_.notify_all(); 268 }; 269 collectHandler_->PostTask(initDoneTask); 270 std::unique_lock<std::mutex> lock(caseDoneLock_); 271 caseDoneCondition_.wait_for(lock, std::chrono::milliseconds(MAX_WAIT_TIME), __anon9a5d7fab1302() 272 [&] () { return isCaseDone_; }); 273 isCaseDone_ = false; 274 275 networkingCollect->stateCallback_->deviceOnlineSet_.insert("mockDevice"); 276 DistributedHardware::DmDeviceInfo dmDeviceInfo = { 277 .deviceId = "asdad", 278 .deviceName = "asda", 279 .deviceTypeId = 1, 280 }; 281 networkingCollect->stateCallback_->OnDeviceOffline(dmDeviceInfo); 282 networkingCollect->stateCallback_->OnDeviceChanged(dmDeviceInfo); 283 networkingCollect->stateCallback_->OnDeviceReady(dmDeviceInfo); 284 EXPECT_TRUE(networkingCollect->IsOnline()); 285 DTEST_LOG << " OnDeviceOffline002 END" << std::endl; 286 } 287 288 /** 289 * @tc.name: ProcessEvent001 290 * @tc.desc: test ProcessEvent, with error param. 291 * @tc.type: FUNC 292 */ 293 HWTEST_F(DeviceNetworkingCollectTest, ProcessEvent001, TestSize.Level3) 294 { 295 DTEST_LOG << " ProcessEvent001 BEGIN" << std::endl; 296 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 297 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); __anon9a5d7fab1402() 298 auto callback = [networkingCollect] () { 299 networkingCollect->OnStart(); 300 }; 301 collectHandler_->PostTask(callback); __anon9a5d7fab1502() 302 auto initDoneTask = []() { 303 std::lock_guard<std::mutex> autoLock(caseDoneLock_); 304 isCaseDone_ = true; 305 caseDoneCondition_.notify_all(); 306 }; 307 collectHandler_->PostTask(initDoneTask); 308 std::unique_lock<std::mutex> lock(caseDoneLock_); 309 caseDoneCondition_.wait_for(lock, std::chrono::milliseconds(MAX_WAIT_TIME), __anon9a5d7fab1602() 310 [&] () { return isCaseDone_; }); 311 isCaseDone_ = false; 312 auto ret = networkingCollect->workHandler_->SendEvent(DM_DIED_EVENT + 1); 313 EXPECT_EQ(true, ret); 314 auto workHandler = std::static_pointer_cast<WorkHandler>(networkingCollect->workHandler_); 315 workHandler->collect_ = nullptr; 316 ret = networkingCollect->workHandler_->SendEvent(DM_DIED_EVENT + 1); 317 EXPECT_EQ(true, ret); 318 ret = networkingCollect->workHandler_->SendEvent(DM_DIED_EVENT); 319 EXPECT_EQ(true, ret); 320 ret = networkingCollect->workHandler_->SendEvent(DM_DIED_EVENT, -1); 321 EXPECT_EQ(false, ret); 322 DTEST_LOG << " ProcessEvent001 END" << std::endl; 323 } 324 325 /** 326 * @tc.name: AddDeviceChangeListener001 327 * @tc.desc: test AddDeviceChangeListener, with init DeviceManager failed. 328 * @tc.type: FUNC 329 * @tc.require: I6OU0A 330 */ 331 HWTEST_F(DeviceNetworkingCollectTest, AddDeviceChangeListener001, TestSize.Level3) 332 { 333 DTEST_LOG << " AddDeviceChangeListener001 BEGIN" << std::endl; 334 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 335 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 336 networkingCollect->initCallback_ = nullptr; 337 bool result = networkingCollect->AddDeviceChangeListener(); 338 EXPECT_FALSE(result); 339 DTEST_LOG << " AddDeviceChangeListener001 END" << std::endl; 340 } 341 342 /** 343 * @tc.name: CheckCondition001 344 * @tc.desc: test CheckCondition, with condition is on and is online. 345 * @tc.type: FUNC 346 * @tc.require: I6OU0A 347 */ 348 HWTEST_F(DeviceNetworkingCollectTest, CheckCondition001, TestSize.Level3) 349 { 350 DTEST_LOG << " CheckCondition001 BEGIN" << std::endl; 351 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 352 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 353 OnDemandCondition condition; 354 condition.value = "on"; 355 networkingCollect->stateCallback_ = std::make_shared<DeviceStateCallback>(networkingCollect); 356 networkingCollect->stateCallback_->deviceOnlineSet_.insert("mockDeivce"); 357 bool result = networkingCollect->CheckCondition(condition); 358 EXPECT_TRUE(result); 359 DTEST_LOG << " CheckCondition001 END" << std::endl; 360 } 361 362 /** 363 * @tc.name: CheckCondition002 364 * @tc.desc: test CheckCondition, with condition is on and is offline. 365 * @tc.type: FUNC 366 * @tc.require: I6OU0A 367 */ 368 HWTEST_F(DeviceNetworkingCollectTest, CheckCondition002, TestSize.Level3) 369 { 370 DTEST_LOG << " CheckCondition002 BEGIN" << std::endl; 371 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 372 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 373 OnDemandCondition condition; 374 condition.value = "on"; 375 bool result = networkingCollect->CheckCondition(condition); 376 EXPECT_FALSE(result); 377 DTEST_LOG << " CheckCondition002 END" << std::endl; 378 } 379 380 /** 381 * @tc.name: CheckCondition003 382 * @tc.desc: test CheckCondition, with condition is off and is online. 383 * @tc.type: FUNC 384 * @tc.require: I6OU0A 385 */ 386 HWTEST_F(DeviceNetworkingCollectTest, CheckCondition003, TestSize.Level3) 387 { 388 DTEST_LOG << " CheckCondition003 BEGIN" << std::endl; 389 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 390 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 391 OnDemandCondition condition; 392 condition.value = "off"; 393 networkingCollect->stateCallback_ = std::make_shared<DeviceStateCallback>(networkingCollect); 394 networkingCollect->stateCallback_->deviceOnlineSet_.insert("mockDeivce"); 395 bool result = networkingCollect->CheckCondition(condition); 396 EXPECT_FALSE(result); 397 DTEST_LOG << " CheckCondition003 END" << std::endl; 398 } 399 400 /** 401 * @tc.name: CheckCondition004 402 * @tc.desc: test CheckCondition, with condition is off and is offline. 403 * @tc.type: FUNC 404 * @tc.require: I6OU0A 405 */ 406 HWTEST_F(DeviceNetworkingCollectTest, CheckCondition004, TestSize.Level3) 407 { 408 DTEST_LOG << " CheckCondition004 BEGIN" << std::endl; 409 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 410 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 411 OnDemandCondition condition; 412 condition.value = "off"; 413 bool result = networkingCollect->CheckCondition(condition); 414 EXPECT_TRUE(result); 415 DTEST_LOG << " CheckCondition004 END" << std::endl; 416 } 417 418 /** 419 * @tc.name: CheckCondition005 420 * @tc.desc: test CheckCondition, with condition is invalid and is online. 421 * @tc.type: FUNC 422 * @tc.require: I6OU0A 423 */ 424 HWTEST_F(DeviceNetworkingCollectTest, CheckCondition005, TestSize.Level3) 425 { 426 DTEST_LOG << " CheckCondition005 BEGIN" << std::endl; 427 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 428 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 429 OnDemandCondition condition; 430 condition.value = "invalid"; 431 networkingCollect->stateCallback_ = std::make_shared<DeviceStateCallback>(networkingCollect); 432 networkingCollect->stateCallback_->deviceOnlineSet_.insert("mockDeivce"); 433 bool result = networkingCollect->CheckCondition(condition); 434 EXPECT_FALSE(result); 435 DTEST_LOG << " CheckCondition005 END" << std::endl; 436 } 437 438 /** 439 * @tc.name: CheckCondition006 440 * @tc.desc: test CheckCondition, with condition is invalid and is offline. 441 * @tc.type: FUNC 442 * @tc.require: I6OU0A 443 */ 444 HWTEST_F(DeviceNetworkingCollectTest, CheckCondition006, TestSize.Level3) 445 { 446 DTEST_LOG << " CheckCondition006 BEGIN" << std::endl; 447 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 448 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 449 OnDemandCondition condition; 450 condition.value = "invalid"; 451 bool result = networkingCollect->CheckCondition(condition); 452 EXPECT_FALSE(result); 453 DTEST_LOG << " CheckCondition006 END" << std::endl; 454 } 455 456 /** 457 * @tc.name: ffrt001 458 * @tc.desc: test ffrt. 459 * @tc.type: FUNC 460 * @tc.require: I6OU0A 461 */ 462 HWTEST_F(DeviceNetworkingCollectTest, ffrt001, TestSize.Level3) 463 { 464 DTEST_LOG << " test ffrt001 BEGIN" << std::endl; 465 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 466 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 467 networkingCollect->OnStart(); 468 networkingCollect->SetFfrt(); 469 networkingCollect->CleanFfrt(); 470 networkingCollect->OnStop(); 471 EXPECT_NE(collect, nullptr); 472 DTEST_LOG << " test ffrt001 END" << std::endl; 473 } 474 475 /** 476 * @tc.name: ReportMissedEvents001 477 * @tc.desc: test ReportMissedEvents. 478 * @tc.type: FUNC 479 * @tc.require: I6OU0A 480 */ 481 HWTEST_F(DeviceNetworkingCollectTest, ReportMissedEvents001, TestSize.Level3) 482 { 483 DTEST_LOG << " test ReportMissedEvents BEGIN" << std::endl; 484 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 485 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 486 networkingCollect->OnStart(); 487 networkingCollect->ReportMissedEvents(); 488 networkingCollect->stateCallback_->deviceOnlineSet_.emplace("1"); 489 networkingCollect->ReportMissedEvents(); 490 EXPECT_NE(collect, nullptr); 491 DTEST_LOG << " test ReportMissedEvents END" << std::endl; 492 } 493 494 /** 495 * @tc.name: UpdateDeviceOnlineSet001 496 * @tc.desc: test UpdateDeviceOnlineSet. 497 * @tc.type: FUNC 498 * @tc.require: I6OU0A 499 */ 500 HWTEST_F(DeviceNetworkingCollectTest, UpdateDeviceOnlineSet001, TestSize.Level3) 501 { 502 DTEST_LOG << " test UpdateDeviceOnlineSet BEGIN" << std::endl; 503 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 504 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 505 networkingCollect->OnStart(); 506 networkingCollect->UpdateDeviceOnlineSet("1"); 507 EXPECT_NE(collect, nullptr); 508 DTEST_LOG << " test UpdateDeviceOnlineSet END" << std::endl; 509 } 510 511 /** 512 * @tc.name: ClearDeviceOnlineSet001 513 * @tc.desc: test ClearDeviceOnlineSet. 514 * @tc.type: FUNC 515 * @tc.require: I6OU0A 516 */ 517 HWTEST_F(DeviceNetworkingCollectTest, ClearDeviceOnlineSet001, TestSize.Level3) 518 { 519 DTEST_LOG << " test ClearDeviceOnlineSet BEGIN" << std::endl; 520 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 521 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 522 networkingCollect->OnStart(); 523 networkingCollect->ClearDeviceOnlineSet(); 524 EXPECT_NE(collect, nullptr); 525 DTEST_LOG << " test ClearDeviceOnlineSet END" << std::endl; 526 } 527 528 /** 529 * @tc.name: OnRemoteDied002 530 * @tc.desc: test OnRemoteDied. 531 * @tc.type: FUNC 532 * @tc.require: I6OU0A 533 */ 534 HWTEST_F(DeviceNetworkingCollectTest, OnRemoteDied002, TestSize.Level3) 535 { 536 DTEST_LOG << " test OnRemoteDied BEGIN" << std::endl; 537 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 538 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 539 networkingCollect->OnStart(); 540 networkingCollect->initCallback_->OnRemoteDied(); 541 EXPECT_NE(collect, nullptr); 542 DTEST_LOG << " test OnRemoteDied END" << std::endl; 543 } 544 545 /** 546 * @tc.name: OnDeviceOnline002 547 * @tc.desc: test OnDeviceOnline. 548 * @tc.type: FUNC 549 * @tc.require: I6OU0A 550 */ 551 HWTEST_F(DeviceNetworkingCollectTest, OnDeviceOnline002, TestSize.Level3) 552 { 553 DTEST_LOG << " test OnDeviceOnline BEGIN" << std::endl; 554 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 555 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 556 networkingCollect->OnStart(); 557 DistributedHardware::DmDeviceInfo dmDeviceInfo = { 558 .deviceId = "asdad", 559 .deviceName = "asda", 560 .deviceTypeId = 1, 561 }; 562 networkingCollect->stateCallback_->OnDeviceOnline(dmDeviceInfo); 563 EXPECT_NE(collect, nullptr); 564 DTEST_LOG << " test OnDeviceOnline END" << std::endl; 565 } 566 567 /** 568 * @tc.name: OnDeviceOffline003 569 * @tc.desc: test OnDeviceOffline 570 * @tc.type: FUNC 571 */ 572 HWTEST_F(DeviceNetworkingCollectTest, OnDeviceOffline003, TestSize.Level3) 573 { 574 DTEST_LOG << " OnDeviceOffline003 BEGIN" << std::endl; 575 sptr<DeviceStatusCollectManager> collect = new DeviceStatusCollectManager(); 576 sptr<DeviceNetworkingCollect> networkingCollect = new DeviceNetworkingCollect(collect); 577 networkingCollect->OnStart(); 578 DistributedHardware::DmDeviceInfo dmDeviceInfo = { 579 .deviceId = "asdad", 580 .deviceName = "asda", 581 .deviceTypeId = 1, 582 }; 583 networkingCollect->stateCallback_->OnDeviceOffline(dmDeviceInfo); 584 networkingCollect->stateCallback_->OnDeviceChanged(dmDeviceInfo); 585 networkingCollect->stateCallback_->OnDeviceReady(dmDeviceInfo); 586 EXPECT_NE(collect, nullptr); 587 DTEST_LOG << " OnDeviceOffline003 END" << std::endl; 588 } 589 } // namespace OHOS 590