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
36using namespace testing::ext;
37using namespace std;
38using namespace OHOS;
39
40static int g_tokenType = OHOS::Security::AccessToken::TOKEN_HAP;
41static int g_tokenVerifyResult = 0;
42namespace OHOS {
43namespace Security {
44namespace AccessToken {
45ATokenTypeEnum AccessTokenKit::GetTokenTypeFlag(AccessTokenID tokenID)
46{
47    return static_cast<ATokenTypeEnum>(g_tokenType);
48}
49int AccessTokenKit::VerifyAccessToken(AccessTokenID tokenID, const std::string& permissionName)
50{
51    return g_tokenVerifyResult;
52}
53} // namespace AccessToken
54} // namespace Security
55} // namespace OHOS
56
57const int UDID_LEN = 65;
58namespace init_ut {
59using DeviceInfoServicePtr = OHOS::device_info::DeviceInfoService *;
60class DeviceInfoUnittest : public testing::Test {
61public:
62    DeviceInfoUnittest() {};
63    virtual ~DeviceInfoUnittest() {};
64    static void SetUpTestCase(void) {};
65    static void TearDownTestCase(void) {};
66    void SetUp() {};
67    void TearDown() {};
68    void TestBody(void) {};
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
83HWTEST_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
93HWTEST_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
108HWTEST_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
119HWTEST_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
133HWTEST_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
156HWTEST_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
191HWTEST_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
204HWTEST_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
228HWTEST_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