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