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_bulk_test.h"
17
18 #include <thread>
19 #include <mutex>
20 #include <functional>
21 #include <condition_variable>
22 #include <atomic>
23 #include <csignal>
24 #include <iostream>
25 #include <vector>
26
27 #include "if_system_ability_manager.h"
28 #include "ipc_skeleton.h"
29 #include "iservice_registry.h"
30 #include "iusb_srv.h"
31 #include "system_ability_definition.h"
32 #include "usb_common.h"
33 #include "usb_common_test.h"
34 #include "usb_device_pipe.h"
35 #include "usb_request.h"
36 #include "usb_srv_client.h"
37 #include "v1_2/usb_types.h"
38 #include "usb_errors.h"
39 #include "ashmem.h"
40
41 using namespace testing::ext;
42 using namespace OHOS::USB;
43 using namespace OHOS;
44 using namespace std;
45 using namespace OHOS::USB::Common;
46
47 namespace OHOS {
48 namespace USB {
49 namespace SubmitTransfer {
50 constexpr int32_t SLEEP_TIME = 3;
51 constexpr int32_t TIMEOUT = 2000;
52 constexpr int32_t USB_DEVICE_CLASS_HUB = 9;
53 std::mutex g_mtx; // Global mutexes to protect shared resources
54 std::condition_variable g_cv; // Condition variables for synchronization between threads
55 std::vector<bool> g_threadSuccessFlags; // Mark whether the thread operation was successful
56 std::atomic<int32_t> g_completedThreads(0); // Used to mark the number of thread completions
57 std::atomic<int32_t> g_successCount(0); // Counts the number of successful ASSERT_EQ (ret, UEC_OK).
SetUpTestCase(void)58 void UsbSubmitTransferBulkTest::SetUpTestCase(void)
59 {
60 UsbCommonTest::GrantPermissionSysNative();
61 auto &srvClient = UsbSrvClient::GetInstance();
62 auto ret = srvClient.SetPortRole(1, 1, 1);
63 sleep(SLEEP_TIME);
64 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkTest:: [Device] SetPortRole:%{public}d", ret);
65 ret = UsbCommonTest::SwitchErrCode(ret);
66 ASSERT_TRUE(ret == 0);
67 if (ret != 0) {
68 exit(0);
69 }
70 std::cout << "please connect device, press enter to continue" << std::endl;
71 int c;
72 do {
73 c = getchar();
74 } while (c != '\n' && c != EOF);
75 USB_HILOGI(MODULE_USB_SERVICE, "Start UsbSubmitTransferBulkTest");
76 }
77
TearDownTestCase(void)78 void UsbSubmitTransferBulkTest::TearDownTestCase(void)
79 {
80 USB_HILOGI(MODULE_USB_SERVICE, "End UsbSubmitTransferBulkTest");
81 }
82
SetUp(void)83 void UsbSubmitTransferBulkTest::SetUp(void) {}
84
TearDown(void)85 void UsbSubmitTransferBulkTest::TearDown(void) {}
86
UsbSubmitTransferBulkWriteThreadFunc(int32_t threadId)87 void UsbSubmitTransferBulkWriteThreadFunc(int32_t threadId)
88 {
89 std::unique_lock<std::mutex> lock(g_mtx);
90 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite enter.");
91 vector<UsbDevice> delist;
92 auto &UsbSrvClient = UsbSrvClient::GetInstance();
93 auto ret = UsbSrvClient.GetDevices(delist);
94 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
95 USBDevicePipe pipe;
96 UsbDevice device;
97 bool hasDevice = false;
98 for (int32_t i = 0; i < delist.size(); i++) {
99 if (delist[i].GetClass() != USB_DEVICE_CLASS_HUB) {
100 device = delist[i];
101 hasDevice = true;
102 }
103 }
104 EXPECT_TRUE(hasDevice);
105 UsbSrvClient.RequestRight(device.GetName());
106 ret = UsbSrvClient.OpenDevice(device, pipe);
107 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d OpenDevice=%{public}d", __LINE__,
108 ret);
109 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
110 USBEndpoint point = interface.GetEndpoints().front();
111 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d point=%{public}d", __LINE__,
112 point.GetInterfaceId());
113 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
114 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
115 ASSERT_NE(ashmem, nullptr);
116 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
117 ashmem->MapReadAndWriteAshmem();
118 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
119 ASSERT_TRUE(writeSuccess);
120 HDI::Usb::V1_2::USBTransferInfo transferInfo;
121 transferInfo.endpoint = 0x01; // 0x01写 0x81读
122 transferInfo.flags = 0;
123 transferInfo.type = TYPE_BULK; // 开发板仅支持bulk
124 transferInfo.timeOut = TIMEOUT;
125 transferInfo.length = TEN; // 期望长度
126 transferInfo.userData = 0;
127 transferInfo.numIsoPackets = 0; // iso传输包数量 iso单包传输最大长度192
128 auto callback = [](const TransferCallbackInfo &info,
129 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {};
130 ret = UsbSrvClient.UsbSubmitTransfer(pipe, transferInfo, callback, ashmem);
131 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferBulkWrite ret:%{public}d", __LINE__, ret);
132 if (ret == UEC_OK) {
133 g_successCount++;
134 }
135 ASSERT_EQ(ret, UEC_OK);
136 bool close = UsbSrvClient.Close(pipe);
137 EXPECT_TRUE(close);
138 lock.unlock();
139 g_threadSuccessFlags[threadId] = true;
140 g_completedThreads++;
141 g_cv.notify_one();
142 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite end.");
143 }
144
145 HWTEST_F(UsbSubmitTransferBulkTest, UsbSubmitTransferBulkWriteConcurrent, TestSize.Level1)
146 {
147 int32_t numThreads = 5; // 并发线程数量
148 g_threadSuccessFlags.resize(numThreads);
149 std::vector<std::thread> threads;
150 // 启动多个线程
151 for (int32_t i = 0; i < numThreads; ++i) {
__anonb32fd79a0202() 152 threads.emplace_back([i]() { UsbSubmitTransferBulkWriteThreadFunc(i); });
153 }
154 // 等待所有线程完成
155 std::unique_lock<std::mutex> lock(g_mtx);
__anonb32fd79a0302null156 g_cv.wait(lock, [numThreads]{ return g_completedThreads == numThreads; });
157 // 清理资源和验证结果
158 for (auto& t : threads) {
159 t.join();
160 }
161 // 检查是否所有线程都成功完成操作
162 for (int32_t i = 0; i < numThreads; ++i) {
163 EXPECT_TRUE(g_threadSuccessFlags[i]) << "Thread " << i << " did not complete successfully.";
164 }
165 // 检查是否所有的 ASSERT_EQ(ret, UEC_OK) 都成功
166 EXPECT_EQ(g_successCount, numThreads) << "Not all UsbSubmitTransfer calls returned UEC_OK.";
167 }
168
169 /**
170 * @tc.name: UsbSubmitTransferBulkWrite
171 * @tc.desc: Test the USB data write functionality of UsbSubmitTransfer OK.
172 * @tc.type: FUNC
173 */
174 HWTEST_F(UsbSubmitTransferBulkTest, UsbSubmitTransferBulkWrite, TestSize.Level1)
175 {
176 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite enter.");
177 vector<UsbDevice> delist;
178 auto &UsbSrvClient = UsbSrvClient::GetInstance();
179 auto ret = UsbSrvClient.GetDevices(delist);
180 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d ret=%{public}d", __LINE__, ret);
181 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
182 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d size=%{public}zu", __LINE__,
183 delist.size());
184 USBDevicePipe pipe;
185 UsbDevice device;
186 bool hasDevice = false;
187 for (int32_t i = 0; i < delist.size(); i++) {
188 if (delist[i].GetClass() != USB_DEVICE_CLASS_HUB) {
189 device = delist[i];
190 hasDevice = true;
191 }
192 }
193 EXPECT_TRUE(hasDevice);
194 UsbSrvClient.RequestRight(device.GetName());
195 ret = UsbSrvClient.OpenDevice(device, pipe);
196 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d OpenDevice=%{public}d", __LINE__,
197 ret);
198 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
199 USBEndpoint point = interface.GetEndpoints().front();
200 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d point=%{public}d", __LINE__,
201 point.GetInterfaceId());
202 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
203 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
204 ASSERT_NE(ashmem, nullptr);
205 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
206 ashmem->MapReadAndWriteAshmem();
207 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
208 ASSERT_TRUE(writeSuccess);
209 HDI::Usb::V1_2::USBTransferInfo transferInfo;
210 transferInfo.endpoint = 0x01; // 0x01写 0x81读
211 transferInfo.flags = 0;
212 transferInfo.type = TYPE_BULK;
213 transferInfo.timeOut = 2000;
214 transferInfo.length = TEN; // 期望长度
215 transferInfo.userData = 0;
216 transferInfo.numIsoPackets = 0; // iso传输包数量 iso单包传输最大长度192
217 auto callback = [](const TransferCallbackInfo &info,
__anonb32fd79a0402(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 218 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
219 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite cb status:%{public}d,actualLength:%{public}d",
220 info.status, info.actualLength);
221 };
222 ret = UsbSrvClient.UsbSubmitTransfer(pipe, transferInfo, callback, ashmem);
223 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferBulkWrite ret:%{public}d", __LINE__, ret);
224 ASSERT_EQ(ret, UEC_OK);
225 bool close = UsbSrvClient.Close(pipe);
226 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d close=%{public}d", __LINE__, close);
227 EXPECT_TRUE(close);
228 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite end.");
229 }
230
231 /**
232 * @tc.name: UsbSubmitTransferBulkWriteParamError
233 * @tc.desc: Test the USB data write functionality of UsbSubmitTransfer OK.
234 * @tc.type: FUNC
235 */
236 HWTEST_F(UsbSubmitTransferBulkTest, UsbSubmitTransferBulkWriteParamError, TestSize.Level1)
237 {
238 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteParamError enter.");
239 vector<UsbDevice> delist;
240 auto &UsbSrvClient = UsbSrvClient::GetInstance();
241 auto ret = UsbSrvClient.GetDevices(delist);
242 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteParamError %{public}d ret=%{public}d", __LINE__, ret);
243 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
244 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteParamError %{public}d size=%{public}zu", __LINE__,
245 delist.size());
246 USBDevicePipe pipe;
247 UsbDevice device;
248 bool hasDevice = false;
249 for (int32_t i = 0; i < delist.size(); i++) {
250 if (delist[i].GetClass() != USB_DEVICE_CLASS_HUB) {
251 device = delist[i];
252 hasDevice = true;
253 }
254 }
255 EXPECT_TRUE(hasDevice);
256 UsbSrvClient.RequestRight(device.GetName());
257 ret = UsbSrvClient.OpenDevice(device, pipe);
258 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteParamError %{public}d OpenDevice=%{public}d", __LINE__,
259 ret);
260 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
261 USBEndpoint point = interface.GetEndpoints().front();
262 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteParamError %{public}d point=%{public}d", __LINE__,
263 point.GetInterfaceId());
264 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
265 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
266 ASSERT_NE(ashmem, nullptr);
267 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
268 ashmem->MapReadAndWriteAshmem();
269 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
270 ASSERT_TRUE(writeSuccess);
271 HDI::Usb::V1_2::USBTransferInfo transferInfo;
272 transferInfo.endpoint = 0x01; // 0x01写 0x81读
273 transferInfo.flags = 0;
274 transferInfo.type = 5; // 错误类型
275 transferInfo.timeOut = 2000;
276 transferInfo.length = TEN; // 期望长度
277 transferInfo.userData = 0;
278 transferInfo.numIsoPackets = 0; // iso传输包数量 iso单包传输最大长度192
279 auto callback = [](const TransferCallbackInfo &info,
__anonb32fd79a0502(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 280 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
281 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite cb status:%{public}d,actualLength:%{public}d",
282 info.status, info.actualLength);
283 };
284 ret = UsbSrvClient.UsbSubmitTransfer(pipe, transferInfo, callback, ashmem);
285 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. BulkWriteParamError ret:%{public}d", __LINE__, ret);
286 ASSERT_EQ(ret, OHEC_COMMON_PARAM_ERROR);
287 bool close = UsbSrvClient.Close(pipe);
288 EXPECT_TRUE(close);
289 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteParamError end.");
290 }
291
292 /**
293 * @tc.name: UsbSubmitTransferBulkReadTimeOut
294 * @tc.desc: Test the USB data read functionality of UsbSubmitTransfer
295 * @tc.type: FUNC
296 */
297 HWTEST_F(UsbSubmitTransferBulkTest, UsbSubmitTransferBulkReadTimeOut, TestSize.Level1)
298 {
299 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkReadTimeOut enter.");
300
301 vector<UsbDevice> delist;
302 auto &UsbSrvClient = UsbSrvClient::GetInstance();
303 auto ret = UsbSrvClient.GetDevices(delist);
304 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
305 UsbDevice device;
306 bool hasDevice = false;
307 for (int32_t i = 0; i < delist.size(); i++) {
308 if (delist[i].GetClass() != USB_DEVICE_CLASS_HUB) {
309 device = delist[i];
310 hasDevice = true;
311 }
312 }
313 EXPECT_TRUE(hasDevice);
314 ret = UsbSrvClient.RequestRight(device.GetName());
315 USBDevicePipe pip;
316 ret = UsbSrvClient.OpenDevice(device, pip);
317 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
318 USBEndpoint point = interface.GetEndpoints().front();
319 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
320 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkReadTimeOut ClaimInterface ret%{public}d", ret);
321
322 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
323 ASSERT_NE(ashmem, nullptr);
324 ashmem->MapReadAndWriteAshmem();
325
326 HDI::Usb::V1_2::USBTransferInfo transferInfo;
327 transferInfo.endpoint = 0x81; // 0x01写 0x81读
328 transferInfo.flags = 0;
329 transferInfo.type = TYPE_BULK; // 开发板仅支持bulk
330 transferInfo.timeOut = 2000;
331 transferInfo.length = TEN; // 期望长度
332 transferInfo.userData = 0;
333 transferInfo.numIsoPackets = 0; // iso传输包数量 iso单包传输最大长度192
334
335 auto callback = [](const TransferCallbackInfo &info,
__anonb32fd79a0602(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 336 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
337 USB_HILOGI(MODULE_USB_SERVICE,
338 "UsbSubmitTransferBulkReadTimeOut Callback status: %{public}d, actualLength: %{public}d",
339 info.status, info.actualLength);
340 };
341
342 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
343 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferBulkReadTimeOut ret:%{public}d", __LINE__, ret);
344 ASSERT_EQ(ret, UEC_OK);
345
346 bool close = UsbSrvClient.Close(pip);
347 EXPECT_TRUE(close);
348 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkReadTimeOut end.");
349 }
350
351 /**
352 * @tc.name: UsbSubmitTransferBulkWriteIOError
353 * @tc.desc: Test the USB data write functionality of UsbSubmitTransfer with invalid endpoint type
354 * @tc.type: FUNC
355 */
356 HWTEST_F(UsbSubmitTransferBulkTest, UsbSubmitTransferBulkWriteIOError, TestSize.Level1)
357 {
358 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteIOError begin.");
359
360 vector<UsbDevice> delist;
361 auto &UsbSrvClient = UsbSrvClient::GetInstance();
362 auto ret = UsbSrvClient.GetDevices(delist);
363 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
364 UsbDevice device;
365 bool hasDevice = false;
366 for (int32_t i = 0; i < delist.size(); i++) {
367 if (delist[i].GetClass() != USB_DEVICE_CLASS_HUB) {
368 device = delist[i];
369 hasDevice = true;
370 }
371 }
372 EXPECT_TRUE(hasDevice);
373 ret = UsbSrvClient.RequestRight(device.GetName());
374 USBDevicePipe pip;
375 ret = UsbSrvClient.OpenDevice(device, pip);
376 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
377 USBEndpoint point = interface.GetEndpoints().front();
378 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
379 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferBulkWriteIOError ret:%{public}d",
380 __LINE__, ret);
381
382 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
383 ASSERT_NE(ashmem, nullptr);
384 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
385 ashmem->MapReadAndWriteAshmem();
386 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
387 ASSERT_TRUE(writeSuccess);
388 HDI::Usb::V1_2::USBTransferInfo transferInfo;
389 transferInfo.endpoint = 0xFF; //无效参数
390 transferInfo.flags = 0;
391 transferInfo.type = TYPE_BULK; // 开发板仅支持bulk
392 transferInfo.timeOut = 2000;
393 transferInfo.length = TEN; // 期望长度
394 transferInfo.userData = 0;
395 transferInfo.numIsoPackets = 0; // iso传输包数量 iso单包传输最大长度192
396
397 auto callback = [](const TransferCallbackInfo &info,
__anonb32fd79a0702(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 398 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
399 USB_HILOGI(MODULE_USB_SERVICE,
400 "UsbSubmitTransferBulkWriteIOError cb status: %{public}d, actualLength: %{public}d",
401 info.status, info.actualLength);
402 };
403 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
404 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferBulkWriteIOError ret=%{public}d",
405 __LINE__, ret);
406 ASSERT_EQ(ret, USB_SUBMIT_TRANSFER_IO_ERROR);
407 bool close = UsbSrvClient.Close(pip);
408 EXPECT_TRUE(close);
409 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteIOError end.");
410 }
411
412 /**
413 * @tc.name: UsbCancelTransferBulkWrite
414 * @tc.desc: Test the functionality of UsbCancelTransfer for write operation
415 * @tc.type: FUNC
416 */
417 HWTEST_F(UsbSubmitTransferBulkTest, UsbCancelTransferBulkWrite, TestSize.Level1)
418 {
419 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWrite enter.");
420 vector<UsbDevice> delist;
421 auto &UsbSrvClient = UsbSrvClient::GetInstance();
422 auto ret = UsbSrvClient.GetDevices(delist);
423 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
424 UsbDevice device;
425 bool hasDevice = false;
426 for (int32_t i = 0; i < delist.size(); i++) {
427 if (delist[i].GetClass() != USB_DEVICE_CLASS_HUB) {
428 device = delist[i];
429 hasDevice = true;
430 }
431 }
432 EXPECT_TRUE(hasDevice);
433 ret = UsbSrvClient.RequestRight(device.GetName());
434 USBDevicePipe pip;
435 ret = UsbSrvClient.OpenDevice(device, pip);
436
437 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
438 USBEndpoint point = interface.GetEndpoints().front();
439 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
440 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWrite ClaimInterface %{public}d ret:%{public}d",
441 __LINE__, ret);
442
443 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
444 ASSERT_NE(ashmem, nullptr);
445 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
446 ashmem->MapReadAndWriteAshmem();
447 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, TEN, 0);
448 ASSERT_TRUE(writeSuccess);
449
450 HDI::Usb::V1_2::USBTransferInfo transferInfo;
451 transferInfo.endpoint = 0x01; // 写操作
452 transferInfo.flags = 0;
453 transferInfo.type = TYPE_BULK; // 开发板不支持ISO传输类型
454 transferInfo.timeOut = 0; // 设置超时时间
455 transferInfo.length = TEN; // 设置传输数据的长度
456 transferInfo.userData = 0;
457 transferInfo.numIsoPackets = 0; // 只有type为1有iso
458
459 auto callback = [](const TransferCallbackInfo &info,
__anonb32fd79a0802(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 460 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
461 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWrite cb status:%{public}d,actualLength:%{public}d",
462 info.status, info.actualLength);
463 };
464 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
465 ASSERT_EQ(ret, UEC_OK);
466 // 取消写操作
467 ret = UsbSrvClient.UsbCancelTransfer(pip, transferInfo.endpoint);
468 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbCancelTransferBulkWrite ret:%{public}d", __LINE__, ret);
469 if (ret == USB_SUBMIT_TRANSFER_NOT_FOUND_ERROR) {
470 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. Transfer has been canceled ret:%{public}d", __LINE__, ret);
471 ret = UEC_OK;
472 }
473 ASSERT_EQ(ret, UEC_OK);
474
475 bool close = UsbSrvClient.Close(pip);
476 EXPECT_TRUE(close);
477 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWrite end.");
478 }
479
480 /**
481 * @tc.name: UsbCancelTransferBulkWriteNotFound
482 * @tc.desc: Test the functionality of UsbCancelTransfer for write operation
483 * @tc.type: FUNC
484 */
485 HWTEST_F(UsbSubmitTransferBulkTest, UsbCancelTransferBulkWriteNotFound, TestSize.Level1)
486 {
487 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWriteNotFound enter.");
488 vector<UsbDevice> delist;
489 auto &UsbSrvClient = UsbSrvClient::GetInstance();
490 auto ret = UsbSrvClient.GetDevices(delist);
491 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
492 UsbDevice device;
493 bool hasDevice = false;
494 for (int32_t i = 0; i < delist.size(); i++) {
495 if (delist[i].GetClass() != USB_DEVICE_CLASS_HUB) {
496 device = delist[i];
497 hasDevice = true;
498 }
499 }
500 EXPECT_TRUE(hasDevice);
501 ret = UsbSrvClient.RequestRight(device.GetName());
502 USBDevicePipe pip;
503 ret = UsbSrvClient.OpenDevice(device, pip);
504
505 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
506 USBEndpoint point = interface.GetEndpoints().front();
507 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
508 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWrite ClaimInterface %{public}d ret:%{public}d",
509 __LINE__, ret);
510
511 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
512 ASSERT_NE(ashmem, nullptr);
513 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
514 ashmem->MapReadAndWriteAshmem();
515 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, TEN, 0);
516 ASSERT_TRUE(writeSuccess);
517
518 HDI::Usb::V1_2::USBTransferInfo transferInfo;
519 transferInfo.endpoint = 0x01; // 写操作
520 transferInfo.flags = 0;
521 transferInfo.type = TYPE_BULK; // 开发板不支持ISO传输类型
522 transferInfo.timeOut = 0; // 设置超时时间
523 transferInfo.length = TEN; // 设置传输数据的长度
524 transferInfo.userData = 0;
525 transferInfo.numIsoPackets = 0; // 只有type为1有iso
526
527 auto callback = [](const TransferCallbackInfo &info,
__anonb32fd79a0902(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 528 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
529 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWrite cb status:%{public}d,actualLength:%{public}d",
530 info.status, info.actualLength);
531 };
532 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
533 ASSERT_EQ(ret, UEC_OK);
534 // 取消写操作
535 UsbSrvClient.UsbCancelTransfer(pip, transferInfo.endpoint);
536 // 再次调用取消
537 ret = UsbSrvClient.UsbCancelTransfer(pip, transferInfo.endpoint);
538 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbCancelTransferBulkWrite ret:%{public}d", __LINE__, ret);
539 ASSERT_EQ(ret, USB_SUBMIT_TRANSFER_NOT_FOUND_ERROR);
540
541 bool close = UsbSrvClient.Close(pip);
542 EXPECT_TRUE(close);
543 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWriteNotFound end.");
544 }
545
546 /**
547 * @tc.name: UsbCancelTransferBulkRead
548 * @tc.desc: Test the functionality of UsbCancelTransfer for read operation
549 * @tc.type: FUNC
550 */
551 HWTEST_F(UsbSubmitTransferBulkTest, UsbCancelTransferBulkRead, TestSize.Level1)
552 {
553 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkRead enter.");
554 vector<UsbDevice> delist;
555 auto &UsbSrvClient = UsbSrvClient::GetInstance();
556 auto ret = UsbSrvClient.GetDevices(delist);
557 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
558 UsbDevice device;
559 bool hasDevice = false;
560 for (int32_t i = 0; i < delist.size(); i++) {
561 if (delist[i].GetClass() != USB_DEVICE_CLASS_HUB) {
562 device = delist[i];
563 hasDevice = true;
564 }
565 }
566 EXPECT_TRUE(hasDevice);
567 ret = UsbSrvClient.RequestRight(device.GetName());
568 USBDevicePipe pip;
569 ret = UsbSrvClient.OpenDevice(device, pip);
570 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
571 USBEndpoint point = interface.GetEndpoints().front();
572 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
573 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbCancelTransferBulkRead ClaimInterface ret: %{public}d",
574 __LINE__, ret);
575
576 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
577 ASSERT_NE(ashmem, nullptr);
578 ashmem->MapReadAndWriteAshmem();
579
580 HDI::Usb::V1_2::USBTransferInfo transferInfo;
581 transferInfo.endpoint = 0x81; // 读操作
582 transferInfo.flags = 0;
583 transferInfo.type = TYPE_BULK; // 开发板不支持ISO传输类型
584 transferInfo.timeOut = 0; // 设置超时时间
585 transferInfo.length = TEN; // 设置传输数据的长度
586 transferInfo.userData = 0;
587 transferInfo.numIsoPackets = 0; // 只有type为1有iso
588
589 auto callback = [](const TransferCallbackInfo &info,
__anonb32fd79a0a02(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 590 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
591 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkRead cb status:%{public}d,actualLength: %{public}d",
592 info.status, info.actualLength);
593 };
594
595 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
596 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbCancelTransferBulkRead ret: %{public}d", __LINE__, ret);
597 ASSERT_EQ(ret, UEC_OK);
598
599 // 取消读操作
600 ret = UsbSrvClient.UsbCancelTransfer(pip, transferInfo.endpoint);
601 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbCancelTransferBulkRead ret: %{public}d", __LINE__, ret);
602 ASSERT_EQ(ret, UEC_OK);
603
604 bool close = UsbSrvClient.Close(pip);
605 EXPECT_TRUE(close);
606 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkRead end.");
607 }
608
609 } // namespace SubmitTransfer
610 } // namespace USB
611 } // namespace OHOS