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