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