1 /*
2 * Copyright (c) 2021-2025 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 "usb_submit_transfer_isochronous_test.h"
17
18 #include <csignal>
19 #include <iostream>
20 #include <vector>
21
22 #include "if_system_ability_manager.h"
23 #include "ipc_skeleton.h"
24 #include "iservice_registry.h"
25 #include "iusb_srv.h"
26 #include "system_ability_definition.h"
27 #include "usb_common.h"
28 #include "usb_common_test.h"
29 #include "usb_device_pipe.h"
30 #include "usb_request.h"
31 #include "usb_srv_client.h"
32 #include "v1_2/usb_types.h"
33 #include "usb_errors.h"
34 #include "ashmem.h"
35
36 using namespace testing::ext;
37 using namespace OHOS::USB;
38 using namespace OHOS;
39 using namespace std;
40 using namespace OHOS::USB::Common;
41
42 namespace OHOS {
43 namespace USB {
44 namespace SubmitTransfer {
45 constexpr int32_t SLEEP_TIME = 3;
46
SetUpTestCase(void)47 void UsbSubmitTransferIsochronousTest::SetUpTestCase(void)
48 {
49 UsbCommonTest::GrantPermissionSysNative();
50 auto &srvClient = UsbSrvClient::GetInstance();
51 auto ret = srvClient.SetPortRole(1, 1, 1);
52 sleep(SLEEP_TIME);
53 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousTest:: [Device] SetPortRole:%{public}d", ret);
54 ret = UsbCommonTest::SwitchErrCode(ret);
55 ASSERT_TRUE(ret == 0);
56 if (ret != 0) {
57 exit(0);
58 }
59 std::cout << "please connect device, press enter to continue" << std::endl;
60 int c;
61 do {
62 c = getchar();
63 } while (c != '\n' && c != EOF);
64 USB_HILOGI(MODULE_USB_SERVICE, "Start UsbSubmitTransferIsochronousTest");
65 }
66
TearDownTestCase(void)67 void UsbSubmitTransferIsochronousTest::TearDownTestCase(void)
68 {
69 USB_HILOGI(MODULE_USB_SERVICE, "End UsbSubmitTransferIsochronousTest");
70 }
71
SetUp(void)72 void UsbSubmitTransferIsochronousTest::SetUp(void) {}
73
TearDown(void)74 void UsbSubmitTransferIsochronousTest::TearDown(void) {}
75
76 /**
77 * @tc.name: UsbSubmitTransferIsochronousWrite
78 * @tc.desc: Test the USB data write functionality of UsbSubmitTransfer OK.
79 * @tc.type: FUNC
80 */
81 HWTEST_F(UsbSubmitTransferIsochronousTest, UsbSubmitTransferIsochronousWrite, TestSize.Level1)
82 {
83 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite enter.");
84 vector<UsbDevice> devi;
85 auto &UsbSrvClient = UsbSrvClient::GetInstance();
86 auto ret = UsbSrvClient.GetDevices(devi);
87 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite %{public}d ret=%{public}d", __LINE__, ret);
88 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
89 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite %{public}d size=%{public}zu", __LINE__,
90 devi.size());
91 USBDevicePipe pipe;
92 UsbDevice device = devi.front();
93 UsbSrvClient.RequestRight(device.GetName());
94 ret = UsbSrvClient.OpenDevice(device, pipe);
95 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite %{public}d OpenDevice=%{public}d", __LINE__,
96 ret);
97 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
98 USBEndpoint point = interface.GetEndpoints().front();
99 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite %{public}d point=%{public}d", __LINE__,
100 point.GetInterfaceId());
101 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
102 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite %{public}d ClaimInterface=%{public}d",
103 __LINE__, ret);
104 UsbSrvClient.SetInterface(pipe, interface);
105 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
106 ASSERT_NE(ashmem, nullptr);
107 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
108 ashmem->MapReadAndWriteAshmem();
109 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
110 ASSERT_TRUE(writeSuccess);
111 HDI::Usb::V1_2::USBTransferInfo transferInfo;
112 transferInfo.endpoint = 0x05; // 0x01写 0x81读 测试设备：usb耳机，端点0x05
113 transferInfo.flags = 0;
114 transferInfo.type = TYPE_ISOCHRONOUS; // 开发板仅支持bulk
115 transferInfo.timeOut = 2000;
116 transferInfo.length = TEN; // 期望长度
117 transferInfo.userData = 0;
118 transferInfo.numIsoPackets = 1; // iso传输包数量 iso单包传输最大长度192
119 auto callback = [](const TransferCallbackInfo &info,
__anonbf509da60102(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 120 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
121 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite cb status:%{public}d,actualLength:%{public}d",
122 info.status, info.actualLength);
123 };
124 ret = UsbSrvClient.UsbSubmitTransfer(pipe, transferInfo, callback, ashmem);
125 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferIsochronousWrite ret:%{public}d", __LINE__, ret);
126 ASSERT_EQ(ret, UEC_OK);
127 bool close = UsbSrvClient.Close(pipe);
128 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite %{public}d close=%{public}d", __LINE__, close);
129 EXPECT_TRUE(close);
130 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite end.");
131 }
132
133 /**
134 * @tc.name: UsbSubmitTransferIsochronousRead
135 * @tc.desc: Test the USB data read functionality of UsbSubmitTransfer
136 * @tc.type: FUNC
137 */
138 HWTEST_F(UsbSubmitTransferIsochronousTest, UsbSubmitTransferIsochronousRead, TestSize.Level1)
139 {
140 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousRead enter.");
141
142 vector<UsbDevice> delist;
143 auto &UsbSrvClient = UsbSrvClient::GetInstance();
144 auto ret = UsbSrvClient.GetDevices(delist);
145 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
146 UsbDevice device = delist.front();
147 ret = UsbSrvClient.RequestRight(device.GetName());
148 USBDevicePipe pip;
149 ret = UsbSrvClient.OpenDevice(device, pip);
150 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
151 USBEndpoint point = interface.GetEndpoints().front();
152 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
153 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousRead ClaimInterface ret%{public}d", ret);
154 UsbSrvClient.SetInterface(pip, interface);
155 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
156 ASSERT_NE(ashmem, nullptr);
157 ashmem->MapReadAndWriteAshmem();
158
159 HDI::Usb::V1_2::USBTransferInfo transferInfo;
160 transferInfo.endpoint = 0x84; // 0x01写 0x81读
161 transferInfo.flags = 0;
162 transferInfo.type = TYPE_ISOCHRONOUS; // 开发板仅支持bulk
163 transferInfo.timeOut = 2000;
164 transferInfo.length = TEN; // 期望长度
165 transferInfo.userData = 0;
166 transferInfo.numIsoPackets = 1; // iso传输包数量 iso单包传输最大长度192
167
168 auto callback = [](const TransferCallbackInfo &info,
__anonbf509da60202(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 169 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
170 USB_HILOGI(MODULE_USB_SERVICE,
171 "UsbSubmitTransferIsochronousRead Callback status: %{public}d, actualLength: %{public}d",
172 info.status, info.actualLength);
173 };
174
175 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
176 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferIsochronousRead ret:%{public}d", __LINE__, ret);
177 ASSERT_EQ(ret, UEC_OK);
178
179 bool close = UsbSrvClient.Close(pip);
180 EXPECT_TRUE(close);
181 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousRead end.");
182 }
183
184 /**
185 * @tc.name: UsbSubmitTransferIsochronousWriteInvalidEndpoint
186 * @tc.desc: Test the USB data write functionality of UsbSubmitTransfer with invalid endpoint type
187 * @tc.type: FUNC
188 */
189 HWTEST_F(UsbSubmitTransferIsochronousTest, UsbSubmitTransferIsochronousWriteInvalidEndpoint, TestSize.Level1)
190 {
191 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWriteInvalidEndpoint begin.");
192
193 vector<UsbDevice> delist;
194 auto &UsbSrvClient = UsbSrvClient::GetInstance();
195 auto ret = UsbSrvClient.GetDevices(delist);
196 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
197 UsbDevice device = delist.front();
198 ret = UsbSrvClient.RequestRight(device.GetName());
199 USBDevicePipe pip;
200 ret = UsbSrvClient.OpenDevice(device, pip);
201 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
202 USBEndpoint point = interface.GetEndpoints().front();
203 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
204 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferIsochronousWriteInvalidEndpoint ret:%{public}d",
205 __LINE__, ret);
206
207 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
208 ASSERT_NE(ashmem, nullptr);
209 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
210 ashmem->MapReadAndWriteAshmem();
211 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
212 ASSERT_TRUE(writeSuccess);
213 HDI::Usb::V1_2::USBTransferInfo transferInfo;
214 transferInfo.endpoint = 0xFF; //无效参数
215 transferInfo.flags = 0;
216 transferInfo.type = TYPE_ISOCHRONOUS; // 开发板仅支持bulk
217 transferInfo.timeOut = 2000;
218 transferInfo.length = TEN; // 期望长度
219 transferInfo.userData = 0;
220 transferInfo.numIsoPackets = 1; // iso传输包数量 iso单包传输最大长度192
221
222 auto callback = [](const TransferCallbackInfo &info,
__anonbf509da60302(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 223 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
224 USB_HILOGI(MODULE_USB_SERVICE,
225 "UsbSubmitTransferIsochronousWriteInvalidEndpoint cb status: %{public}d, actualLength: %{public}d",
226 info.status, info.actualLength);
227 };
228 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
229 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferIsochronousWriteInvalidEndpoint ret=%{public}d",
230 __LINE__, ret);
231 ASSERT_EQ(ret, OHEC_COMMON_PARAM_ERROR);
232 bool close = UsbSrvClient.Close(pip);
233 EXPECT_TRUE(close);
234 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWriteInvalidEndpoint end.");
235 }
236
237 /**
238 * @tc.name: UsbSubmitTransferIsochronousWriteIoError
239 * @tc.desc: Test USB I/O error when interface is not claimed.
240 * @tc.type: FUNC
241 */
242 HWTEST_F(UsbSubmitTransferIsochronousTest, UsbSubmitTransferIsochronousWriteIoError, TestSize.Level1)
243 {
244 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWriteIoError begin.");
245 vector<UsbDevice> delist;
246 auto &UsbSrvClient = UsbSrvClient::GetInstance();
247 auto ret = UsbSrvClient.GetDevices(delist);
248 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
249 UsbDevice device = delist.front();
250 ret = UsbSrvClient.RequestRight(device.GetName());
251 USBDevicePipe pip;
252 ret = UsbSrvClient.OpenDevice(device, pip);
253 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
254 USBEndpoint point = interface.GetEndpoints().front();
255 UsbSrvClient.ReleaseInterface(pip, interface);
256 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
257 ASSERT_NE(ashmem, nullptr);
258 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
259 ashmem->MapReadAndWriteAshmem();
260 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
261 ASSERT_TRUE(writeSuccess);
262 HDI::Usb::V1_2::USBTransferInfo transferInfo;
263 transferInfo.endpoint = 0x01; // 写操作（对于开发板，0x81是读操作）
264 transferInfo.flags = 0;
265 transferInfo.type = TYPE_ISOCHRONOUS; // 开发板仅支持bulk
266 transferInfo.timeOut = 2000;
267 transferInfo.length = TEN; // 期望长度
268 transferInfo.userData = 0;
269 transferInfo.numIsoPackets = 1; // iso传输包数量 iso单包传输最大长度192
270 auto callback = [](const TransferCallbackInfo &info,
__anonbf509da60402(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 271 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
272 USB_HILOGI(MODULE_USB_SERVICE, "IsochronousWriteIoError status:%{public}d,actualLength:%{public}d",
273 info.status, info.actualLength);
274 };
275 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
276 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferIsochronousWriteIoError ret:%{public}d",
277 __LINE__, ret);
278 ASSERT_EQ(ret, USB_SUBMIT_TRANSFER_IO_ERROR);
279 bool close = UsbSrvClient.Close(pip);
280 EXPECT_TRUE(close);
281 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWriteIoError end.");
282 }
283
284 /**
285 * @tc.name: UsbCancelTransferIsochronousWrite
286 * @tc.desc: Test the functionality of UsbCancelTransfer for write operation
287 * @tc.type: FUNC
288 */
289 HWTEST_F(UsbSubmitTransferIsochronousTest, UsbCancelTransferIsochronousWrite, TestSize.Level1)
290 {
291 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferIsochronousWrite enter.");
292 vector<UsbDevice> delist;
293 auto &UsbSrvClient = UsbSrvClient::GetInstance();
294 auto ret = UsbSrvClient.GetDevices(delist);
295 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
296 UsbDevice device = delist.front();
297 ret = UsbSrvClient.RequestRight(device.GetName());
298 USBDevicePipe pip;
299 ret = UsbSrvClient.OpenDevice(device, pip);
300 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
301 USBEndpoint point = interface.GetEndpoints().front();
302 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
303 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferIsochronousWrite ClaimInterface %{public}d ret:%{public}d",
304 __LINE__, ret);
305
306 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
307 ASSERT_NE(ashmem, nullptr);
308 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
309 ashmem->MapReadAndWriteAshmem();
310 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, TEN, 0);
311 ASSERT_TRUE(writeSuccess);
312
313 HDI::Usb::V1_2::USBTransferInfo transferInfo;
314 transferInfo.endpoint = 0x05; // 写操作
315 transferInfo.flags = 0;
316 transferInfo.type = TYPE_ISOCHRONOUS; // 开发板不支持ISO传输类型
317 transferInfo.timeOut = 0; // 设置超时时间
318 transferInfo.length = TEN; // 设置传输数据的长度
319 transferInfo.userData = 0;
320 transferInfo.numIsoPackets = 1; // 只有type为1有iso
321
322 auto callback = [](const TransferCallbackInfo &info,
__anonbf509da60502(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 323 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
324 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferIsochronousWrite cb status:%{public}d,actualLength:%{public}d",
325 info.status, info.actualLength);
326 };
327 UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
328 // 取消写操作
329 ret = UsbSrvClient.UsbCancelTransfer(pip, transferInfo.endpoint);
330 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbCancelTransferIsochronousWrite ret:%{public}d", __LINE__, ret);
331 ASSERT_EQ(ret, USB_SUBMIT_TRANSFER_NOT_FOUND_ERROR); // 传输已完成或者已被取消
332
333 bool close = UsbSrvClient.Close(pip);
334 EXPECT_TRUE(close);
335
336 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferIsochronousWrite end.");
337 }
338 } // namespace SubmitTransfer
339 } // namespace USB
340 } // namespace OHOS