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::listenerSet_.clear();
241     std::shared_ptr<AppExecFwk::EventHandler> dnetworkHandler = DnetworkAdapter::GetInstance()->dnetworkHandler_;
242     DnetworkAdapter::GetInstance()->dnetworkHandler_ = nullptr;
243     std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
244     bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
245     DnetworkAdapter::GetInstance()->dnetworkHandler_ = dnetworkHandler;
246     EXPECT_EQ(res, false);
247 }
248 
249 /**
250  * @tc.name: AddDeviceChangeListener_002
251  * @tc.desc: deviceNodeListener is not exist
252  * @tc.type: FUNC
253  * @tc.require: I5WKCK
254  */
255 HWTEST_F(DMSNetworkAdapterTest, AddDeviceChangeListener_002, TestSize.Level3)
256 {
257     DnetworkAdapter::listenerSet_.clear();
258     std::shared_ptr<DeviceListener> oldDeviceNodeListener = std::make_shared<MockDeviceListener>();
259     DnetworkAdapter::listenerSet_.insert(oldDeviceNodeListener);
260     std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
261     bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
262     EXPECT_EQ(res, true);
263 }
264 
265 /**
266  * @tc.name: AddDeviceChangeListener_003
267  * @tc.desc: deviceNodeListener is not exist
268  * @tc.type: FUNC
269  * @tc.require: I5WKCK
270  */
271 HWTEST_F(DMSNetworkAdapterTest, AddDeviceChangeListener_003, TestSize.Level3)
272 {
273     DnetworkAdapter::listenerSet_.clear();
274     std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
275     bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
276     EXPECT_EQ(res, true);
277 }
278 
279 /**
280  * @tc.name: AddDeviceChangeListener_004
281  * @tc.desc: deviceNodeListener is exist
282  * @tc.type: FUNC
283  * @tc.require: I5WKCK
284  */
285 HWTEST_F(DMSNetworkAdapterTest, AddDeviceChangeListener_004, TestSize.Level3)
286 {
287     DnetworkAdapter::listenerSet_.clear();
288     std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
289     DnetworkAdapter::listenerSet_.insert(deviceNodeListener);
290     bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
291     EXPECT_EQ(res, true);
292 }
293 
294 /**
295  * @tc.name: AddDeviceChangeListener_005
296  * @tc.desc: test AddDeviceChangeListener when initCallback_ is nullptr
297  * @tc.type: FUNC
298  * @tc.require: I621C1
299  */
300 HWTEST_F(DMSNetworkAdapterTest, AddDeviceChangeListener_005, TestSize.Level3)
301 {
302     std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
303     DnetworkAdapter::listenerSet_.clear();
304     DnetworkAdapter::listenerSet_.insert(deviceNodeListener);
305     DnetworkAdapter::GetInstance()->initCallback_ = nullptr;
306     bool ret = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
307     EXPECT_TRUE(ret);
308     DnetworkAdapter::GetInstance()->initCallback_ = std::make_shared<DnetworkAdapter::DeviceInitCallBack>();
309 }
310 
311 /**
312  * @tc.name: AddDeviceChangeListener_006
313  * @tc.desc: test AddDeviceChangeListener when stateCallback_ is nullptr
314  * @tc.type: FUNC
315  * @tc.require: I621C1
316  */
317 HWTEST_F(DMSNetworkAdapterTest, AddDeviceChangeListener_006, TestSize.Level3)
318 {
319     DistributedHardware::DmDeviceInfo deviceInfo;
320     /**
321      * @tc.steps: step1. OnDeviceChanged
322      */
323     DnetworkAdapter::GetInstance()->stateCallback_->OnDeviceChanged(deviceInfo);
324     /**
325      * @tc.steps: step2. OnDeviceReady
326      */
327     DnetworkAdapter::GetInstance()->stateCallback_->OnDeviceReady(deviceInfo);
328     /**
329      * @tc.steps: step3. AddDeviceChangeListener when stateCallback_ is nullptr
330      */
331     std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
332     DnetworkAdapter::listenerSet_.clear();
333     DnetworkAdapter::listenerSet_.insert(deviceNodeListener);
334     DnetworkAdapter::GetInstance()->stateCallback_ = nullptr;
335     bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
336     EXPECT_EQ(res, true);
337     DnetworkAdapter::GetInstance()->stateCallback_ =
338         std::make_shared<DnetworkAdapter::DmsDeviceStateCallback>();
339 }
340 
341 /**
342  * @tc.name: AddDeviceChangeListener_007
343  * @tc.desc: test OnDeviceChanged
344  * @tc.type: FUNC
345  * @tc.require: I621C1
346  */
347 HWTEST_F(DMSNetworkAdapterTest, AddDeviceChangeListener_007, TestSize.Level3)
348 {
349     DistributedHardware::DmDeviceInfo deviceInfo;
350     /**
351      * @tc.steps: step1. OnDeviceChanged
352      */
353     DnetworkAdapter::GetInstance()->stateCallback_->OnDeviceChanged(deviceInfo);
354     /**
355      * @tc.steps: step2. AddDeviceChangeListener
356      */
357     DnetworkAdapter::listenerSet_.clear();
358     std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
359     DnetworkAdapter::listenerSet_.insert(deviceNodeListener);
360     bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
361     EXPECT_EQ(res, true);
362 }
363 
364 /**
365  * @tc.name: OnDeviceReady_001
366  * @tc.desc: test OnDeviceReady
367  * @tc.type: FUNC
368  * @tc.require: I621C1
369  */
370 HWTEST_F(DMSNetworkAdapterTest, OnDeviceReady_001, TestSize.Level3)
371 {
372     DistributedHardware::DmDeviceInfo deviceInfo;
373     /**
374      * @tc.steps: step1. OnDeviceReady
375      */
376     DnetworkAdapter::GetInstance()->stateCallback_->OnDeviceReady(deviceInfo);
377     /**
378      * @tc.steps: step2. AddDeviceChangeListener
379      */
380     DnetworkAdapter::listenerSet_.clear();
381     std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
382     DnetworkAdapter::listenerSet_.insert(deviceNodeListener);
383     bool res = DnetworkAdapter::GetInstance()->AddDeviceChangeListener(deviceNodeListener);
384     EXPECT_EQ(res, true);
385 }
386 
387 /**
388  * @tc.name: RemoveDeviceChangeListener_001
389  * @tc.desc: listenerSet_ size is 0
390  * @tc.type: FUNC
391  * @tc.require: I5WKCK
392  */
393 HWTEST_F(DMSNetworkAdapterTest, RemoveDeviceChangeListener_001, TestSize.Level3)
394 {
395     DnetworkAdapter::listenerSet_.clear();
396     std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
397     DnetworkAdapter::GetInstance()->RemoveDeviceChangeListener(deviceNodeListener);
398     EXPECT_EQ(DnetworkAdapter::listenerSet_.size(), 0);
399 }
400 
401 /**
402  * @tc.name: RemoveDeviceChangeListener_002
403  * @tc.desc: listenerSet_ size is 1
404  * @tc.type: FUNC
405  * @tc.require: I5WKCK
406  */
407 HWTEST_F(DMSNetworkAdapterTest, RemoveDeviceChangeListener_002, TestSize.Level3)
408 {
409     /**
410      * @tc.steps: step1. test RemoveDeviceChangeListener when listenerSet_ size is 1
411      */
412     DnetworkAdapter::listenerSet_.clear();
413     std::shared_ptr<DeviceListener> oldDeviceNodeListener = std::make_shared<MockDeviceListener>();
414     DnetworkAdapter::listenerSet_.insert(oldDeviceNodeListener);
415     std::shared_ptr<DeviceListener> deviceNodeListener = std::make_shared<MockDeviceListener>();
416     DnetworkAdapter::GetInstance()->RemoveDeviceChangeListener(deviceNodeListener);
417     EXPECT_EQ(DnetworkAdapter::listenerSet_.size(), 1);
418     /**
419      * @tc.steps: step2. OnRemoteDied
420      */
421     DnetworkAdapter::GetInstance()->initCallback_->OnRemoteDied();
422 }
423 
424 /**
425  * @tc.name: UpdateDeviceInfoStorage_001
426  * @tc.desc: test UpdateDeviceInfoStorage
427  * @tc.type: FUNC
428  */
429 HWTEST_F(DMSNetworkAdapterTest, UpdateDeviceInfoStorage_001, TestSize.Level3)
430 {
431     DistributedSchedUtil::MockBundlePermission();
432     bool result = DnetworkAdapter::GetInstance()->UpdateDeviceInfoStorage();
433     EXPECT_EQ(result, true);
434 }
435 } // namespace DistributedSchedule
436 } // namespace OHOS