1 /*
2 * Copyright (c) 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 <chrono>
17 #include <cinttypes>
18 #include <iostream>
19 #include <thread>
20 #include <gtest/gtest.h>
21 #include "accesstoken_kit.h"
22 #include "nativetoken_kit.h"
23 #include "token_setproc.h"
24 #include "driver_ext_mgr_callback_stub.h"
25 #include "driver_ext_mgr_client.h"
26 #include "edm_errors.h"
27 #include "ext_object.h"
28 #include "hilog_wrapper.h"
29 #include "iservice_registry.h"
30 #include "system_ability_definition.h"
31 #include "system_ability_load_callback_stub.h"
32 #include "hdf_ext_devmgr_interface_code.h"
33
34 namespace OHOS {
35 namespace ExternalDeviceManager {
36 using namespace testing::ext;
37
38 class DrvExtMgrClientTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42
SetUp()43 void SetUp() override {}
TearDown()44 void TearDown() override {}
45
46 private:
47 class LoadCallback : public SystemAbilityLoadCallbackStub {
48 public:
49 void OnLoadSystemAbilitySuccess(int32_t systemAbilityId, const sptr<IRemoteObject> &remoteObject) override;
50 void OnLoadSystemAbilityFail(int32_t systemAbilityId) override;
51 };
52 };
53
54 enum class LoadStatus {
55 LOAD_SUCCESS,
56 LOAD_FAILED,
57 ALREADY_EXISTS,
58 };
59
60 static LoadStatus g_loadStatus_ = LoadStatus::LOAD_FAILED;
61 static sptr<IRemoteObject> g_saObject = nullptr;
62 static constexpr int32_t ERROR_CODE_WITH_INVALID_CODE = 305;
63 static constexpr uint64_t START_SA_SERVICE_WAIT_TIME = 3;
64
GetNativeToken()65 void GetNativeToken()
66 {
67 uint64_t tokenId;
68 const char **perms = new const char *[1];
69 perms[0] = "ohos.permission.ACCESS_EXTENSIONAL_DEVICE_DRIVER";
70
71 NativeTokenInfoParams infoInstance = {
72 .dcapsNum = 0,
73 .permsNum = 1,
74 .aclsNum = 0,
75 .dcaps = nullptr,
76 .perms = perms,
77 .acls = nullptr,
78 .aplStr = "system_core",
79 };
80
81 infoInstance.processName = "TestCase";
82 tokenId = GetAccessTokenId(&infoInstance);
83 EXPECT_EQ(0, SetSelfTokenID(tokenId));
84 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
85 delete[] perms;
86 }
87
SetUpTestCase()88 void DrvExtMgrClientTest::SetUpTestCase()
89 {
90 GetNativeToken();
91 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
92 if (samgr == nullptr) {
93 EDM_LOGE(EDM_MODULE_TEST, "%{public}s get samgr failed", __func__);
94 g_loadStatus_ = LoadStatus::LOAD_FAILED;
95 return;
96 }
97
98 auto saObj = samgr->CheckSystemAbility(HDF_EXTERNAL_DEVICE_MANAGER_SA_ID);
99 if (saObj != nullptr) {
100 g_saObject = saObj;
101 g_loadStatus_ = LoadStatus::ALREADY_EXISTS;
102 return;
103 }
104
105 sptr<LoadCallback> loadCallback_ = new LoadCallback();
106 int32_t ret = samgr->LoadSystemAbility(HDF_EXTERNAL_DEVICE_MANAGER_SA_ID, loadCallback_);
107 if (ret != UsbErrCode::EDM_OK) {
108 EDM_LOGE(EDM_MODULE_TEST, "%{public}s load hdf_ext_devmgr failed", __func__);
109 g_loadStatus_ = LoadStatus::LOAD_FAILED;
110 return;
111 }
112 }
113
TearDownTestCase()114 void DrvExtMgrClientTest::TearDownTestCase()
115 {
116 if (g_loadStatus_ == LoadStatus::LOAD_FAILED || g_loadStatus_ == LoadStatus::ALREADY_EXISTS) {
117 return;
118 }
119
120 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
121 if (samgr == nullptr) {
122 EDM_LOGE(EDM_MODULE_TEST, "%{public}s get samgr failed", __func__);
123 return;
124 }
125
126 int32_t ret = samgr->UnloadSystemAbility(HDF_EXTERNAL_DEVICE_MANAGER_SA_ID);
127 if (ret != UsbErrCode::EDM_OK) {
128 EDM_LOGE(EDM_MODULE_TEST, "%{public}s unload hdf_ext_devmgr failed, ret:%{public}d", __func__, ret);
129 } else {
130 EDM_LOGE(EDM_MODULE_TEST, "%{public}s unload hdf_ext_devmgr successlfuly", __func__);
131 }
132 }
133
OnLoadSystemAbilitySuccess(int32_t systemAbilityId,const sptr<IRemoteObject> & remoteObject)134 void DrvExtMgrClientTest::LoadCallback::OnLoadSystemAbilitySuccess(
135 int32_t systemAbilityId, const sptr<IRemoteObject> &remoteObject)
136 {
137 std::cout << "load success: systemAbilityId:" << systemAbilityId
138 << " IRemoteObject result:" << ((remoteObject != nullptr) ? "succeed" : "failed") << std::endl;
139 g_loadStatus_ = LoadStatus::LOAD_SUCCESS;
140 g_saObject = remoteObject;
141 }
142
OnLoadSystemAbilityFail(int32_t systemAbilityId)143 void DrvExtMgrClientTest::LoadCallback::OnLoadSystemAbilityFail(int32_t systemAbilityId)
144 {
145 std::cout << "load failed: systemAbilityId:" << systemAbilityId << std::endl;
146 g_loadStatus_ = LoadStatus::LOAD_FAILED;
147 g_saObject = nullptr;
148 }
149
150 HWTEST_F(DrvExtMgrClientTest, CheckSAServiceLoad001, TestSize.Level1)
151 {
152 if (g_loadStatus_ != LoadStatus::ALREADY_EXISTS) {
153 std::this_thread::sleep_for(std::chrono::seconds(START_SA_SERVICE_WAIT_TIME));
154 }
155
156 ASSERT_NE(g_saObject, nullptr);
157 }
158
159 HWTEST_F(DrvExtMgrClientTest, QueryDevice001, TestSize.Level1)
160 {
161 uint32_t busType = static_cast<uint32_t>(BusType::BUS_TYPE_INVALID);
162 std::vector<std::shared_ptr<DeviceData>> devices;
163 UsbErrCode ret = DriverExtMgrClient::GetInstance().QueryDevice(busType, devices);
164 ASSERT_EQ(ret, UsbErrCode::EDM_ERR_INVALID_PARAM);
165 ASSERT_TRUE(devices.empty());
166 }
167
168 HWTEST_F(DrvExtMgrClientTest, QueryDevice002, TestSize.Level1)
169 {
170 uint32_t busType = static_cast<uint32_t>(BusType::BUS_TYPE_USB);
171 std::vector<std::shared_ptr<DeviceData>> devices;
172 UsbErrCode ret = DriverExtMgrClient::GetInstance().QueryDevice(busType, devices);
173 ASSERT_EQ(ret, UsbErrCode::EDM_OK);
174 std::cout << "size of devices:" << devices.size() << std::endl;
175 for (const auto &device : devices) {
176 std::cout << device->Dump() << std::endl;
177 }
178 }
179
180 HWTEST_F(DrvExtMgrClientTest, BindDevice001, TestSize.Level1)
181 {
182 uint64_t deviceId = 0;
183 sptr<IDriverExtMgrCallback> connectCallback = nullptr;
184 UsbErrCode ret = DriverExtMgrClient::GetInstance().BindDevice(deviceId, connectCallback);
185 ASSERT_EQ(ret, UsbErrCode::EDM_ERR_INVALID_PARAM);
186 }
187
188 class DriverExtMgrCallbackTest : public DriverExtMgrCallbackStub {
189 public:
190 ErrCode OnConnect(uint64_t deviceId, const sptr<IRemoteObject> &drvExtObj, const ErrMsg &errMsg) override;
191
192 ErrCode OnDisconnect(uint64_t deviceId, const ErrMsg &errMsg) override;
193
194 ErrCode OnUnBind(uint64_t deviceId, const ErrMsg &errMsg) override;
195 };
196
OnConnect(uint64_t deviceId,const sptr<IRemoteObject> & drvExtObj,const ErrMsg & errMsg)197 ErrCode DriverExtMgrCallbackTest::OnConnect(
198 uint64_t deviceId, const sptr<IRemoteObject> &drvExtObj, const ErrMsg &errMsg)
199 {
200 EDM_LOGE(EDM_MODULE_TEST, "ErrMsg:%{public}d:%{public}s, deviceId:%{public}016" PRIX64 "",
201 static_cast<UsbErrCode>(errMsg.errCode), errMsg.msg.c_str(), deviceId);
202 std::cout << "OnConnect {errCode:" << static_cast<UsbErrCode>(errMsg.errCode) << ", ";
203 std::cout << "msg:" << errMsg.msg << ", ";
204 std::cout << "deviceId:" << deviceId << "}" << std::endl;
205 return EDM_OK;
206 }
207
OnDisconnect(uint64_t deviceId,const ErrMsg & errMsg)208 ErrCode DriverExtMgrCallbackTest::OnDisconnect(uint64_t deviceId, const ErrMsg &errMsg)
209 {
210 EDM_LOGE(EDM_MODULE_TEST, "ErrMsg:%{public}d:%{public}s, deviceId:%{public}016" PRIX64 "",
211 static_cast<UsbErrCode>(errMsg.errCode), errMsg.msg.c_str(), deviceId);
212 std::cout << "OnDisconnect {errCode:" << static_cast<UsbErrCode>(errMsg.errCode) << ", ";
213 std::cout << "msg:" << errMsg.msg << ", ";
214 std::cout << "deviceId:" << deviceId << "}" << std::endl;
215 return EDM_OK;
216 }
217
OnUnBind(uint64_t deviceId,const ErrMsg & errMsg)218 ErrCode DriverExtMgrCallbackTest::OnUnBind(uint64_t deviceId, const ErrMsg &errMsg)
219 {
220 EDM_LOGE(EDM_MODULE_TEST, "ErrMsg:%{public}d:%{public}s, deviceId:%{public}016" PRIX64 "",
221 static_cast<UsbErrCode>(errMsg.errCode), errMsg.msg.c_str(), deviceId);
222 std::cout << "OnUnBind {errCode:" << static_cast<UsbErrCode>(errMsg.errCode) << ", ";
223 std::cout << "msg:" << errMsg.msg << ", ";
224 std::cout << "deviceId:" << deviceId << "}" << std::endl;
225 return EDM_OK;
226 }
227
228 HWTEST_F(DrvExtMgrClientTest, BindDevice002, TestSize.Level1)
229 {
230 uint64_t deviceId = 0;
231 sptr<IDriverExtMgrCallback> connectCallback = new DriverExtMgrCallbackTest {};
232 UsbErrCode ret = DriverExtMgrClient::GetInstance().BindDevice(deviceId, connectCallback);
233 ASSERT_EQ(ret, UsbErrCode::EDM_NOK);
234 }
235
236 HWTEST_F(DrvExtMgrClientTest, UnBindDevice001, TestSize.Level1)
237 {
238 uint64_t deviceId = 0;
239 UsbErrCode ret = DriverExtMgrClient::GetInstance().UnBindDevice(deviceId);
240 ASSERT_EQ(ret, UsbErrCode::EDM_NOK);
241 }
242
243 HWTEST_F(DrvExtMgrClientTest, InvalidCode001, TestSize.Level1)
244 {
245 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
246 ASSERT_NE(samgr, nullptr);
247
248 auto saObj = samgr->CheckSystemAbility(HDF_EXTERNAL_DEVICE_MANAGER_SA_ID);
249 ASSERT_NE(saObj, nullptr);
250
251 uint32_t invalid_code = static_cast<uint32_t>(DriverExtMgrInterfaceCode::INVALID_CODE);
252 MessageParcel data;
253 MessageParcel reply;
254 MessageOption option;
255
256 ASSERT_TRUE(data.WriteInterfaceToken(IDriverExtMgr::GetDescriptor()));
257 int32_t ret = saObj->SendRequest(invalid_code, data, reply, option);
258 ASSERT_EQ(ret, ERROR_CODE_WITH_INVALID_CODE);
259 }
260 } // namespace ExternalDeviceManager
261 } // namespace OHOS