1 /*
2 * Copyright (c) 2022-2023 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_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 std::shared_ptr<DnetworkAdapter> dnetworkAdapter = DnetworkAdapter::GetInstance();
121 DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_ = nullptr;
122 /**
123 * @tc.steps: step1. test InitNetworkIdManager when networkIdMgrHandler_ is nullptr;
124 */
125 bool result = DtbschedmgrDeviceInfoStorage::GetInstance().InitNetworkIdManager(dnetworkAdapter);
126 EXPECT_TRUE(result);
127
128 /**
129 * @tc.steps: step2. test InitNetworkIdManager when networkIdMgrHandler_ is not nullptr;
130 */
131 result = DtbschedmgrDeviceInfoStorage::GetInstance().InitNetworkIdManager(dnetworkAdapter);
132 EXPECT_TRUE(result);
133 /**
134 * @tc.steps: step3. test Stop when deviceNodeListener_ is nullptr;
135 */
136 DtbschedmgrDeviceInfoStorage::GetInstance().deviceNodeListener_ = nullptr;
137 DtbschedmgrDeviceInfoStorage::GetInstance().Stop();
138 /**
139 * @tc.steps: step4. test Stop when deviceNodeListener_ is not nullptr;
140 */
141 DtbschedmgrDeviceInfoStorage::GetInstance().deviceNodeListener_ = std::make_shared<DistributedDeviceNodeListener>();
142 DtbschedmgrDeviceInfoStorage::GetInstance().Stop();
143 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest InitNetworkIdManagerTest_001 end" << std::endl;
144 }
145
146 /**
147 * @tc.name: WaitForDnetworkReadyTest_001
148 * @tc.desc: test WaitForDnetworkReady
149 * @tc.type: FUNC
150 */
151 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, WaitForDnetworkReadyTest_001, TestSize.Level3)
152 {
153 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest WaitForDnetworkReadyTest_001 start" << std::endl;
154 /**
155 * @tc.steps: step1. test WaitForDnetworkReady;
156 */
157 bool result = DtbschedmgrDeviceInfoStorage::GetInstance().WaitForDnetworkReady();
158 EXPECT_TRUE(result);
159 /**
160 * @tc.steps: step2. test RegisterUuidNetworkIdMap;
161 */
162 std::string networkId = "";
163 DtbschedmgrDeviceInfoStorage::GetInstance().RegisterUuidNetworkIdMap(networkId);
164 /**
165 * @tc.steps: step3. test UnregisterUuidNetworkIdMap;
166 */
167 DtbschedmgrDeviceInfoStorage::GetInstance().UnregisterUuidNetworkIdMap(networkId);
168 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest WaitForDnetworkReadyTest_001 end" << std::endl;
169 }
170
171 /**
172 * @tc.name: GetDeviceIdSetTest_001
173 * @tc.desc: test GetDeviceIdSet
174 * @tc.type: FUNC
175 */
176 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetDeviceIdSetTest_001, TestSize.Level3)
177 {
178 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceIdSetTest_001 start" << std::endl;
179 /**
180 * @tc.steps: step1. test GetDeviceIdSet;
181 */
182 set<std::string> deviceIdSet;
183 DtbschedmgrDeviceInfoStorage::GetInstance().GetDeviceIdSet(deviceIdSet);
184 EXPECT_TRUE(deviceIdSet.empty());
185 /**
186 * @tc.steps: step2. test GetDeviceIdSet when remoteDevices_ is not empty;
187 */
188 std::string networkId = "invalid networkId for DeviceOnlineNotify";
189 std::string deviceName = "invalid deviceName for DeviceOnlineNotify";
190 int32_t deviceType = 0;
191 std::shared_ptr<DmsDeviceInfo> devInfo = make_shared<DmsDeviceInfo>(deviceName, deviceType, networkId);
192 DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_[networkId] = devInfo;
193 DtbschedmgrDeviceInfoStorage::GetInstance().GetDeviceIdSet(deviceIdSet);
194 EXPECT_FALSE(deviceIdSet.empty());
195 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceIdSetTest_001 end" << std::endl;
196 }
197
198 /**
199 * @tc.name: GetLocalDeviceFromDnetTest_001
200 * @tc.desc: test GetLocalDeviceFromDnet
201 * @tc.type: FUNC
202 */
203 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetLocalDeviceFromDnetTest_001, TestSize.Level3)
204 {
205 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetLocalDeviceFromDnetTest_001 start" << std::endl;
206 std::string deviceId;
207 /**
208 * @tc.steps: step1. test GetLocalDeviceFromDnet;
209 */
210 bool result = DtbschedmgrDeviceInfoStorage::GetInstance().GetLocalDeviceId(deviceId);
211 EXPECT_TRUE(result);
212 /**
213 * @tc.steps: step2. test DeviceOnlineNotify when devInfo is nullptr;
214 */
215 std::shared_ptr<DmsDeviceInfo> devInfo = nullptr;
216 DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOnlineNotify(devInfo);
217 /**
218 * @tc.steps: step3. test DeviceOnlineNotify when networkIdMgrHandler_ is nullptr;
219 */
220 std::string networkId = "invalid networkId for DeviceOnlineNotify";
221 std::string deviceName = "invalid deviceName for DeviceOnlineNotify";
222 int32_t deviceType = 0;
223 devInfo = make_shared<DmsDeviceInfo>(deviceName, deviceType, networkId);
224 DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_ = nullptr;
225 DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOnlineNotify(devInfo);
226 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetLocalDeviceFromDnetTest_001 end" << std::endl;
227 }
228
229 /**
230 * @tc.name: ClearAllDevicesTest_001
231 * @tc.desc: test ClearAllDevices
232 * @tc.type: FUNC
233 */
234 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, ClearAllDevicesTest_001, TestSize.Level3)
235 {
236 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest ClearAllDevicesTest_001 start" << std::endl;
237 /**
238 * @tc.steps: step1. test ClearAllDevices;
239 */
240 DtbschedmgrDeviceInfoStorage::GetInstance().ClearAllDevices();
241 {
242 lock_guard<mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().deviceLock_);
243 EXPECT_TRUE(DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_.empty());
244 }
245 /**
246 * @tc.steps: step2. test DeviceOfflineNotify when deviceId is empty;
247 */
248 std::string deviceId;
249 DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOfflineNotify(deviceId);
250 /**
251 * @tc.steps: step3. test DeviceOfflineNotify when networkIdMgrHandler_ is nullptr;
252 */
253 deviceId = "invalid deviceId for DeviceOnlineNotify";
254 DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_ = nullptr;
255 DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOfflineNotify(deviceId);
256 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest ClearAllDevicesTest_001 end" << std::endl;
257 }
258
259 /**
260 * @tc.name: GetDeviceInfoByIdTest_001
261 * @tc.desc: test GetDeviceInfoById
262 * @tc.type: FUNC
263 */
264 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetDeviceInfoByIdTest_001, TestSize.Level3)
265 {
266 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceInfoByIdTest_001 start" << std::endl;
267 /**
268 * @tc.steps: step1. test GetDeviceInfoById when networkId is not in map;
269 */
270 std::string networkId = "invalid networkId for GetDeviceInfoById";
271 {
272 lock_guard<mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().deviceLock_);
273 DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_.clear();
274 }
275 std::shared_ptr<DmsDeviceInfo> dmsDeviceInfo =
276 DtbschedmgrDeviceInfoStorage::GetInstance().GetDeviceInfoById(networkId);
277 EXPECT_EQ(dmsDeviceInfo, nullptr);
278 /**
279 * @tc.steps: step2. test GetDeviceInfoById when networkId is in map;
280 */
281 {
282 lock_guard<mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().deviceLock_);
283 std::string deviceName = "invalid deviceName for GetDeviceInfoById";
284 int32_t deviceType = 0;
285 DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_[networkId] =
286 make_shared<DmsDeviceInfo>(deviceName, deviceType, networkId);
287 }
288 dmsDeviceInfo = DtbschedmgrDeviceInfoStorage::GetInstance().GetDeviceInfoById(networkId);
289 EXPECT_NE(dmsDeviceInfo, nullptr);
290 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceInfoByIdTest_001 end" << std::endl;
291 }
292
293 /**
294 * @tc.name: GetUuidByNetworkIdTest_001
295 * @tc.desc: test GetUuidByNetworkId
296 * @tc.type: FUNC
297 */
298 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetUuidByNetworkIdTest_001, TestSize.Level3)
299 {
300 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetUuidByNetworkIdTest_001 start" << std::endl;
301 /**
302 * @tc.steps: step1. test GetUuidByNetworkId when networkId is empty;
303 */
304 std::string networkId;
305 std::string result = DtbschedmgrDeviceInfoStorage::GetInstance().GetUuidByNetworkId(networkId);
306 EXPECT_TRUE(result.empty());
307 /**
308 * @tc.steps: step2. test GetUuidByNetworkId when networkId is not in map;
309 */
310 networkId = "invalid networkId for GetUuidByNetworkId";
311 result = DtbschedmgrDeviceInfoStorage::GetInstance().GetUuidByNetworkId(networkId);
312 EXPECT_TRUE(result.empty());
313 /**
314 * @tc.steps: step3. test GetUuidByNetworkId when networkId is in map;
315 */
316 std::string uuid = "invalid uuid for GetUuidByNetworkId";
317 {
318 lock_guard<mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().uuidNetworkIdLock_);
319 DtbschedmgrDeviceInfoStorage::GetInstance().uuidNetworkIdMap_[uuid] = networkId;
320 }
321 result = DtbschedmgrDeviceInfoStorage::GetInstance().GetUuidByNetworkId(networkId);
322 EXPECT_EQ(result, uuid);
323 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetUuidByNetworkIdTest_001 end" << std::endl;
324 }
325
326 /**
327 * @tc.name: GetNetworkIdByUuidTest_001
328 * @tc.desc: test GetNetworkIdByUuid
329 * @tc.type: FUNC
330 */
331 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetNetworkIdByUuidTest_001, TestSize.Level3)
332 {
333 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetNetworkIdByUuidTest_001 start" << std::endl;
334 /**
335 * @tc.steps: step1. test GetNetworkIdByUuid when uuid is null;
336 */
337 std::string uuid;
338 std::string result = DtbschedmgrDeviceInfoStorage::GetInstance().GetNetworkIdByUuid(uuid);
339 EXPECT_TRUE(result.empty());
340 /**
341 * @tc.steps: step2. test GetNetworkIdByUuid when uuid is invalid;
342 */
343 uuid = "invalid uuid for GetNetworkIdByUuid";
344 result = DtbschedmgrDeviceInfoStorage::GetInstance().GetNetworkIdByUuid(uuid);
345 EXPECT_TRUE(result.empty());
346 /**
347 * @tc.steps: step3. test GetNetworkIdByUuid;
348 */
349 std::string networkId = "invalid networkId for GetNetworkIdByUuid";
350 {
351 std::lock_guard<std::mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().uuidNetworkIdLock_);
352 DtbschedmgrDeviceInfoStorage::GetInstance().uuidNetworkIdMap_[uuid] = networkId;
353 }
354 result = DtbschedmgrDeviceInfoStorage::GetInstance().GetNetworkIdByUuid(uuid);
355 EXPECT_EQ(result, networkId);
356 /**
357 * @tc.steps: step4. test OnDeviceInfoChanged;
358 */
359 std::string deviceId = "invalid deviceId for OnDeviceInfoChanged";
360 DtbschedmgrDeviceInfoStorage::GetInstance().OnDeviceInfoChanged(deviceId);
361
362 /**
363 * @tc.steps: step5. test OnRemoteDied;
364 */
365 wptr<IRemoteObject> remote = nullptr;
366 sptr<DnetServiceDeathRecipient> dnetServiceDeathRecipient = new DnetServiceDeathRecipient();
367 dnetServiceDeathRecipient->OnRemoteDied(remote);
368 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetNetworkIdByUuidTest_001 end" << std::endl;
369 }
370
371 /**
372 * @tc.name: UpdateDeviceInfoStorageTest_001
373 * @tc.desc: test UpdateDeviceInfoStorage
374 * @tc.type: FUNC
375 */
376 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, UpdateDeviceInfoStorageTest_001, TestSize.Level3)
377 {
378 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest UpdateDeviceInfoStorageTest_001 start" << std::endl;
379 std::vector<DistributedHardware::DmDeviceInfo> dmDeviceInfoList;
380 dmDeviceInfoList.clear();
381 DtbschedmgrDeviceInfoStorage::GetInstance().UpdateDeviceInfoStorage(dmDeviceInfoList);
382 EXPECT_EQ(dmDeviceInfoList.empty(), true);
383 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest UpdateDeviceInfoStorageTest_001 end" << std::endl;
384 }
385
386 /**
387 * @tc.name: UpdateDeviceInfoStorageTest_002
388 * @tc.desc: test UpdateDeviceInfoStorage
389 * @tc.type: FUNC
390 */
391 HWTEST_F(DtbschedmgrDeviceInfoStorageTest, UpdateDeviceInfoStorageTest_002, TestSize.Level3)
392 {
393 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest UpdateDeviceInfoStorageTest_002 start" << std::endl;
394 std::vector<DistributedHardware::DmDeviceInfo> dmDeviceInfoList;
395 DistributedHardware::DmDeviceInfo dmDeviceInfo;
396 dmDeviceInfoList.emplace_back(dmDeviceInfo);
397 DtbschedmgrDeviceInfoStorage::GetInstance().UpdateDeviceInfoStorage(dmDeviceInfoList);
398 EXPECT_EQ(!dmDeviceInfoList.empty(), true);
399 DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest UpdateDeviceInfoStorageTest_002 end" << std::endl;
400 }
401 } // namespace DistributedSchedule
402 } // namespace OHOS
403