1 /*
2 * Copyright (c) 2021-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 "gtest/gtest.h"
17
18 #include <condition_variable>
19 #include <shared_mutex>
20 #include <thread>
21 #define private public
22 #include "adapter/dnetwork_adapter.h"
23 #undef private
24 #include "distributed_sched_test_util.h"
25 #include "dtbschedmgr_device_info_storage.h"
26
27 using namespace std;
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace {
32 const std::string NETWORKID = "1234567";
33 constexpr int32_t SLEEP_TIME = 2000;
34 constexpr int32_t MAX_WAIT_TIME = 10000;
35 }
36
37 namespace OHOS {
38 namespace DistributedSchedule {
39 class MockDeviceListener : public DeviceListener {
40 public:
41 MockDeviceListener() = default;
42 ~MockDeviceListener() = default;
43
OnDeviceOnline(const DistributedHardware::DmDeviceInfo & deviceInfo)44 void OnDeviceOnline(const DistributedHardware::DmDeviceInfo& deviceInfo) override {}
OnDeviceOffline(const DistributedHardware::DmDeviceInfo & deviceInfo)45 void OnDeviceOffline(const DistributedHardware::DmDeviceInfo& deviceInfo) override {}
OnDeviceInfoChanged(const DistributedHardware::DmDeviceInfo & deviceInfo)46 void OnDeviceInfoChanged(const DistributedHardware::DmDeviceInfo& deviceInfo) override {}
47 };
48
49 class DMSNetworkAdapterTest : public testing::Test {
50 public:
51 static void SetUpTestCase();
52 static void TearDownTestCase();
53 void SetUp();
54 void TearDown();
55 static bool isCaseDone_;
56 static std::mutex caseDoneLock_;
57 static std::condition_variable caseDoneCondition_;
58 };
59
60 bool DMSNetworkAdapterTest::isCaseDone_ = false;
61 std::mutex DMSNetworkAdapterTest::caseDoneLock_;
62 std::condition_variable DMSNetworkAdapterTest::caseDoneCondition_;
63
SetUpTestCase()64 void DMSNetworkAdapterTest::SetUpTestCase()
65 {
66 }
67
TearDownTestCase()68 void DMSNetworkAdapterTest::TearDownTestCase()
69 {
70 // Wait until all asyn tasks are completed before exiting the test suite
71 auto caseDoneNotifyTask = []() {
72 std::lock_guard<std::mutex> autoLock(caseDoneLock_);
73 isCaseDone_ = true;
74 caseDoneCondition_.notify_all();
75 };
76 if (DnetworkAdapter::GetInstance()->dnetworkHandler_ != nullptr) {
77 DnetworkAdapter::GetInstance()->dnetworkHandler_->PostTask(caseDoneNotifyTask);
78 }
79
80 std::unique_lock<std::mutex> lock(caseDoneLock_);
81 caseDoneCondition_.wait_for(lock, std::chrono::milliseconds(MAX_WAIT_TIME),
82 [&] () { return isCaseDone_; });
83 }
84
SetUp()85 void DMSNetworkAdapterTest::SetUp()
86 {
87 }
88
TearDown()89 void DMSNetworkAdapterTest::TearDown()
90 {
91 }
92
93 /**
94 * @tc.name: testGetUdidByNetworkId001
95 * @tc.desc: testGetUdidByNetworkId empty
96 * @tc.type: FUNC
97 */
98 HWTEST_F(DMSNetworkAdapterTest, testGetUdidByNetworkId001, TestSize.Level3)
99 {
100 std::string res = DnetworkAdapter::GetInstance()->GetUdidByNetworkId("");
101 EXPECT_EQ(res, "");
102 }
103
104 /**
105 * @tc.name: testGetUdidByNetworkId002
106 * @tc.desc: testGetUdidByNetworkId not empty
107 * @tc.type: FUNC
108 */
109 HWTEST_F(DMSNetworkAdapterTest, testGetUdidByNetworkId002, TestSize.Level3)
110 {
111 std::string res = DnetworkAdapter::GetInstance()->GetUdidByNetworkId(NETWORKID);
112 EXPECT_EQ(res, "");
113 }
114
115 /**
116 * @tc.name: testGetUuidByNetworkId001
117 * @tc.desc: testGetUuidByNetworkId empty
118 * @tc.type: FUNC
119 */
120 HWTEST_F(DMSNetworkAdapterTest, testGetUuidByNetworkId001, TestSize.Level3)
121 {
122 std::string res = DnetworkAdapter::GetInstance()->GetUuidByNetworkId("");
123 EXPECT_EQ(res, "");
124 }
125
126 /**
127 * @tc.name: testGetUuidByNetworkId001
128 * @tc.desc: testGetUuidByNetworkId not empty
129 * @tc.type: FUNC
130 */
131 HWTEST_F(DMSNetworkAdapterTest, testGetUuidByNetworkId002, TestSize.Level3)
132 {
133 std::string res = DnetworkAdapter::GetInstance()->GetUuidByNetworkId(NETWORKID);
134 EXPECT_EQ(res, "");
135 }
136
137 /**
138 * @tc.name: Init
139 * @tc.desc: testInit
140 * @tc.type: FUNC
141 */
142 HWTEST_F(DMSNetworkAdapterTest, testInit001, TestSize.Level3)
143 {
144 DnetworkAdapter::GetInstance()->Init();
145 bool res = DtbschedmgrDeviceInfoStorage::GetInstance().Init();
146 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
147 EXPECT_EQ(res, true);
148 }
149
150 /**
151 * @tc.name: testGetUdidByNetworkId003
152 * @tc.desc: testGetUdidByNetworkId not empty with init
153 * @tc.type: FUNC
154 */
155 HWTEST_F(DMSNetworkAdapterTest, testGetUdidByNetworkId003, TestSize.Level3)
156 {
157 std::string res = DnetworkAdapter::GetInstance()->GetUdidByNetworkId(NETWORKID);
158 EXPECT_EQ(res, "");
159 }
160
161 /**
162 * @tc.name: testGetUuidByNetworkId003
163 * @tc.desc: testGetUuidByNetworkId not empty with init
164 * @tc.type: FUNC
165 */
166 HWTEST_F(DMSNetworkAdapterTest, testGetUuidByNetworkId003, TestSize.Level3)
167 {
168 std::string res = DnetworkAdapter::GetInstance()->GetUuidByNetworkId(NETWORKID);
169 EXPECT_EQ(res, "");
170 }
171
172 /**
173 * @tc.name: OnDeviceOnline_001
174 * @tc.desc: listenerSet_ is empty
175 * @tc.type: FUNC
176 * @tc.require: I5WKCK
177 */
178 HWTEST_F(DMSNetworkAdapterTest, OnDeviceOnline_001, TestSize.Level3)
179 {
180 DistributedHardware::DmDeviceInfo deviceInfo;
181 DnetworkAdapter::listenerSet_.clear();
182 DnetworkAdapter::GetInstance()->stateCallback_->OnDeviceOnline(deviceInfo);
183 EXPECT_EQ(DnetworkAdapter::listenerSet_.size(), 0);
184 }
185
186 /**
187 * @tc.name: OnDeviceOnline_002
188 * @tc.desc: listenerSet_ is not empty
189 * @tc.type: FUNC
190 * @tc.require: I5WKCK
191 */
192 HWTEST_F(DMSNetworkAdapterTest, OnDeviceOnline_002, TestSize.Level3)
193 {
194 DistributedHardware::DmDeviceInfo deviceInfo;
195 DnetworkAdapter::listenerSet_.clear();
196 std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
197 DnetworkAdapter::listenerSet_.insert(deviceNodeListener);
198 DnetworkAdapter::GetInstance()->stateCallback_->OnDeviceOnline(deviceInfo);
199 EXPECT_EQ(DnetworkAdapter::listenerSet_.size(), 1);
200 }
201
202 /**
203 * @tc.name: OnDeviceOffline_001
204 * @tc.desc: listenerSet_ is empty
205 * @tc.type: FUNC
206 * @tc.require: I5WKCK
207 */
208 HWTEST_F(DMSNetworkAdapterTest, OnDeviceOffline_001, TestSize.Level3)
209 {
210 DistributedHardware::DmDeviceInfo deviceInfo;
211 DnetworkAdapter::listenerSet_.clear();
212 DnetworkAdapter::GetInstance()->stateCallback_->OnDeviceOffline(deviceInfo);
213 EXPECT_EQ(DnetworkAdapter::listenerSet_.size(), 0);
214 }
215
216 /**
217 * @tc.name: OnDeviceOffline_002
218 * @tc.desc: listenerSet_ is not empty
219 * @tc.type: FUNC
220 * @tc.require: I5WKCK
221 */
222 HWTEST_F(DMSNetworkAdapterTest, OnDeviceOffline_002, TestSize.Level3)
223 {
224 DistributedHardware::DmDeviceInfo deviceInfo;
225 DnetworkAdapter::listenerSet_.clear();
226 std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
227 DnetworkAdapter::listenerSet_.insert(deviceNodeListener);
228 DnetworkAdapter::GetInstance()->stateCallback_->OnDeviceOffline(deviceInfo);
229 EXPECT_EQ(DnetworkAdapter::listenerSet_.size(), 1);
230 }
231
232 /**
233 * @tc.name: AddDeviceChangeListener_001
234 * @tc.desc: dnetworkHandler_ is nullptr
235 * @tc.type: FUNC
236 * @tc.require: I5WKCK
237 */
238 HWTEST_F(DMSNetworkAdapterTest, AddDeviceChangeListener_001, TestSize.Level3)
239 {
240 DnetworkAdapter::GetInstance()->dnetworkHandler_ = nullptr;
241 std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
242 bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
243 DnetworkAdapter::GetInstance()->Init();
244 EXPECT_EQ(res, false);
245 }
246
247 /**
248 * @tc.name: AddDeviceChangeListener_002
249 * @tc.desc: deviceNodeListener is not exist
250 * @tc.type: FUNC
251 * @tc.require: I5WKCK
252 */
253 HWTEST_F(DMSNetworkAdapterTest, AddDeviceChangeListener_002, TestSize.Level3)
254 {
255 DnetworkAdapter::listenerSet_.clear();
256 std::shared_ptr<DeviceListener> oldDeviceNodeListener = std::make_shared<MockDeviceListener>();
257 DnetworkAdapter::listenerSet_.insert(oldDeviceNodeListener);
258 std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
259 bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
260 EXPECT_EQ(res, true);
261 }
262
263 /**
264 * @tc.name: AddDeviceChangeListener_003
265 * @tc.desc: deviceNodeListener is not exist
266 * @tc.type: FUNC
267 * @tc.require: I5WKCK
268 */
269 HWTEST_F(DMSNetworkAdapterTest, AddDeviceChangeListener_003, TestSize.Level3)
270 {
271 DnetworkAdapter::listenerSet_.clear();
272 std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
273 bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
274 EXPECT_EQ(res, true);
275 }
276
277 /**
278 * @tc.name: AddDeviceChangeListener_004
279 * @tc.desc: deviceNodeListener is exist
280 * @tc.type: FUNC
281 * @tc.require: I5WKCK
282 */
283 HWTEST_F(DMSNetworkAdapterTest, AddDeviceChangeListener_004, TestSize.Level3)
284 {
285 DnetworkAdapter::listenerSet_.clear();
286 std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
287 DnetworkAdapter::listenerSet_.insert(deviceNodeListener);
288 bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
289 EXPECT_EQ(res, true);
290 }
291
292 /**
293 * @tc.name: AddDeviceChangeListener_005
294 * @tc.desc: test AddDeviceChangeListener when initCallback_ is nullptr
295 * @tc.type: FUNC
296 * @tc.require: I621C1
297 */
298 HWTEST_F(DMSNetworkAdapterTest, AddDeviceChangeListener_005, TestSize.Level3)
299 {
300 std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
301 DnetworkAdapter::listenerSet_.clear();
302 DnetworkAdapter::listenerSet_.insert(deviceNodeListener);
303 DnetworkAdapter::GetInstance()->initCallback_ = nullptr;
304 bool ret = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
305 EXPECT_TRUE(ret);
306 DnetworkAdapter::GetInstance()->initCallback_ = std::make_shared<DnetworkAdapter::DeviceInitCallBack>();
307 }
308
309 /**
310 * @tc.name: AddDeviceChangeListener_006
311 * @tc.desc: test AddDeviceChangeListener when stateCallback_ is nullptr
312 * @tc.type: FUNC
313 * @tc.require: I621C1
314 */
315 HWTEST_F(DMSNetworkAdapterTest, AddDeviceChangeListener_006, TestSize.Level3)
316 {
317 DistributedHardware::DmDeviceInfo deviceInfo;
318 /**
319 * @tc.steps: step1. OnDeviceChanged
320 */
321 DnetworkAdapter::GetInstance()->stateCallback_->OnDeviceChanged(deviceInfo);
322 /**
323 * @tc.steps: step2. OnDeviceReady
324 */
325 DnetworkAdapter::GetInstance()->stateCallback_->OnDeviceReady(deviceInfo);
326 /**
327 * @tc.steps: step3. AddDeviceChangeListener when stateCallback_ is nullptr
328 */
329 std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
330 DnetworkAdapter::listenerSet_.clear();
331 DnetworkAdapter::listenerSet_.insert(deviceNodeListener);
332 DnetworkAdapter::GetInstance()->stateCallback_ = nullptr;
333 bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
334 EXPECT_EQ(res, true);
335 DnetworkAdapter::GetInstance()->stateCallback_ =
336 std::make_shared<DnetworkAdapter::DmsDeviceStateCallback>();
337 }
338
339 /**
340 * @tc.name: AddDeviceChangeListener_007
341 * @tc.desc: test OnDeviceChanged
342 * @tc.type: FUNC
343 * @tc.require: I621C1
344 */
345 HWTEST_F(DMSNetworkAdapterTest, AddDeviceChangeListener_007, TestSize.Level3)
346 {
347 DistributedHardware::DmDeviceInfo deviceInfo;
348 /**
349 * @tc.steps: step1. OnDeviceChanged
350 */
351 DnetworkAdapter::GetInstance()->stateCallback_->OnDeviceChanged(deviceInfo);
352 /**
353 * @tc.steps: step2. AddDeviceChangeListener
354 */
355 DnetworkAdapter::listenerSet_.clear();
356 std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
357 DnetworkAdapter::listenerSet_.insert(deviceNodeListener);
358 bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
359 EXPECT_EQ(res, true);
360 }
361
362 /**
363 * @tc.name: OnDeviceReady_001
364 * @tc.desc: test OnDeviceReady
365 * @tc.type: FUNC
366 * @tc.require: I621C1
367 */
368 HWTEST_F(DMSNetworkAdapterTest, OnDeviceReady_001, TestSize.Level3)
369 {
370 DistributedHardware::DmDeviceInfo deviceInfo;
371 /**
372 * @tc.steps: step1. OnDeviceReady
373 */
374 DnetworkAdapter::GetInstance()->stateCallback_->OnDeviceReady(deviceInfo);
375 /**
376 * @tc.steps: step2. AddDeviceChangeListener
377 */
378 DnetworkAdapter::listenerSet_.clear();
379 std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
380 DnetworkAdapter::listenerSet_.insert(deviceNodeListener);
381 bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
382 EXPECT_EQ(res, true);
383 }
384
385 /**
386 * @tc.name: RemoveDeviceChangeListener_001
387 * @tc.desc: listenerSet_ size is 0
388 * @tc.type: FUNC
389 * @tc.require: I5WKCK
390 */
391 HWTEST_F(DMSNetworkAdapterTest, RemoveDeviceChangeListener_001, TestSize.Level3)
392 {
393 DnetworkAdapter::listenerSet_.clear();
394 std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
395 DnetworkAdapter::GetInstance()->RemoveDeviceChangeListener(deviceNodeListener);
396 EXPECT_EQ(DnetworkAdapter::listenerSet_.size(), 0);
397 }
398
399 /**
400 * @tc.name: RemoveDeviceChangeListener_002
401 * @tc.desc: listenerSet_ size is 1
402 * @tc.type: FUNC
403 * @tc.require: I5WKCK
404 */
405 HWTEST_F(DMSNetworkAdapterTest, RemoveDeviceChangeListener_002, TestSize.Level3)
406 {
407 /**
408 * @tc.steps: step1. test RemoveDeviceChangeListener when listenerSet_ size is 1
409 */
410 DnetworkAdapter::listenerSet_.clear();
411 std::shared_ptr<DeviceListener> oldDeviceNodeListener = std::make_shared<MockDeviceListener>();
412 DnetworkAdapter::listenerSet_.insert(oldDeviceNodeListener);
413 std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
414 DnetworkAdapter::GetInstance()->RemoveDeviceChangeListener(deviceNodeListener);
415 EXPECT_EQ(DnetworkAdapter::listenerSet_.size(), 1);
416 /**
417 * @tc.steps: step2. OnRemoteDied
418 */
419 DnetworkAdapter::GetInstance()->initCallback_->OnRemoteDied();
420 }
421
422 /**
423 * @tc.name: UpdateDeviceInfoStorage_001
424 * @tc.desc: test UpdateDeviceInfoStorage
425 * @tc.type: FUNC
426 */
427 HWTEST_F(DMSNetworkAdapterTest, UpdateDeviceInfoStorage_001, TestSize.Level3)
428 {
429 DistributedSchedUtil::MockBundlePermission();
430 bool result = DnetworkAdapter::GetInstance()->UpdateDeviceInfoStorage();
431 EXPECT_EQ(result, true);
432 }
433 } // namespace DistributedSchedule
434 } // namespace OHOS