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 #include <chrono>
16 #include <thread>
17 #include <string>
18 #include <iostream>
19 #include <gtest/gtest.h>
20
21 #include "accesstoken_kit.h"
22 #include "parameter.h"
23 #include "system_ability_definition.h"
24 #include "if_system_ability_manager.h"
25 #include "iservice_registry.h"
26 #include "parcel.h"
27 #include "string_ex.h"
28 #include "device_info_kits.h"
29 #include "device_info_load.h"
30 #include "device_info_proxy.h"
31 #include "idevice_info.h"
32 #include "device_info_stub.h"
33 #include "device_info_service.h"
34 #include "sysparam_errno.h"
35
36 using namespace testing::ext;
37 using namespace std;
38 using namespace OHOS;
39
40 int g_tokenType = OHOS::Security::AccessToken::TOKEN_HAP;
41 int g_tokenVerifyResult = 0;
42 namespace OHOS {
43 namespace Security {
44 namespace AccessToken {
GetTokenTypeFlag(AccessTokenID tokenID)45 ATokenTypeEnum AccessTokenKit::GetTokenTypeFlag(AccessTokenID tokenID)
46 {
47 return static_cast<ATokenTypeEnum>(g_tokenType);
48 }
VerifyAccessToken(AccessTokenID tokenID,const std::string & permissionName)49 int AccessTokenKit::VerifyAccessToken(AccessTokenID tokenID, const std::string& permissionName)
50 {
51 return g_tokenVerifyResult;
52 }
53 } // namespace AccessToken
54 } // namespace Security
55 } // namespace OHOS
56
57 const int UDID_LEN = 65;
58 constexpr int DISK_SN_LEN = 20;
59 namespace init_ut {
60 using DeviceInfoServicePtr = OHOS::device_info::DeviceInfoService *;
61 class DeviceInfoUnittest : public testing::Test {
62 public:
DeviceInfoUnittest()63 DeviceInfoUnittest() {};
~DeviceInfoUnittest()64 virtual ~DeviceInfoUnittest() {};
SetUpTestCase(void)65 static void SetUpTestCase(void) {};
TearDownTestCase(void)66 static void TearDownTestCase(void) {};
SetUp()67 void SetUp() {};
TearDown()68 void TearDown() {};
TestBody(void)69 void TestBody(void) {};
GetDeviceInfoService()70 DeviceInfoServicePtr GetDeviceInfoService()
71 {
72 static DeviceInfoServicePtr deviceInfoServicePtr = nullptr;
73 if (deviceInfoServicePtr == nullptr) {
74 deviceInfoServicePtr = new OHOS::device_info::DeviceInfoService(0, true);
75 if (deviceInfoServicePtr == nullptr) {
76 return nullptr;
77 }
78 deviceInfoServicePtr->OnStart();
79 }
80 return deviceInfoServicePtr;
81 }
82 };
83
84 HWTEST_F(DeviceInfoUnittest, Init_DevInfoAgentTest_001, TestSize.Level1)
85 {
86 OHOS::device_info::DeviceInfoKits &kits = OHOS::device_info::DeviceInfoKits::GetInstance();
87 std::string serial = {};
88 int ret = kits.GetSerialID(serial);
89 EXPECT_EQ(ret, SYSPARAM_PERMISSION_DENIED);
90 ret = kits.GetUdid(serial);
91 EXPECT_EQ(ret, SYSPARAM_PERMISSION_DENIED);
92 ret = kits.GetDiskSN(serial);
93 EXPECT_EQ(ret, SYSPARAM_PERMISSION_DENIED);
94 }
95
96 HWTEST_F(DeviceInfoUnittest, Init_DevInfoDiedTest_001, TestSize.Level1)
97 {
98 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
99 DINFO_CHECK(samgr != nullptr, return, "Get samgr failed");
100 sptr<IRemoteObject> object = samgr->GetSystemAbility(SYSPARAM_DEVICE_SERVICE_ID);
101 DINFO_CHECK(object != nullptr, return, "Get deviceinfo manager object from samgr failed");
102 OHOS::device_info::DeviceInfoKits &kits = OHOS::device_info::DeviceInfoKits::GetInstance();
103 if (kits.GetDeathRecipient() != nullptr) {
104 kits.GetDeathRecipient()->OnRemoteDied(object);
105 }
106 std::string serial = {};
107 int ret = kits.GetSerialID(serial);
108 EXPECT_EQ(ret, SYSPARAM_PERMISSION_DENIED);
109 }
110
111 HWTEST_F(DeviceInfoUnittest, Init_DevInfoAgentFail_001, TestSize.Level1)
112 {
113 sptr<OHOS::device_info::DeviceInfoLoad> deviceInfoLoad = new (std::nothrow) OHOS::device_info::DeviceInfoLoad();
114 ASSERT_NE(deviceInfoLoad, nullptr);
115 deviceInfoLoad->OnLoadSystemAbilityFail(SYSPARAM_DEVICE_SERVICE_ID);
116 deviceInfoLoad->OnLoadSystemAbilityFail(SYSPARAM_DEVICE_SERVICE_ID + 1);
117
118 OHOS::device_info::DeviceInfoKits &kits = OHOS::device_info::DeviceInfoKits::GetInstance();
119 kits.FinishStartSAFailed();
120 }
121
122 HWTEST_F(DeviceInfoUnittest, Init_DeviceInfoServiceInvalidTokenTest_001, TestSize.Level1)
123 {
124 string result;
125 DeviceInfoServicePtr deviceInfoService = GetDeviceInfoService();
126 ASSERT_NE(deviceInfoService, nullptr);
127 MessageParcel data;
128 MessageParcel reply;
129 MessageOption option;
130 g_tokenType = OHOS::Security::AccessToken::TOKEN_INVALID;
131 data.WriteInterfaceToken(OHOS::device_info::DeviceInfoStub::GetDescriptor());
132 deviceInfoService->OnRemoteRequest
133 (static_cast<uint32_t> (OHOS::device_info::IDeviceInfoIpcCode::COMMAND_GET_UDID), data, reply, option);
134 }
135
136 HWTEST_F(DeviceInfoUnittest, Init_DeviceInfoServiceFailTest_001, TestSize.Level1)
137 {
138 string result;
139 DeviceInfoServicePtr deviceInfoService = GetDeviceInfoService();
140 ASSERT_NE(deviceInfoService, nullptr);
141 MessageParcel data;
142 MessageParcel reply;
143 MessageOption option;
144 g_tokenType = OHOS::Security::AccessToken::TOKEN_HAP;
145 g_tokenVerifyResult = OHOS::Security::AccessToken::TypePermissionState::PERMISSION_DENIED;
146
147 // udid
148 data.WriteInterfaceToken(OHOS::device_info::DeviceInfoStub::GetDescriptor());
149 deviceInfoService->OnRemoteRequest
150 (static_cast<uint32_t> (OHOS::device_info::IDeviceInfoIpcCode::COMMAND_GET_UDID),
151 data, reply, option);
152 // serial
153 data.WriteInterfaceToken(OHOS::device_info::DeviceInfoStub::GetDescriptor());
154 deviceInfoService->OnRemoteRequest
155 (static_cast<uint32_t> (OHOS::device_info::IDeviceInfoIpcCode::COMMAND_GET_SERIAL_I_D),
156 data, reply, option);
157 }
158
159 HWTEST_F(DeviceInfoUnittest, Init_DeviceInfoServiceTest_001, TestSize.Level1)
160 {
161 string result;
162 DeviceInfoServicePtr deviceInfoService = GetDeviceInfoService();
163 ASSERT_NE(deviceInfoService, nullptr);
164 MessageParcel data;
165 MessageParcel reply;
166 MessageOption option;
167 g_tokenType = OHOS::Security::AccessToken::TOKEN_HAP;
168 g_tokenVerifyResult = OHOS::Security::AccessToken::TypePermissionState::PERMISSION_GRANTED;
169 data.WriteInterfaceToken(OHOS::device_info::DeviceInfoStub::GetDescriptor());
170 deviceInfoService->OnRemoteRequest
171 (static_cast<uint32_t> (OHOS::device_info::IDeviceInfoIpcCode::COMMAND_GET_UDID),
172 data, reply, option);
173 data.WriteInterfaceToken(OHOS::device_info::DeviceInfoStub::GetDescriptor());
174 deviceInfoService->OnRemoteRequest
175 (static_cast<uint32_t> (OHOS::device_info::IDeviceInfoIpcCode::COMMAND_GET_SERIAL_I_D),
176 data, reply, option);
177 data.WriteInterfaceToken(OHOS::device_info::DeviceInfoStub::GetDescriptor());
178 deviceInfoService->OnRemoteRequest
179 (static_cast<uint32_t>(OHOS::device_info::IDeviceInfoIpcCode::COMMAND_GET_DISK_S_N),
180 data, reply, option);
181 data.WriteInterfaceToken(OHOS::device_info::DeviceInfoStub::GetDescriptor());
182 deviceInfoService->OnRemoteRequest
183 (static_cast<uint32_t> (OHOS::device_info::IDeviceInfoIpcCode::COMMAND_GET_DISK_S_N) + 1,
184 data, reply, option);
185
186 deviceInfoService->OnRemoteRequest
187 (static_cast<uint32_t> (OHOS::device_info::IDeviceInfoIpcCode::COMMAND_GET_DISK_S_N) + 1,
188 data, reply, option);
189 std::this_thread::sleep_for(std::chrono::seconds(3)); // wait sa unload 3s
190 deviceInfoService->GetUdid(result);
191 deviceInfoService->GetSerialID(result);
192 deviceInfoService->GetDiskSN(result);
193 deviceInfoService->OnStop();
194 std::vector<std::u16string> args = {};
195 deviceInfoService->Dump(STDOUT_FILENO, args);
196 deviceInfoService->Dump(-1, args);
197 }
198
199 HWTEST_F(DeviceInfoUnittest, Init_TestInterface_001, TestSize.Level1)
200 {
201 char localDeviceId[UDID_LEN] = {0};
202 int ret = AclGetDevUdid(nullptr, UDID_LEN);
203 ASSERT_NE(ret, 0);
204 ret = AclGetDevUdid(localDeviceId, 2); // 2 test
205 ASSERT_NE(ret, 0);
206
207 ret = AclGetDevUdid(localDeviceId, UDID_LEN);
208 const char *serialNumber = AclGetSerial();
209 EXPECT_NE(nullptr, serialNumber);
210 }
211
212 HWTEST_F(DeviceInfoUnittest, Init_TestInterface_002, TestSize.Level1)
213 {
214 char diskSN[DISK_SN_LEN] = {0};
215 int ret = AclGetDiskSN(nullptr, DISK_SN_LEN);
216 ASSERT_NE(ret, 0);
217 ret = AclGetDiskSN(diskSN, 2); // 2 test
218 ASSERT_NE(ret, 0);
219 }
220
221 HWTEST_F(DeviceInfoUnittest, Init_TestDeviceInfoProxy_001, TestSize.Level1)
222 {
223 sptr<device_info::DeviceInfoProxy> proxy;
224 {
225 OHOS::device_info::DeviceInfoKits &kits = device_info::DeviceInfoKits::GetInstance();
226 std::unique_lock<std::mutex> lock(kits.lock_);
227 auto remotePtr = device_info::DeviceInfoKits::GetInstance().GetService(lock);
228 ASSERT_NE(remotePtr, nullptr);
229 auto remote = remotePtr->AsObject();
230 proxy = new(std::nothrow) device_info::DeviceInfoProxy(remote);
231 ASSERT_NE(proxy, nullptr);
232 }
233 device_info::DeviceInfoKits::GetInstance().FinishStartSASuccess(proxy->AsObject());
234 std::string udid;
235 std::string serialId;
236 proxy->GetUdid(udid);
237 proxy->GetSerialID(serialId);
238 std::string diskSNResult;
239 proxy->GetDiskSN(diskSNResult);
240
241 char localDeviceId[UDID_LEN] = {0};
242 (void)AclGetDevUdid(localDeviceId, UDID_LEN);
243 const char *serialNumber = AclGetSerial();
244 EXPECT_NE(nullptr, serialNumber);
245 char diskSN[DISK_SN_LEN] = {0};
246 AclGetDevUdid(diskSN, DISK_SN_LEN);
247 }
248
249 HWTEST_F(DeviceInfoUnittest, Init_TestDeviceInfoProxy_002, TestSize.Level1)
250 {
251 sptr<device_info::DeviceInfoProxy> proxy = new(std::nothrow) device_info::DeviceInfoProxy(nullptr);
252 ASSERT_NE(proxy, nullptr);
253
254 std::string udid;
255 std::string serialId;
256 proxy->GetUdid(udid);
257 proxy->GetSerialID(serialId);
258 std::string diskSN;
259 proxy->GetDiskSN(diskSN);
260 }
261
262 HWTEST_F(DeviceInfoUnittest, Init_TestDevicekits_001, TestSize.Level1)
263 {
264 OHOS::device_info::DeviceInfoKits &instance = OHOS::device_info::DeviceInfoKits::GetInstance();
265 std::unique_lock<std::mutex> lock(instance.lock_);
266 EXPECT_NE(nullptr, instance.RetryGetService(lock));
267 }
268
269 HWTEST_F(DeviceInfoUnittest, Init_TestDevicekits_002, TestSize.Level1)
270 {
271 OHOS::device_info::DeviceInfoKits &instance = OHOS::device_info::DeviceInfoKits::GetInstance();
272 instance.deviceInfoService_ = nullptr;
273 std::unique_lock<std::mutex> lock(instance.lock_);
274 EXPECT_NE(nullptr, instance.RetryGetService(lock));
275 }
276 } // namespace init_ut
277