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> delist;
85 auto &UsbSrvClient = UsbSrvClient::GetInstance();
86 auto ret = UsbSrvClient.GetDevices(delist);
87 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite %{public}d ret=%{public}d", __LINE__, ret);
88 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
89 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite %{public}d size=%{public}zu", __LINE__,
90 delist.size());
91 USBDevicePipe pipe;
92 UsbDevice device;
93 bool hasDevice = false;
94 for (int32_t i = 0; i < delist.size(); i++) {
95 if (delist[i].GetClass() != 9) {
96 device = delist[i];
97 hasDevice = true;
98 }
99 }
100 EXPECT_TRUE(hasDevice);
101 UsbSrvClient.RequestRight(device.GetName());
102 ret = UsbSrvClient.OpenDevice(device, pipe);
103 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite %{public}d OpenDevice=%{public}d", __LINE__,
104 ret);
105 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
106 USBEndpoint point = interface.GetEndpoints().front();
107 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite %{public}d point=%{public}d", __LINE__,
108 point.GetInterfaceId());
109 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
110 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite %{public}d ClaimInterface=%{public}d",
111 __LINE__, ret);
112 UsbSrvClient.SetInterface(pipe, interface);
113 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
114 ASSERT_NE(ashmem, nullptr);
115 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
116 ashmem->MapReadAndWriteAshmem();
117 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
118 ASSERT_TRUE(writeSuccess);
119 HDI::Usb::V1_2::USBTransferInfo transferInfo;
120 transferInfo.endpoint = 0x05; // 0x01写 0x81读 测试设备：usb耳机，端点0x05
121 transferInfo.flags = 0;
122 transferInfo.type = TYPE_ISOCHRONOUS; // 开发板仅支持bulk
123 transferInfo.timeOut = 2000;
124 transferInfo.length = TEN; // 期望长度
125 transferInfo.userData = 0;
126 transferInfo.numIsoPackets = 1; // iso传输包数量 iso单包传输最大长度192
127 auto callback = [](const TransferCallbackInfo &info,
__anond424f6080102(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 128 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
129 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite cb status:%{public}d,actualLength:%{public}d",
130 info.status, info.actualLength);
131 };
132 ret = UsbSrvClient.UsbSubmitTransfer(pipe, transferInfo, callback, ashmem);
133 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferIsochronousWrite ret:%{public}d", __LINE__, ret);
134 ASSERT_EQ(ret, UEC_OK);
135 bool close = UsbSrvClient.Close(pipe);
136 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite %{public}d close=%{public}d", __LINE__, close);
137 EXPECT_TRUE(close);
138 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWrite end.");
139 }
140
141 /**
142 * @tc.name: UsbSubmitTransferIsochronousRead
143 * @tc.desc: Test the USB data read functionality of UsbSubmitTransfer
144 * @tc.type: FUNC
145 */
146 HWTEST_F(UsbSubmitTransferIsochronousTest, UsbSubmitTransferIsochronousRead, TestSize.Level1)
147 {
148 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousRead enter.");
149
150 vector<UsbDevice> delist;
151 auto &UsbSrvClient = UsbSrvClient::GetInstance();
152 auto ret = UsbSrvClient.GetDevices(delist);
153 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
154 UsbDevice device;
155 bool hasDevice = false;
156 for (int32_t i = 0; i < delist.size(); i++) {
157 if (delist[i].GetClass() != 9) {
158 device = delist[i];
159 hasDevice = true;
160 }
161 }
162 EXPECT_TRUE(hasDevice);
163 ret = UsbSrvClient.RequestRight(device.GetName());
164 USBDevicePipe pip;
165 ret = UsbSrvClient.OpenDevice(device, pip);
166 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
167 USBEndpoint point = interface.GetEndpoints().front();
168 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
169 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousRead ClaimInterface ret%{public}d", ret);
170 UsbSrvClient.SetInterface(pip, interface);
171 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
172 ASSERT_NE(ashmem, nullptr);
173 ashmem->MapReadAndWriteAshmem();
174
175 HDI::Usb::V1_2::USBTransferInfo transferInfo;
176 transferInfo.endpoint = 0x84; // 0x01写 0x81读
177 transferInfo.flags = 0;
178 transferInfo.type = TYPE_ISOCHRONOUS; // 开发板仅支持bulk
179 transferInfo.timeOut = 2000;
180 transferInfo.length = TEN; // 期望长度
181 transferInfo.userData = 0;
182 transferInfo.numIsoPackets = 1; // iso传输包数量 iso单包传输最大长度192
183
184 auto callback = [](const TransferCallbackInfo &info,
__anond424f6080202(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 185 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
186 USB_HILOGI(MODULE_USB_SERVICE,
187 "UsbSubmitTransferIsochronousRead Callback status: %{public}d, actualLength: %{public}d",
188 info.status, info.actualLength);
189 };
190
191 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
192 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferIsochronousRead ret:%{public}d", __LINE__, ret);
193 ASSERT_EQ(ret, UEC_OK);
194
195 bool close = UsbSrvClient.Close(pip);
196 EXPECT_TRUE(close);
197 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousRead end.");
198 }
199
200 /**
201 * @tc.name: UsbSubmitTransferIsochronousWriteInvalidEndpoint
202 * @tc.desc: Test the USB data write functionality of UsbSubmitTransfer with invalid endpoint type
203 * @tc.type: FUNC
204 */
205 HWTEST_F(UsbSubmitTransferIsochronousTest, UsbSubmitTransferIsochronousWriteInvalidEndpoint, TestSize.Level1)
206 {
207 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWriteInvalidEndpoint begin.");
208
209 vector<UsbDevice> delist;
210 auto &UsbSrvClient = UsbSrvClient::GetInstance();
211 auto ret = UsbSrvClient.GetDevices(delist);
212 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
213 UsbDevice device;
214 bool hasDevice = false;
215 for (int32_t i = 0; i < delist.size(); i++) {
216 if (delist[i].GetClass() != 9) {
217 device = delist[i];
218 hasDevice = true;
219 }
220 }
221 EXPECT_TRUE(hasDevice);
222 ret = UsbSrvClient.RequestRight(device.GetName());
223 USBDevicePipe pip;
224 ret = UsbSrvClient.OpenDevice(device, pip);
225 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
226 USBEndpoint point = interface.GetEndpoints().front();
227 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
228 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferIsochronousWriteInvalidEndpoint ret:%{public}d",
229 __LINE__, ret);
230
231 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
232 ASSERT_NE(ashmem, nullptr);
233 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
234 ashmem->MapReadAndWriteAshmem();
235 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
236 ASSERT_TRUE(writeSuccess);
237 HDI::Usb::V1_2::USBTransferInfo transferInfo;
238 transferInfo.endpoint = 0xFF; //无效参数
239 transferInfo.flags = 0;
240 transferInfo.type = TYPE_ISOCHRONOUS; // 开发板仅支持bulk
241 transferInfo.timeOut = 2000;
242 transferInfo.length = TEN; // 期望长度
243 transferInfo.userData = 0;
244 transferInfo.numIsoPackets = 1; // iso传输包数量 iso单包传输最大长度192
245
246 auto callback = [](const TransferCallbackInfo &info,
__anond424f6080302(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 247 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
248 USB_HILOGI(MODULE_USB_SERVICE,
249 "UsbSubmitTransferIsochronousWriteInvalidEndpoint cb status: %{public}d, actualLength: %{public}d",
250 info.status, info.actualLength);
251 };
252 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
253 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferIsochronousWriteInvalidEndpoint ret=%{public}d",
254 __LINE__, ret);
255 ASSERT_EQ(ret, OHEC_COMMON_PARAM_ERROR);
256 bool close = UsbSrvClient.Close(pip);
257 EXPECT_TRUE(close);
258 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWriteInvalidEndpoint end.");
259 }
260
261 /**
262 * @tc.name: UsbSubmitTransferIsochronousWriteIoError
263 * @tc.desc: Test USB I/O error when interface is not claimed.
264 * @tc.type: FUNC
265 */
266 HWTEST_F(UsbSubmitTransferIsochronousTest, UsbSubmitTransferIsochronousWriteIoError, TestSize.Level1)
267 {
268 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWriteIoError begin.");
269 vector<UsbDevice> delist;
270 auto &UsbSrvClient = UsbSrvClient::GetInstance();
271 auto ret = UsbSrvClient.GetDevices(delist);
272 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
273 UsbDevice device;
274 bool hasDevice = false;
275 for (int32_t i = 0; i < delist.size(); i++) {
276 if (delist[i].GetClass() != 9) {
277 device = delist[i];
278 hasDevice = true;
279 }
280 }
281 EXPECT_TRUE(hasDevice);
282 ret = UsbSrvClient.RequestRight(device.GetName());
283 USBDevicePipe pip;
284 ret = UsbSrvClient.OpenDevice(device, pip);
285 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
286 USBEndpoint point = interface.GetEndpoints().front();
287 UsbSrvClient.ReleaseInterface(pip, interface);
288 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
289 ASSERT_NE(ashmem, nullptr);
290 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
291 ashmem->MapReadAndWriteAshmem();
292 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
293 ASSERT_TRUE(writeSuccess);
294 HDI::Usb::V1_2::USBTransferInfo transferInfo;
295 transferInfo.endpoint = 0x01; // 写操作（对于开发板，0x81是读操作）
296 transferInfo.flags = 0;
297 transferInfo.type = TYPE_ISOCHRONOUS; // 开发板仅支持bulk
298 transferInfo.timeOut = 2000;
299 transferInfo.length = TEN; // 期望长度
300 transferInfo.userData = 0;
301 transferInfo.numIsoPackets = 1; // iso传输包数量 iso单包传输最大长度192
302 auto callback = [](const TransferCallbackInfo &info,
__anond424f6080402(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 303 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
304 USB_HILOGI(MODULE_USB_SERVICE, "IsochronousWriteIoError status:%{public}d,actualLength:%{public}d",
305 info.status, info.actualLength);
306 };
307 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
308 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferIsochronousWriteIoError ret:%{public}d",
309 __LINE__, ret);
310 ASSERT_EQ(ret, USB_SUBMIT_TRANSFER_IO_ERROR);
311 bool close = UsbSrvClient.Close(pip);
312 EXPECT_TRUE(close);
313 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferIsochronousWriteIoError end.");
314 }
315
316 /**
317 * @tc.name: UsbCancelTransferIsochronousWrite
318 * @tc.desc: Test the functionality of UsbCancelTransfer for write operation
319 * @tc.type: FUNC
320 */
321 HWTEST_F(UsbSubmitTransferIsochronousTest, UsbCancelTransferIsochronousWrite, TestSize.Level1)
322 {
323 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferIsochronousWrite enter.");
324 vector<UsbDevice> delist;
325 auto &UsbSrvClient = UsbSrvClient::GetInstance();
326 auto ret = UsbSrvClient.GetDevices(delist);
327 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
328 UsbDevice device;
329 bool hasDevice = false;
330 for (int32_t i = 0; i < delist.size(); i++) {
331 if (delist[i].GetClass() != 9) {
332 device = delist[i];
333 hasDevice = true;
334 }
335 }
336 EXPECT_TRUE(hasDevice);
337 ret = UsbSrvClient.RequestRight(device.GetName());
338 USBDevicePipe pip;
339 ret = UsbSrvClient.OpenDevice(device, pip);
340 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
341 USBEndpoint point = interface.GetEndpoints().front();
342 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
343 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferIsochronousWrite ClaimInterface %{public}d ret:%{public}d",
344 __LINE__, ret);
345
346 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
347 ASSERT_NE(ashmem, nullptr);
348 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
349 ashmem->MapReadAndWriteAshmem();
350 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, TEN, 0);
351 ASSERT_TRUE(writeSuccess);
352
353 HDI::Usb::V1_2::USBTransferInfo transferInfo;
354 transferInfo.endpoint = 0x05; // 写操作
355 transferInfo.flags = 0;
356 transferInfo.type = TYPE_ISOCHRONOUS; // 开发板不支持ISO传输类型
357 transferInfo.timeOut = 0; // 设置超时时间
358 transferInfo.length = TEN; // 设置传输数据的长度
359 transferInfo.userData = 0;
360 transferInfo.numIsoPackets = 1; // 只有type为1有iso
361
362 auto callback = [](const TransferCallbackInfo &info,
__anond424f6080502(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 363 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
364 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferIsochronousWrite cb status:%{public}d,actualLength:%{public}d",
365 info.status, info.actualLength);
366 };
367 UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
368 // 取消写操作
369 ret = UsbSrvClient.UsbCancelTransfer(pip, transferInfo.endpoint);
370 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbCancelTransferIsochronousWrite ret:%{public}d", __LINE__, ret);
371 ASSERT_EQ(ret, USB_SUBMIT_TRANSFER_NOT_FOUND_ERROR); // 传输已完成或者已被取消
372
373 bool close = UsbSrvClient.Close(pip);
374 EXPECT_TRUE(close);
375
376 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferIsochronousWrite end.");
377 }
378 } // namespace SubmitTransfer
379 } // namespace USB
380 } // namespace OHOS