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 "usb_request_mock_test.h"
17 
18 #include <csignal>
19 #include <cstring>
20 #include <iostream>
21 #include <vector>
22 
23 #include "iusb_srv.h"
24 #include "usb_common.h"
25 #include "usb_common_test.h"
26 #include "usb_impl_mock.h"
27 #include "usb_request.h"
28 #include "usb_service.h"
29 #include "usb_srv_client.h"
30 
31 using namespace OHOS;
32 using namespace OHOS::USB;
33 using namespace OHOS::USB::Common;
34 using namespace std;
35 using namespace testing::ext;
36 using ::testing::Eq;
37 using ::testing::Exactly;
38 using ::testing::Ge;
39 using ::testing::Le;
40 using ::testing::Ne;
41 using ::testing::Return;
42 
43 namespace OHOS {
44 namespace USB {
45 constexpr int32_t BUFFER_SIZE = 255;
46 constexpr int32_t REQUEST_TIME_OUT = 5000;
47 sptr<MockUsbImpl> UsbRequestMockTest::mockUsbImpl_ = nullptr;
48 sptr<UsbService> UsbRequestMockTest::usbSrv_ = nullptr;
49 UsbDev UsbRequestMockTest::dev_ = {BUS_NUM_OK, DEV_ADDR_OK};
50 UsbInterface UsbRequestMockTest::interface_ {};
51 
SetUpTestCase(void)52 void UsbRequestMockTest::SetUpTestCase(void)
53 {
54     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest SetUpTestCase");
55     UsbCommonTest::SetTestCaseHapApply();
56 
57     usbSrv_ = DelayedSpSingleton<UsbService>::GetInstance();
58     EXPECT_NE(usbSrv_, nullptr);
59     mockUsbImpl_ = DelayedSpSingleton<MockUsbImpl>::GetInstance();
60     EXPECT_NE(mockUsbImpl_, nullptr);
61 
62     usbSrv_->SetUsbd(mockUsbImpl_);
63 
64     sptr<UsbServiceSubscriber> iSubscriber = new UsbServiceSubscriber();
65     EXPECT_NE(iSubscriber, nullptr);
66     mockUsbImpl_->BindUsbdSubscriber(iSubscriber);
67 
68     EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
69     EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
70     USBDeviceInfo info = {ACT_DEVUP, BUS_NUM_OK, DEV_ADDR_OK};
71     auto ret = mockUsbImpl_->SubscriberDeviceEvent(info);
72     EXPECT_EQ(0, ret);
73 
74     ret = mockUsbImpl_->SetPortRole(DEFAULT_PORT_ID, UsbSrvSupport::POWER_ROLE_SOURCE, UsbSrvSupport::DATA_ROLE_HOST);
75     EXPECT_EQ(0, ret);
76     if (ret != 0) {
77         exit(0);
78     }
79 
80     vector<UsbDevice> devList;
81     ret = usbSrv_->GetDevices(devList);
82     EXPECT_EQ(0, ret);
83     EXPECT_FALSE(devList.empty()) << "devList NULL";
84     UsbDevice device = MockUsbImpl::FindDeviceInfo(devList);
85 
86     EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
87     ret = usbSrv_->OpenDevice(dev_.busNum, dev_.devAddr);
88     EXPECT_EQ(0, ret);
89 
90     interface_ = device.GetConfigs().front().GetInterfaces().at(1);
91     uint8_t interfaceId = interface_.GetId();
92     EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
93     ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
94     EXPECT_EQ(0, ret);
95 }
96 
TearDownTestCase(void)97 void UsbRequestMockTest::TearDownTestCase(void)
98 {
99     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest TearDownTestCase");
100     EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
101     auto ret = usbSrv_->Close(dev_.busNum, dev_.devAddr);
102     EXPECT_EQ(0, ret);
103 
104     USBDeviceInfo info = {ACT_DEVDOWN, BUS_NUM_OK, DEV_ADDR_OK};
105     ret = mockUsbImpl_->SubscriberDeviceEvent(info);
106     EXPECT_EQ(0, ret);
107 
108     mockUsbImpl_->UnbindUsbdSubscriber(nullptr);
109     sptr<IUsbInterface> usbd = IUsbInterface::Get();
110     usbSrv_->SetUsbd(usbd);
111 
112     mockUsbImpl_ = nullptr;
113     usbSrv_ = nullptr;
114     DelayedSpSingleton<UsbService>::DestroyInstance();
115     DelayedSpSingleton<MockUsbImpl>::DestroyInstance();
116 }
117 
SetUp(void)118 void UsbRequestMockTest::SetUp(void) {}
119 
TearDown(void)120 void UsbRequestMockTest::TearDown(void) {}
121 /**
122  * @tc.name: UsbrequestQueue001
123  * @tc.desc: Test functions of RequestQueue(UsbRequest &request, uint8_t *buffer, uint32_t length)
124  * @tc.desc: Positive test: parameters correctly
125  * @tc.type: FUNC
126  */
127 HWTEST_F(UsbRequestMockTest, UsbrequestQueue001, TestSize.Level1)
128 {
129     USBEndpoint point = interface_.GetEndpoints().at(0);
130     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
131     std::vector<uint8_t> cmdData = {'q', 'u', 'e', 'u', 'e', ' ', 'r', 'e', 'a', 'd', '0', '0', '1'};
132     std::vector<uint8_t> bufferData(BUFFER_SIZE);
133     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
134     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, bufferData);
135     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest::UsbrequestQueue001 queue=%{public}d ", ret);
136     EXPECT_EQ(0, ret);
137 }
138 
139 /**
140  * @tc.name: UsbrequestQueue002
141  * @tc.desc: Test functions of RequestQueue(UsbRequest &request, uint8_t *buffer, uint32_t length)
142  * @tc.desc: Positive test: parameters correctly
143  * @tc.type: FUNC
144  */
145 HWTEST_F(UsbRequestMockTest, UsbrequestQueue002, TestSize.Level1)
146 {
147     USBEndpoint point = interface_.GetEndpoints().at(1);
148     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
149     std::vector<uint8_t> cmdData = {'q', 'u', 'e', 'u', 'e', ' ', 'w', 'r', 'i', 't', 'e', '0', '0', '1'};
150     std::vector<uint8_t> dataBuffer = {'r', 'e', 'q', 'u', 'e', 's', 't', ' ', 't', 'e', 's', 't'};
151     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
152     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, dataBuffer);
153     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest:UsbrequestQueue002 queue=%{public}d ", ret);
154     EXPECT_EQ(0, ret);
155 }
156 
157 /**
158  * @tc.name: UsbrequestQueue003
159  * @tc.desc: Test functions of RequestQueue(UsbRequest &request, uint8_t *buffer, uint32_t length)
160  * @tc.desc: Negative test: parameters exception, busNum error
161  * @tc.type: FUNC
162  */
163 HWTEST_F(UsbRequestMockTest, UsbrequestQueue003, TestSize.Level1)
164 {
165     USBEndpoint point = interface_.GetEndpoints().at(0);
166     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
167     std::vector<uint8_t> cmdData = {'q', 'u', 'e', 'u', 'e', ' ', 'r', 'e', 'a', 'd', '0', '0', '3'};
168     std::vector<uint8_t> bufferData(BUFFER_SIZE);
169     dev_.busNum = BUS_NUM_INVALID;
170     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_))
171         .WillRepeatedly(Return(RETVAL_INVALID));
172     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, bufferData);
173     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest::UsbrequestQueue003 queue=%{public}d ", ret);
174     EXPECT_NE(ret, 0);
175 
176     dev_.busNum = BUS_NUM_OK;
177 }
178 
179 /**
180  * @tc.name: UsbrequestQueue004
181  * @tc.desc: Test functions of RequestQueue(UsbRequest &request, uint8_t *buffer, uint32_t length)
182  * @tc.desc: Negative test: parameters exception, devAddr error
183  * @tc.type: FUNC
184  */
185 HWTEST_F(UsbRequestMockTest, UsbrequestQueue004, TestSize.Level1)
186 {
187     USBEndpoint point = interface_.GetEndpoints().at(0);
188     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
189     std::vector<uint8_t> cmdData = {'q', 'u', 'e', 'u', 'e', ' ', 'r', 'e', 'a', 'd', '0', '0', '4'};
190     std::vector<uint8_t> bufferData(BUFFER_SIZE);
191     dev_.devAddr = DEV_ADDR_INVALID;
192     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_))
193         .WillRepeatedly(Return(RETVAL_INVALID));
194     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, bufferData);
195     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest::UsbrequestQueue004 queue=%{public}d ", ret);
196     EXPECT_NE(ret, 0);
197 
198     dev_.devAddr = DEV_ADDR_OK;
199 }
200 
201 /**
202  * @tc.name: UsbrequestQueue005
203  * @tc.desc: Test functions of RequestQueue(UsbRequest &request, uint8_t *buffer, uint32_t length)
204  * @tc.desc: Negative test: parameters exception, busNum error
205  * @tc.type: FUNC
206  */
207 HWTEST_F(UsbRequestMockTest, UsbrequestQueue005, TestSize.Level1)
208 {
209     USBEndpoint point = interface_.GetEndpoints().at(1);
210     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
211     std::vector<uint8_t> cmdData = {'q', 'u', 'e', 'u', 'e', ' ', 'w', 'r', 'i', 't', 'e', '0', '0', '5'};
212     std::vector<uint8_t> dataBuffer = {'r', 'e', 'q', 'u', 'e', 's', 't', ' ', 't', 'e', 's', 't'};
213     dev_.busNum = BUS_NUM_INVALID;
214     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_))
215         .WillRepeatedly(Return(RETVAL_INVALID));
216     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, dataBuffer);
217     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest::UsbrequestQueue005 queue=%{public}d ", ret);
218     EXPECT_NE(ret, 0);
219 
220     dev_.busNum = BUS_NUM_OK;
221 }
222 
223 /**
224  * @tc.name: UsbrequestQueue006
225  * @tc.desc: Test functions of RequestQueue(UsbRequest &request, uint8_t *buffer, uint32_t length)
226  * @tc.desc: Negative test: parameters exception, devAddr error
227  * @tc.type: FUNC
228  */
229 HWTEST_F(UsbRequestMockTest, UsbrequestQueue006, TestSize.Level1)
230 {
231     USBEndpoint point = interface_.GetEndpoints().at(1);
232     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
233     std::vector<uint8_t> cmdData = {'q', 'u', 'e', 'u', 'e', ' ', 'w', 'r', 'i', 't', 'e', '0', '0', '6'};
234     std::vector<uint8_t> dataBuffer = {'r', 'e', 'q', 'u', 'e', 's', 't', ' ', 't', 'e', 's', 't'};
235     dev_.devAddr = DEV_ADDR_INVALID;
236     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_))
237         .WillRepeatedly(Return(RETVAL_INVALID));
238     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, dataBuffer);
239     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest::UsbrequestQueue006 queue=%{public}d ", ret);
240     EXPECT_NE(ret, 0);
241 
242     dev_.devAddr = DEV_ADDR_OK;
243 }
244 
245 /**
246  * @tc.name: RequestCancel001
247  * @tc.desc: Test functions of RequestFree(UsbRequest &request);
248  * @tc.desc: Positive test: parameters correctly
249  * @tc.type: FUNC
250  */
251 HWTEST_F(UsbRequestMockTest, RequestCancel001, TestSize.Level1)
252 {
253     uint8_t interfaceId = interface_.GetId();
254     USBEndpoint point = interface_.GetEndpoints().at(0);
255     uint8_t endpointId = point.GetAddress();
256     EXPECT_CALL(*mockUsbImpl_, RequestCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
257     auto ret = usbSrv_->RequestCancel(dev_.busNum, dev_.devAddr, interfaceId, endpointId);
258     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest:RequestCancel001 free=%{public}d ", ret);
259     EXPECT_EQ(0, ret);
260 }
261 
262 /**
263  * @tc.name: RequestCancel002
264  * @tc.desc: Test functions of RequestFree(UsbRequest &request);
265  * @tc.desc: Negative test: parameters exception, busNum error
266  * @tc.type: FUNC
267  */
268 HWTEST_F(UsbRequestMockTest, RequestCancel002, TestSize.Level1)
269 {
270     uint8_t interfaceId = interface_.GetId();
271     USBEndpoint point = interface_.GetEndpoints().at(0);
272     uint8_t endpointId = point.GetAddress();
273     dev_.busNum = BUS_NUM_INVALID;
274     EXPECT_CALL(*mockUsbImpl_, RequestCancel(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
275     auto ret = usbSrv_->RequestCancel(dev_.busNum, dev_.devAddr, interfaceId, endpointId);
276     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest:RequestCancel002 free=%{public}d ", ret);
277     EXPECT_NE(ret, 0);
278 
279     dev_.busNum = BUS_NUM_OK;
280 }
281 
282 /**
283  * @tc.name: RequestCancel003
284  * @tc.desc: Test functions of RequestFree(UsbRequest &request);
285  * @tc.desc: Negative test: parameters exception, devAddr error
286  * @tc.type: FUNC
287  */
288 HWTEST_F(UsbRequestMockTest, RequestCancel003, TestSize.Level1)
289 {
290     uint8_t interfaceId = interface_.GetId();
291     USBEndpoint point = interface_.GetEndpoints().at(0);
292     uint8_t endpointId = point.GetAddress();
293     dev_.devAddr = DEV_ADDR_INVALID;
294     EXPECT_CALL(*mockUsbImpl_, RequestCancel(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
295     auto ret = usbSrv_->RequestCancel(dev_.busNum, dev_.devAddr, interfaceId, endpointId);
296     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest:RequestCancel003 free=%{public}d ", ret);
297     EXPECT_NE(ret, 0);
298 
299     dev_.devAddr = DEV_ADDR_OK;
300 }
301 
302 /**
303  * @tc.name: RequestCancel004
304  * @tc.desc: Test functions of RequestFree(UsbRequest &request);
305  * @tc.desc: Positive test: parameters correctly
306  * @tc.type: FUNC
307  */
308 HWTEST_F(UsbRequestMockTest, RequestCancel004, TestSize.Level1)
309 {
310     uint8_t interfaceId = interface_.GetId();
311     USBEndpoint point = interface_.GetEndpoints().at(1);
312     uint8_t endpointId = point.GetAddress();
313     EXPECT_CALL(*mockUsbImpl_, RequestCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
314     auto ret = usbSrv_->RequestCancel(dev_.busNum, dev_.devAddr, interfaceId, endpointId);
315     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest:RequestCancel004 free=%{public}d ", ret);
316     EXPECT_EQ(0, ret);
317 }
318 
319 /**
320  * @tc.name: RequestCancel005
321  * @tc.desc: Test functions of RequestFree(UsbRequest &request);
322  * @tc.desc: Negative test: parameters exception, busNum error
323  * @tc.type: FUNC
324  */
325 HWTEST_F(UsbRequestMockTest, RequestCancel005, TestSize.Level1)
326 {
327     uint8_t interfaceId = interface_.GetId();
328     USBEndpoint point = interface_.GetEndpoints().at(1);
329     uint8_t endpointId = point.GetAddress();
330     dev_.busNum = BUS_NUM_INVALID;
331     EXPECT_CALL(*mockUsbImpl_, RequestCancel(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
332     auto ret = usbSrv_->RequestCancel(dev_.busNum, dev_.devAddr, interfaceId, endpointId);
333     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest:RequestCancel005 free=%{public}d ", ret);
334     EXPECT_NE(ret, 0);
335 
336     dev_.busNum = BUS_NUM_OK;
337 }
338 
339 /**
340  * @tc.name: RequestCancel006
341  * @tc.desc: Test functions of RequestFree(UsbRequest &request);
342  * @tc.desc: Negative test: parameters exception, devAddr error
343  * @tc.type: FUNC
344  */
345 HWTEST_F(UsbRequestMockTest, RequestCancel006, TestSize.Level1)
346 {
347     uint8_t interfaceId = interface_.GetId();
348     USBEndpoint point = interface_.GetEndpoints().at(1);
349     uint8_t endpointId = point.GetAddress();
350     dev_.devAddr = DEV_ADDR_INVALID;
351     EXPECT_CALL(*mockUsbImpl_, RequestCancel(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
352     auto ret = usbSrv_->RequestCancel(dev_.busNum, dev_.devAddr, interfaceId, endpointId);
353     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest:RequestCancel006 free=%{public}d ", ret);
354     EXPECT_NE(ret, 0);
355 
356     dev_.devAddr = DEV_ADDR_OK;
357 }
358 
359 /**
360  * @tc.name: Usbrequestabort001
361  * @tc.desc: Test functions of RequestAbort(request)
362  * @tc.desc: Positive test: parameters correctly
363  * @tc.type: FUNC
364  */
365 HWTEST_F(UsbRequestMockTest, Usbrequestabort001, TestSize.Level1)
366 {
367     uint8_t interfaceId = interface_.GetId();
368     USBEndpoint point = interface_.GetEndpoints().at(0);
369     const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
370     std::vector<uint8_t> cmdData = {'h', 'e', 'l', 'l', 'o', ' ', 'a', 'b', 'o', 'r', 't', '0', '0', '1'};
371     std::vector<uint8_t> dataBuffer = {'a', 'b', 'o', 'r', 't', '0', '0', '1'};
372     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
373     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, dataBuffer);
374     EXPECT_EQ(0, ret);
375 
376     uint8_t endpointId = point.GetAddress();
377     EXPECT_CALL(*mockUsbImpl_, RequestCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
378     ret = usbSrv_->RequestCancel(dev_.busNum, dev_.devAddr, interfaceId, endpointId);
379     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest:Usbrequestabort001 Abort=%{public}d ", ret);
380     EXPECT_EQ(0, ret);
381 }
382 
383 /**
384  * @tc.name: Usbrequestabort002
385  * @tc.desc: Test functions of RequestAbort(request)
386  * @tc.desc: Negative test: parameters exception, busNum error
387  * @tc.type: FUNC
388  */
389 HWTEST_F(UsbRequestMockTest, Usbrequestabort002, TestSize.Level1)
390 {
391     uint8_t interfaceId = interface_.GetId();
392     USBEndpoint point = interface_.GetEndpoints().at(0);
393     const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
394     std::vector<uint8_t> cmdData = {'a', 'b', 'o', 'r', 't', '0', '0', '2'};
395     std::vector<uint8_t> bufferData(BUFFER_SIZE);
396     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
397     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, bufferData);
398     EXPECT_EQ(0, ret);
399 
400     uint8_t endpointId = point.GetAddress();
401     dev_.busNum = BUS_NUM_INVALID;
402     EXPECT_CALL(*mockUsbImpl_, RequestCancel(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
403     ret = usbSrv_->RequestCancel(dev_.busNum, dev_.devAddr, interfaceId, endpointId);
404     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest:Usbrequestabort002 Abort=%{public}d ", ret);
405     EXPECT_NE(ret, 0);
406     dev_.busNum = BUS_NUM_OK;
407 }
408 
409 /**
410  * @tc.name: Usbrequestabort003
411  * @tc.desc: Test functions of RequestAbort(request)
412  * @tc.desc: Negative test: parameters exception, devAddr error
413  * @tc.type: FUNC
414  */
415 HWTEST_F(UsbRequestMockTest, Usbrequestabort003, TestSize.Level1)
416 {
417     uint8_t interfaceId = interface_.GetId();
418     USBEndpoint point = interface_.GetEndpoints().at(0);
419     const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
420     std::vector<uint8_t> cmdData = {'a', 'b', 'o', 'r', 't', '0', '0', '3'};
421     std::vector<uint8_t> bufferData(BUFFER_SIZE);
422     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
423     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, bufferData);
424     EXPECT_EQ(0, ret);
425 
426     uint8_t endpointId = point.GetAddress();
427     dev_.devAddr = DEV_ADDR_INVALID;
428     EXPECT_CALL(*mockUsbImpl_, RequestCancel(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
429     ret = usbSrv_->RequestCancel(dev_.busNum, dev_.devAddr, interfaceId, endpointId);
430     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest:Usbrequestabort003 Abort=%{public}d ", ret);
431     EXPECT_NE(ret, 0);
432 
433     dev_.devAddr = DEV_ADDR_OK;
434 }
435 
436 /**
437  * @tc.name: Usbrequestabort004
438  * @tc.desc: Test functions of RequestAbort(request)
439  * @tc.desc: Positive test: parameters correctly
440  * @tc.type: FUNC
441  */
442 HWTEST_F(UsbRequestMockTest, Usbrequestabort004, TestSize.Level1)
443 {
444     uint8_t interfaceId = interface_.GetId();
445     USBEndpoint point = interface_.GetEndpoints().at(1);
446     const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
447     std::vector<uint8_t> cmdData = {'h', 'e', 'l', 'l', 'o', ' ', 'a', 'b', 'o', 'r', 't', '0', '0', '4'};
448     std::vector<uint8_t> dataBuffer = {'a', 'b', 'o', 'r', 't', '0', '0', '4'};
449     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
450     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, dataBuffer);
451     EXPECT_EQ(0, ret);
452 
453     uint8_t endpointId = point.GetAddress();
454     EXPECT_CALL(*mockUsbImpl_, RequestCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
455     ret = usbSrv_->RequestCancel(dev_.busNum, dev_.devAddr, interfaceId, endpointId);
456     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest:Usbrequestabort004 abort=%{public}d ", ret);
457     EXPECT_EQ(0, ret);
458 }
459 
460 /**
461  * @tc.name: Usbrequestabort005
462  * @tc.desc: Test functions of RequestAbort(request)
463  * @tc.desc: Negative test: parameters exception, busNum error
464  * @tc.type: FUNC
465  */
466 HWTEST_F(UsbRequestMockTest, Usbrequestabort005, TestSize.Level1)
467 {
468     uint8_t interfaceId = interface_.GetId();
469     USBEndpoint point = interface_.GetEndpoints().at(1);
470     const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
471     std::vector<uint8_t> cmdData = {'h', 'e', 'l', 'l', 'o', ' ', 'a', 'b', 'o', 'r', 't', '0', '0', '5'};
472     std::vector<uint8_t> dataBuffer = {'a', 'b', 'o', 'r', 't', '0', '0', '5'};
473     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
474     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, dataBuffer);
475     EXPECT_EQ(0, ret);
476 
477     uint8_t endpointId = point.GetAddress();
478     dev_.busNum = BUS_NUM_INVALID;
479     EXPECT_CALL(*mockUsbImpl_, RequestCancel(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
480     ret = usbSrv_->RequestCancel(dev_.busNum, dev_.devAddr, interfaceId, endpointId);
481     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest:Usbrequestabort005 Abort=%{public}d ", ret);
482     EXPECT_NE(ret, 0);
483 
484     dev_.busNum = BUS_NUM_OK;
485 }
486 
487 /**
488  * @tc.name: Usbrequestabort006
489  * @tc.desc: Test functions of RequestAbort(request)
490  * @tc.desc: Negative test: parameters exception, devAddr error
491  * @tc.type: FUNC
492  */
493 HWTEST_F(UsbRequestMockTest, Usbrequestabort006, TestSize.Level1)
494 {
495     uint8_t interfaceId = interface_.GetId();
496     USBEndpoint point = interface_.GetEndpoints().at(1);
497     const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
498     std::vector<uint8_t> cmdData = {'h', 'e', 'l', 'l', 'o', ' ', 'a', 'b', 'o', 'r', 't', '0', '0', '6'};
499     std::vector<uint8_t> dataBuffer = {'a', 'b', 'o', 'r', 't', '0', '0', '6'};
500     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
501     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, dataBuffer);
502     EXPECT_EQ(0, ret);
503 
504     uint8_t endpointId = point.GetAddress();
505     dev_.devAddr = DEV_ADDR_INVALID;
506     EXPECT_CALL(*mockUsbImpl_, RequestCancel(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
507     ret = usbSrv_->RequestCancel(dev_.busNum, dev_.devAddr, interfaceId, endpointId);
508     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest:Usbrequestabort006 Abort=%{public}d ", ret);
509     EXPECT_NE(ret, 0);
510 
511     dev_.devAddr = DEV_ADDR_OK;
512 }
513 
514 /**
515  * @tc.name: UsbRequestWait001
516  * @tc.desc: Test functions of UsbRequestWait(USBDevicePipe &pip, int64_t timeout, UsbRequest &req)
517  * @tc.desc: Positive test: parameters correctly
518  * @tc.type: FUNC
519  */
520 HWTEST_F(UsbRequestMockTest, UsbRequestWait001, TestSize.Level1)
521 {
522     USBEndpoint point = interface_.GetEndpoints().front();
523     const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
524     std::vector<uint8_t> cmdData = {'w', 'a', 'i', 't', '0', '0', '1'};
525     std::vector<uint8_t> bufferData(BUFFER_SIZE);
526     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
527     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, bufferData);
528     EXPECT_EQ(0, ret);
529 
530     EXPECT_CALL(*mockUsbImpl_, RequestWait(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
531     ret = usbSrv_->RequestWait(dev_, REQUEST_TIME_OUT, cmdData, bufferData);
532     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest::UsbRequestWait001 UsbRequestWait=%{public}d", ret);
533     EXPECT_EQ(0, ret);
534 }
535 
536 /**
537  * @tc.name: UsbRequestWait002
538  * @tc.desc: Test functions of UsbRequestWait(USBDevicePipe &pip, int64_t timeout, UsbRequest &req)
539  * @tc.desc: Negative test: parameters exception, busNum error
540  * @tc.type: FUNC
541  */
542 HWTEST_F(UsbRequestMockTest, UsbRequestWait002, TestSize.Level1)
543 {
544     USBEndpoint point = interface_.GetEndpoints().front();
545     const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
546     std::vector<uint8_t> cmdData = {'w', 'a', 'i', 't', '0', '0', '2'};
547     std::vector<uint8_t> bufferData(BUFFER_SIZE);
548     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
549     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, bufferData);
550     EXPECT_EQ(0, ret);
551 
552     dev_.busNum = BUS_NUM_INVALID;
553     EXPECT_CALL(*mockUsbImpl_, RequestWait(testing::_, testing::_, testing::_, testing::_))
554         .WillRepeatedly(Return(RETVAL_INVALID));
555     ret = usbSrv_->RequestWait(dev_, REQUEST_TIME_OUT, cmdData, bufferData);
556     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest::UsbRequestWait002 UsbRequestWait=%{public}d", ret);
557     EXPECT_NE(ret, 0);
558 
559     dev_.busNum = BUS_NUM_OK;
560 }
561 
562 /**
563  * @tc.name: UsbRequestWait003
564  * @tc.desc: Test functions of UsbRequestWait(USBDevicePipe &pip, int64_t timeout, UsbRequest &req)
565  * @tc.desc: Negative test: parameters exception, devAddr error
566  * @tc.type: FUNC
567  */
568 HWTEST_F(UsbRequestMockTest, UsbRequestWait003, TestSize.Level1)
569 {
570     USBEndpoint point = interface_.GetEndpoints().front();
571     const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
572     std::vector<uint8_t> cmdData = {'w', 'a', 'i', 't', '0', '0', '3'};
573     std::vector<uint8_t> bufferData(BUFFER_SIZE);
574     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
575     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, bufferData);
576     EXPECT_EQ(0, ret);
577 
578     dev_.devAddr = DEV_ADDR_INVALID;
579     EXPECT_CALL(*mockUsbImpl_, RequestWait(testing::_, testing::_, testing::_, testing::_))
580         .WillRepeatedly(Return(RETVAL_INVALID));
581     ret = usbSrv_->RequestWait(dev_, REQUEST_TIME_OUT, cmdData, bufferData);
582     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest::UsbRequestWait003 UsbRequestWait=%{public}d", ret);
583     EXPECT_NE(ret, 0);
584 
585     dev_.devAddr = DEV_ADDR_OK;
586 }
587 
588 /**
589  * @tc.name: UsbRequestWait004
590  * @tc.desc: Test functions of UsbRequestWait(USBDevicePipe &pip, int64_t timeout, UsbRequest &req)
591  * @tc.desc: Positive test: parameters correctly
592  * @tc.type: FUNC
593  */
594 HWTEST_F(UsbRequestMockTest, UsbRequestWait004, TestSize.Level1)
595 {
596     USBEndpoint point = interface_.GetEndpoints().at(1);
597     const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
598     std::vector<uint8_t> cmdData = {'w', 'a', 'i', 't', '0', '0', '4'};
599     std::vector<uint8_t> dataBuffer = {'w', 'a', 'i', 't', ' ', 't', 'e', 's', 't', '0', '0', '4'};
600     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
601     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, dataBuffer);
602     EXPECT_EQ(0, ret);
603 
604     EXPECT_CALL(*mockUsbImpl_, RequestWait(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
605     ret = usbSrv_->RequestWait(dev_, REQUEST_TIME_OUT, cmdData, dataBuffer);
606     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest::UsbRequestWait004 UsbRequestWait=%{public}d", ret);
607     EXPECT_EQ(0, ret);
608 }
609 
610 /**
611  * @tc.name: UsbRequestWait005
612  * @tc.desc: Test functions of UsbRequestWait(USBDevicePipe &pip, int64_t timeout, UsbRequest &req)
613  * @tc.desc: Negative test: parameters exception, busNum error
614  * @tc.type: FUNC
615  */
616 HWTEST_F(UsbRequestMockTest, UsbRequestWait005, TestSize.Level1)
617 {
618     USBEndpoint point = interface_.GetEndpoints().at(1);
619     const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
620     std::vector<uint8_t> cmdData = {'w', 'a', 'i', 't', '0', '0', '5'};
621     std::vector<uint8_t> dataBuffer = {'w', 'a', 'i', 't', ' ', 't', 'e', 's', 't', '0', '0', '5'};
622     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
623     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, dataBuffer);
624     EXPECT_EQ(0, ret);
625 
626     dev_.busNum = BUS_NUM_INVALID;
627     EXPECT_CALL(*mockUsbImpl_, RequestWait(testing::_, testing::_, testing::_, testing::_))
628         .WillRepeatedly(Return(RETVAL_INVALID));
629     ret = usbSrv_->RequestWait(dev_, REQUEST_TIME_OUT, cmdData, dataBuffer);
630     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest::UsbRequestWait005 UsbRequestWait=%{public}d", ret);
631     EXPECT_NE(ret, 0);
632 
633     dev_.busNum = BUS_NUM_OK;
634 }
635 
636 /**
637  * @tc.name: UsbRequestWait006
638  * @tc.desc: Test functions of UsbRequestWait(USBDevicePipe &pip, int64_t timeout, UsbRequest &req)
639  * @tc.desc: Negative test: parameters exception, devAddr error
640  * @tc.type: FUNC
641  */
642 HWTEST_F(UsbRequestMockTest, UsbRequestWait006, TestSize.Level1)
643 {
644     USBEndpoint point = interface_.GetEndpoints().at(1);
645     const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
646     std::vector<uint8_t> cmdData = {'w', 'a', 'i', 't', '0', '0', '6'};
647     std::vector<uint8_t> dataBuffer = {'w', 'a', 'i', 't', ' ', 't', 'e', 's', 't', '0', '0', '6'};
648     EXPECT_CALL(*mockUsbImpl_, RequestQueue(testing::_, testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
649     auto ret = usbSrv_->RequestQueue(dev_, pipe, cmdData, dataBuffer);
650     EXPECT_EQ(0, ret);
651 
652     dev_.devAddr = DEV_ADDR_INVALID;
653     EXPECT_CALL(*mockUsbImpl_, RequestWait(testing::_, testing::_, testing::_, testing::_))
654         .WillRepeatedly(Return(RETVAL_INVALID));
655     ret = usbSrv_->RequestWait(dev_, REQUEST_TIME_OUT, cmdData, dataBuffer);
656     USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestMockTest::UsbRequestWait006 UsbRequestWait=%{public}d", ret);
657     EXPECT_NE(ret, 0);
658 
659     dev_.devAddr = DEV_ADDR_OK;
660 }
661 } // namespace USB
662 } // namespace OHOS
663