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 <algorithm>
17 #include <chrono>
18 #include <securec.h>
19 #include <thread>
20 #include <vector>
21
22 #include "gtest/gtest.h"
23
24 #define private public
25 #include "access_manager.h"
26 #undef private
27 #include "dm_device_info.h"
28 #include "distributed_hardware_errno.h"
29 #include "distributed_hardware_manager_factory.h"
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace DistributedHardware {
34 namespace {
35 enum class Status : uint32_t {
36 DEVICE_ONLINE = 0,
37 DEVICE_OFFLINE = 1,
38 };
39
40 constexpr int32_t INTERVAL_TIME_MS = 100;
41 constexpr uint16_t TEST_DEV_TYPE_PAD = 0x11;
42
43 /* save networkId and uuid */
44 const std::vector<std::pair<std::string, std::string>> TEST_DEVICES = {
45 { "11111111111111111111111111111111", "22222222222222222222222222222222" },
46 { "33333333333333333333333333333333", "44444444444444444444444444444444" },
47 { "55555555555555555555555555555555", "66666666666666666666666666666666" },
48 { "77777777777777777777777777777777", "88888888888888888888888888888888" },
49 };
50 }
51
52 class AccessManagerTest : public testing::Test {
53 public:
54 static void SetUpTestCase(void);
55 static void TearDownTestCase(void);
56 void SetUp();
57 void TearDown();
58 std::mutex testAccessMutex_;
59 };
60
SetUp()61 void AccessManagerTest::SetUp()
62 {
63 // at last one device online, ensure sa not exit
64 std::string networkId = "00000000000000000000000000000000";
65 std::string uuid = "99999999999999999999999999999999";
66 DistributedHardwareManagerFactory::GetInstance().SendOnLineEvent(networkId, uuid, TEST_DEV_TYPE_PAD);
67 }
68
TearDown()69 void AccessManagerTest::TearDown()
70 {
71 // clear all the online devices
72 for (const auto &dev : TEST_DEVICES) {
73 DistributedHardwareManagerFactory::GetInstance().SendOffLineEvent(dev.first, dev.second, TEST_DEV_TYPE_PAD);
74 }
75 }
76
SetUpTestCase()77 void AccessManagerTest::SetUpTestCase() {}
78
TearDownTestCase()79 void AccessManagerTest::TearDownTestCase() {}
80
81 /**
82 * @tc.name: SendOnLineEvent_001
83 * @tc.desc: Verify the online success
84 * @tc.type: FUNC
85 * @tc.require: AR000GHSJK
86 */
87 HWTEST_F(AccessManagerTest, SendOnLineEvent_001, TestSize.Level1)
88 {
89 ASSERT_TRUE(DistributedHardwareManagerFactory::GetInstance().IsInit());
90
91 for (const auto &dev : TEST_DEVICES) {
92 auto ret =
93 DistributedHardwareManagerFactory::GetInstance().SendOnLineEvent(dev.first, dev.second, TEST_DEV_TYPE_PAD);
94 ASSERT_EQ(DH_FWK_SUCCESS, ret);
95 ASSERT_TRUE(DistributedHardwareManagerFactory::GetInstance().IsInit());
96 }
97 }
98
99 /**
100 * @tc.name: SendOnLineEvent_002
101 * @tc.desc: Verify the online failed
102 * @tc.type: FUNC
103 * @tc.require: AR000GHSJK
104 */
105 HWTEST_F(AccessManagerTest, SendOnLineEvent_002, TestSize.Level1)
106 {
107 ASSERT_TRUE(DistributedHardwareManagerFactory::GetInstance().IsInit());
108
109 auto ret =
110 DistributedHardwareManagerFactory::GetInstance().SendOnLineEvent("", TEST_DEVICES[0].second, TEST_DEV_TYPE_PAD);
111 ASSERT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
112 ASSERT_TRUE(DistributedHardwareManagerFactory::GetInstance().IsInit());
113
114 ret =
115 DistributedHardwareManagerFactory::GetInstance().SendOnLineEvent(TEST_DEVICES[0].first, "", TEST_DEV_TYPE_PAD);
116 ASSERT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
117 ASSERT_TRUE(DistributedHardwareManagerFactory::GetInstance().IsInit());
118 }
119
120 /**
121 * @tc.name: SendOffLineEvent_001
122 * @tc.desc: Verify the offline success
123 * @tc.type: FUNC
124 * @tc.require: AR000GHSJM
125 */
126 HWTEST_F(AccessManagerTest, SendOffLineEvent_001, TestSize.Level1)
127 {
128 ASSERT_TRUE(DistributedHardwareManagerFactory::GetInstance().IsInit());
129
130 for (const auto &dev : TEST_DEVICES) {
131 auto ret =
132 DistributedHardwareManagerFactory::GetInstance().SendOnLineEvent(dev.first, dev.second, TEST_DEV_TYPE_PAD);
133 ASSERT_EQ(DH_FWK_SUCCESS, ret);
134 ASSERT_TRUE(DistributedHardwareManagerFactory::GetInstance().IsInit());
135 }
136
137 for (const auto &dev : TEST_DEVICES) {
138 auto ret =
139 DistributedHardwareManagerFactory::GetInstance().SendOffLineEvent(dev.first, dev.second, TEST_DEV_TYPE_PAD);
140 ASSERT_EQ(DH_FWK_SUCCESS, ret);
141 }
142 ASSERT_TRUE(DistributedHardwareManagerFactory::GetInstance().IsInit());
143 }
144
145 /**
146 * @tc.name: SendOffLineEvent_002
147 * @tc.desc: Verify the offline failed
148 * @tc.type: FUNC
149 * @tc.require: AR000GHSJM
150 */
151 HWTEST_F(AccessManagerTest, SendOffLineEvent_002, TestSize.Level1)
152 {
153 ASSERT_TRUE(DistributedHardwareManagerFactory::GetInstance().IsInit());
154
155 auto ret = DistributedHardwareManagerFactory::GetInstance().SendOffLineEvent("", TEST_DEVICES[0].second,
156 TEST_DEV_TYPE_PAD);
157 ASSERT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
158 ASSERT_TRUE(DistributedHardwareManagerFactory::GetInstance().IsInit());
159
160 ret =
161 DistributedHardwareManagerFactory::GetInstance().SendOffLineEvent(TEST_DEVICES[0].first, "", TEST_DEV_TYPE_PAD);
162 ASSERT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
163 ASSERT_TRUE(DistributedHardwareManagerFactory::GetInstance().IsInit());
164 }
165
166 /**
167 * @tc.name: SendOffLineEvent_003
168 * @tc.desc: Verify the SendOnLineEvent for Multi-thread
169 * @tc.type: FUNC
170 * @tc.require: AR000GHSJM
171 */
172 HWTEST_F(AccessManagerTest, SendOffLineEvent_003, TestSize.Level0)
173 {
__anon9dcc684f0202(Status status, std::string networkId, std::string uuid, int32_t expect) 174 auto handler = [this](Status status, std::string networkId, std::string uuid, int32_t expect) {
175 if (status == Status::DEVICE_ONLINE) {
176 std::lock_guard<std::mutex> lock(testAccessMutex_);
177 std::this_thread::sleep_for(std::chrono::milliseconds(100));
178 auto onlineResult =
179 DistributedHardwareManagerFactory::GetInstance().SendOnLineEvent(networkId, uuid, TEST_DEV_TYPE_PAD);
180 EXPECT_EQ(expect, onlineResult);
181 } else {
182 std::lock_guard<std::mutex> lock(testAccessMutex_);
183 std::this_thread::sleep_for(std::chrono::milliseconds(90));
184 auto offlineResult =
185 DistributedHardwareManagerFactory::GetInstance().SendOffLineEvent(networkId, uuid, TEST_DEV_TYPE_PAD);
186 EXPECT_EQ(expect, offlineResult);
187 }
188 };
189
190 std::vector<std::thread> threadVec;
191 threadVec.emplace_back(
192 std::thread(handler, Status::DEVICE_ONLINE, TEST_DEVICES[0].first, TEST_DEVICES[0].second, DH_FWK_SUCCESS));
193 std::this_thread::sleep_for(std::chrono::milliseconds(INTERVAL_TIME_MS));
194
195 threadVec.emplace_back(
196 std::thread(handler, Status::DEVICE_ONLINE, TEST_DEVICES[1].first, TEST_DEVICES[1].second, DH_FWK_SUCCESS));
197 std::this_thread::sleep_for(std::chrono::milliseconds(INTERVAL_TIME_MS));
198
199 threadVec.emplace_back(std::thread(handler, Status::DEVICE_ONLINE, TEST_DEVICES[0].first, TEST_DEVICES[0].second,
200 ERR_DH_FWK_HARDWARE_MANAGER_DEVICE_REPEAT_ONLINE));
201 std::this_thread::sleep_for(std::chrono::milliseconds(INTERVAL_TIME_MS));
202
203 threadVec.emplace_back(
204 std::thread(handler, Status::DEVICE_ONLINE, TEST_DEVICES[2].first, TEST_DEVICES[2].second, DH_FWK_SUCCESS));
205 std::this_thread::sleep_for(std::chrono::milliseconds(INTERVAL_TIME_MS));
206
207 threadVec.emplace_back(
208 std::thread(handler, Status::DEVICE_ONLINE, TEST_DEVICES[3].first, TEST_DEVICES[3].second, DH_FWK_SUCCESS));
209 std::this_thread::sleep_for(std::chrono::milliseconds(INTERVAL_TIME_MS));
210
211 threadVec.emplace_back(
212 std::thread(handler, Status::DEVICE_OFFLINE, TEST_DEVICES[3].first, TEST_DEVICES[3].second, DH_FWK_SUCCESS));
213 std::this_thread::sleep_for(std::chrono::milliseconds(INTERVAL_TIME_MS));
214
215 threadVec.emplace_back(std::thread(handler, Status::DEVICE_OFFLINE, TEST_DEVICES[3].first, TEST_DEVICES[3].second,
216 ERR_DH_FWK_HARDWARE_MANAGER_DEVICE_REPEAT_OFFLINE));
217 std::this_thread::sleep_for(std::chrono::milliseconds(INTERVAL_TIME_MS));
218
219 threadVec.emplace_back(
220 std::thread(handler, Status::DEVICE_OFFLINE, TEST_DEVICES[1].first, TEST_DEVICES[1].second, DH_FWK_SUCCESS));
221 std::this_thread::sleep_for(std::chrono::milliseconds(INTERVAL_TIME_MS));
222
223 threadVec.emplace_back(
224 std::thread(handler, Status::DEVICE_OFFLINE, TEST_DEVICES[0].first, TEST_DEVICES[0].second, DH_FWK_SUCCESS));
225 std::this_thread::sleep_for(std::chrono::milliseconds(INTERVAL_TIME_MS));
226
227 threadVec.emplace_back(
228 std::thread(handler, Status::DEVICE_OFFLINE, TEST_DEVICES[2].first, TEST_DEVICES[2].second, DH_FWK_SUCCESS));
229
__anon9dcc684f0302(std::thread &t) 230 for_each(threadVec.begin(), threadVec.end(), [](std::thread &t) { t.join(); });
231 }
232
233 /**
234 * @tc.name: AccessManagerInit
235 * @tc.desc: Verify the Init function
236 * @tc.type: FUNC
237 * @tc.require: AR000GHSJM
238 */
239 HWTEST_F(AccessManagerTest, AccessManagerInit, TestSize.Level0)
240 {
241 EXPECT_EQ(DH_FWK_SUCCESS, AccessManager::GetInstance()->Init());
242 }
243
244 /**
245 * @tc.name: OnRemoteDied_001
246 * @tc.desc: Verify the OnRemoteDied function
247 * @tc.type: FUNC
248 * @tc.require: AR000GHSJM
249 */
250 HWTEST_F(AccessManagerTest, OnRemoteDied_001, TestSize.Level0)
251 {
252 AccessManager::GetInstance()->OnRemoteDied();
253 EXPECT_EQ(DH_FWK_SUCCESS, AccessManager::GetInstance()->Init());
254 }
255
256 /**
257 * @tc.name: OnDeviceOnline_001
258 * @tc.desc: Verify the OnDeviceOnline function
259 * @tc.type: FUNC
260 * @tc.require: AR000GHSJM
261 */
262 HWTEST_F(AccessManagerTest, OnDeviceOnline_001, TestSize.Level0)
263 {
264 DmDeviceInfo deviceInfo;
265 AccessManager::GetInstance()->OnDeviceOnline(deviceInfo);
266 EXPECT_EQ(DH_FWK_SUCCESS, AccessManager::GetInstance()->Init());
267 }
268
269 /**
270 * @tc.name: OnDeviceOffline_001
271 * @tc.desc: Verify the OnDeviceOffline function
272 * @tc.type: FUNC
273 * @tc.require: AR000GHSJM
274 */
275 HWTEST_F(AccessManagerTest, OnDeviceOffline_001, TestSize.Level0)
276 {
277 DmDeviceInfo deviceInfo;
278 AccessManager::GetInstance()->OnDeviceOffline(deviceInfo);
279 EXPECT_EQ(DH_FWK_SUCCESS, AccessManager::GetInstance()->Init());
280 }
281
282 /**
283 * @tc.name: OnDeviceOffline_002
284 * @tc.desc: Verify the OnDeviceOffline function
285 * @tc.type: FUNC
286 * @tc.require: AR000GHSJM
287 */
288 HWTEST_F(AccessManagerTest, OnDeviceOffline_002, TestSize.Level0)
289 {
290 DmDeviceInfo deviceInfo;
291 std::string devId = "000001";
292 int32_t ret = memcpy_s(deviceInfo.deviceId, DM_MAX_DEVICE_ID_LEN, devId.c_str(), devId.length());
293 if (ret != EOK) {
294 return;
295 }
296 AccessManager::GetInstance()->OnDeviceOffline(deviceInfo);
297 EXPECT_EQ(DH_FWK_SUCCESS, AccessManager::GetInstance()->Init());
298 }
299
300 /**
301 * @tc.name: OnDeviceOffline_003
302 * @tc.desc: Verify the OnDeviceOffline function
303 * @tc.type: FUNC
304 * @tc.require: AR000GHSJM
305 */
306 HWTEST_F(AccessManagerTest, OnDeviceOffline_003, TestSize.Level0)
307 {
308 DmDeviceInfo deviceInfo;
309 std::string devId = "000001";
310 int32_t ret = memcpy_s(deviceInfo.deviceId, DM_MAX_DEVICE_ID_LEN, devId.c_str(), devId.length());
311 if (ret != EOK) {
312 return;
313 }
314 std::string netId = "000002";
315 ret = memcpy_s(deviceInfo.networkId, DM_MAX_DEVICE_ID_LEN, netId.c_str(), netId.length());
316 if (ret != EOK) {
317 return;
318 }
319 AccessManager::GetInstance()->OnDeviceOffline(deviceInfo);
320 EXPECT_EQ(DH_FWK_SUCCESS, AccessManager::GetInstance()->Init());
321 }
322
323 /**
324 * @tc.name: OnDeviceReady_001
325 * @tc.desc: Verify the OnDeviceReady function
326 * @tc.type: FUNC
327 * @tc.require: AR000GHSJM
328 */
329 HWTEST_F(AccessManagerTest, OnDeviceReady_001, TestSize.Level0)
330 {
331 DmDeviceInfo deviceInfo;
332 AccessManager::GetInstance()->OnDeviceReady(deviceInfo);
333 EXPECT_EQ(DH_FWK_SUCCESS, AccessManager::GetInstance()->Init());
334 }
335
336 /**
337 * @tc.name: OnDeviceReady_002
338 * @tc.desc: Verify the OnDeviceReady function
339 * @tc.type: FUNC
340 * @tc.require: AR000GHSJM
341 */
342 HWTEST_F(AccessManagerTest, OnDeviceReady_002, TestSize.Level0)
343 {
344 DmDeviceInfo deviceInfo;
345 std::string devId = "000001";
346 int32_t ret = memcpy_s(deviceInfo.deviceId, DM_MAX_DEVICE_ID_LEN, devId.c_str(), devId.length());
347 if (ret != EOK) {
348 return;
349 }
350 AccessManager::GetInstance()->OnDeviceReady(deviceInfo);
351 EXPECT_EQ(DH_FWK_SUCCESS, AccessManager::GetInstance()->Init());
352 }
353
354 /**
355 * @tc.name: OnDeviceReady_003
356 * @tc.desc: Verify the OnDeviceReady function
357 * @tc.type: FUNC
358 * @tc.require: AR000GHSJM
359 */
360 HWTEST_F(AccessManagerTest, OnDeviceReady_003, TestSize.Level0)
361 {
362 DmDeviceInfo deviceInfo;
363 std::string devId = "000001";
364 int32_t ret = memcpy_s(deviceInfo.deviceId, DM_MAX_DEVICE_ID_LEN, devId.c_str(), devId.length());
365 if (ret != EOK) {
366 return;
367 }
368 std::string netId = "000002";
369 ret = memcpy_s(deviceInfo.networkId, DM_MAX_DEVICE_ID_LEN, netId.c_str(), netId.length());
370 if (ret != EOK) {
371 return;
372 }
373 AccessManager::GetInstance()->OnDeviceReady(deviceInfo);
374 EXPECT_EQ(DH_FWK_SUCCESS, AccessManager::GetInstance()->Init());
375 }
376
377 /**
378 * @tc.name: OnDeviceChanged_001
379 * @tc.desc: Verify the OnDeviceChanged function
380 * @tc.type: FUNC
381 * @tc.require: AR000GHSJM
382 */
383 HWTEST_F(AccessManagerTest, OnDeviceChanged_001, TestSize.Level0)
384 {
385 DmDeviceInfo deviceInfo;
386 AccessManager::GetInstance()->OnDeviceChanged(deviceInfo);
387 EXPECT_EQ(DH_FWK_SUCCESS, AccessManager::GetInstance()->Init());
388 }
389
390 /**
391 * @tc.name: UnInit_001
392 * @tc.desc: Verify the UnInit function
393 * @tc.type: FUNC
394 * @tc.require: AR000GHSJM
395 */
396 HWTEST_F(AccessManagerTest, UnInit_001, TestSize.Level0)
397 {
398 EXPECT_EQ(DH_FWK_SUCCESS, AccessManager::GetInstance()->UnInit());
399 }
400
401 /**
402 * @tc.name: UnRegisterDevStateCallback_001
403 * @tc.desc: Verify the UnRegisterDevStateCallback function
404 * @tc.type: FUNC
405 * @tc.require: AR000GHSJM
406 */
407 HWTEST_F(AccessManagerTest, UnRegisterDevStateCallback_001, TestSize.Level0)
408 {
409 EXPECT_EQ(DH_FWK_SUCCESS, AccessManager::GetInstance()->UnRegisterDevStateCallback());
410 }
411 } // namespace DistributedHardware
412 } // namespace OHOS
413