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_device_pipe_mock_test.h"
17
18 #include <cstdio>
19 #include <cstring>
20 #include <iostream>
21 #include <sstream>
22 #include <sys/time.h>
23 #include <unistd.h>
24 #include <vector>
25
26 #include "delayed_sp_singleton.h"
27 #include "file_ex.h"
28 #include "hilog_wrapper.h"
29 #include "iusb_srv.h"
30 #include "securec.h"
31 #include "usb_common.h"
32 #include "usb_common_test.h"
33 #include "usb_descriptor_parser.h"
34 #include "usb_errors.h"
35 #include "usb_port_manager.h"
36 #include "usb_service.h"
37 #include "usb_srv_client.h"
38 #include "usbd_bulkcallback_impl.h"
39
40 using namespace OHOS;
41 using namespace OHOS::USB;
42 using namespace OHOS::USB::Common;
43 using namespace std;
44 using namespace testing::ext;
45 using ::testing::Eq;
46 using ::testing::Exactly;
47 using ::testing::Ge;
48 using ::testing::Le;
49 using ::testing::Ne;
50 using ::testing::Return;
51
52 namespace OHOS {
53 namespace USB {
54 constexpr int32_t BUFFER_SIZE = 255;
55 constexpr int32_t CTL_VALUE = 0x100;
56 constexpr int32_t TRANSFER_TIME_OUT = 500;
57 constexpr int32_t TRANSFER_TIME = -5;
58 constexpr int32_t TRANSFER_LEN_LONG = 16;
59 constexpr int32_t TRANSFER_LEN_SHORT = 8;
60 constexpr int32_t USB_REQUEST_TARGET_INTERFACE = 1;
61 constexpr int32_t USB_REQUEST_TARGET_ENDPOINT = 2;
62 constexpr uint8_t USB_SERVICE_CDC_REQ_SET_LINE_CODING = 0x20;
63 constexpr uint8_t USB_SERVICE_CDC_REQ_SET_CONTROL_LINE_STATE = 0x22;
64 constexpr uint8_t USB_SERVICE_REQ_GET_CONFIGURATION = 0x08;
65 constexpr uint8_t USB_SERVICE_REQ_GET_DESCRIPTOR = 0x06;
66 constexpr uint8_t USB_SERVICE_REQ_GET_INTERFACE = 0x0A;
67 constexpr uint8_t USB_SERVICE_REQ_SYNCH_FRAME = 0x0C;
68 constexpr uint8_t USB_SERVICE_REQ_GET_STATUS = 0x00;
69 constexpr uint8_t USB_SERVICE_TYPE_CLASS = 0x20;
70
71 sptr<MockUsbImpl> UsbDevicePipeMockTest::mockUsbImpl_ = nullptr;
72 sptr<UsbService> UsbDevicePipeMockTest::usbSrv_ = nullptr;
73 UsbDev UsbDevicePipeMockTest::dev_ = {BUS_NUM_OK, DEV_ADDR_OK};
74 UsbDevice UsbDevicePipeMockTest::device_ {};
75
SetUpTestCase(void)76 void UsbDevicePipeMockTest::SetUpTestCase(void)
77 {
78 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest SetUpTestCase");
79 UsbCommonTest::SetTestCaseHapApply();
80
81 usbSrv_ = DelayedSpSingleton<UsbService>::GetInstance();
82 EXPECT_NE(usbSrv_, nullptr);
83 mockUsbImpl_ = DelayedSpSingleton<MockUsbImpl>::GetInstance();
84 EXPECT_NE(mockUsbImpl_, nullptr);
85
86 usbSrv_->SetUsbd(mockUsbImpl_);
87
88 sptr<UsbServiceSubscriber> iSubscriber = new UsbServiceSubscriber();
89 EXPECT_NE(iSubscriber, nullptr);
90 mockUsbImpl_->BindUsbdSubscriber(iSubscriber);
91
92 EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
93 EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
94 USBDeviceInfo info = {ACT_DEVUP, BUS_NUM_OK, DEV_ADDR_OK};
95 auto ret = mockUsbImpl_->SubscriberDeviceEvent(info);
96 EXPECT_EQ(0, ret);
97
98 ret = mockUsbImpl_->SetPortRole(DEFAULT_PORT_ID, UsbSrvSupport::POWER_ROLE_SOURCE, UsbSrvSupport::DATA_ROLE_HOST);
99 EXPECT_EQ(0, ret);
100 if (ret != 0) {
101 exit(0);
102 }
103
104 vector<UsbDevice> devList;
105 ret = usbSrv_->GetDevices(devList);
106 EXPECT_EQ(0, ret);
107 EXPECT_FALSE(devList.empty()) << "devList NULL";
108 device_ = MockUsbImpl::FindDeviceInfo(devList);
109
110 EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
111 ret = usbSrv_->OpenDevice(dev_.busNum, dev_.devAddr);
112 EXPECT_EQ(0, ret);
113 }
114
TearDownTestCase(void)115 void UsbDevicePipeMockTest::TearDownTestCase(void)
116 {
117 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest TearDownTestCase");
118 EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
119 auto ret = usbSrv_->Close(dev_.busNum, dev_.devAddr);
120 EXPECT_EQ(0, ret);
121
122 USBDeviceInfo info = {ACT_DEVDOWN, BUS_NUM_OK, DEV_ADDR_OK};
123 ret = mockUsbImpl_->SubscriberDeviceEvent(info);
124 EXPECT_EQ(0, ret);
125
126 mockUsbImpl_->UnbindUsbdSubscriber(nullptr);
127 sptr<IUsbInterface> usbd = IUsbInterface::Get();
128 usbSrv_->SetUsbd(usbd);
129
130 mockUsbImpl_ = nullptr;
131 usbSrv_ = nullptr;
132 DelayedSpSingleton<UsbService>::DestroyInstance();
133 DelayedSpSingleton<MockUsbImpl>::DestroyInstance();
134 }
135
SetUp(void)136 void UsbDevicePipeMockTest::SetUp(void) {}
137
TearDown(void)138 void UsbDevicePipeMockTest::TearDown(void) {}
139 /**
140 * @tc.name: getDevices001
141 * @tc.desc: Test functions to getDevices(std::vector<UsbDevice> &deviceList);
142 * @tc.desc: Positive test: parameters correctly
143 * @tc.type: FUNC
144 */
145 HWTEST_F(UsbDevicePipeMockTest, getDevices001, TestSize.Level1)
146 {
147 vector<UsbDevice> devList;
148 auto ret = usbSrv_->GetDevices(devList);
149 EXPECT_EQ(0, ret);
150 EXPECT_FALSE(devList.empty()) << "devList NULL";
151 UsbDevice device = MockUsbImpl::FindDeviceInfo(devList);
152 }
153 /**
154 * @tc.name: UsbOpenDevice001
155 * @tc.desc: Test functions of OpenDevice
156 * @tc.desc: Positive：code run normal,return 0
157 * @tc.type: FUNC
158 */
159 HWTEST_F(UsbDevicePipeMockTest, UsbOpenDevice001, TestSize.Level1)
160 {
161 EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
162 auto ret = usbSrv_->Close(dev_.busNum, dev_.devAddr);
163 EXPECT_EQ(0, ret);
164
165 EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
166 ret = usbSrv_->OpenDevice(dev_.busNum, dev_.devAddr);
167 EXPECT_EQ(0, ret);
168 }
169
170 /**
171 * @tc.name: UsbControlTransferRead001
172 * @tc.desc: Test functions to ControlTransfer
173 * @tc.desc: Positive test: parameters correctly
174 * @tc.type: FUNC
175 */
176 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead001, TestSize.Level1)
177 {
178 struct UsbCtrlTransfer ctrlData = {USB_ENDPOINT_DIR_IN, USB_SERVICE_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
179 std::vector<uint8_t> ctrlBuffer(TRANSFER_LEN_SHORT);
180 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
181 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
182 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead001 ControlTransfer=%{public}d", ret);
183 EXPECT_EQ(0, ret);
184 }
185
186 /**
187 * @tc.name: UsbControlTransferRead002
188 * @tc.desc: Test functions to ControlTransfer
189 * @tc.desc: Negative test: parameters exception, busNum error
190 * @tc.type: FUNC
191 */
192 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead002, TestSize.Level1)
193 {
194 dev_.busNum = BUS_NUM_INVALID;
195 struct UsbCtrlTransfer ctrlData = {USB_ENDPOINT_DIR_IN, USB_SERVICE_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
196 std::vector<uint8_t> ctrlBuffer(TRANSFER_LEN_SHORT);
197 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
198 .WillRepeatedly(Return(RETVAL_INVALID));
199 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
200 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead002 ControlTransfer=%{public}d", ret);
201 EXPECT_NE(ret, 0);
202
203 dev_.busNum = BUS_NUM_OK;
204 }
205
206 /**
207 * @tc.name: UsbControlTransferRead003
208 * @tc.desc: Test functions to ControlTransfer
209 * @tc.desc: Negative test: parameters exception, devAddr error
210 * @tc.type: FUNC
211 */
212 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead003, TestSize.Level1)
213 {
214 dev_.devAddr = DEV_ADDR_INVALID;
215 struct UsbCtrlTransfer ctrlData = {USB_ENDPOINT_DIR_IN, USB_SERVICE_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
216 std::vector<uint8_t> ctrlBuffer(TRANSFER_LEN_SHORT);
217 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
218 .WillRepeatedly(Return(RETVAL_INVALID));
219 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
220 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead003 ControlTransfer=%{public}d", ret);
221 EXPECT_NE(ret, 0);
222
223 dev_.devAddr = DEV_ADDR_OK;
224 }
225
226 /**
227 * @tc.name: UsbControlTransferRead004
228 * @tc.desc: Test functions to ControlTransfer
229 * @tc.desc: Positive test: parameters correctly
230 * @tc.type: FUNC
231 */
232 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead004, TestSize.Level1)
233 {
234 struct UsbCtrlTransfer ctrlData = {
235 USB_ENDPOINT_DIR_IN, USB_SERVICE_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, TRANSFER_TIME_OUT};
236 std::vector<uint8_t> ctrlBuffer(TRANSFER_LEN_SHORT);
237 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
238 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
239 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead004 ControlTransfer=%{public}d", ret);
240 EXPECT_EQ(0, ret);
241 }
242
243 /**
244 * @tc.name: UsbControlTransferRead005
245 * @tc.desc: Test functions to ControlTransfer
246 * @tc.desc: Negative test: parameters exception, busNum error
247 * @tc.type: FUNC
248 */
249 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead005, TestSize.Level1)
250 {
251 dev_.busNum = BUS_NUM_INVALID;
252 struct UsbCtrlTransfer ctrlData = {
253 USB_ENDPOINT_DIR_IN, USB_SERVICE_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, TRANSFER_TIME_OUT};
254 std::vector<uint8_t> ctrlBuffer(TRANSFER_LEN_SHORT);
255 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
256 .WillRepeatedly(Return(RETVAL_INVALID));
257 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
258 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead005 ControlTransfer=%{public}d", ret);
259 EXPECT_NE(ret, 0);
260
261 dev_.busNum = BUS_NUM_OK;
262 }
263
264 /**
265 * @tc.name: UsbControlTransferRead006
266 * @tc.desc: Test functions to ControlTransfer
267 * @tc.desc: Negative test: parameters exception, devAddr error
268 * @tc.type: FUNC
269 */
270 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead006, TestSize.Level1)
271 {
272 dev_.devAddr = DEV_ADDR_INVALID;
273 struct UsbCtrlTransfer ctrlData = {
274 USB_ENDPOINT_DIR_IN, USB_SERVICE_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, TRANSFER_TIME_OUT};
275 std::vector<uint8_t> ctrlBuffer(TRANSFER_LEN_SHORT);
276 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
277 .WillRepeatedly(Return(RETVAL_INVALID));
278 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
279 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead006 ControlTransfer=%{public}d", ret);
280 EXPECT_NE(ret, 0);
281
282 dev_.devAddr = DEV_ADDR_OK;
283 }
284
285 /**
286 * @tc.name: UsbControlTransferRead007
287 * @tc.desc: Test functions to ControlTransfer
288 * @tc.desc: Positive test: parameters correctly
289 * @tc.type: FUNC
290 */
291 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead007, TestSize.Level1)
292 {
293 struct UsbCtrlTransfer ctrlData = {
294 USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, USB_SERVICE_REQ_GET_INTERFACE, 0, 0, TRANSFER_TIME_OUT};
295 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
296 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
297 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
298 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead007 ControlTransfer=%{public}d", ret);
299 EXPECT_EQ(0, ret);
300 }
301
302 /**
303 * @tc.name: UsbControlTransferRead008
304 * @tc.desc: Test functions to ControlTransfer
305 * @tc.desc: Negative test: parameters exception, busNum error
306 * @tc.type: FUNC
307 */
308 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead008, TestSize.Level1)
309 {
310 dev_.busNum = BUS_NUM_INVALID;
311 struct UsbCtrlTransfer ctrlData = {
312 USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, USB_SERVICE_REQ_GET_INTERFACE, 0, 0, TRANSFER_TIME_OUT};
313 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
314 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
315 .WillRepeatedly(Return(RETVAL_INVALID));
316 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
317 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead008 ControlTransfer=%{public}d", ret);
318 EXPECT_NE(ret, 0);
319
320 dev_.busNum = BUS_NUM_OK;
321 }
322
323 /**
324 * @tc.name: UsbControlTransferRead009
325 * @tc.desc: Test functions to ControlTransfer
326 * @tc.desc: Negative test: parameters exception, devAddr error
327 * @tc.type: FUNC
328 */
329 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead009, TestSize.Level1)
330 {
331 dev_.devAddr = DEV_ADDR_INVALID;
332 struct UsbCtrlTransfer ctrlData = {
333 USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, USB_SERVICE_REQ_GET_INTERFACE, 0, 0, TRANSFER_TIME_OUT};
334 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
335 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
336 .WillRepeatedly(Return(RETVAL_INVALID));
337 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
338 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead009 ControlTransfer=%{public}d", ret);
339 EXPECT_NE(ret, 0);
340
341 dev_.devAddr = DEV_ADDR_OK;
342 }
343
344 /**
345 * @tc.name: UsbControlTransferRead010
346 * @tc.desc: Test functions to ControlTransfer
347 * @tc.desc: Positive test: parameters correctly
348 * @tc.type: FUNC
349 */
350 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead010, TestSize.Level1)
351 {
352 struct UsbCtrlTransfer ctrlData = {USB_ENDPOINT_DIR_IN, USB_SERVICE_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
353 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
354 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
355 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
356 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead010 ControlTransfer=%{public}d", ret);
357 EXPECT_EQ(0, ret);
358 }
359
360 /**
361 * @tc.name: UsbControlTransferRead011
362 * @tc.desc: Test functions to ControlTransfer
363 * @tc.desc: Negative test: parameters exception, busNum error
364 * @tc.type: FUNC
365 */
366 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead011, TestSize.Level1)
367 {
368 dev_.busNum = BUS_NUM_INVALID;
369 struct UsbCtrlTransfer ctrlData = {USB_ENDPOINT_DIR_IN, USB_SERVICE_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
370 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
371 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
372 .WillRepeatedly(Return(RETVAL_INVALID));
373 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
374 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead011 ControlTransfer=%{public}d", ret);
375 EXPECT_NE(ret, 0);
376
377 dev_.busNum = BUS_NUM_OK;
378 }
379
380 /**
381 * @tc.name: UsbControlTransferRead012
382 * @tc.desc: Test functions to ControlTransfer
383 * @tc.desc: Negative test: parameters exception, devAddr error
384 * @tc.type: FUNC
385 */
386 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead012, TestSize.Level1)
387 {
388 dev_.devAddr = DEV_ADDR_INVALID;
389 struct UsbCtrlTransfer ctrlData = {USB_ENDPOINT_DIR_IN, USB_SERVICE_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
390 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
391 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
392 .WillRepeatedly(Return(RETVAL_INVALID));
393 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
394 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead012 ControlTransfer=%{public}d", ret);
395 EXPECT_NE(ret, 0);
396
397 dev_.devAddr = DEV_ADDR_OK;
398 }
399
400 /**
401 * @tc.name: UsbControlTransferRead0013
402 * @tc.desc: Test functions to ControlTransfer
403 * @tc.desc: Positive test: parameters correctly
404 * @tc.type: FUNC
405 */
406 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead0013, TestSize.Level1)
407 {
408 struct UsbCtrlTransfer ctrlData = {
409 USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, USB_SERVICE_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
410 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
411 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
412 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
413 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead0013 ControlTransfer=%{public}d", ret);
414 EXPECT_EQ(0, ret);
415 }
416
417 /**
418 * @tc.name: UsbControlTransferRead0014
419 * @tc.desc: Test functions to ControlTransfer
420 * @tc.desc: Negative test: parameters exception, busNum error
421 * @tc.type: FUNC
422 */
423 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead0014, TestSize.Level1)
424 {
425 dev_.busNum = BUS_NUM_INVALID;
426 struct UsbCtrlTransfer ctrlData = {
427 USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, USB_SERVICE_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
428 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
429 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
430 .WillRepeatedly(Return(RETVAL_INVALID));
431 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
432 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead0014 ControlTransfer=%{public}d", ret);
433 EXPECT_NE(ret, 0);
434
435 dev_.busNum = BUS_NUM_OK;
436 }
437
438 /**
439 * @tc.name: UsbControlTransferRead0015
440 * @tc.desc: Test functions to ControlTransfer
441 * @tc.desc: Negative test: parameters exception, devAddr error
442 * @tc.type: FUNC
443 */
444 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead0015, TestSize.Level1)
445 {
446 dev_.devAddr = DEV_ADDR_INVALID;
447 struct UsbCtrlTransfer ctrlData = {
448 USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, USB_SERVICE_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
449 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
450 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
451 .WillRepeatedly(Return(RETVAL_INVALID));
452 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
453 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead0015 ControlTransfer=%{public}d", ret);
454 EXPECT_NE(ret, 0);
455
456 dev_.devAddr = DEV_ADDR_OK;
457 }
458
459 /**
460 * @tc.name: UsbControlTransferRead016
461 * @tc.desc: Test functions to ControlTransfer
462 * @tc.desc: Positive test: parameters correctly
463 * @tc.type: FUNC
464 */
465 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead016, TestSize.Level1)
466 {
467 struct UsbCtrlTransfer ctrlData = {
468 USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_SERVICE_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
469 std::vector<uint8_t> ctrlBuffer(TRANSFER_LEN_LONG);
470 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
471 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
472 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead016 ControlTransfer=%{public}d", ret);
473 EXPECT_EQ(0, ret);
474 }
475
476 /**
477 * @tc.name: UsbControlTransferRead017
478 * @tc.desc: Test functions to ControlTransfer
479 * @tc.desc: Negative test: parameters exception, busNum error
480 * @tc.type: FUNC
481 */
482 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead017, TestSize.Level1)
483 {
484 dev_.busNum = BUS_NUM_INVALID;
485 struct UsbCtrlTransfer ctrlData = {
486 USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_SERVICE_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
487 std::vector<uint8_t> ctrlBuffer(TRANSFER_LEN_LONG);
488 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
489 .WillRepeatedly(Return(RETVAL_INVALID));
490 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
491 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead017 ControlTransfer=%{public}d", ret);
492 EXPECT_NE(ret, 0);
493
494 dev_.busNum = BUS_NUM_OK;
495 }
496
497 /**
498 * @tc.name: UsbControlTransferRead018
499 * @tc.desc: Test functions to ControlTransfer
500 * @tc.desc: Negative test: parameters exception, devAddr error
501 * @tc.type: FUNC
502 */
503 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead018, TestSize.Level1)
504 {
505 dev_.devAddr = DEV_ADDR_INVALID;
506 struct UsbCtrlTransfer ctrlData = {
507 USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_SERVICE_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
508 std::vector<uint8_t> ctrlBuffer(TRANSFER_LEN_LONG);
509 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
510 .WillRepeatedly(Return(RETVAL_INVALID));
511 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
512 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead018 ControlTransfer=%{public}d", ret);
513 EXPECT_NE(ret, 0);
514
515 dev_.devAddr = DEV_ADDR_OK;
516 }
517
518 /**
519 * @tc.name: UsbControlTransferRead019
520 * @tc.desc: Test functions to ControlTransfer
521 * @tc.desc: Positive test: parameters correctly
522 * @tc.type: FUNC
523 */
524 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead019, TestSize.Level1)
525 {
526 struct UsbCtrlTransfer ctrlData = {
527 USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_SERVICE_REQ_SYNCH_FRAME, 0, 0, TRANSFER_TIME_OUT};
528 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
529 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
530 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
531 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead019 ControlTransfer=%{public}d", ret);
532 EXPECT_EQ(0, ret);
533 }
534
535 /**
536 * @tc.name: UsbControlTransferRead020
537 * @tc.desc: Test functions to ControlTransfer
538 * @tc.desc: Negative test: parameters exception, busNum error
539 * @tc.type: FUNC
540 */
541 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead020, TestSize.Level1)
542 {
543 dev_.busNum = BUS_NUM_INVALID;
544 struct UsbCtrlTransfer ctrlData = {
545 USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_SERVICE_REQ_SYNCH_FRAME, 0, 0, TRANSFER_TIME_OUT};
546 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
547 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
548 .WillRepeatedly(Return(RETVAL_INVALID));
549 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
550 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead020 ControlTransfer=%{public}d", ret);
551 EXPECT_NE(ret, 0);
552
553 dev_.busNum = BUS_NUM_OK;
554 }
555
556 /**
557 * @tc.name: UsbControlTransferRead021
558 * @tc.desc: Test functions to ControlTransfer
559 * @tc.desc: Negative test: parameters exception, devAddr error
560 * @tc.type: FUNC
561 */
562 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferRead021, TestSize.Level1)
563 {
564 dev_.devAddr = DEV_ADDR_INVALID;
565 struct UsbCtrlTransfer ctrlData = {
566 USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_SERVICE_REQ_SYNCH_FRAME, 0, 0, TRANSFER_TIME_OUT};
567 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
568 EXPECT_CALL(*mockUsbImpl_, ControlTransferRead(testing::_, testing::_, testing::_))
569 .WillRepeatedly(Return(RETVAL_INVALID));
570 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
571 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferRead021 ControlTransfer=%{public}d", ret);
572 EXPECT_NE(ret, 0);
573
574 dev_.devAddr = DEV_ADDR_OK;
575 }
576
577 /**
578 * @tc.name: UsbControlTransferWrite001
579 * @tc.desc: Test functions to ControlTransfer
580 * @tc.desc: Positive test: parameters correctly
581 * @tc.type: FUNC
582 */
583 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferWrite001, TestSize.Level1)
584 {
585 struct UsbCtrlTransfer ctrlData = {USB_ENDPOINT_DIR_OUT | USB_SERVICE_TYPE_CLASS | USB_REQUEST_TARGET_INTERFACE,
586 USB_SERVICE_CDC_REQ_SET_LINE_CODING, 0, 0, TRANSFER_TIME_OUT};
587 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
588 EXPECT_CALL(*mockUsbImpl_, ControlTransferWrite(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
589 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
590 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferWrite001 ControlTransfer=%{public}d", ret);
591 EXPECT_EQ(0, ret);
592 }
593
594 /**
595 * @tc.name: UsbControlTransferWrite002
596 * @tc.desc: Test functions to ControlTransfer
597 * @tc.desc: Negative test: parameters exception, busNum error
598 * @tc.type: FUNC
599 */
600 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferWrite002, TestSize.Level1)
601 {
602 struct UsbCtrlTransfer ctrlData = {USB_ENDPOINT_DIR_OUT | USB_SERVICE_TYPE_CLASS | USB_REQUEST_TARGET_INTERFACE,
603 USB_SERVICE_CDC_REQ_SET_LINE_CODING, 0, 0, TRANSFER_TIME_OUT};
604 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
605 dev_.busNum = BUS_NUM_INVALID;
606 EXPECT_CALL(*mockUsbImpl_, ControlTransferWrite(testing::_, testing::_, testing::_))
607 .WillRepeatedly(Return(RETVAL_INVALID));
608 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
609 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferWrite002 ControlTransfer=%{public}d", ret);
610 EXPECT_NE(ret, 0);
611
612 dev_.busNum = BUS_NUM_OK;
613 }
614
615 /**
616 * @tc.name: UsbControlTransferWrite003
617 * @tc.desc: Test functions to ControlTransfer
618 * @tc.desc: Negative test: parameters exception, devAddr error
619 * @tc.type: FUNC
620 */
621 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferWrite003, TestSize.Level1)
622 {
623 struct UsbCtrlTransfer ctrlData = {USB_ENDPOINT_DIR_OUT | USB_SERVICE_TYPE_CLASS | USB_REQUEST_TARGET_INTERFACE,
624 USB_SERVICE_CDC_REQ_SET_LINE_CODING, 0, 0, TRANSFER_TIME_OUT};
625 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
626 EXPECT_CALL(*mockUsbImpl_, ControlTransferWrite(testing::_, testing::_, testing::_))
627 .WillRepeatedly(Return(RETVAL_INVALID));
628 dev_.devAddr = DEV_ADDR_INVALID;
629 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
630 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferWrite003 ControlTransfer=%{public}d", ret);
631 EXPECT_NE(ret, 0);
632
633 dev_.devAddr = DEV_ADDR_OK;
634 }
635
636 /**
637 * @tc.name: UsbControlTransferWrite004
638 * @tc.desc: Test functions to ControlTransfer
639 * @tc.desc: Positive test: parameters correctly
640 * @tc.type: FUNC
641 */
642 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferWrite004, TestSize.Level1)
643 {
644 struct UsbCtrlTransfer ctrlData = {USB_ENDPOINT_DIR_OUT | USB_SERVICE_TYPE_CLASS | USB_REQUEST_TARGET_INTERFACE,
645 USB_SERVICE_CDC_REQ_SET_CONTROL_LINE_STATE, 0, 0, TRANSFER_TIME_OUT};
646 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
647 EXPECT_CALL(*mockUsbImpl_, ControlTransferWrite(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
648 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
649 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferWrite002 ControlTransfer=%{public}d", ret);
650 EXPECT_EQ(0, ret);
651 }
652
653 /**
654 * @tc.name: UsbControlTransferWrite005
655 * @tc.desc: Test functions to ControlTransfer
656 * @tc.desc: Negative test: parameters exception, busNum error
657 * @tc.type: FUNC
658 */
659 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferWrite005, TestSize.Level1)
660 {
661 struct UsbCtrlTransfer ctrlData = {USB_ENDPOINT_DIR_OUT | USB_SERVICE_TYPE_CLASS | USB_REQUEST_TARGET_INTERFACE,
662 USB_SERVICE_CDC_REQ_SET_CONTROL_LINE_STATE, 0, 0, TRANSFER_TIME_OUT};
663 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
664 EXPECT_CALL(*mockUsbImpl_, ControlTransferWrite(testing::_, testing::_, testing::_))
665 .WillRepeatedly(Return(RETVAL_INVALID));
666 dev_.busNum = BUS_NUM_INVALID;
667 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
668 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferWrite006 ControlTransfer=%{public}d", ret);
669 EXPECT_NE(ret, 0);
670
671 dev_.busNum = BUS_NUM_OK;
672 }
673
674 /**
675 * @tc.name: UsbControlTransferWrite006
676 * @tc.desc: Test functions to ControlTransfer
677 * @tc.desc: Negative test: parameters exception, devAddr error
678 * @tc.type: FUNC
679 */
680 HWTEST_F(UsbDevicePipeMockTest, UsbControlTransferWrite006, TestSize.Level1)
681 {
682 struct UsbCtrlTransfer ctrlData = {USB_ENDPOINT_DIR_OUT | USB_SERVICE_TYPE_CLASS | USB_REQUEST_TARGET_INTERFACE,
683 USB_SERVICE_CDC_REQ_SET_CONTROL_LINE_STATE, 0, 0, TRANSFER_TIME_OUT};
684 std::vector<uint8_t> ctrlBuffer(BUFFER_SIZE);
685 dev_.devAddr = DEV_ADDR_INVALID;
686 EXPECT_CALL(*mockUsbImpl_, ControlTransferWrite(testing::_, testing::_, testing::_))
687 .WillRepeatedly(Return(RETVAL_INVALID));
688 auto ret = usbSrv_->ControlTransfer(dev_, ctrlData, ctrlBuffer);
689 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbControlTransferWrite006 ControlTransfer=%{public}d", ret);
690 EXPECT_NE(ret, 0);
691
692 dev_.devAddr = DEV_ADDR_OK;
693 }
694
695 /**
696 * @tc.name: UsbClaimInterface001
697 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
698 * @tc.desc: Positive test: parameters correctly
699 * @tc.type: FUNC
700 */
701 HWTEST_F(UsbDevicePipeMockTest, UsbClaimInterface001, TestSize.Level1)
702 {
703 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().front();
704 uint8_t interfaceId = interface.GetId();
705 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
706 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
707 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbClaimInterface001 ClaimInterface=%{public}d", ret);
708 EXPECT_EQ(0, ret);
709 }
710
711 /**
712 * @tc.name: UsbClaimInterface002
713 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
714 * @tc.desc: Positive test: parameters correctly
715 * @tc.type: FUNC
716 */
717 HWTEST_F(UsbDevicePipeMockTest, UsbClaimInterface002, TestSize.Level1)
718 {
719 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().front();
720 uint8_t interfaceId = interface.GetId();
721 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
722 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, false);
723 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbClaimInterface002 ClaimInterface=%{public}d", ret);
724 EXPECT_EQ(0, ret);
725 }
726
727 /**
728 * @tc.name: UsbClaimInterface003
729 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
730 * @tc.desc: Positive test: parameters correctly
731 * @tc.type: FUNC
732 */
733 HWTEST_F(UsbDevicePipeMockTest, UsbClaimInterface003, TestSize.Level1)
734 {
735 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
736 uint8_t interfaceId = interface.GetId();
737 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
738 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
739 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbClaimInterface003 ClaimInterface=%{public}d", ret);
740 EXPECT_EQ(0, ret);
741 }
742
743 /**
744 * @tc.name: UsbClaimInterface004
745 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
746 * @tc.desc: Positive test: parameters correctly
747 * @tc.type: FUNC
748 */
749 HWTEST_F(UsbDevicePipeMockTest, UsbClaimInterface004, TestSize.Level1)
750 {
751 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
752 uint8_t interfaceId = interface.GetId();
753 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
754 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, false);
755 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbClaimInterface004 ClaimInterface=%{public}d", ret);
756 EXPECT_EQ(0, ret);
757 }
758
759 /**
760 * @tc.name: UsbClaimInterface005
761 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
762 * @tc.desc: Negative test: parameters exception, busNum error
763 * @tc.type: FUNC
764 */
765 HWTEST_F(UsbDevicePipeMockTest, UsbClaimInterface005, TestSize.Level1)
766 {
767 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().front();
768 uint8_t interfaceId = interface.GetId();
769 dev_.busNum = BUS_NUM_INVALID;
770 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_))
771 .WillRepeatedly(Return(RETVAL_INVALID));
772 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
773 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbClaimInterface005 ClaimInterface=%{public}d", ret);
774 EXPECT_NE(ret, 0);
775
776 dev_.busNum = BUS_NUM_OK;
777 }
778
779 /**
780 * @tc.name: UsbClaimInterface006
781 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
782 * @tc.desc: Negative test: parameters exception, devAddr error
783 * @tc.type: FUNC
784 */
785 HWTEST_F(UsbDevicePipeMockTest, UsbClaimInterface006, TestSize.Level1)
786 {
787 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().front();
788 uint8_t interfaceId = interface.GetId();
789 dev_.devAddr = DEV_ADDR_INVALID;
790 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_))
791 .WillRepeatedly(Return(RETVAL_INVALID));
792 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
793 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbClaimInterface006 ClaimInterface=%{public}d", ret);
794 EXPECT_NE(ret, 0);
795 dev_.devAddr = DEV_ADDR_OK;
796 }
797
798 /**
799 * @tc.name: UsbClaimInterface007
800 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
801 * @tc.desc: Negative test: parameters exception, busNum error
802 * @tc.type: FUNC
803 */
804 HWTEST_F(UsbDevicePipeMockTest, UsbClaimInterface007, TestSize.Level1)
805 {
806 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
807 uint8_t interfaceId = interface.GetId();
808 dev_.busNum = BUS_NUM_INVALID;
809 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_))
810 .WillRepeatedly(Return(RETVAL_INVALID));
811 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
812 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbClaimInterface007 ClaimInterface=%{public}d", ret);
813 EXPECT_NE(ret, 0);
814
815 dev_.busNum = BUS_NUM_OK;
816 }
817
818 /**
819 * @tc.name: UsbClaimInterface008
820 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
821 * @tc.desc: Negative test: parameters exception, devAddr error
822 * @tc.type: FUNC
823 */
824 HWTEST_F(UsbDevicePipeMockTest, UsbClaimInterface008, TestSize.Level1)
825 {
826 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
827 uint8_t interfaceId = interface.GetId();
828 dev_.devAddr = DEV_ADDR_INVALID;
829 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_))
830 .WillRepeatedly(Return(RETVAL_INVALID));
831 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
832 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbClaimInterface008 ClaimInterface=%{public}d", ret);
833 EXPECT_NE(ret, 0);
834
835 dev_.devAddr = DEV_ADDR_OK;
836 }
837
838 /**
839 * @tc.name: UsbReleaseInterface001
840 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
841 * @tc.desc: Positive test: parameters correctly
842 * @tc.type: FUNC
843 */
844 HWTEST_F(UsbDevicePipeMockTest, UsbReleaseInterface001, TestSize.Level1)
845 {
846 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(0);
847 uint8_t interfaceId = interface.GetId();
848 EXPECT_CALL(*mockUsbImpl_, ReleaseInterface(testing::_, testing::_)).WillRepeatedly(Return(0));
849 auto ret = usbSrv_->ReleaseInterface(dev_.busNum, dev_.devAddr, interfaceId);
850 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbReleaseInterface001 ReleaseInterface=%{public}d", ret);
851 EXPECT_EQ(0, ret);
852 }
853
854 /**
855 * @tc.name: UsbReleaseInterface002
856 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
857 * @tc.desc: Negative test: parameters exception, busNum error
858 * @tc.type: FUNC
859 */
860 HWTEST_F(UsbDevicePipeMockTest, UsbReleaseInterface002, TestSize.Level1)
861 {
862 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(0);
863 uint8_t interfaceId = interface.GetId();
864 dev_.busNum = BUS_NUM_INVALID;
865 EXPECT_CALL(*mockUsbImpl_, ReleaseInterface(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
866 auto ret = usbSrv_->ReleaseInterface(dev_.busNum, dev_.devAddr, interfaceId);
867 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbReleaseInterface002 ReleaseInterface=%{public}d", ret);
868 EXPECT_NE(ret, 0);
869
870 dev_.busNum = BUS_NUM_OK;
871 }
872
873 /**
874 * @tc.name: UsbReleaseInterface003
875 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
876 * @tc.desc: Negative test: parameters exception, devAddr error
877 * @tc.type: FUNC
878 */
879 HWTEST_F(UsbDevicePipeMockTest, UsbReleaseInterface003, TestSize.Level1)
880 {
881 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(0);
882 uint8_t interfaceId = interface.GetId();
883 dev_.devAddr = DEV_ADDR_INVALID;
884 EXPECT_CALL(*mockUsbImpl_, ReleaseInterface(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
885 auto ret = usbSrv_->ReleaseInterface(dev_.busNum, dev_.devAddr, interfaceId);
886 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbReleaseInterface003 ReleaseInterface=%{public}d", ret);
887 EXPECT_NE(ret, 0);
888
889 dev_.devAddr = DEV_ADDR_OK;
890 }
891
892 /**
893 * @tc.name: UsbReleaseInterface004
894 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
895 * @tc.desc: Positive test: parameters correctly
896 * @tc.type: FUNC
897 */
898 HWTEST_F(UsbDevicePipeMockTest, UsbReleaseInterface004, TestSize.Level1)
899 {
900 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
901 uint8_t interfaceId = interface.GetId();
902 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
903 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
904 EXPECT_EQ(0, ret);
905
906 EXPECT_CALL(*mockUsbImpl_, ReleaseInterface(testing::_, testing::_)).WillRepeatedly(Return(0));
907 ret = usbSrv_->ReleaseInterface(dev_.busNum, dev_.devAddr, interfaceId);
908 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbReleaseInterface004 ReleaseInterface=%{public}d", ret);
909 EXPECT_EQ(0, ret);
910 }
911
912 /**
913 * @tc.name: UsbReleaseInterface005
914 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
915 * @tc.desc: Negative test: parameters exception, busNum error
916 * @tc.type: FUNC
917 */
918 HWTEST_F(UsbDevicePipeMockTest, UsbReleaseInterface005, TestSize.Level1)
919 {
920 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
921 uint8_t interfaceId = interface.GetId();
922 dev_.busNum = BUS_NUM_INVALID;
923 EXPECT_CALL(*mockUsbImpl_, ReleaseInterface(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
924 auto ret = usbSrv_->ReleaseInterface(dev_.busNum, dev_.devAddr, interfaceId);
925 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbReleaseInterface005 ReleaseInterface=%{public}d", ret);
926 EXPECT_NE(ret, 0);
927
928 dev_.busNum = BUS_NUM_OK;
929 }
930
931 /**
932 * @tc.name: UsbReleaseInterface006
933 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
934 * @tc.desc: Negative test: parameters exception, devAddr error
935 * @tc.type: FUNC
936 */
937 HWTEST_F(UsbDevicePipeMockTest, UsbReleaseInterface006, TestSize.Level1)
938 {
939 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
940 uint8_t interfaceId = interface.GetId();
941 dev_.devAddr = DEV_ADDR_INVALID;
942 EXPECT_CALL(*mockUsbImpl_, ReleaseInterface(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
943 auto ret = usbSrv_->ReleaseInterface(dev_.busNum, dev_.devAddr, interfaceId);
944 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbReleaseInterface006 ReleaseInterface=%{public}d", ret);
945 EXPECT_NE(ret, 0);
946
947 dev_.devAddr = DEV_ADDR_OK;
948 }
949
950 /**
951 * @tc.name: UsbBulkTransfer001
952 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
953 * timeout);
954 * @tc.desc: Positive test: parameters correctly
955 * @tc.type: FUNC
956 */
957 HWTEST_F(UsbDevicePipeMockTest, UsbBulkTransfer001, TestSize.Level1)
958 {
959 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
960 uint8_t interfaceId = interface.GetId();
961 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
962 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
963 EXPECT_EQ(0, ret);
964
965 USBEndpoint point = interface.GetEndpoints().front();
966 UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
967 std::vector<uint8_t> bulkBuffer = {'b', 'u', 'l', 'k', ' ', 'r', 'e', 'a', 'd', '0', '0', '1'};
968 EXPECT_CALL(*mockUsbImpl_, BulkTransferRead(testing::_, testing::_, testing::_, testing::_))
969 .WillRepeatedly(Return(0));
970 ret = usbSrv_->BulkTransferRead(dev_, pipe, bulkBuffer, TRANSFER_TIME_OUT);
971 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbBulkTransfer001 BulkTransfer=%{public}d", ret);
972 EXPECT_EQ(0, ret);
973 }
974
975 /**
976 * @tc.name: UsbBulkTransfer002
977 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
978 * timeout);
979 * @tc.desc: @tc.desc: Positive test: parameters correctly
980 * @tc.type: FUNC
981 */
982 HWTEST_F(UsbDevicePipeMockTest, UsbBulkTransfer002, TestSize.Level1)
983 {
984 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
985 uint8_t interfaceId = interface.GetId();
986
987 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
988 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
989 EXPECT_EQ(0, ret);
990
991 std::vector<uint8_t> bulkBuffer = {'b', 'u', 'l', 'k', ' ', 'r', 'e', 'a', 'd', '0', '0', '2'};
992 USBEndpoint point = interface.GetEndpoints().front();
993 UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
994 EXPECT_CALL(*mockUsbImpl_, BulkTransferRead(testing::_, testing::_, testing::_, testing::_))
995 .WillRepeatedly(Return(0));
996 ret = usbSrv_->BulkTransferRead(dev_, pipe, bulkBuffer, TRANSFER_TIME);
997 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbBulkTransfer002 BulkTransfer=%{public}d", ret);
998 EXPECT_EQ(0, ret);
999 }
1000
1001 /**
1002 * @tc.name: UsbBulkTransfer003
1003 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1004 * timeout);
1005 * @tc.desc: Negative test: parameters exception, busNum error
1006 * @tc.type: FUNC
1007 */
1008 HWTEST_F(UsbDevicePipeMockTest, UsbBulkTransfer003, TestSize.Level1)
1009 {
1010 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
1011 uint8_t interfaceId = interface.GetId();
1012 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1013 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1014 EXPECT_EQ(0, ret);
1015
1016 dev_.busNum = BUS_NUM_INVALID;
1017 USBEndpoint point = interface.GetEndpoints().front();
1018 UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
1019 std::vector<uint8_t> bulkBuffer = {'b', 'u', 'l', 'k', ' ', 'r', 'e', 'a', 'd', '0', '0', '3'};
1020 EXPECT_CALL(*mockUsbImpl_, BulkTransferRead(testing::_, testing::_, testing::_, testing::_))
1021 .WillRepeatedly(Return(RETVAL_INVALID));
1022 ret = usbSrv_->BulkTransferRead(dev_, pipe, bulkBuffer, TRANSFER_TIME_OUT);
1023 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbBulkTransfer003 BulkTransfer=%{public}d", ret);
1024 EXPECT_NE(ret, 0);
1025
1026 dev_.busNum = BUS_NUM_OK;
1027 }
1028
1029 /**
1030 * @tc.name: UsbBulkTransfer004
1031 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1032 * timeout);
1033 * @tc.desc: Negative test: parameters exception, devAddr error
1034 * @tc.type: FUNC
1035 */
1036 HWTEST_F(UsbDevicePipeMockTest, UsbBulkTransfer004, TestSize.Level1)
1037 {
1038 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
1039 uint8_t interfaceId = interface.GetId();
1040 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1041 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1042 EXPECT_EQ(0, ret);
1043
1044 dev_.devAddr = DEV_ADDR_INVALID;
1045 USBEndpoint point = interface.GetEndpoints().front();
1046 UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
1047 std::vector<uint8_t> bulkBuffer = {'b', 'u', 'l', 'k', ' ', 'r', 'e', 'a', 'd', '0', '0', '4'};
1048 EXPECT_CALL(*mockUsbImpl_, BulkTransferRead(testing::_, testing::_, testing::_, testing::_))
1049 .WillRepeatedly(Return(RETVAL_INVALID));
1050 ret = usbSrv_->BulkTransferRead(dev_, pipe, bulkBuffer, TRANSFER_TIME_OUT);
1051 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbBulkTransfer004 BulkTransfer=%{public}d", ret);
1052 EXPECT_NE(ret, 0);
1053
1054 dev_.devAddr = DEV_ADDR_OK;
1055 }
1056
1057 /**
1058 * @tc.name: UsbBulkTransfer005
1059 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1060 * timeout);
1061 * @tc.desc: Negative test: parameters exception, point error
1062 * @tc.type: FUNC
1063 */
1064 HWTEST_F(UsbDevicePipeMockTest, UsbBulkTransfer005, TestSize.Level1)
1065 {
1066 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
1067 uint8_t interfaceId = interface.GetId();
1068 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1069 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1070 EXPECT_EQ(0, ret);
1071
1072 USBEndpoint point = interface.GetEndpoints().front();
1073 UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
1074 point.SetInterfaceId(BUFFER_SIZE);
1075 std::vector<uint8_t> bulkBuffer = {'b', 'u', 'l', 'k', ' ', 'r', 'e', 'a', 'd', '0', '0', '5'};
1076 EXPECT_CALL(*mockUsbImpl_, BulkTransferRead(testing::_, testing::_, testing::_, testing::_))
1077 .WillRepeatedly(Return(RETVAL_INVALID));
1078 ret = usbSrv_->BulkTransferRead(dev_, pipe, bulkBuffer, TRANSFER_TIME_OUT);
1079 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbBulkTransfer005 BulkTransfer=%{public}d", ret);
1080 EXPECT_NE(ret, 0);
1081 }
1082
1083 /**
1084 * @tc.name: UsbBulkTransfer006
1085 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1086 * timeout);
1087 * @tc.desc: Negative test: parameters exception, point SetAddr error
1088 * @tc.type: FUNC
1089 */
1090 HWTEST_F(UsbDevicePipeMockTest, UsbBulkTransfer006, TestSize.Level1)
1091 {
1092 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
1093 uint8_t interfaceId = interface.GetId();
1094 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1095 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1096 EXPECT_EQ(0, ret);
1097
1098 USBEndpoint point = interface.GetEndpoints().front();
1099 UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
1100 point.SetAddr(BUFFER_SIZE);
1101 std::vector<uint8_t> bulkBuffer = {'b', 'u', 'l', 'k', ' ', 'r', 'e', 'a', 'd', '0', '0', '6'};
1102 EXPECT_CALL(*mockUsbImpl_, BulkTransferRead(testing::_, testing::_, testing::_, testing::_))
1103 .WillRepeatedly(Return(RETVAL_INVALID));
1104 ret = usbSrv_->BulkTransferRead(dev_, pipe, bulkBuffer, TRANSFER_TIME_OUT);
1105 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbBulkTransfer006 BulkTransfer=%{public}d", ret);
1106 EXPECT_NE(ret, 0);
1107 }
1108
1109 /**
1110 * @tc.name: UsbBulkTransfer007
1111 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1112 * timeout);
1113 * @tc.desc: Positive test: parameters correctly
1114 * @tc.type: FUNC
1115 */
1116 HWTEST_F(UsbDevicePipeMockTest, UsbBulkTransfer007, TestSize.Level1)
1117 {
1118 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
1119 uint8_t interfaceId = interface.GetId();
1120 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1121 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1122 EXPECT_EQ(0, ret);
1123
1124 USBEndpoint point = interface.GetEndpoints().at(1);
1125 UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
1126 std::vector<uint8_t> bulkBuffer = {'b', 'u', 'l', 'k', ' ', 'r', 'e', 'a', 'd', '0', '0', '7'};
1127 EXPECT_CALL(*mockUsbImpl_, BulkTransferWrite(testing::_, testing::_, testing::_, testing::_))
1128 .WillRepeatedly(Return(0));
1129 ret = usbSrv_->BulkTransferWrite(dev_, pipe, bulkBuffer, TRANSFER_TIME_OUT);
1130 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbBulkTransfer007 BulkTransfer=%{public}d", ret);
1131 EXPECT_EQ(0, ret);
1132 }
1133
1134 /**
1135 * @tc.name: UsbBulkTransfer008
1136 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1137 * timeout);
1138 * @tc.desc: Negative test: parameters exception, devAddr error
1139 * @tc.type: FUNC
1140 */
1141 HWTEST_F(UsbDevicePipeMockTest, UsbBulkTransfer008, TestSize.Level1)
1142 {
1143 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
1144 uint8_t interfaceId = interface.GetId();
1145 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1146 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1147 EXPECT_EQ(0, ret);
1148
1149 dev_.devAddr = DEV_ADDR_INVALID;
1150 USBEndpoint point = interface.GetEndpoints().at(1);
1151 const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
1152 std::vector<uint8_t> bulkBuffer = {'b', 'u', 'l', 'k', ' ', 'r', 'e', 'a', 'd', '0', '0', '8'};
1153 EXPECT_CALL(*mockUsbImpl_, BulkTransferWrite(testing::_, testing::_, testing::_, testing::_))
1154 .WillRepeatedly(Return(RETVAL_INVALID));
1155 ret = usbSrv_->BulkTransferWrite(dev_, pipe, bulkBuffer, TRANSFER_TIME_OUT);
1156 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbBulkTransfer008 BulkTransfer=%{public}d", ret);
1157 EXPECT_NE(ret, 0);
1158
1159 dev_.devAddr = DEV_ADDR_OK;
1160 }
1161
1162 /**
1163 * @tc.name: UsbBulkTransfer009
1164 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1165 * timeout);
1166 * @tc.desc: Negative test: parameters exception, busNum error
1167 * @tc.type: FUNC
1168 */
1169 HWTEST_F(UsbDevicePipeMockTest, UsbBulkTransfer009, TestSize.Level1)
1170 {
1171 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
1172 uint8_t interfaceId = interface.GetId();
1173 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1174 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1175 EXPECT_EQ(0, ret);
1176
1177 dev_.busNum = BUS_NUM_INVALID;
1178 USBEndpoint point = interface.GetEndpoints().at(1);
1179 const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
1180 std::vector<uint8_t> bulkBuffer = {'b', 'u', 'l', 'k', ' ', 'r', 'e', 'a', 'd', '0', '0', '9'};
1181 EXPECT_CALL(*mockUsbImpl_, BulkTransferWrite(testing::_, testing::_, testing::_, testing::_))
1182 .WillRepeatedly(Return(RETVAL_INVALID));
1183 ret = usbSrv_->BulkTransferWrite(dev_, pipe, bulkBuffer, TRANSFER_TIME_OUT);
1184 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbBulkTransfer009 BulkTransfer=%{public}d", ret);
1185 EXPECT_NE(ret, 0);
1186
1187 dev_.busNum = BUS_NUM_OK;
1188 }
1189
1190 /**
1191 * @tc.name: UsbBulkTransfer010
1192 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1193 * timeout);
1194 * @tc.desc: Positive test: parameters correctly
1195 * @tc.type: FUNC
1196 */
1197 HWTEST_F(UsbDevicePipeMockTest, UsbBulkTransfer010, TestSize.Level1)
1198 {
1199 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(1);
1200 uint8_t interfaceId = interface.GetId();
1201 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1202 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1203 EXPECT_EQ(0, ret);
1204
1205 USBEndpoint point = interface.GetEndpoints().at(1);
1206 const UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
1207 std::vector<uint8_t> bulkBuffer = {'b', 'u', 'l', 'k', ' ', 'r', 'e', 'a', 'd', '0', '1', '0'};
1208 EXPECT_CALL(*mockUsbImpl_, BulkTransferWrite(testing::_, testing::_, testing::_, testing::_))
1209 .WillRepeatedly(Return(0));
1210 ret = usbSrv_->BulkTransferWrite(dev_, pipe, bulkBuffer, TRANSFER_TIME);
1211 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::UsbBulkTransfer010 BulkTransfer=%{public}d", ret);
1212 EXPECT_EQ(0, ret);
1213 }
1214
1215 /**
1216 * @tc.name: SetConfiguration001
1217 * @tc.desc: Test functions to SetConfiguration(const USBConfig &config);
1218 * @tc.desc: Positive test: parameters correctly
1219 * @tc.type: FUNC
1220 */
1221 HWTEST_F(UsbDevicePipeMockTest, SetConfiguration001, TestSize.Level1)
1222 {
1223 USBConfig config = device_.GetConfigs().front();
1224 uint8_t configIndex = config.GetiConfiguration();
1225 EXPECT_CALL(*mockUsbImpl_, SetConfig(testing::_, testing::_)).WillRepeatedly(Return(0));
1226 auto ret = usbSrv_->SetActiveConfig(dev_.busNum, dev_.devAddr, configIndex);
1227 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::SetConfiguration001 SetConfiguration=%{public}d", ret);
1228 EXPECT_EQ(0, ret);
1229 }
1230
1231 /**
1232 * @tc.name: SetConfiguration002
1233 * @tc.desc: Test functions to SetConfiguration(const USBConfig &config);
1234 * @tc.desc: Negative test: parameters exception, busNum error
1235 * @tc.type: FUNC
1236 */
1237 HWTEST_F(UsbDevicePipeMockTest, SetConfiguration002, TestSize.Level1)
1238 {
1239 USBConfig config = device_.GetConfigs().front();
1240 uint8_t configIndex = config.GetiConfiguration();
1241 dev_.busNum = BUS_NUM_INVALID;
1242 EXPECT_CALL(*mockUsbImpl_, SetConfig(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
1243 auto ret = usbSrv_->SetActiveConfig(dev_.busNum, dev_.devAddr, configIndex);
1244 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::SetConfiguration002 ret=%{public}d", ret);
1245 EXPECT_NE(ret, 0);
1246
1247 dev_.busNum = BUS_NUM_OK;
1248 }
1249
1250 /**
1251 * @tc.name: SetConfiguration003
1252 * @tc.desc: Test functions to SetConfiguration(const USBConfig &config);
1253 * @tc.desc: Negative test: parameters exception, devAddr error
1254 * @tc.type: FUNC
1255 */
1256 HWTEST_F(UsbDevicePipeMockTest, SetConfiguration003, TestSize.Level1)
1257 {
1258 USBConfig config = device_.GetConfigs().front();
1259 uint8_t configIndex = config.GetiConfiguration();
1260 dev_.devAddr = DEV_ADDR_INVALID;
1261 EXPECT_CALL(*mockUsbImpl_, SetConfig(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
1262 auto ret = usbSrv_->SetActiveConfig(dev_.busNum, dev_.devAddr, configIndex);
1263 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::SetConfiguration003 SetConfiguration=%{public}d", ret);
1264 EXPECT_NE(ret, 0);
1265
1266 dev_.devAddr = DEV_ADDR_OK;
1267 }
1268
1269 /**
1270 * @tc.name: Close001
1271 * @tc.desc: Test functions to Close();
1272 * @tc.desc: Positive test: parameters correctly
1273 * @tc.type: FUNC
1274 */
1275 HWTEST_F(UsbDevicePipeMockTest, Close001, TestSize.Level1)
1276 {
1277 EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
1278 auto ret = usbSrv_->Close(dev_.busNum, dev_.devAddr);
1279 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::Close001 close=%{public}d", ret);
1280 EXPECT_EQ(0, ret);
1281
1282 EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
1283 ret = usbSrv_->OpenDevice(dev_.busNum, dev_.devAddr);
1284 EXPECT_EQ(0, ret);
1285 }
1286
1287 /**
1288 * @tc.name: Close002
1289 * @tc.desc: Test functions to Close();
1290 * @tc.desc: Negative test: parameters exception, busNum error
1291 * @tc.type: FUNC
1292 */
1293 HWTEST_F(UsbDevicePipeMockTest, Close002, TestSize.Level1)
1294 {
1295 dev_.busNum = BUS_NUM_INVALID;
1296 EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
1297 auto ret = usbSrv_->Close(dev_.busNum, dev_.devAddr);
1298 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::Close002 close=%{public}d", ret);
1299 EXPECT_NE(ret, 0);
1300
1301 dev_.busNum = BUS_NUM_OK;
1302 EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
1303 ret = usbSrv_->OpenDevice(dev_.busNum, dev_.devAddr);
1304 EXPECT_EQ(0, ret);
1305 }
1306
1307 /**
1308 * @tc.name: Close003
1309 * @tc.desc: Test functions to Close();
1310 * @tc.desc: Negative test: parameters exception, devAddr error
1311 * @tc.type: FUNC
1312 */
1313 HWTEST_F(UsbDevicePipeMockTest, Close003, TestSize.Level1)
1314 {
1315 dev_.devAddr = DEV_ADDR_INVALID;
1316 EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
1317 auto ret = usbSrv_->Close(dev_.busNum, dev_.devAddr);
1318 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::Close003 ret=%{public}d", ret);
1319 EXPECT_NE(ret, 0);
1320
1321 dev_.devAddr = DEV_ADDR_OK;
1322 EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
1323 ret = usbSrv_->OpenDevice(dev_.busNum, dev_.devAddr);
1324 EXPECT_EQ(0, ret);
1325 }
1326
1327 /**
1328 * @tc.name: SetInterface001
1329 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
1330 * @tc.desc: Positive test: parameters correctly
1331 * @tc.type: FUNC
1332 */
1333 HWTEST_F(UsbDevicePipeMockTest, SetInterface001, TestSize.Level1)
1334 {
1335 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(0);
1336 uint8_t interfaceId = interface.GetId();
1337 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1338 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1339 EXPECT_EQ(0, ret);
1340
1341 uint8_t altIndex = interface.GetAlternateSetting();
1342 EXPECT_CALL(*mockUsbImpl_, SetInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1343 ret = usbSrv_->SetInterface(dev_.busNum, dev_.devAddr, interfaceId, altIndex);
1344 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::SetInterface001 SetInterface=%{public}d", ret);
1345 EXPECT_EQ(0, ret);
1346 }
1347
1348 /**
1349 * @tc.name: SetInterface002
1350 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
1351 * @tc.desc: Negative test: parameters exception, busNum error
1352 * @tc.type: FUNC
1353 */
1354 HWTEST_F(UsbDevicePipeMockTest, SetInterface002, TestSize.Level1)
1355 {
1356 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(0);
1357 uint8_t interfaceId = interface.GetId();
1358 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1359 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1360 EXPECT_EQ(0, ret);
1361
1362 dev_.busNum = BUS_NUM_INVALID;
1363 uint8_t altIndex = interface.GetAlternateSetting();
1364 EXPECT_CALL(*mockUsbImpl_, SetInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
1365 ret = usbSrv_->SetInterface(dev_.busNum, dev_.devAddr, interfaceId, altIndex);
1366 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::SetInterface002 SetInterface=%{public}d", ret);
1367 EXPECT_NE(ret, 0);
1368
1369 dev_.busNum = BUS_NUM_OK;
1370 }
1371
1372 /**
1373 * @tc.name: SetInterface003
1374 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
1375 * @tc.desc: Negative test: parameters exception, devAddr error
1376 * @tc.type: FUNC
1377 */
1378 HWTEST_F(UsbDevicePipeMockTest, SetInterface003, TestSize.Level1)
1379 {
1380 UsbInterface interface = device_.GetConfigs().front().GetInterfaces().at(0);
1381 uint8_t interfaceId = interface.GetId();
1382 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1383 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1384 EXPECT_EQ(0, ret);
1385
1386 dev_.devAddr = DEV_ADDR_INVALID;
1387 uint8_t altIndex = interface.GetAlternateSetting();
1388 EXPECT_CALL(*mockUsbImpl_, SetInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
1389 ret = usbSrv_->SetInterface(dev_.busNum, dev_.devAddr, interfaceId, altIndex);
1390 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::SetInterface003 SetInterface=%{public}d", ret);
1391 EXPECT_NE(ret, 0);
1392
1393 dev_.devAddr = DEV_ADDR_OK;
1394 }
1395
1396 /**
1397 * @tc.name: SetInterface004
1398 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
1399 * @tc.desc: Positive test: parameters correctly
1400 * @tc.type: FUNC
1401 */
1402 HWTEST_F(UsbDevicePipeMockTest, SetInterface004, TestSize.Level1)
1403 {
1404 UsbInterface interface = device_.GetConfigs().at(0).GetInterfaces().at(1);
1405 uint8_t interfaceId = interface.GetId();
1406 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1407 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1408 EXPECT_EQ(0, ret);
1409
1410 uint8_t altIndex = interface.GetAlternateSetting();
1411 EXPECT_CALL(*mockUsbImpl_, SetInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1412 ret = usbSrv_->SetInterface(dev_.busNum, dev_.devAddr, interfaceId, altIndex);
1413 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::SetInterface004 SetInterface=%{public}d", ret);
1414 EXPECT_EQ(0, ret);
1415 }
1416
1417 /**
1418 * @tc.name: SetInterface005
1419 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
1420 * @tc.desc: Negative test: parameters exception, busNum error
1421 * @tc.type: FUNC
1422 */
1423 HWTEST_F(UsbDevicePipeMockTest, SetInterface005, TestSize.Level1)
1424 {
1425 UsbInterface interface = device_.GetConfigs().at(0).GetInterfaces().at(1);
1426 uint8_t interfaceId = interface.GetId();
1427
1428 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1429 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1430 EXPECT_EQ(0, ret);
1431
1432 dev_.busNum = BUS_NUM_INVALID;
1433 uint8_t altIndex = interface.GetAlternateSetting();
1434 EXPECT_CALL(*mockUsbImpl_, SetInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
1435 ret = usbSrv_->SetInterface(dev_.busNum, dev_.devAddr, interfaceId, altIndex);
1436 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::SetInterface005 SetInterface=%{public}d", ret);
1437 EXPECT_NE(ret, 0);
1438
1439 dev_.busNum = BUS_NUM_OK;
1440 }
1441
1442 /**
1443 * @tc.name: SetInterface006
1444 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
1445 * @tc.desc: Negative test: parameters exception, devAddr error
1446 * @tc.type: FUNC
1447 */
1448 HWTEST_F(UsbDevicePipeMockTest, SetInterface006, TestSize.Level1)
1449 {
1450 UsbInterface interface = device_.GetConfigs().at(0).GetInterfaces().at(1);
1451 uint8_t interfaceId = interface.GetId();
1452 EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
1453 auto ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
1454 EXPECT_EQ(0, ret);
1455
1456 dev_.devAddr = DEV_ADDR_INVALID;
1457 uint8_t altIndex = interface.GetAlternateSetting();
1458 EXPECT_CALL(*mockUsbImpl_, SetInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
1459 ret = usbSrv_->SetInterface(dev_.busNum, dev_.devAddr, interfaceId, altIndex);
1460 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::SetInterface006 SetInterface=%{public}d", ret);
1461 EXPECT_NE(ret, 0);
1462
1463 dev_.devAddr = DEV_ADDR_OK;
1464 }
1465
1466 /**
1467 * @tc.name: GetRawDescriptors001
1468 * @tc.desc: Test functions to GetRawDescriptors
1469 * @tc.desc: Positive test: parameters correctly
1470 * @tc.type: FUNC
1471 */
1472 HWTEST_F(UsbDevicePipeMockTest, GetRawDescriptors001, TestSize.Level1)
1473 {
1474 std::vector<uint8_t> buffer;
1475 auto ret = usbSrv_->GetRawDescriptor(dev_.busNum, dev_.devAddr, buffer);
1476 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::GetRawDescriptors001 GetRawDescriptors=%{public}d", ret);
1477 EXPECT_EQ(0, ret);
1478 }
1479
1480 /**
1481 * @tc.name: GetRawDescriptors002
1482 * @tc.desc: Test functions to GetRawDescriptors
1483 * @tc.desc: Negative test: parameters exception, busNum error
1484 * @tc.type: FUNC
1485 */
1486 HWTEST_F(UsbDevicePipeMockTest, GetRawDescriptors002, TestSize.Level1)
1487 {
1488 std::vector<uint8_t> buffer;
1489 dev_.busNum = BUS_NUM_INVALID;
1490 auto ret = usbSrv_->GetRawDescriptor(dev_.busNum, dev_.devAddr, buffer);
1491 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::GetRawDescriptors002 GetRawDescriptors=%{public}d", ret);
1492 EXPECT_NE(ret, 0);
1493
1494 dev_.busNum = BUS_NUM_OK;
1495 }
1496
1497 /**
1498 * @tc.name: GetRawDescriptors003
1499 * @tc.desc: Test functions to GetRawDescriptors
1500 * @tc.desc: Negative test: parameters exception, devAddr error
1501 * @tc.type: FUNC
1502 */
1503 HWTEST_F(UsbDevicePipeMockTest, GetRawDescriptors003, TestSize.Level1)
1504 {
1505 std::vector<uint8_t> buffer;
1506 dev_.devAddr = DEV_ADDR_INVALID;
1507 auto ret = usbSrv_->GetRawDescriptor(dev_.busNum, dev_.devAddr, buffer);
1508 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::GetRawDescriptors003 GetRawDescriptors=%{public}d", ret);
1509 EXPECT_NE(ret, 0);
1510
1511 dev_.devAddr = DEV_ADDR_OK;
1512 }
1513
1514 /**
1515 * @tc.name: GetFileDescriptors001
1516 * @tc.desc: Test functions to GetRawDescriptors
1517 * @tc.desc: Positive test: parameters correctly
1518 * @tc.type: FUNC
1519 */
1520 HWTEST_F(UsbDevicePipeMockTest, GetFileDescriptors001, TestSize.Level1)
1521 {
1522 std::vector<uint8_t> buffer;
1523 auto ret = usbSrv_->GetRawDescriptor(dev_.busNum, dev_.devAddr, buffer);
1524 EXPECT_EQ(0, ret);
1525
1526 int32_t fd = 0;
1527 EXPECT_CALL(*mockUsbImpl_, GetFileDescriptor(testing::_, testing::_)).WillRepeatedly(Return(0));
1528 ret = usbSrv_->GetFileDescriptor(dev_.busNum, dev_.devAddr, fd);
1529 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::GetFileDescriptors001 GetFileDescriptor=%{public}d", ret);
1530 EXPECT_EQ(0, ret);
1531 }
1532
1533 /**
1534 * @tc.name: GetFileDescriptors002
1535 * @tc.desc: Test functions to GetRawDescriptors
1536 * @tc.desc: Negative test: parameters exception, busNum error
1537 * @tc.type: FUNC
1538 */
1539 HWTEST_F(UsbDevicePipeMockTest, GetFileDescriptors002, TestSize.Level1)
1540 {
1541 std::vector<uint8_t> buffer;
1542 auto ret = usbSrv_->GetRawDescriptor(dev_.busNum, dev_.devAddr, buffer);
1543 EXPECT_EQ(0, ret);
1544
1545 dev_.busNum = BUS_NUM_INVALID;
1546 int32_t fd = 0;
1547 EXPECT_CALL(*mockUsbImpl_, GetFileDescriptor(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
1548 ret = usbSrv_->GetFileDescriptor(dev_.busNum, dev_.devAddr, fd);
1549 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::GetFileDescriptors002 GetFileDescriptor=%{public}d", ret);
1550 EXPECT_NE(ret, 0);
1551
1552 dev_.busNum = BUS_NUM_OK;
1553 }
1554
1555 /**
1556 * @tc.name: GetFileDescriptors003
1557 * @tc.desc: Test functions to GetRawDescriptors
1558 * @tc.desc: Negative test: parameters exception, devAddr error
1559 * @tc.type: FUNC
1560 */
1561 HWTEST_F(UsbDevicePipeMockTest, GetFileDescriptors003, TestSize.Level1)
1562 {
1563 std::vector<uint8_t> buffer;
1564 auto ret = usbSrv_->GetRawDescriptor(dev_.busNum, dev_.devAddr, buffer);
1565 EXPECT_EQ(0, ret);
1566
1567 dev_.devAddr = DEV_ADDR_INVALID;
1568 int32_t fd = 0;
1569 EXPECT_CALL(*mockUsbImpl_, GetFileDescriptor(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
1570 ret = usbSrv_->GetFileDescriptor(dev_.busNum, dev_.devAddr, fd);
1571 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeMockTest::GetFileDescriptors003 GetFileDescriptor=%{public}d", ret);
1572 EXPECT_NE(ret, 0);
1573
1574 dev_.devAddr = DEV_ADDR_OK;
1575 }
1576 } // namespace USB
1577 } // namespace OHOS
1578