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 "sysparam_errno.h"
34 #include "deviceinfoservice_ipc_interface_code.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 namespace init_ut {
59 using DeviceInfoServicePtr = OHOS::device_info::DeviceInfoService *;
60 class DeviceInfoUnittest : public testing::Test {
61 public:
DeviceInfoUnittest()62     DeviceInfoUnittest() {};
~DeviceInfoUnittest()63     virtual ~DeviceInfoUnittest() {};
SetUpTestCase(void)64     static void SetUpTestCase(void) {};
TearDownTestCase(void)65     static void TearDownTestCase(void) {};
SetUp()66     void SetUp() {};
TearDown()67     void TearDown() {};
TestBody(void)68     void TestBody(void) {};
GetDeviceInfoService()69     DeviceInfoServicePtr GetDeviceInfoService()
70     {
71         static DeviceInfoServicePtr deviceInfoServicePtr = nullptr;
72         if (deviceInfoServicePtr == nullptr) {
73             deviceInfoServicePtr = new OHOS::device_info::DeviceInfoService(0, true);
74             if (deviceInfoServicePtr == nullptr) {
75                 return nullptr;
76             }
77             deviceInfoServicePtr->OnStart();
78         }
79         return deviceInfoServicePtr;
80     }
81 };
82 
83 HWTEST_F(DeviceInfoUnittest, Init_DevInfoAgentTest_001, TestSize.Level1)
84 {
85     OHOS::device_info::DeviceInfoKits &kits = OHOS::device_info::DeviceInfoKits::GetInstance();
86     std::string serial = {};
87     int ret = kits.GetSerialID(serial);
88     EXPECT_EQ(ret, SYSPARAM_PERMISSION_DENIED);
89     ret = kits.GetUdid(serial);
90     EXPECT_EQ(ret, SYSPARAM_PERMISSION_DENIED);
91 }
92 
93 HWTEST_F(DeviceInfoUnittest, Init_DevInfoDiedTest_001, TestSize.Level1)
94 {
95     sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
96     DINFO_CHECK(samgr != nullptr, return, "Get samgr failed");
97     sptr<IRemoteObject> object = samgr->GetSystemAbility(SYSPARAM_DEVICE_SERVICE_ID);
98     DINFO_CHECK(object != nullptr, return, "Get deviceinfo manager object from samgr failed");
99     OHOS::device_info::DeviceInfoKits &kits = OHOS::device_info::DeviceInfoKits::GetInstance();
100     if (kits.GetDeathRecipient() != nullptr) {
101         kits.GetDeathRecipient()->OnRemoteDied(object);
102     }
103     std::string serial = {};
104     int ret = kits.GetSerialID(serial);
105     EXPECT_EQ(ret, SYSPARAM_PERMISSION_DENIED);
106 }
107 
108 HWTEST_F(DeviceInfoUnittest, Init_DevInfoAgentFail_001, TestSize.Level1)
109 {
110     sptr<OHOS::device_info::DeviceInfoLoad> deviceInfoLoad = new (std::nothrow) OHOS::device_info::DeviceInfoLoad();
111     ASSERT_NE(deviceInfoLoad, nullptr);
112     deviceInfoLoad->OnLoadSystemAbilityFail(SYSPARAM_DEVICE_SERVICE_ID);
113     deviceInfoLoad->OnLoadSystemAbilityFail(SYSPARAM_DEVICE_SERVICE_ID + 1);
114 
115     OHOS::device_info::DeviceInfoKits &kits = OHOS::device_info::DeviceInfoKits::GetInstance();
116     kits.FinishStartSAFailed();
117 }
118 
119 HWTEST_F(DeviceInfoUnittest, Init_DeviceInfoServiceInvalidTokenTest_001, TestSize.Level1)
120 {
121     string result;
122     DeviceInfoServicePtr deviceInfoService = GetDeviceInfoService();
123     ASSERT_NE(deviceInfoService, nullptr);
124     MessageParcel data;
125     MessageParcel reply;
126     MessageOption option;
127     g_tokenType = OHOS::Security::AccessToken::TOKEN_INVALID;
128     data.WriteInterfaceToken(OHOS::device_info::DeviceInfoStub::GetDescriptor());
129     deviceInfoService->OnRemoteRequest
130         (static_cast<uint32_t> (OHOS::device_info::DeviceInfoInterfaceCode::COMMAND_GET_UDID), data, reply, option);
131 }
132 
133 HWTEST_F(DeviceInfoUnittest, Init_DeviceInfoServiceFailTest_001, TestSize.Level1)
134 {
135     string result;
136     DeviceInfoServicePtr deviceInfoService = GetDeviceInfoService();
137     ASSERT_NE(deviceInfoService, nullptr);
138     MessageParcel data;
139     MessageParcel reply;
140     MessageOption option;
141     g_tokenType = OHOS::Security::AccessToken::TOKEN_HAP;
142     g_tokenVerifyResult = OHOS::Security::AccessToken::TypePermissionState::PERMISSION_DENIED;
143 
144     // udid
145     data.WriteInterfaceToken(OHOS::device_info::DeviceInfoStub::GetDescriptor());
146     deviceInfoService->OnRemoteRequest
147         (static_cast<uint32_t> (OHOS::device_info::DeviceInfoInterfaceCode::COMMAND_GET_UDID),
148         data, reply, option);
149     // serial
150     data.WriteInterfaceToken(OHOS::device_info::DeviceInfoStub::GetDescriptor());
151     deviceInfoService->OnRemoteRequest
152         (static_cast<uint32_t> (OHOS::device_info::DeviceInfoInterfaceCode::COMMAND_GET_SERIAL_ID),
153         data, reply, option);
154 }
155 
156 HWTEST_F(DeviceInfoUnittest, Init_DeviceInfoServiceTest_001, TestSize.Level1)
157 {
158     string result;
159     DeviceInfoServicePtr deviceInfoService = GetDeviceInfoService();
160     ASSERT_NE(deviceInfoService, nullptr);
161     MessageParcel data;
162     MessageParcel reply;
163     MessageOption option;
164     g_tokenType = OHOS::Security::AccessToken::TOKEN_HAP;
165     g_tokenVerifyResult = OHOS::Security::AccessToken::TypePermissionState::PERMISSION_GRANTED;
166     data.WriteInterfaceToken(OHOS::device_info::DeviceInfoStub::GetDescriptor());
167     deviceInfoService->OnRemoteRequest
168         (static_cast<uint32_t> (OHOS::device_info::DeviceInfoInterfaceCode::COMMAND_GET_UDID),
169         data, reply, option);
170     data.WriteInterfaceToken(OHOS::device_info::DeviceInfoStub::GetDescriptor());
171     deviceInfoService->OnRemoteRequest
172         (static_cast<uint32_t> (OHOS::device_info::DeviceInfoInterfaceCode::COMMAND_GET_SERIAL_ID),
173         data, reply, option);
174     data.WriteInterfaceToken(OHOS::device_info::DeviceInfoStub::GetDescriptor());
175     deviceInfoService->OnRemoteRequest
176         (static_cast<uint32_t> (OHOS::device_info::DeviceInfoInterfaceCode::COMMAND_GET_SERIAL_ID) + 1,
177         data, reply, option);
178 
179     deviceInfoService->OnRemoteRequest
180         (static_cast<uint32_t> (OHOS::device_info::DeviceInfoInterfaceCode::COMMAND_GET_SERIAL_ID) + 1,
181         data, reply, option);
182     std::this_thread::sleep_for(std::chrono::seconds(3)); // wait sa unload 3s
183     deviceInfoService->GetUdid(result);
184     deviceInfoService->GetSerialID(result);
185     deviceInfoService->OnStop();
186     std::vector<std::u16string> args = {};
187     deviceInfoService->Dump(STDOUT_FILENO, args);
188     deviceInfoService->Dump(-1, args);
189 }
190 
191 HWTEST_F(DeviceInfoUnittest, Init_TestInterface_001, TestSize.Level1)
192 {
193     char localDeviceId[UDID_LEN] = {0};
194     int ret = AclGetDevUdid(nullptr, UDID_LEN);
195     ASSERT_NE(ret, 0);
196     ret = AclGetDevUdid(localDeviceId, 2); // 2 test
197     ASSERT_NE(ret, 0);
198 
199     ret = AclGetDevUdid(localDeviceId, UDID_LEN);
200     const char *serialNumber = AclGetSerial();
201     EXPECT_NE(nullptr, serialNumber);
202 }
203 
204 HWTEST_F(DeviceInfoUnittest, Init_TestDeviceInfoProxy_001, TestSize.Level1)
205 {
206     sptr<device_info::DeviceInfoProxy> proxy;
207     {
208         OHOS::device_info::DeviceInfoKits &kits = device_info::DeviceInfoKits::GetInstance();
209         std::unique_lock<std::mutex> lock(kits.lock_);
210         auto remotePtr = device_info::DeviceInfoKits::GetInstance().GetService(lock);
211         ASSERT_NE(remotePtr, nullptr);
212         auto remote = remotePtr->AsObject();
213         proxy = new(std::nothrow) device_info::DeviceInfoProxy(remote);
214         ASSERT_NE(proxy, nullptr);
215     }
216     device_info::DeviceInfoKits::GetInstance().FinishStartSASuccess(proxy->AsObject());
217     std::string udid;
218     std::string serialId;
219     proxy->GetUdid(udid);
220     proxy->GetSerialID(serialId);
221 
222     char localDeviceId[UDID_LEN] = {0};
223     (void)AclGetDevUdid(localDeviceId, UDID_LEN);
224     const char *serialNumber = AclGetSerial();
225     EXPECT_NE(nullptr, serialNumber);
226 }
227 
228 HWTEST_F(DeviceInfoUnittest, Init_TestDeviceInfoProxy_002, TestSize.Level1)
229 {
230     sptr<device_info::DeviceInfoProxy> proxy = new(std::nothrow) device_info::DeviceInfoProxy(nullptr);
231     ASSERT_NE(proxy, nullptr);
232 
233     std::string udid;
234     std::string serialId;
235     proxy->GetUdid(udid);
236     proxy->GetSerialID(serialId);
237 }
238 }  // namespace init_ut
239