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