1 /* 2 * Copyright (c) 2022-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 "dtbschedmgr_device_info_storage_test.h" 17 18 #include "distributed_sched_test_util.h" 19 #include "dtbschedmgr_log.h" 20 #include "test_log.h" 21 #include <cstddef> 22 23 namespace OHOS { 24 namespace DistributedSchedule { 25 using namespace std; 26 using namespace testing; 27 using namespace testing::ext; 28 namespace { 29 constexpr int32_t MAX_WAIT_TIME = 10000; 30 } 31 32 int32_t DtbschedmgrDeviceInfoStorageTest::startTaskNum_ = 2; 33 std::mutex DtbschedmgrDeviceInfoStorageTest::caseDoneLock_; 34 std::condition_variable DtbschedmgrDeviceInfoStorageTest::caseDoneCondition_; 35 SetUpTestCase()36 void DtbschedmgrDeviceInfoStorageTest::SetUpTestCase() 37 { 38 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest::SetUpTestCase" << std::endl; 39 if (!DistributedSchedUtil::LoadDistributedSchedService()) { 40 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest::SetUpTestCase load dms SA failed" << std::endl; 41 } 42 } 43 TearDownTestCase()44 void DtbschedmgrDeviceInfoStorageTest::TearDownTestCase() 45 { 46 // Wait until all async tasks are completed before exiting the test suite 47 auto caseDoneNotifyTask = []() { 48 std::lock_guard<std::mutex> autoLock(caseDoneLock_); 49 --startTaskNum_; 50 caseDoneCondition_.notify_all(); 51 }; 52 if (DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_ != nullptr) { 53 DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_->PostTask(caseDoneNotifyTask); 54 } 55 if (DtbschedmgrDeviceInfoStorage::GetInstance().initHandler_ != nullptr) { 56 DtbschedmgrDeviceInfoStorage::GetInstance().initHandler_->PostTask(caseDoneNotifyTask); 57 } 58 std::unique_lock<std::mutex> lock(caseDoneLock_); 59 caseDoneCondition_.wait_for(lock, std::chrono::milliseconds(MAX_WAIT_TIME), 60 [&] () { return startTaskNum_ == 0; }); 61 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest::TearDownTestCase" << std::endl; 62 } 63 SetUp()64 void DtbschedmgrDeviceInfoStorageTest::SetUp() 65 { 66 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest::SetUp" << std::endl; 67 } 68 TearDown()69 void DtbschedmgrDeviceInfoStorageTest::TearDown() 70 { 71 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest::TearDown" << std::endl; 72 } 73 74 /** 75 * @tc.name: InitTest_001 76 * @tc.desc: test Init 77 * @tc.type: FUNC 78 */ 79 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, InitTest_001, TestSize.Level3) 80 { 81 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest InitTest_001 start" << std::endl; 82 /** 83 * @tc.steps: step1. test Init with listener when initHandler_ is nullptr; 84 */ 85 DtbschedmgrDeviceInfoStorage::GetInstance().initHandler_ = nullptr; 86 bool result = DtbschedmgrDeviceInfoStorage::GetInstance().Init(); 87 EXPECT_TRUE(result); 88 /** 89 * @tc.steps: step2. test Init when initHandler_ is not nullptr; 90 */ 91 result = DtbschedmgrDeviceInfoStorage::GetInstance().Init(); 92 EXPECT_TRUE(result); 93 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest InitTest_001 end" << std::endl; 94 } 95 96 /** 97 * @tc.name: ConnectSoftbusTest_001 98 * @tc.desc: test ConnectSoftbus 99 * @tc.type: FUNC 100 */ 101 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, ConnectSoftbusTest_001, TestSize.Level3) 102 { 103 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest ConnectSoftbusTest_001 start" << std::endl; 104 /** 105 * @tc.steps: step1. test ConnectSoftbus; 106 */ 107 bool result = DtbschedmgrDeviceInfoStorage::GetInstance().ConnectSoftbus(); 108 EXPECT_TRUE(result); 109 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest ConnectSoftbusTest_001 end" << std::endl; 110 } 111 112 /** 113 * @tc.name: InitNetworkIdManagerTest_001 114 * @tc.desc: test InitNetworkIdManager 115 * @tc.type: FUNC 116 */ 117 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, InitNetworkIdManagerTest_001, TestSize.Level3) 118 { 119 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest InitNetworkIdManagerTest_001 start" << std::endl; 120 bool result = DtbschedmgrDeviceInfoStorage::GetInstance().InitNetworkIdManager(nullptr); 121 EXPECT_FALSE(result); 122 std::shared_ptr<DnetworkAdapter> dnetworkAdapter = DnetworkAdapter::GetInstance(); 123 DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_ = nullptr; 124 /** 125 * @tc.steps: step1. test InitNetworkIdManager when networkIdMgrHandler_ is nullptr; 126 */ 127 result = DtbschedmgrDeviceInfoStorage::GetInstance().InitNetworkIdManager(dnetworkAdapter); 128 EXPECT_TRUE(result); 129 130 /** 131 * @tc.steps: step2. test InitNetworkIdManager when networkIdMgrHandler_ is not nullptr; 132 */ 133 result = DtbschedmgrDeviceInfoStorage::GetInstance().InitNetworkIdManager(dnetworkAdapter); 134 EXPECT_TRUE(result); 135 /** 136 * @tc.steps: step3. test Stop when deviceNodeListener_ is nullptr; 137 */ 138 DtbschedmgrDeviceInfoStorage::GetInstance().deviceNodeListener_ = nullptr; 139 DtbschedmgrDeviceInfoStorage::GetInstance().Stop(); 140 /** 141 * @tc.steps: step4. test Stop when deviceNodeListener_ is not nullptr; 142 */ 143 DtbschedmgrDeviceInfoStorage::GetInstance().deviceNodeListener_ = std::make_shared<DistributedDeviceNodeListener>(); 144 DtbschedmgrDeviceInfoStorage::GetInstance().Stop(); 145 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest InitNetworkIdManagerTest_001 end" << std::endl; 146 } 147 148 /** 149 * @tc.name: WaitForDnetworkReadyTest_001 150 * @tc.desc: test WaitForDnetworkReady 151 * @tc.type: FUNC 152 */ 153 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, WaitForDnetworkReadyTest_001, TestSize.Level3) 154 { 155 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest WaitForDnetworkReadyTest_001 start" << std::endl; 156 /** 157 * @tc.steps: step1. test WaitForDnetworkReady; 158 */ 159 bool result = DtbschedmgrDeviceInfoStorage::GetInstance().WaitForDnetworkReady(); 160 EXPECT_TRUE(result); 161 /** 162 * @tc.steps: step2. test RegisterUuidNetworkIdMap; 163 */ 164 std::string networkId = ""; 165 DtbschedmgrDeviceInfoStorage::GetInstance().RegisterUuidNetworkIdMap(networkId); 166 /** 167 * @tc.steps: step3. test UnregisterUuidNetworkIdMap; 168 */ 169 DtbschedmgrDeviceInfoStorage::GetInstance().UnregisterUuidNetworkIdMap(networkId); 170 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest WaitForDnetworkReadyTest_001 end" << std::endl; 171 } 172 173 /** 174 * @tc.name: GetDeviceIdSetTest_001 175 * @tc.desc: test GetDeviceIdSet 176 * @tc.type: FUNC 177 */ 178 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetDeviceIdSetTest_001, TestSize.Level3) 179 { 180 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceIdSetTest_001 start" << std::endl; 181 /** 182 * @tc.steps: step1. test GetDeviceIdSet; 183 */ 184 set<std::string> deviceIdSet; 185 DtbschedmgrDeviceInfoStorage::GetInstance().GetDeviceIdSet(deviceIdSet); 186 EXPECT_TRUE(deviceIdSet.empty()); 187 /** 188 * @tc.steps: step2. test GetDeviceIdSet when remoteDevices_ is not empty; 189 */ 190 std::string networkId = "invalid networkId for DeviceOnlineNotify"; 191 std::string deviceName = "invalid deviceName for DeviceOnlineNotify"; 192 int32_t deviceType = 0; 193 std::shared_ptr<DmsDeviceInfo> devInfo = make_shared<DmsDeviceInfo>(deviceName, deviceType, networkId); 194 DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_[networkId] = devInfo; 195 DtbschedmgrDeviceInfoStorage::GetInstance().GetDeviceIdSet(deviceIdSet); 196 EXPECT_FALSE(deviceIdSet.empty()); 197 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceIdSetTest_001 end" << std::endl; 198 } 199 200 /** 201 * @tc.name: GetLocalDeviceFromDnetTest_001 202 * @tc.desc: test GetLocalDeviceFromDnet 203 * @tc.type: FUNC 204 */ 205 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetLocalDeviceFromDnetTest_001, TestSize.Level3) 206 { 207 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetLocalDeviceFromDnetTest_001 start" << std::endl; 208 DistributedSchedUtil::MockBundlePermission(); 209 std::string deviceId; 210 /** 211 * @tc.steps: step1. test GetLocalDeviceFromDnet; 212 */ 213 bool result = DtbschedmgrDeviceInfoStorage::GetInstance().GetLocalDeviceId(deviceId); 214 EXPECT_TRUE(result); 215 /** 216 * @tc.steps: step2. test DeviceOnlineNotify when devInfo is nullptr; 217 */ 218 std::shared_ptr<DmsDeviceInfo> devInfo = nullptr; 219 DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOnlineNotify(devInfo); 220 /** 221 * @tc.steps: step3. test DeviceOnlineNotify when networkIdMgrHandler_ is nullptr; 222 */ 223 std::string networkId = "invalid networkId for DeviceOnlineNotify"; 224 std::string deviceName = "invalid deviceName for DeviceOnlineNotify"; 225 int32_t deviceType = 0; 226 devInfo = make_shared<DmsDeviceInfo>(deviceName, deviceType, networkId); 227 DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_ = nullptr; 228 DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOnlineNotify(devInfo); 229 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetLocalDeviceFromDnetTest_001 end" << std::endl; 230 } 231 232 /** 233 * @tc.name: ClearAllDevicesTest_001 234 * @tc.desc: test ClearAllDevices 235 * @tc.type: FUNC 236 */ 237 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, ClearAllDevicesTest_001, TestSize.Level3) 238 { 239 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest ClearAllDevicesTest_001 start" << std::endl; 240 /** 241 * @tc.steps: step1. test ClearAllDevices; 242 */ 243 DtbschedmgrDeviceInfoStorage::GetInstance().ClearAllDevices(); 244 { 245 lock_guard<mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().deviceLock_); 246 EXPECT_TRUE(DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_.empty()); 247 } 248 /** 249 * @tc.steps: step2. test DeviceOfflineNotify when deviceId is empty; 250 */ 251 std::string deviceId; 252 DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOfflineNotify(deviceId); 253 /** 254 * @tc.steps: step3. test DeviceOfflineNotify when networkIdMgrHandler_ is nullptr; 255 */ 256 deviceId = "invalid deviceId for DeviceOnlineNotify"; 257 DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_ = nullptr; 258 DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOfflineNotify(deviceId); 259 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest ClearAllDevicesTest_001 end" << std::endl; 260 } 261 262 /** 263 * @tc.name: GetDeviceInfoByIdTest_001 264 * @tc.desc: test GetDeviceInfoById 265 * @tc.type: FUNC 266 */ 267 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetDeviceInfoByIdTest_001, TestSize.Level3) 268 { 269 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceInfoByIdTest_001 start" << std::endl; 270 /** 271 * @tc.steps: step1. test GetDeviceInfoById when networkId is in map; 272 */ 273 std::string networkId = "invalid networkId for GetDeviceInfoById"; 274 { 275 lock_guard<mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().deviceLock_); 276 std::string deviceName = "invalid deviceName for GetDeviceInfoById"; 277 int32_t deviceType = 0; 278 DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_[networkId] = 279 make_shared<DmsDeviceInfo>(deviceName, deviceType, networkId); 280 } 281 std::shared_ptr<DmsDeviceInfo> dmsDeviceInfo = 282 DtbschedmgrDeviceInfoStorage::GetInstance().GetDeviceInfoById(networkId); 283 EXPECT_NE(dmsDeviceInfo, nullptr); 284 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceInfoByIdTest_001 end" << std::endl; 285 } 286 287 /** 288 * @tc.name: GetUuidByNetworkIdTest_001 289 * @tc.desc: test GetUuidByNetworkId 290 * @tc.type: FUNC 291 */ 292 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetUuidByNetworkIdTest_001, TestSize.Level3) 293 { 294 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetUuidByNetworkIdTest_001 start" << std::endl; 295 /** 296 * @tc.steps: step1. test GetUuidByNetworkId when networkId is empty; 297 */ 298 std::string networkId; 299 std::string result = DtbschedmgrDeviceInfoStorage::GetInstance().GetUuidByNetworkId(networkId); 300 EXPECT_TRUE(result.empty()); 301 /** 302 * @tc.steps: step2. test GetUuidByNetworkId when networkId is not in map; 303 */ 304 networkId = "invalid networkId for GetUuidByNetworkId"; 305 result = DtbschedmgrDeviceInfoStorage::GetInstance().GetUuidByNetworkId(networkId); 306 EXPECT_TRUE(result.empty()); 307 /** 308 * @tc.steps: step3. test GetUuidByNetworkId when networkId is in map; 309 */ 310 std::string uuid = "invalid uuid for GetUuidByNetworkId"; 311 { 312 lock_guard<mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().uuidNetworkIdLock_); 313 DtbschedmgrDeviceInfoStorage::GetInstance().uuidNetworkIdMap_[uuid] = networkId; 314 } 315 result = DtbschedmgrDeviceInfoStorage::GetInstance().GetUuidByNetworkId(networkId); 316 EXPECT_EQ(result, uuid); 317 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetUuidByNetworkIdTest_001 end" << std::endl; 318 } 319 320 /** 321 * @tc.name: GetNetworkIdByUuidTest_001 322 * @tc.desc: test GetNetworkIdByUuid 323 * @tc.type: FUNC 324 */ 325 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetNetworkIdByUuidTest_001, TestSize.Level3) 326 { 327 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetNetworkIdByUuidTest_001 start" << std::endl; 328 /** 329 * @tc.steps: step1. test GetNetworkIdByUuid when uuid is null; 330 */ 331 std::string uuid; 332 std::string result = DtbschedmgrDeviceInfoStorage::GetInstance().GetNetworkIdByUuid(uuid); 333 EXPECT_TRUE(result.empty()); 334 /** 335 * @tc.steps: step2. test GetNetworkIdByUuid when uuid is invalid; 336 */ 337 uuid = "invalid uuid for GetNetworkIdByUuid"; 338 result = DtbschedmgrDeviceInfoStorage::GetInstance().GetNetworkIdByUuid(uuid); 339 EXPECT_TRUE(result.empty()); 340 /** 341 * @tc.steps: step3. test GetNetworkIdByUuid; 342 */ 343 std::string networkId = "invalid networkId for GetNetworkIdByUuid"; 344 { 345 std::lock_guard<std::mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().uuidNetworkIdLock_); 346 DtbschedmgrDeviceInfoStorage::GetInstance().uuidNetworkIdMap_[uuid] = networkId; 347 } 348 result = DtbschedmgrDeviceInfoStorage::GetInstance().GetNetworkIdByUuid(uuid); 349 EXPECT_EQ(result, networkId); 350 /** 351 * @tc.steps: step4. test OnDeviceInfoChanged; 352 */ 353 std::string deviceId = "invalid deviceId for OnDeviceInfoChanged"; 354 DtbschedmgrDeviceInfoStorage::GetInstance().OnDeviceInfoChanged(deviceId); 355 356 /** 357 * @tc.steps: step5. test OnRemoteDied; 358 */ 359 wptr<IRemoteObject> remote = nullptr; 360 sptr<DnetServiceDeathRecipient> dnetServiceDeathRecipient(new DnetServiceDeathRecipient()); 361 ASSERT_NE(dnetServiceDeathRecipient, nullptr); 362 dnetServiceDeathRecipient->OnRemoteDied(remote); 363 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetNetworkIdByUuidTest_001 end" << std::endl; 364 } 365 366 /** 367 * @tc.name: UpdateDeviceInfoStorageTest_001 368 * @tc.desc: test UpdateDeviceInfoStorage 369 * @tc.type: FUNC 370 */ 371 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, UpdateDeviceInfoStorageTest_001, TestSize.Level3) 372 { 373 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest UpdateDeviceInfoStorageTest_001 start" << std::endl; 374 EXPECT_EQ(DtbschedmgrDeviceInfoStorage::GetInstance().UpdateDeviceInfoStorage(), true); 375 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest UpdateDeviceInfoStorageTest_001 end" << std::endl; 376 } 377 378 /** 379 * @tc.name: GetLocalDeviceUdidTest_001 380 * @tc.desc: test GetLocalDeviceUdid 381 * @tc.type: FUNC 382 */ 383 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetLocalDeviceUdidTest_001, TestSize.Level3) 384 { 385 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetLocalDeviceUdidTest_001 start" << std::endl; 386 std::string udid = ""; 387 DtbschedmgrDeviceInfoStorage::GetInstance().GetLocalUdid(udid); 388 EXPECT_EQ(udid.empty(), true); 389 DistributedSchedUtil::MockPermission(); 390 DtbschedmgrDeviceInfoStorage::GetInstance().GetLocalUdid(udid); 391 EXPECT_EQ(!udid.empty(), true); 392 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetLocalDeviceUdidTest_001 end" << std::endl; 393 } 394 395 /** 396 * @tc.name: GetLocalDeviceUuidTest_001 397 * @tc.desc: test GetLocalDeviceUuid 398 * @tc.type: FUNC 399 */ 400 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetLocalDeviceUuidTest_001, TestSize.Level3) 401 { 402 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetLocalDeviceUuidTest_001 start" << std::endl; 403 std::string uuid = ""; 404 DtbschedmgrDeviceInfoStorage::GetInstance().GetLocalUuid(uuid); 405 EXPECT_EQ(uuid.empty(), false); 406 DistributedSchedUtil::MockPermission(); 407 DtbschedmgrDeviceInfoStorage::GetInstance().GetLocalUuid(uuid); 408 EXPECT_EQ(!uuid.empty(), true); 409 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetLocalDeviceUuidTest_001 end" << std::endl; 410 } 411 412 /** 413 * @tc.name: GetDeviceName_001 414 * @tc.desc: test GetDeviceName 415 * @tc.type: FUNC 416 */ 417 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetDeviceName_001, TestSize.Level3) 418 { 419 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceName_001 start" << std::endl; 420 std::string netWorkId = "netWorkId"; 421 std::shared_ptr<DmsDeviceInfo> deviceInfo = std::make_shared<DmsDeviceInfo>("deviceName", 0, "netWorkId"); 422 DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_[netWorkId] = deviceInfo; 423 std::string ret = DtbschedmgrDeviceInfoStorage::GetInstance().GetDeviceName(netWorkId); 424 EXPECT_NE(ret, ""); 425 426 DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_.clear(); 427 std::shared_ptr<DmsDeviceInfo> deviceInfo1 = std::make_shared<DmsDeviceInfo>("deviceName", 0, "netWorkId1"); 428 DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_[netWorkId] = deviceInfo1; 429 ret = DtbschedmgrDeviceInfoStorage::GetInstance().GetDeviceName(netWorkId); 430 EXPECT_EQ(ret, ""); 431 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceName_001 end" << std::endl; 432 } 433 434 /** 435 * @tc.name: GetNetworkIdList_001 436 * @tc.desc: test GetNetworkIdList 437 * @tc.type: FUNC 438 */ 439 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetNetworkIdList_001, TestSize.Level3) 440 { 441 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetNetworkIdList_001 start" << std::endl; 442 DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_.clear(); 443 std::vector<std::string> devices; 444 std::string netWorkId = "netWorkId"; 445 devices = DtbschedmgrDeviceInfoStorage::GetInstance().GetNetworkIdList(); 446 EXPECT_EQ(devices.empty(), true); 447 448 std::shared_ptr<DmsDeviceInfo> deviceInfo = std::make_shared<DmsDeviceInfo>("deviceName", 0, "netWorkId"); 449 DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_[netWorkId] = deviceInfo; 450 devices = DtbschedmgrDeviceInfoStorage::GetInstance().GetNetworkIdList(); 451 EXPECT_EQ(devices.empty(), false); 452 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetNetworkIdList_001 end" << std::endl; 453 } 454 } // namespace DistributedSchedule 455 } // namespace OHOS 456