1 /*
2 * Copyright (c) 2021-2025 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 "access_manager.h"
17
18 #include "gtest/gtest.h"
19
20 #include "dm_device_info.h"
21 #include "device_manager.h"
22 #include "device_manager_impl.h"
23
24 #include "device_param_mgr.h"
25 #include "dh_context.h"
26 #include "distributed_hardware_manager_factory.h"
27 #include "distributed_hardware_errno.h"
28
29 using namespace testing::ext;
30 using namespace testing;
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 constexpr int32_t INVALID_OSTYPE = 10;
42 constexpr int32_t OLD_HO_DEVICE_TYPE = -1;
43 constexpr int32_t NEW_HO_DEVICE_TYPE = 11;
44 const std::string TEST_NETWORKID = "111111";
45 const std::string TEST_UUID = "222222";
46 const std::string TEST_UDID = "333333";
47 }
48
49 static int32_t g_InitDMValue = 0;
50 static int32_t g_UnInitDMValue = 0;
51 static int32_t g_RegisterDMValue = 0;
52 static int32_t g_UnRegisterDMValue = 0;
53
InitDeviceManager(const std::string & pkgName,std::shared_ptr<DmInitCallback> dmInitCallback)54 int32_t DeviceManagerImpl::InitDeviceManager(const std::string &pkgName,
55 std::shared_ptr<DmInitCallback> dmInitCallback)
56 {
57 return g_InitDMValue;
58 }
59
UnInitDeviceManager(const std::string & pkgName)60 int32_t DeviceManagerImpl::UnInitDeviceManager(const std::string &pkgName)
61 {
62 return g_UnInitDMValue;
63 }
64
RegisterDevStateCallback(const std::string & pkgName,const std::string & extra,std::shared_ptr<DeviceStateCallback> callback)65 int32_t DeviceManagerImpl::RegisterDevStateCallback(const std::string &pkgName,
66 const std::string &extra, std::shared_ptr<DeviceStateCallback> callback)
67 {
68 return g_RegisterDMValue;
69 }
70
UnRegisterDevStateCallback(const std::string & pkgName)71 int32_t DeviceManagerImpl::UnRegisterDevStateCallback(const std::string &pkgName)
72 {
73 return g_UnRegisterDMValue;
74 }
75
76 class AccessManagerTest : public testing::Test {
77 public:
78 static void SetUpTestCase(void);
79 static void TearDownTestCase(void);
80 void SetUp();
81 void TearDown();
82 };
83
SetUp()84 void AccessManagerTest::SetUp()
85 {
86 DistributedHardwareManagerFactory::GetInstance().isInit_.store(true);
87 g_InitDMValue = 0;
88 g_UnInitDMValue = 0;
89 g_RegisterDMValue = 0;
90 g_UnRegisterDMValue = 0;
91 }
92
TearDown()93 void AccessManagerTest::TearDown() {}
94
SetUpTestCase()95 void AccessManagerTest::SetUpTestCase() {}
96
TearDownTestCase()97 void AccessManagerTest::TearDownTestCase() {}
98
99 /**
100 * @tc.name: SendOnLineEvent_001
101 * @tc.desc: Verify the online success
102 * @tc.type: FUNC
103 * @tc.require: AR000GHSJK
104 */
105 HWTEST_F(AccessManagerTest, SendOnLineEvent_001, TestSize.Level1)
106 {
107 int32_t ostype = -1;
108 DHContext::GetInstance().AddOnlineDevice(TEST_UDID, TEST_UUID, TEST_NETWORKID);
109 auto ret = DistributedHardwareManagerFactory::GetInstance().SendOnLineEvent(TEST_NETWORKID, TEST_UUID, TEST_UDID,
110 TEST_DEV_TYPE_PAD, ostype);
111 EXPECT_EQ(ERR_DH_FWK_HARDWARE_MANAGER_DEVICE_REPEAT_ONLINE, ret);
112
113 DHContext::GetInstance().devIdEntrySet_.clear();
114 ret = DistributedHardwareManagerFactory::GetInstance().SendOnLineEvent(TEST_NETWORKID, TEST_UUID, TEST_UDID,
115 TEST_DEV_TYPE_PAD, ostype);
116 EXPECT_EQ(DH_FWK_SUCCESS, ret);
117
118 DHContext::GetInstance().devIdEntrySet_.clear();
119 ret = DistributedHardwareManagerFactory::GetInstance().SendOnLineEvent(TEST_NETWORKID, TEST_UUID, TEST_UDID,
120 TEST_DEV_TYPE_PAD, INVALID_OSTYPE);
121 EXPECT_EQ(DH_FWK_SUCCESS, ret);
122 }
123
124 /**
125 * @tc.name: SendOffLineEvent_001
126 * @tc.desc: Verify the offline success
127 * @tc.type: FUNC
128 * @tc.require: AR000GHSJM
129 */
130 HWTEST_F(AccessManagerTest, SendOffLineEvent_001, TestSize.Level1)
131 {
132 DHContext::GetInstance().devIdEntrySet_.clear();
133 auto ret = DistributedHardwareManagerFactory::GetInstance().SendOffLineEvent("", TEST_UUID, TEST_UDID,
134 TEST_DEV_TYPE_PAD);
135 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
136 ret = DistributedHardwareManagerFactory::GetInstance().SendOffLineEvent(TEST_NETWORKID, "", TEST_UDID,
137 TEST_DEV_TYPE_PAD);
138 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
139 ret = DistributedHardwareManagerFactory::GetInstance().SendOffLineEvent(TEST_NETWORKID, TEST_UUID, "",
140 TEST_DEV_TYPE_PAD);
141 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
142
143 DHContext::GetInstance().AddOnlineDevice(TEST_UDID, TEST_UUID, TEST_NETWORKID);
144 ret = DistributedHardwareManagerFactory::GetInstance().SendOffLineEvent(TEST_NETWORKID, TEST_UUID, TEST_UDID,
145 TEST_DEV_TYPE_PAD);
146 EXPECT_EQ(DH_FWK_SUCCESS, ret);
147 DHContext::GetInstance().devIdEntrySet_.clear();
148 }
149
150 /**
151 * @tc.name: Init_001
152 * @tc.desc: Verify the Init function
153 * @tc.type: FUNC
154 * @tc.require: AR000GHSJM
155 */
156 HWTEST_F(AccessManagerTest, Init_001, TestSize.Level1)
157 {
158 g_InitDMValue = -1;
159 auto ret = AccessManager::GetInstance()->Init();
160 EXPECT_EQ(ERR_DH_FWK_ACCESS_INIT_DM_FAILED, ret);
161 }
162
163 HWTEST_F(AccessManagerTest, Init_002, TestSize.Level1)
164 {
165 g_RegisterDMValue = -1;
166 auto ret = AccessManager::GetInstance()->Init();
167 EXPECT_EQ(ERR_DH_FWK_ACCESS_REGISTER_DM_FAILED, ret);
168 }
169
170 HWTEST_F(AccessManagerTest, Init_003, TestSize.Level1)
171 {
172 g_RegisterDMValue = 0;
173 auto ret = AccessManager::GetInstance()->Init();
174 EXPECT_EQ(DH_FWK_SUCCESS, ret);
175 }
176
177 /**
178 * @tc.name: UnInit_001
179 * @tc.desc: Verify the UnInit function
180 * @tc.type: FUNC
181 * @tc.require: AR000GHSJM
182 */
183 HWTEST_F(AccessManagerTest, UnInit_001, TestSize.Level1)
184 {
185 g_UnInitDMValue = -1;
186 auto ret = AccessManager::GetInstance()->UnInit();
187 EXPECT_EQ(ERR_DH_FWK_ACCESS_UNINIT_DM_FAILED, ret);
188 }
189
190 HWTEST_F(AccessManagerTest, UnInit_002, TestSize.Level1)
191 {
192 g_UnRegisterDMValue = -1;
193 auto ret = AccessManager::GetInstance()->UnInit();
194 EXPECT_EQ(ERR_DH_FWK_ACCESS_UNREGISTER_DM_FAILED, ret);
195 }
196
197 HWTEST_F(AccessManagerTest, UnInit_003, TestSize.Level1)
198 {
199 g_UnRegisterDMValue = 0;
200 auto ret = AccessManager::GetInstance()->UnInit();
201 EXPECT_EQ(DH_FWK_SUCCESS, ret);
202 }
203
204 /**
205 * @tc.name: OnRemoteDied_001
206 * @tc.desc: Verify the OnRemoteDied function
207 * @tc.type: FUNC
208 * @tc.require: AR000GHSJM
209 */
210 HWTEST_F(AccessManagerTest, OnRemoteDied_001, TestSize.Level1)
211 {
212 g_InitDMValue = -1;
213 ASSERT_NO_FATAL_FAILURE(AccessManager::GetInstance()->OnRemoteDied());
214
215 g_InitDMValue = 0;
216 ASSERT_NO_FATAL_FAILURE(AccessManager::GetInstance()->OnRemoteDied());
217 }
218
219 /**
220 * @tc.name: OnDeviceOnline_001
221 * @tc.desc: Verify the OnDeviceOnline function
222 * @tc.type: FUNC
223 * @tc.require: AR000GHSJM
224 */
225 HWTEST_F(AccessManagerTest, OnDeviceOnline_001, TestSize.Level1)
226 {
227 DmDeviceInfo deviceInfo = {
228 .deviceId = "123456789",
229 .deviceName = "deviceName_test",
230 .deviceTypeId = 1,
231 .networkId = ""
232 };
233 ASSERT_NO_FATAL_FAILURE(AccessManager::GetInstance()->OnDeviceOnline(deviceInfo));
234 }
235
236 HWTEST_F(AccessManagerTest, OnDeviceOnline_002, TestSize.Level1)
237 {
238 DmDeviceInfo deviceInfo = {
239 .deviceId = "123456789",
240 .deviceName = "deviceName_test",
241 .deviceTypeId = 1,
242 .networkId = "123456789"
243 };
244 ASSERT_NO_FATAL_FAILURE(AccessManager::GetInstance()->OnDeviceOnline(deviceInfo));
245 }
246
247 /**
248 * @tc.name: OnDeviceOffline_001
249 * @tc.desc: Verify the OnDeviceOffline function
250 * @tc.type: FUNC
251 * @tc.require: AR000GHSJM
252 */
253 HWTEST_F(AccessManagerTest, OnDeviceOffline_001, TestSize.Level1)
254 {
255 DmDeviceInfo deviceInfo;
256 ASSERT_NO_FATAL_FAILURE(AccessManager::GetInstance()->OnDeviceOffline(deviceInfo));
257 }
258
259 HWTEST_F(AccessManagerTest, OnDeviceOffline_002, TestSize.Level1)
260 {
261 DmDeviceInfo deviceInfo = {
262 .deviceId = "123456789",
263 .deviceName = "deviceName_test",
264 .deviceTypeId = 1,
265 .networkId = "111111"
266 };
267 ASSERT_NO_FATAL_FAILURE(AccessManager::GetInstance()->OnDeviceOffline(deviceInfo));
268 }
269
270 HWTEST_F(AccessManagerTest, OnDeviceOffline_003, TestSize.Level1)
271 {
272 DmDeviceInfo deviceInfo = {
273 .deviceId = "123456789",
274 .deviceName = "deviceName_test",
275 .deviceTypeId = 1,
276 .networkId = "111111"
277 };
278 DHContext::GetInstance().AddOnlineDevice(TEST_UDID, "", TEST_NETWORKID);
279 ASSERT_NO_FATAL_FAILURE(AccessManager::GetInstance()->OnDeviceOffline(deviceInfo));
280 DHContext::GetInstance().RemoveOnlineDeviceIdEntryByNetworkId(TEST_NETWORKID);
281
282 DHContext::GetInstance().AddOnlineDevice("", TEST_UUID, TEST_NETWORKID);
283 ASSERT_NO_FATAL_FAILURE(AccessManager::GetInstance()->OnDeviceOffline(deviceInfo));
284 DHContext::GetInstance().RemoveOnlineDeviceIdEntryByNetworkId(TEST_NETWORKID);
285
286 DHContext::GetInstance().AddOnlineDevice(TEST_UDID, TEST_UUID, TEST_NETWORKID);
287 ASSERT_NO_FATAL_FAILURE(AccessManager::GetInstance()->OnDeviceOffline(deviceInfo));
288 DHContext::GetInstance().RemoveOnlineDeviceIdEntryByNetworkId(TEST_NETWORKID);
289 }
290
291 /**
292 * @tc.name: CheckExitSAOrNot_001
293 * @tc.desc: Verify the CheckExitSAOrNot function
294 * @tc.type: FUNC
295 * @tc.require: AR000GHSJM
296 */
297 HWTEST_F(AccessManagerTest, CheckExitSAOrNot_001, TestSize.Level1)
298 {
299 ASSERT_NO_FATAL_FAILURE(DistributedHardwareManagerFactory::GetInstance().CheckExitSAOrNot());
300 }
301
302 /**
303 * @tc.name: InitLocalDevInfo_001
304 * @tc.desc: Verify the InitLocalDevInfo function
305 * @tc.type: FUNC
306 * @tc.require: AR000GHSJM
307 */
308 HWTEST_F(AccessManagerTest, InitLocalDevInfo_001, TestSize.Level1)
309 {
310 ASSERT_TRUE(DistributedHardwareManagerFactory::GetInstance().InitLocalDevInfo());
311 }
312
313 HWTEST_F(AccessManagerTest, SendOnLineEvent_002, TestSize.Level1)
314 {
315 std::string networkId = "networkId_1";
316 std::string uuid = "uuid_1";
317 std::string udid = "udid_1";
318 uint16_t deviceType = TEST_DEV_TYPE_PAD;
319 int32_t osType = OLD_HO_DEVICE_TYPE;
320 DistributedHardwareManagerFactory::GetInstance().flagUnInit_.store(false);
321 DistributedHardwareManagerFactory::GetInstance().isInit_.store(true);
322 DeviceParamMgr::GetInstance().isDeviceE2ESync_.store(true);
323 int32_t ret =
324 DistributedHardwareManagerFactory::GetInstance().SendOnLineEvent(networkId, uuid, udid, deviceType, osType);
325 EXPECT_EQ(ret, DH_FWK_SUCCESS);
326 }
327
328 HWTEST_F(AccessManagerTest, SendOnLineEvent_003, TestSize.Level1)
329 {
330 std::string networkId = "networkId_2";
331 std::string uuid = "uuid_2";
332 std::string udid = "udid_2";
333 uint16_t deviceType = TEST_DEV_TYPE_PAD;
334 int32_t osType = NEW_HO_DEVICE_TYPE;
335 DistributedHardwareManagerFactory::GetInstance().flagUnInit_.store(false);
336 DistributedHardwareManagerFactory::GetInstance().isInit_.store(true);
337 DeviceParamMgr::GetInstance().isDeviceE2ESync_.store(true);
338 int32_t ret =
339 DistributedHardwareManagerFactory::GetInstance().SendOnLineEvent(networkId, uuid, udid, deviceType, osType);
340 EXPECT_EQ(ret, DH_FWK_SUCCESS);
341 }
342
343 HWTEST_F(AccessManagerTest, SendOnLineEvent_004, TestSize.Level1)
344 {
345 std::string networkId = "networkId_3";
346 std::string uuid = "uuid_3";
347 std::string udid = "udid_3";
348 uint16_t deviceType = TEST_DEV_TYPE_PAD;
349 int32_t osType = INVALID_OSTYPE;
350 DistributedHardwareManagerFactory::GetInstance().flagUnInit_.store(false);
351 DistributedHardwareManagerFactory::GetInstance().isInit_.store(true);
352 DeviceParamMgr::GetInstance().isDeviceE2ESync_.store(true);
353 int32_t ret =
354 DistributedHardwareManagerFactory::GetInstance().SendOnLineEvent(networkId, uuid, udid, deviceType, osType);
355 EXPECT_EQ(ret, DH_FWK_SUCCESS);
356 }
357 } // namespace DistributedHardware
358 } // namespace OHOS
359