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 std::mutex g_mtx; // 全局互斥锁，用于保护共享资源
53 std::condition_variable g_cv; // 条件变量，用于线程间的同步
54 std::vector<bool> g_threadSuccessFlags; // 用于标记每个线程是否成功完成操作
55 std::atomic<int32_t> g_completedThreads(0); // 用于标记线程完成数量
56 std::atomic<int32_t> g_successCount(0); // 用于统计 ASSERT_EQ(ret, UEC_OK) 成功的次数
57
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> devi;
92 auto &UsbSrvClient = UsbSrvClient::GetInstance();
93 auto ret = UsbSrvClient.GetDevices(devi);
94 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
95 USBDevicePipe pipe;
96 UsbDevice device = devi.front();
97 UsbSrvClient.RequestRight(device.GetName());
98 ret = UsbSrvClient.OpenDevice(device, pipe);
99 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d OpenDevice=%{public}d", __LINE__,
100 ret);
101 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
102 USBEndpoint point = interface.GetEndpoints().front();
103 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d point=%{public}d", __LINE__,
104 point.GetInterfaceId());
105 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
106 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
107 ASSERT_NE(ashmem, nullptr);
108 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
109 ashmem->MapReadAndWriteAshmem();
110 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
111 ASSERT_TRUE(writeSuccess);
112 HDI::Usb::V1_2::USBTransferInfo transferInfo;
113 transferInfo.endpoint = 0x01; // 0x01写 0x81读
114 transferInfo.flags = 0;
115 transferInfo.type = TYPE_BULK; // 开发板仅支持bulk
116 transferInfo.timeOut = TIMEOUT;
117 transferInfo.length = TEN; // 期望长度
118 transferInfo.userData = 0;
119 transferInfo.numIsoPackets = 0; // iso传输包数量 iso单包传输最大长度192
120 auto callback = [](const TransferCallbackInfo &info,
121 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {};
122 ret = UsbSrvClient.UsbSubmitTransfer(pipe, transferInfo, callback, ashmem);
123 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferBulkWrite ret:%{public}d", __LINE__, ret);
124 if (ret == UEC_OK) {
125 g_successCount++;
126 }
127 ASSERT_EQ(ret, UEC_OK);
128 bool close = UsbSrvClient.Close(pipe);
129 EXPECT_TRUE(close);
130 lock.unlock();
131 g_threadSuccessFlags[threadId] = true;
132 g_completedThreads++;
133 g_cv.notify_one();
134 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite end.");
135 }
136
137 HWTEST_F(UsbSubmitTransferBulkTest, UsbSubmitTransferBulkWriteConcurrent, TestSize.Level1)
138 {
139 int32_t numThreads = 5; // 并发线程数量
140 g_threadSuccessFlags.resize(numThreads);
141 std::vector<std::thread> threads;
142 // 启动多个线程
143 for (int32_t i = 0; i < numThreads; ++i) {
__anon2351f4f80202() 144 threads.emplace_back([i]() { UsbSubmitTransferBulkWriteThreadFunc(i); });
145 }
146 // 等待所有线程完成
147 std::unique_lock<std::mutex> lock(g_mtx);
__anon2351f4f80302null148 g_cv.wait(lock, [numThreads]{ return g_completedThreads == numThreads; });
149 // 清理资源和验证结果
150 for (auto& t : threads) {
151 t.join();
152 }
153 // 检查是否所有线程都成功完成操作
154 for (int32_t i = 0; i < numThreads; ++i) {
155 EXPECT_TRUE(g_threadSuccessFlags[i]) << "Thread " << i << " did not complete successfully.";
156 }
157 // 检查是否所有的 ASSERT_EQ(ret, UEC_OK) 都成功
158 EXPECT_EQ(g_successCount, numThreads) << "Not all UsbSubmitTransfer calls returned UEC_OK.";
159 }
160
161 /**
162 * @tc.name: UsbSubmitTransferBulkWrite
163 * @tc.desc: Test the USB data write functionality of UsbSubmitTransfer OK.
164 * @tc.type: FUNC
165 */
166 HWTEST_F(UsbSubmitTransferBulkTest, UsbSubmitTransferBulkWrite, TestSize.Level1)
167 {
168 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite enter.");
169 vector<UsbDevice> devi;
170 auto &UsbSrvClient = UsbSrvClient::GetInstance();
171 auto ret = UsbSrvClient.GetDevices(devi);
172 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d ret=%{public}d", __LINE__, ret);
173 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
174 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d size=%{public}zu", __LINE__,
175 devi.size());
176 USBDevicePipe pipe;
177 UsbDevice device = devi.front();
178 UsbSrvClient.RequestRight(device.GetName());
179 ret = UsbSrvClient.OpenDevice(device, pipe);
180 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d OpenDevice=%{public}d", __LINE__,
181 ret);
182 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
183 USBEndpoint point = interface.GetEndpoints().front();
184 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d point=%{public}d", __LINE__,
185 point.GetInterfaceId());
186 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
187 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
188 ASSERT_NE(ashmem, nullptr);
189 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
190 ashmem->MapReadAndWriteAshmem();
191 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
192 ASSERT_TRUE(writeSuccess);
193 HDI::Usb::V1_2::USBTransferInfo transferInfo;
194 transferInfo.endpoint = 0x01; // 0x01写 0x81读
195 transferInfo.flags = 0;
196 transferInfo.type = TYPE_BULK;
197 transferInfo.timeOut = 2000;
198 transferInfo.length = TEN; // 期望长度
199 transferInfo.userData = 0;
200 transferInfo.numIsoPackets = 0; // iso传输包数量 iso单包传输最大长度192
201 auto callback = [](const TransferCallbackInfo &info,
__anon2351f4f80402(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 202 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
203 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite cb status:%{public}d,actualLength:%{public}d",
204 info.status, info.actualLength);
205 };
206 ret = UsbSrvClient.UsbSubmitTransfer(pipe, transferInfo, callback, ashmem);
207 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferBulkWrite ret:%{public}d", __LINE__, ret);
208 ASSERT_EQ(ret, UEC_OK);
209 bool close = UsbSrvClient.Close(pipe);
210 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite %{public}d close=%{public}d", __LINE__, close);
211 EXPECT_TRUE(close);
212 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite end.");
213 }
214
215 /**
216 * @tc.name: UsbSubmitTransferBulkWriteParamError
217 * @tc.desc: Test the USB data write functionality of UsbSubmitTransfer OK.
218 * @tc.type: FUNC
219 */
220 HWTEST_F(UsbSubmitTransferBulkTest, UsbSubmitTransferBulkWriteParamError, TestSize.Level1)
221 {
222 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteParamError enter.");
223 vector<UsbDevice> devi;
224 auto &UsbSrvClient = UsbSrvClient::GetInstance();
225 auto ret = UsbSrvClient.GetDevices(devi);
226 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteParamError %{public}d ret=%{public}d", __LINE__, ret);
227 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
228 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteParamError %{public}d size=%{public}zu", __LINE__,
229 devi.size());
230 USBDevicePipe pipe;
231 UsbDevice device = devi.front();
232 UsbSrvClient.RequestRight(device.GetName());
233 ret = UsbSrvClient.OpenDevice(device, pipe);
234 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteParamError %{public}d OpenDevice=%{public}d", __LINE__,
235 ret);
236 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
237 USBEndpoint point = interface.GetEndpoints().front();
238 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteParamError %{public}d point=%{public}d", __LINE__,
239 point.GetInterfaceId());
240 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
241 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
242 ASSERT_NE(ashmem, nullptr);
243 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
244 ashmem->MapReadAndWriteAshmem();
245 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
246 ASSERT_TRUE(writeSuccess);
247 HDI::Usb::V1_2::USBTransferInfo transferInfo;
248 transferInfo.endpoint = 0x01; // 0x01写 0x81读
249 transferInfo.flags = 0;
250 transferInfo.type = 5; // 错误类型
251 transferInfo.timeOut = 2000;
252 transferInfo.length = TEN; // 期望长度
253 transferInfo.userData = 0;
254 transferInfo.numIsoPackets = 0; // iso传输包数量 iso单包传输最大长度192
255 auto callback = [](const TransferCallbackInfo &info,
__anon2351f4f80502(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 256 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
257 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWrite cb status:%{public}d,actualLength:%{public}d",
258 info.status, info.actualLength);
259 };
260 ret = UsbSrvClient.UsbSubmitTransfer(pipe, transferInfo, callback, ashmem);
261 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. BulkWriteParamError ret:%{public}d", __LINE__, ret);
262 ASSERT_EQ(ret, OHEC_COMMON_PARAM_ERROR);
263 bool close = UsbSrvClient.Close(pipe);
264 EXPECT_TRUE(close);
265 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteParamError end.");
266 }
267
268 /**
269 * @tc.name: UsbSubmitTransferBulkReadTimeOut
270 * @tc.desc: Test the USB data read functionality of UsbSubmitTransfer
271 * @tc.type: FUNC
272 */
273 HWTEST_F(UsbSubmitTransferBulkTest, UsbSubmitTransferBulkReadTimeOut, TestSize.Level1)
274 {
275 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkReadTimeOut enter.");
276
277 vector<UsbDevice> delist;
278 auto &UsbSrvClient = UsbSrvClient::GetInstance();
279 auto ret = UsbSrvClient.GetDevices(delist);
280 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
281 UsbDevice device = delist.front();
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 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
288 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkReadTimeOut ClaimInterface ret%{public}d", ret);
289
290 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
291 ASSERT_NE(ashmem, nullptr);
292 ashmem->MapReadAndWriteAshmem();
293
294 HDI::Usb::V1_2::USBTransferInfo transferInfo;
295 transferInfo.endpoint = 0x81; // 0x01写 0x81读
296 transferInfo.flags = 0;
297 transferInfo.type = TYPE_BULK; // 开发板仅支持bulk
298 transferInfo.timeOut = 2000;
299 transferInfo.length = TEN; // 期望长度
300 transferInfo.userData = 0;
301 transferInfo.numIsoPackets = 0; // iso传输包数量 iso单包传输最大长度192
302
303 auto callback = [](const TransferCallbackInfo &info,
__anon2351f4f80602(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 304 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
305 USB_HILOGI(MODULE_USB_SERVICE,
306 "UsbSubmitTransferBulkReadTimeOut Callback status: %{public}d, actualLength: %{public}d",
307 info.status, info.actualLength);
308 };
309
310 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
311 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferBulkReadTimeOut ret:%{public}d", __LINE__, ret);
312 ASSERT_EQ(ret, UEC_OK);
313
314 bool close = UsbSrvClient.Close(pip);
315 EXPECT_TRUE(close);
316 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkReadTimeOut end.");
317 }
318
319 /**
320 * @tc.name: UsbSubmitTransferBulkWriteIOError
321 * @tc.desc: Test the USB data write functionality of UsbSubmitTransfer with invalid endpoint type
322 * @tc.type: FUNC
323 */
324 HWTEST_F(UsbSubmitTransferBulkTest, UsbSubmitTransferBulkWriteIOError, TestSize.Level1)
325 {
326 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteIOError begin.");
327
328 vector<UsbDevice> delist;
329 auto &UsbSrvClient = UsbSrvClient::GetInstance();
330 auto ret = UsbSrvClient.GetDevices(delist);
331 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
332 UsbDevice device = delist.front();
333 ret = UsbSrvClient.RequestRight(device.GetName());
334 USBDevicePipe pip;
335 ret = UsbSrvClient.OpenDevice(device, pip);
336 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
337 USBEndpoint point = interface.GetEndpoints().front();
338 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
339 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferBulkWriteIOError ret:%{public}d",
340 __LINE__, ret);
341
342 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
343 ASSERT_NE(ashmem, nullptr);
344 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
345 ashmem->MapReadAndWriteAshmem();
346 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
347 ASSERT_TRUE(writeSuccess);
348 HDI::Usb::V1_2::USBTransferInfo transferInfo;
349 transferInfo.endpoint = 0xFF; //无效参数
350 transferInfo.flags = 0;
351 transferInfo.type = TYPE_BULK; // 开发板仅支持bulk
352 transferInfo.timeOut = 2000;
353 transferInfo.length = TEN; // 期望长度
354 transferInfo.userData = 0;
355 transferInfo.numIsoPackets = 0; // iso传输包数量 iso单包传输最大长度192
356
357 auto callback = [](const TransferCallbackInfo &info,
__anon2351f4f80702(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 358 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
359 USB_HILOGI(MODULE_USB_SERVICE,
360 "UsbSubmitTransferBulkWriteIOError cb status: %{public}d, actualLength: %{public}d",
361 info.status, info.actualLength);
362 };
363 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
364 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferBulkWriteIOError ret=%{public}d",
365 __LINE__, ret);
366 ASSERT_EQ(ret, USB_SUBMIT_TRANSFER_IO_ERROR);
367 bool close = UsbSrvClient.Close(pip);
368 EXPECT_TRUE(close);
369 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferBulkWriteIOError end.");
370 }
371
372 /**
373 * @tc.name: UsbCancelTransferBulkWrite
374 * @tc.desc: Test the functionality of UsbCancelTransfer for write operation
375 * @tc.type: FUNC
376 */
377 HWTEST_F(UsbSubmitTransferBulkTest, UsbCancelTransferBulkWrite, TestSize.Level1)
378 {
379 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWrite enter.");
380 vector<UsbDevice> delist;
381 auto &UsbSrvClient = UsbSrvClient::GetInstance();
382 auto ret = UsbSrvClient.GetDevices(delist);
383 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
384 UsbDevice device = delist.front();
385 ret = UsbSrvClient.RequestRight(device.GetName());
386 USBDevicePipe pip;
387 ret = UsbSrvClient.OpenDevice(device, pip);
388
389 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
390 USBEndpoint point = interface.GetEndpoints().front();
391 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
392 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWrite ClaimInterface %{public}d ret:%{public}d",
393 __LINE__, ret);
394
395 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
396 ASSERT_NE(ashmem, nullptr);
397 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
398 ashmem->MapReadAndWriteAshmem();
399 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, TEN, 0);
400 ASSERT_TRUE(writeSuccess);
401
402 HDI::Usb::V1_2::USBTransferInfo transferInfo;
403 transferInfo.endpoint = 0x01; // 写操作
404 transferInfo.flags = 0;
405 transferInfo.type = TYPE_BULK; // 开发板不支持ISO传输类型
406 transferInfo.timeOut = 0; // 设置超时时间
407 transferInfo.length = TEN; // 设置传输数据的长度
408 transferInfo.userData = 0;
409 transferInfo.numIsoPackets = 0; // 只有type为1有iso
410
411 auto callback = [](const TransferCallbackInfo &info,
__anon2351f4f80802(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 412 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
413 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWrite cb status:%{public}d,actualLength:%{public}d",
414 info.status, info.actualLength);
415 };
416 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
417 ASSERT_EQ(ret, UEC_OK);
418 // 取消写操作
419 ret = UsbSrvClient.UsbCancelTransfer(pip, transferInfo.endpoint);
420 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbCancelTransferBulkWrite ret:%{public}d", __LINE__, ret);
421 if (ret == USB_SUBMIT_TRANSFER_NOT_FOUND_ERROR) {
422 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. Transfer has been canceled ret:%{public}d", __LINE__, ret);
423 ret = UEC_OK;
424 }
425 ASSERT_EQ(ret, UEC_OK);
426
427 bool close = UsbSrvClient.Close(pip);
428 EXPECT_TRUE(close);
429 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWrite end.");
430 }
431
432 /**
433 * @tc.name: UsbCancelTransferBulkWriteNotFound
434 * @tc.desc: Test the functionality of UsbCancelTransfer for write operation
435 * @tc.type: FUNC
436 */
437 HWTEST_F(UsbSubmitTransferBulkTest, UsbCancelTransferBulkWriteNotFound, TestSize.Level1)
438 {
439 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWriteNotFound enter.");
440 vector<UsbDevice> delist;
441 auto &UsbSrvClient = UsbSrvClient::GetInstance();
442 auto ret = UsbSrvClient.GetDevices(delist);
443 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
444 UsbDevice device = delist.front();
445 ret = UsbSrvClient.RequestRight(device.GetName());
446 USBDevicePipe pip;
447 ret = UsbSrvClient.OpenDevice(device, pip);
448
449 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
450 USBEndpoint point = interface.GetEndpoints().front();
451 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
452 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWrite ClaimInterface %{public}d ret:%{public}d",
453 __LINE__, ret);
454
455 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
456 ASSERT_NE(ashmem, nullptr);
457 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
458 ashmem->MapReadAndWriteAshmem();
459 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, TEN, 0);
460 ASSERT_TRUE(writeSuccess);
461
462 HDI::Usb::V1_2::USBTransferInfo transferInfo;
463 transferInfo.endpoint = 0x01; // 写操作
464 transferInfo.flags = 0;
465 transferInfo.type = TYPE_BULK; // 开发板不支持ISO传输类型
466 transferInfo.timeOut = 0; // 设置超时时间
467 transferInfo.length = TEN; // 设置传输数据的长度
468 transferInfo.userData = 0;
469 transferInfo.numIsoPackets = 0; // 只有type为1有iso
470
471 auto callback = [](const TransferCallbackInfo &info,
__anon2351f4f80902(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 472 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
473 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWrite cb status:%{public}d,actualLength:%{public}d",
474 info.status, info.actualLength);
475 };
476 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
477 ASSERT_EQ(ret, UEC_OK);
478 // 取消写操作
479 UsbSrvClient.UsbCancelTransfer(pip, transferInfo.endpoint);
480 // 再次调用取消
481 ret = UsbSrvClient.UsbCancelTransfer(pip, transferInfo.endpoint);
482 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbCancelTransferBulkWrite ret:%{public}d", __LINE__, ret);
483 ASSERT_EQ(ret, USB_SUBMIT_TRANSFER_NOT_FOUND_ERROR);
484
485 bool close = UsbSrvClient.Close(pip);
486 EXPECT_TRUE(close);
487 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkWriteNotFound end.");
488 }
489
490 /**
491 * @tc.name: UsbCancelTransferBulkRead
492 * @tc.desc: Test the functionality of UsbCancelTransfer for read operation
493 * @tc.type: FUNC
494 */
495 HWTEST_F(UsbSubmitTransferBulkTest, UsbCancelTransferBulkRead, TestSize.Level1)
496 {
497 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkRead enter.");
498 vector<UsbDevice> delist;
499 auto &UsbSrvClient = UsbSrvClient::GetInstance();
500 auto ret = UsbSrvClient.GetDevices(delist);
501 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
502 UsbDevice device = delist.front();
503 ret = UsbSrvClient.RequestRight(device.GetName());
504 USBDevicePipe pip;
505 ret = UsbSrvClient.OpenDevice(device, pip);
506 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
507 USBEndpoint point = interface.GetEndpoints().front();
508 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
509 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbCancelTransferBulkRead ClaimInterface ret: %{public}d",
510 __LINE__, ret);
511
512 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
513 ASSERT_NE(ashmem, nullptr);
514 ashmem->MapReadAndWriteAshmem();
515
516 HDI::Usb::V1_2::USBTransferInfo transferInfo;
517 transferInfo.endpoint = 0x81; // 读操作
518 transferInfo.flags = 0;
519 transferInfo.type = TYPE_BULK; // 开发板不支持ISO传输类型
520 transferInfo.timeOut = 0; // 设置超时时间
521 transferInfo.length = TEN; // 设置传输数据的长度
522 transferInfo.userData = 0;
523 transferInfo.numIsoPackets = 0; // 只有type为1有iso
524
525 auto callback = [](const TransferCallbackInfo &info,
__anon2351f4f80a02(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 526 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
527 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkRead cb status:%{public}d,actualLength: %{public}d",
528 info.status, info.actualLength);
529 };
530
531 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
532 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbCancelTransferBulkRead ret: %{public}d", __LINE__, ret);
533 ASSERT_EQ(ret, UEC_OK);
534
535 // 取消读操作
536 ret = UsbSrvClient.UsbCancelTransfer(pip, transferInfo.endpoint);
537 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbCancelTransferBulkRead ret: %{public}d", __LINE__, ret);
538 ASSERT_EQ(ret, UEC_OK);
539
540 bool close = UsbSrvClient.Close(pip);
541 EXPECT_TRUE(close);
542 USB_HILOGI(MODULE_USB_SERVICE, "UsbCancelTransferBulkRead end.");
543 }
544
545 } // namespace SubmitTransfer
546 } // namespace USB
547 } // namespace OHOS