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_bulkcallback_mock_test.h"
17 
18 #include <iostream>
19 #include <sys/time.h>
20 #include <vector>
21 
22 #include "ashmem.h"
23 #include "delayed_sp_singleton.h"
24 #include "hilog_wrapper.h"
25 #include "securec.h"
26 #include "usb_callback_test.h"
27 #include "usb_common_test.h"
28 #include "usb_device_pipe.h"
29 #include "usb_errors.h"
30 #include "usb_service.h"
31 #include "usb_srv_client.h"
32 
33 using namespace OHOS;
34 using namespace OHOS::USB;
35 using namespace OHOS::USB::Common;
36 using namespace std;
37 using namespace testing::ext;
38 using ::testing::Eq;
39 using ::testing::Exactly;
40 using ::testing::Ge;
41 using ::testing::Le;
42 using ::testing::Ne;
43 using ::testing::Return;
44 
45 namespace OHOS {
46 namespace USB {
47 constexpr uint32_t ASHMEM_MAX_SIZE = 1024;
48 constexpr uint32_t MEM_DATA = 1024 * 1024;
49 sptr<MockUsbImpl> UsbBulkcallbackMockTest::mockUsbImpl_ = nullptr;
50 sptr<UsbService> UsbBulkcallbackMockTest::usbSrv_ = nullptr;
51 UsbDev UsbBulkcallbackMockTest::dev_ = {BUS_NUM_OK, DEV_ADDR_OK};
52 UsbInterface UsbBulkcallbackMockTest::interface_ {};
53 
InitAshmemOne(sptr<Ashmem> & asmptr,int32_t asmSize,uint8_t flg)54 int32_t UsbBulkcallbackMockTest::InitAshmemOne(sptr<Ashmem> &asmptr, int32_t asmSize, uint8_t flg)
55 {
56     asmptr = Ashmem::CreateAshmem("ttashmem000", asmSize);
57     if (asmptr == nullptr) {
58         USB_HILOGE(MODULE_USB_SERVICE, "InitAshmemOne CreateAshmem failed");
59         return UEC_SERVICE_NO_MEMORY;
60     }
61 
62     asmptr->MapReadAndWriteAshmem();
63 
64     if (flg == 0) {
65         uint8_t tData[ASHMEM_MAX_SIZE];
66         int32_t offset = 0;
67         int32_t tLen = 0;
68 
69         int32_t retSafe = memset_s(tData, sizeof(tData), 'Y', ASHMEM_MAX_SIZE);
70         if (retSafe != EOK) {
71             USB_HILOGE(MODULE_USB_SERVICE, "InitAshmemOne memset_s failed");
72             return UEC_SERVICE_NO_MEMORY;
73         }
74         while (offset < asmSize) {
75             tLen = (asmSize - offset) < ASHMEM_MAX_SIZE ? (asmSize - offset) : ASHMEM_MAX_SIZE;
76             asmptr->WriteToAshmem(tData, tLen, offset);
77             offset += tLen;
78         }
79     }
80 
81     return 0;
82 }
83 
SetUpTestCase(void)84 void UsbBulkcallbackMockTest::SetUpTestCase(void)
85 {
86     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest SetUpTestCase");
87     UsbCommonTest::SetTestCaseHapApply();
88 
89     usbSrv_ = DelayedSpSingleton<UsbService>::GetInstance();
90     EXPECT_NE(usbSrv_, nullptr);
91     mockUsbImpl_ = DelayedSpSingleton<MockUsbImpl>::GetInstance();
92     EXPECT_NE(mockUsbImpl_, nullptr);
93 
94     usbSrv_->SetUsbd(mockUsbImpl_);
95 
96     sptr<UsbServiceSubscriber> iSubscriber = new UsbServiceSubscriber();
97     EXPECT_NE(iSubscriber, nullptr);
98     mockUsbImpl_->BindUsbdSubscriber(iSubscriber);
99 
100     EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
101     EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
102     USBDeviceInfo info = {ACT_DEVUP, BUS_NUM_OK, DEV_ADDR_OK};
103     auto ret = mockUsbImpl_->SubscriberDeviceEvent(info);
104     EXPECT_EQ(0, ret);
105 
106     ret = mockUsbImpl_->SetPortRole(DEFAULT_PORT_ID, UsbSrvSupport::POWER_ROLE_SOURCE, UsbSrvSupport::DATA_ROLE_HOST);
107     EXPECT_EQ(0, ret);
108     if (ret != 0) {
109         exit(0);
110     }
111 
112     vector<UsbDevice> devList;
113     ret = usbSrv_->GetDevices(devList);
114     EXPECT_EQ(0, ret);
115     EXPECT_FALSE(devList.empty()) << "devList NULL";
116     UsbDevice device = MockUsbImpl::FindDeviceInfo(devList);
117 
118     EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
119     ret = usbSrv_->OpenDevice(dev_.busNum, dev_.devAddr);
120     EXPECT_EQ(0, ret);
121 
122     interface_ = device.GetConfigs().front().GetInterfaces().at(1);
123     uint8_t interfaceId = interface_.GetId();
124     EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
125     ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
126     EXPECT_EQ(0, ret);
127 }
128 
TearDownTestCase(void)129 void UsbBulkcallbackMockTest::TearDownTestCase(void)
130 {
131     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest TearDownTestCase");
132     EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
133     auto ret = usbSrv_->Close(dev_.busNum, dev_.devAddr);
134     EXPECT_EQ(0, ret);
135 
136     USBDeviceInfo info = {ACT_DEVDOWN, BUS_NUM_OK, DEV_ADDR_OK};
137     ret = mockUsbImpl_->SubscriberDeviceEvent(info);
138     EXPECT_EQ(0, ret);
139 
140     mockUsbImpl_->UnbindUsbdSubscriber(nullptr);
141     sptr<IUsbInterface> usbd = IUsbInterface::Get();
142     usbSrv_->SetUsbd(usbd);
143 
144     mockUsbImpl_ = nullptr;
145     usbSrv_ = nullptr;
146     DelayedSpSingleton<UsbService>::DestroyInstance();
147     DelayedSpSingleton<MockUsbImpl>::DestroyInstance();
148 }
149 
SetUp(void)150 void UsbBulkcallbackMockTest::SetUp(void) {}
151 
TearDown(void)152 void UsbBulkcallbackMockTest::TearDown(void) {}
153 
154 /**
155  * @tc.name: RegBulkCallback001
156  * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
157  * sptr<IRemoteObject> &cb)
158  * @tc.desc: Positive test: parameters correctly
159  * @tc.type: FUNC
160  */
161 HWTEST_F(UsbBulkcallbackMockTest, RegBulkCallback001, TestSize.Level1)
162 {
163     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
164     EXPECT_NE(cb, nullptr);
165     USBEndpoint point = interface_.GetEndpoints().front();
166     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
167     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
168     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
169     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::RegBulkCallback001 RegBulkCallback=%{public}d", ret);
170     EXPECT_EQ(0, ret);
171 
172     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
173     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
174     EXPECT_EQ(0, ret);
175 }
176 
177 /**
178  * @tc.name: RegBulkCallback002
179  * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
180  * sptr<IRemoteObject> &cb)
181  * @tc.desc: Positive test: parameters correctly
182  * @tc.type: FUNC
183  */
184 HWTEST_F(UsbBulkcallbackMockTest, RegBulkCallback002, TestSize.Level1)
185 {
186     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
187     EXPECT_NE(cb, nullptr);
188     USBEndpoint point = interface_.GetEndpoints().at(1);
189     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
190     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
191     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
192     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::RegBulkCallback002 RegBulkCallback=%{public}d", ret);
193     EXPECT_EQ(0, ret);
194 
195     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
196     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
197     EXPECT_EQ(0, ret);
198 }
199 
200 /**
201  * @tc.name: RegBulkCallback003
202  * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
203  * sptr<IRemoteObject> &cb)
204  * @tc.desc: Negative test: parameters exception, busNum error
205  * @tc.type: FUNC
206  */
207 HWTEST_F(UsbBulkcallbackMockTest, RegBulkCallback003, TestSize.Level1)
208 {
209     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
210     EXPECT_NE(cb, nullptr);
211     USBEndpoint point = interface_.GetEndpoints().at(1);
212     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
213     dev_.busNum = BUS_NUM_INVALID;
214     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_))
215         .WillRepeatedly(Return(RETVAL_INVALID));
216     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
217     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::RegBulkCallback003 RegBulkCallback=%{public}d", ret);
218     EXPECT_NE(ret, 0);
219 
220     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
221     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
222     EXPECT_NE(ret, 0);
223 
224     dev_.busNum = BUS_NUM_OK;
225 }
226 
227 /**
228  * @tc.name: RegBulkCallback004
229  * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
230  * sptr<IRemoteObject> &cb)
231  * @tc.desc: Negative test: parameters exception, devAddr error
232  * @tc.type: FUNC
233  */
234 HWTEST_F(UsbBulkcallbackMockTest, RegBulkCallback004, TestSize.Level1)
235 {
236     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
237     EXPECT_NE(cb, nullptr);
238     USBEndpoint point = interface_.GetEndpoints().at(1);
239     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
240     dev_.devAddr = DEV_ADDR_INVALID;
241     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_))
242         .WillRepeatedly(Return(RETVAL_INVALID));
243     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
244     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::RegBulkCallback004 RegBulkCallback=%{public}d", ret);
245     EXPECT_NE(ret, 0);
246 
247     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
248     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
249     EXPECT_NE(ret, 0);
250 
251     dev_.devAddr = DEV_ADDR_OK;
252 }
253 
254 /**
255  * @tc.name: BulkRead001
256  * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
257  * @tc.desc: Positive test: parameters correctly
258  * @tc.type: FUNC
259  */
260 HWTEST_F(UsbBulkcallbackMockTest, BulkRead001, TestSize.Level1)
261 {
262     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
263     EXPECT_NE(cb, nullptr);
264     USBEndpoint point = interface_.GetEndpoints().front();
265     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
266     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
267     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
268     EXPECT_EQ(0, ret);
269 
270     sptr<Ashmem> ashmem;
271     uint8_t flg = 0;
272     int32_t asmSize = MEM_DATA;
273     ret = UsbBulkcallbackMockTest::UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
274     EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
275     ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
276     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkRead001 BulkRead=%{public}d", ret);
277     EXPECT_EQ(0, ret);
278 
279     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
280     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
281     EXPECT_EQ(0, ret);
282 
283     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
284     ret = usbSrv_->BulkCancel(dev_, pipe);
285     EXPECT_EQ(0, ret);
286 }
287 
288 /**
289  * @tc.name: BulkRead002
290  * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
291  * @tc.desc: Negative test: parameters exception,point error
292  * @tc.type: FUNC
293  */
294 HWTEST_F(UsbBulkcallbackMockTest, BulkRead002, TestSize.Level1)
295 {
296     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
297     EXPECT_NE(cb, nullptr);
298     USBEndpoint point = interface_.GetEndpoints().at(1);
299     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
300     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
301     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
302     EXPECT_EQ(0, ret);
303 
304     sptr<Ashmem> ashmem;
305     uint8_t flg = 0;
306     int32_t asmSize = MEM_DATA;
307     ret = UsbBulkcallbackMockTest::UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
308     EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
309     ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
310     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkRead002 BulkRead=%{public}d", ret);
311     EXPECT_NE(ret, 0);
312 
313     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
314     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
315     EXPECT_EQ(0, ret);
316 
317     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
318     ret = usbSrv_->BulkCancel(dev_, pipe);
319     EXPECT_EQ(0, ret);
320 }
321 
322 /**
323  * @tc.name: BulkRead003
324  * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
325  * @tc.desc: Negative test: parameters exception,busNum error
326  * @tc.type: FUNC
327  */
328 HWTEST_F(UsbBulkcallbackMockTest, BulkRead003, TestSize.Level1)
329 {
330     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
331     EXPECT_NE(cb, nullptr);
332     USBEndpoint point = interface_.GetEndpoints().front();
333     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
334     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
335     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
336     EXPECT_EQ(0, ret);
337 
338     sptr<Ashmem> ashmem;
339     uint8_t flg = 0;
340     int32_t asmSize = MEM_DATA;
341     ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
342     dev_.busNum = BUS_NUM_INVALID;
343     EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
344     ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
345     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkRead003 BulkRead=%{public}d", ret);
346     EXPECT_NE(ret, 0);
347 
348     dev_.busNum = BUS_NUM_OK;
349     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
350     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
351     EXPECT_EQ(0, ret);
352 
353     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
354     ret = usbSrv_->BulkCancel(dev_, pipe);
355     EXPECT_EQ(0, ret);
356 }
357 
358 /**
359  * @tc.name: BulkRead004
360  * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
361  * @tc.desc: Negative test: parameters exception,devAddr error
362  * @tc.type: FUNC
363  */
364 HWTEST_F(UsbBulkcallbackMockTest, BulkRead004, TestSize.Level1)
365 {
366     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
367     EXPECT_NE(cb, nullptr);
368     USBEndpoint point = interface_.GetEndpoints().front();
369     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
370     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
371     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
372     EXPECT_EQ(0, ret);
373 
374     sptr<Ashmem> ashmem;
375     uint8_t flg = 0;
376     int32_t asmSize = MEM_DATA;
377     ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
378     dev_.devAddr = DEV_ADDR_INVALID;
379     EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
380     ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
381     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkRead004 BulkRead=%{public}d", ret);
382     EXPECT_NE(ret, 0);
383 
384     dev_.devAddr = DEV_ADDR_OK;
385     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
386     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
387     EXPECT_EQ(0, ret);
388 
389     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
390     ret = usbSrv_->BulkCancel(dev_, pipe);
391     EXPECT_EQ(0, ret);
392 }
393 
394 /**
395  * @tc.name: BulkWrite001
396  * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
397  * @tc.desc: Positive test: parameters correctly
398  * @tc.type: FUNC
399  */
400 HWTEST_F(UsbBulkcallbackMockTest, BulkWrite001, TestSize.Level1)
401 {
402     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
403     EXPECT_NE(cb, nullptr);
404     USBEndpoint point = interface_.GetEndpoints().at(1);
405     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
406     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
407     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
408     EXPECT_EQ(0, ret);
409 
410     sptr<Ashmem> ashmem;
411     uint8_t flg = 0;
412     int32_t asmSize = MEM_DATA;
413     ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
414     EXPECT_CALL(*mockUsbImpl_, BulkWrite(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
415     ret = usbSrv_->BulkWrite(dev_, pipe, ashmem);
416     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkWrite001 BulkWrite=%{public}d", ret);
417     EXPECT_EQ(0, ret);
418 
419     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
420     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
421     EXPECT_EQ(0, ret);
422 
423     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
424     ret = usbSrv_->BulkCancel(dev_, pipe);
425     EXPECT_EQ(0, ret);
426 }
427 
428 /**
429  * @tc.name: BulkWrite002
430  * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
431  * @tc.desc: Negative test: parameters exception,point error
432  * @tc.type: FUNC
433  */
434 HWTEST_F(UsbBulkcallbackMockTest, BulkWrite002, TestSize.Level1)
435 {
436     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
437     EXPECT_NE(cb, nullptr);
438     USBEndpoint point = interface_.GetEndpoints().front();
439     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
440     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
441     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
442     EXPECT_EQ(0, ret);
443 
444     sptr<Ashmem> ashmem;
445     uint8_t flg = 0;
446     int32_t asmSize = MEM_DATA;
447     ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
448     EXPECT_CALL(*mockUsbImpl_, BulkWrite(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
449     ret = usbSrv_->BulkWrite(dev_, pipe, ashmem);
450     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkWrite002 BulkWrite=%{public}d", ret);
451     EXPECT_NE(ret, 0);
452 
453     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
454     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
455     EXPECT_EQ(0, ret);
456 
457     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
458     ret = usbSrv_->BulkCancel(dev_, pipe);
459     EXPECT_EQ(0, ret);
460 }
461 
462 /**
463  * @tc.name: BulkWrite003
464  * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
465  * @tc.desc: Negative test: parameters exception,busNum error
466  * @tc.type: FUNC
467  */
468 HWTEST_F(UsbBulkcallbackMockTest, BulkWrite003, TestSize.Level1)
469 {
470     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
471     EXPECT_NE(cb, nullptr);
472     USBEndpoint point = interface_.GetEndpoints().at(1);
473     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
474     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
475     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
476     EXPECT_EQ(0, ret);
477 
478     sptr<Ashmem> ashmem;
479     uint8_t flg = 0;
480     int32_t asmSize = MEM_DATA;
481     ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
482     dev_.busNum = BUS_NUM_INVALID;
483     EXPECT_CALL(*mockUsbImpl_, BulkWrite(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
484     ret = usbSrv_->BulkWrite(dev_, pipe, ashmem);
485     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkWrite003 BulkWrite=%{public}d", ret);
486     EXPECT_NE(ret, 0);
487 
488     dev_.busNum = BUS_NUM_OK;
489     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
490     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
491     EXPECT_EQ(0, ret);
492 
493     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
494     ret = usbSrv_->BulkCancel(dev_, pipe);
495     EXPECT_EQ(0, ret);
496 }
497 
498 /**
499  * @tc.name: BulkWrite004
500  * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
501  * @tc.desc: Negative test: parameters exception,devAddr error
502  * @tc.type: FUNC
503  */
504 HWTEST_F(UsbBulkcallbackMockTest, BulkWrite004, TestSize.Level1)
505 {
506     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
507     EXPECT_NE(cb, nullptr);
508     USBEndpoint point = interface_.GetEndpoints().at(1);
509     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
510     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
511     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
512     EXPECT_EQ(0, ret);
513 
514     sptr<Ashmem> ashmem;
515     uint8_t flg = 0;
516     int32_t asmSize = MEM_DATA;
517     ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
518     dev_.devAddr = DEV_ADDR_INVALID;
519     EXPECT_CALL(*mockUsbImpl_, BulkWrite(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
520     ret = usbSrv_->BulkWrite(dev_, pipe, ashmem);
521     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkWrite004 BulkWrite=%{public}d", ret);
522     EXPECT_NE(ret, 0);
523 
524     dev_.devAddr = DEV_ADDR_OK;
525     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
526     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
527     EXPECT_EQ(0, ret);
528 
529     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
530     ret = usbSrv_->BulkCancel(dev_, pipe);
531     EXPECT_EQ(0, ret);
532 }
533 
534 /**
535  * @tc.name: BulkCancel001
536  * @tc.desc: Test functions to int32_t BulkCancel(const UsbDev &devInfo, const UsbPipe &pipe)
537  * @tc.desc: Positive test: parameters correctly
538  * @tc.type: FUNC
539  */
540 HWTEST_F(UsbBulkcallbackMockTest, BulkCancel001, TestSize.Level1)
541 {
542     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
543     EXPECT_NE(cb, nullptr);
544     USBEndpoint point = interface_.GetEndpoints().front();
545     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
546     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
547     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
548     EXPECT_EQ(0, ret);
549 
550     sptr<Ashmem> ashmem;
551     uint8_t flg = 0;
552     int32_t asmSize = MEM_DATA;
553     ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
554     EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
555     ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
556     EXPECT_EQ(0, ret);
557 
558     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
559     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
560     EXPECT_EQ(0, ret);
561 
562     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
563     ret = usbSrv_->BulkCancel(dev_, pipe);
564     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkCancel001 BulkCancel=%{public}d", ret);
565     EXPECT_EQ(0, ret);
566 
567     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
568     ret = usbSrv_->BulkCancel(dev_, pipe);
569     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkCancel001 BulkCancel=%{public}d", ret);
570     EXPECT_EQ(0, ret);
571 }
572 
573 /**
574  * @tc.name: BulkCancel002
575  * @tc.desc: Test functions to int32_t BulkCancel(const UsbDev &devInfo, const UsbPipe &pipe)
576  * @tc.desc: Negative test: parameters exception,busNum error
577  * @tc.type: FUNC
578  */
579 HWTEST_F(UsbBulkcallbackMockTest, BulkCancel002, TestSize.Level1)
580 {
581     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
582     EXPECT_NE(cb, nullptr);
583     USBEndpoint point = interface_.GetEndpoints().front();
584     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
585     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
586     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
587     EXPECT_EQ(0, ret);
588 
589     sptr<Ashmem> ashmem;
590     uint8_t flg = 0;
591     int32_t asmSize = MEM_DATA;
592     ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
593     EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
594     ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
595     EXPECT_EQ(0, ret);
596 
597     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
598     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
599     EXPECT_EQ(0, ret);
600 
601     dev_.busNum = BUS_NUM_INVALID;
602     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
603     ret = usbSrv_->BulkCancel(dev_, pipe);
604     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkCancel002 BulkCancel=%{public}d", ret);
605     EXPECT_NE(ret, 0);
606 
607     dev_.busNum = BUS_NUM_OK;
608     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
609     ret = usbSrv_->BulkCancel(dev_, pipe);
610     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkCancel002 BulkCancel=%{public}d", ret);
611     EXPECT_EQ(0, ret);
612 }
613 
614 /**
615  * @tc.name: BulkCancel003
616  * @tc.desc: Test functions to int32_t BulkCancel(const UsbDev &devInfo, const UsbPipe &pipe)
617  * @tc.desc: Negative test: parameters exception,devAddr error
618  * @tc.type: FUNC
619  */
620 HWTEST_F(UsbBulkcallbackMockTest, BulkCancel003, TestSize.Level1)
621 {
622     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
623     EXPECT_NE(cb, nullptr);
624     USBEndpoint point = interface_.GetEndpoints().front();
625     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
626     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
627     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
628     EXPECT_EQ(0, ret);
629 
630     sptr<Ashmem> ashmem;
631     uint8_t flg = 0;
632     int32_t asmSize = MEM_DATA;
633     ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
634     EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
635     ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
636     EXPECT_EQ(0, ret);
637 
638     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
639     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
640     EXPECT_EQ(0, ret);
641 
642     dev_.devAddr = DEV_ADDR_INVALID;
643     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
644     ret = usbSrv_->BulkCancel(dev_, pipe);
645     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkCancel002 BulkCancel=%{public}d", ret);
646     EXPECT_NE(ret, 0);
647 
648     dev_.devAddr = DEV_ADDR_OK;
649     EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
650     ret = usbSrv_->BulkCancel(dev_, pipe);
651     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkCancel003 BulkCancel=%{public}d", ret);
652     EXPECT_EQ(0, ret);
653 }
654 
655 /**
656  * @tc.name: UnRegBulkCallback001
657  * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe)
658  * @tc.desc: Positive test: parameters correctly
659  * @tc.type: FUNC
660  */
661 HWTEST_F(UsbBulkcallbackMockTest, UnRegBulkCallback001, TestSize.Level1)
662 {
663     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
664     EXPECT_NE(cb, nullptr);
665     USBEndpoint point = interface_.GetEndpoints().front();
666     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
667     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
668     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
669     EXPECT_EQ(0, ret);
670 
671     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
672     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
673     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::UnRegBulkCallback001 UnRegBulkCallback=%{public}d", ret);
674     EXPECT_EQ(0, ret);
675 }
676 
677 /**
678  * @tc.name: UnRegBulkCallback002
679  * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe)
680  * @tc.desc: Negative test: parameters exception,busNum error
681  * @tc.type: FUNC
682  */
683 HWTEST_F(UsbBulkcallbackMockTest, UnRegBulkCallback002, TestSize.Level1)
684 {
685     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
686     EXPECT_NE(cb, nullptr);
687     USBEndpoint point = interface_.GetEndpoints().front();
688     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
689     dev_.busNum = BUS_NUM_INVALID;
690     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_))
691         .WillRepeatedly(Return(RETVAL_INVALID));
692     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
693     EXPECT_NE(ret, 0);
694 
695     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
696     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
697     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::UnRegBulkCallback002 UnRegBulkCallback=%{public}d", ret);
698     EXPECT_NE(ret, 0);
699 
700     dev_.busNum = BUS_NUM_OK;
701 }
702 
703 /**
704  * @tc.name: UnRegBulkCallback003
705  * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe)
706  * @tc.desc: Negative test: parameters exception,devAddr error
707  * @tc.type: FUNC
708  */
709 HWTEST_F(UsbBulkcallbackMockTest, UnRegBulkCallback003, TestSize.Level1)
710 {
711     sptr<UsbCallbackTest> cb = new UsbCallbackTest();
712     EXPECT_NE(cb, nullptr);
713     USBEndpoint point = interface_.GetEndpoints().front();
714     UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
715     dev_.devAddr = DEV_ADDR_INVALID;
716     EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_))
717         .WillRepeatedly(Return(RETVAL_INVALID));
718     auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
719     EXPECT_NE(ret, 0);
720 
721     EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
722     ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
723     USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::UnRegBulkCallback003 UnRegBulkCallback=%{public}d", ret);
724     EXPECT_NE(ret, 0);
725 
726     dev_.devAddr = DEV_ADDR_OK;
727 }
728 } // namespace USB
729 } // namespace OHOS
730