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 #include <benchmark/benchmark.h>
16 #include <gtest/gtest.h>
17 #include <iostream>
18 #include <vector>
19 #include "hdf_log.h"
20 #include "usbd_port.h"
21 #include "UsbSubscriberTest.h"
22 #include "v1_0/iusb_interface.h"
23 #include "v1_0/iusbd_bulk_callback.h"
24 #include "v1_0/usb_types.h"
25 
26 using namespace benchmark::internal;
27 using namespace OHOS;
28 using namespace OHOS::USB;
29 using namespace std;
30 using namespace OHOS::HDI::Usb::V1_0;
31 
32 namespace {
33 sptr<IUsbInterface> g_usbInterface = nullptr;
34 struct UsbDev g_dev = {0, 0};
35 
36 const int SLEEP_TIME = 3;
37 const uint8_t INDEX_0 = 0;
38 const uint8_t INDEX_1 = 1;
39 const int TAG_NUM_10 = 10;
40 const uint8_t CONFIG_ID_0 = 0;
41 const uint8_t INTERFACEID_OK = 1;
42 const uint32_t MAX_BUFFER_LENGTH = 255;
43 constexpr int32_t ITERATION_FREQUENCY = 100;
44 constexpr int32_t REPETITION_FREQUENCY = 3;
45 const uint32_t TIME_WAIT = 10000;
46 // data interface have 2 point : 1->bulk_out 2->bulk_in
47 const uint8_t POINTID_DIR_IN = USB_ENDPOINT_DIR_IN | 2;
48 
49 class HdfUsbdBenchmarkRequestTest : public benchmark::Fixture {
50 public:
51     void InitPara(const sptr<UsbSubscriberTest> &subscriber);
52     void ReleasePara(const sptr<UsbSubscriberTest> &subscriber);
53     void SetUp(const ::benchmark::State &state);
54     void TearDown(const ::benchmark::State &state);
55 };
56 
57 
58 class UsbdBulkCallbackTest : public OHOS::HDI::Usb::V1_0::IUsbdBulkCallback {
59 public:
60     UsbdBulkCallbackTest() = default;
61     ~UsbdBulkCallbackTest() = default;
OnBulkWriteCallback(int32_t status,int32_t actLength)62     int32_t OnBulkWriteCallback(int32_t status, int32_t actLength) override
63     {
64         return 0;
65     };
OnBulkReadCallback(int32_t status,int32_t actLength)66     int32_t OnBulkReadCallback(int32_t status, int32_t actLength) override
67     {
68         return 0;
69     };
70 };
71 
SwitchErrCode(int32_t ret)72 int32_t SwitchErrCode(int32_t ret)
73 {
74     return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
75 }
76 
SetUp(const::benchmark::State & state)77 void HdfUsbdBenchmarkRequestTest::SetUp(const ::benchmark::State& state)
78 {
79     g_usbInterface = IUsbInterface::Get();
80     ASSERT_TRUE(g_usbInterface != nullptr);
81     auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, POWER_ROLE_SOURCE, DATA_ROLE_HOST);
82     sleep(SLEEP_TIME);
83     ret = SwitchErrCode(ret);
84     EXPECT_EQ(0, ret);
85 }
86 
TearDown(const::benchmark::State & state)87 void HdfUsbdBenchmarkRequestTest::TearDown(const ::benchmark::State& state) {}
88 
InitPara(const sptr<UsbSubscriberTest> & subscriber)89 void HdfUsbdBenchmarkRequestTest::InitPara(const sptr<UsbSubscriberTest> &subscriber)
90 {
91     if (g_usbInterface->BindUsbdSubscriber(subscriber) != HDF_SUCCESS) {
92         HDF_LOGW("HdfUsbdBenchmarkRequestTest::bind usbdsubscriber fail");
93     }
94     g_dev = {subscriber->busNum_, subscriber->devAddr_};
95     auto ret = g_usbInterface->OpenDevice(g_dev);
96     EXPECT_EQ(0, ret);
97 }
98 
ReleasePara(const sptr<UsbSubscriberTest> & subscriber)99 void HdfUsbdBenchmarkRequestTest::ReleasePara(const sptr<UsbSubscriberTest> &subscriber)
100 {
101     ASSERT_TRUE(g_usbInterface != nullptr);
102     auto ret = g_usbInterface->UnbindUsbdSubscriber(subscriber);
103     EXPECT_EQ(0, ret);
104     ret = g_usbInterface->CloseDevice(g_dev);
105     EXPECT_EQ(0, ret);
106 }
107 /**
108  * @tc.name: SetConfig
109  * @tc.desc: Test functions to SetConfig benchmark test
110  * @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
111  * @tc.desc: Positive test: parameters correctly
112  * @tc.type: FUNC
113  */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SetConfig)114 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SetConfig)(benchmark::State& state)
115 {
116     ASSERT_TRUE(g_usbInterface != nullptr);
117     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
118     ASSERT_TRUE(subscriber != nullptr);
119     uint8_t configIndex = INDEX_1;
120     InitPara(subscriber);
121     auto ret = 0;
122     for (auto _ : state) {
123         ret = g_usbInterface->SetConfig(g_dev, configIndex);
124     }
125     ASSERT_EQ(0, ret);
126     ReleasePara(subscriber);
127 }
128 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SetConfig)->
129     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
130 
131 /**
132  * @tc.name: GetConfig
133  * @tc.desc: Test functions to GetConfig benchmark test
134  * @tc.desc: int32_t GetConfig(const UsbDev &dev, uint8_t &configIndex);
135  * @tc.desc: Positive test: parameters correctly
136  * @tc.type: FUNC
137  */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,GetConfig)138 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, GetConfig)(benchmark::State& state)
139 {
140     ASSERT_TRUE(g_usbInterface != nullptr);
141     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
142     ASSERT_TRUE(subscriber != nullptr);
143     uint8_t configIndex = INDEX_1;
144     InitPara(subscriber);
145     auto ret = 0;
146     for (auto _ : state) {
147         ret = g_usbInterface->GetConfig(g_dev, configIndex);
148     }
149     EXPECT_EQ(0, ret);
150     ReleasePara(subscriber);
151 }
152 
153 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, GetConfig)->
154     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
155 
156 /**
157  * @tc.name: ClaimInterface
158  * @tc.desc: Test functions to ClaimInterface benchmark test
159  * @tc.desc: int32_t  ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
160  * @tc.desc: Positive test: parameters correctly
161  * @tc.type: FUNC
162  */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,ClaimInterface)163 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, ClaimInterface)(benchmark::State& state)
164 {
165     ASSERT_TRUE(g_usbInterface != nullptr);
166     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
167     ASSERT_TRUE(subscriber != nullptr);
168     uint8_t interfaceId = INTERFACEID_OK;
169     InitPara(subscriber);
170     auto ret = 0;
171     for (auto _ : state) {
172         ret = g_usbInterface->ClaimInterface(g_dev, interfaceId, 1);
173     }
174     EXPECT_EQ(0, ret);
175     ReleasePara(subscriber);
176 }
177 
178 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, ClaimInterface)->
179     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
180 
181 /**
182  * @tc.name: SetInterface
183  * @tc.desc: Test functions to SetInterface benchmark test
184  * @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
185  * @tc.desc: Positive test: parameters correctly
186  * @tc.type: FUNC
187  */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SetInterface)188 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SetInterface)(benchmark::State& state)
189 {
190     ASSERT_TRUE(g_usbInterface != nullptr);
191     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
192     ASSERT_TRUE(subscriber != nullptr);
193     InitPara(subscriber);
194     uint8_t interfaceId = INTERFACEID_OK;
195     uint8_t altIndex = INDEX_0;
196     auto ret = g_usbInterface->ClaimInterface(g_dev, interfaceId, 1);
197     EXPECT_EQ(0, ret);
198     for (auto _ : state) {
199         ret = g_usbInterface->SetInterface(g_dev, interfaceId, altIndex);
200     }
201     EXPECT_EQ(0, ret);
202     ReleasePara(subscriber);
203 }
204 
205 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SetInterface)->
206     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
207 
208 /**
209  * @tc.name: GetDeviceDescriptor
210  * @tc.desc: Test functions to GetDeviceDescriptor benchmark test
211  * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
212  * @tc.desc: Positive test: parameters correctly
213  * @tc.type: FUNC
214  */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,GetDeviceDescriptor)215 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, GetDeviceDescriptor)(benchmark::State& state)
216 {
217     ASSERT_TRUE(g_usbInterface != nullptr);
218     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
219     ASSERT_TRUE(subscriber != nullptr);
220     InitPara(subscriber);
221     std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
222     auto ret = 0;
223     for (auto _ : state) {
224         ret = g_usbInterface->GetDeviceDescriptor(g_dev, devData);
225     }
226     EXPECT_EQ(0, ret);
227     ReleasePara(subscriber);
228 }
229 
230 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, GetDeviceDescriptor)->
231     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
232 
233 /**
234  * @tc.name: GetStringDescriptor
235  * @tc.desc: Test functions to GetStringDescriptor benchmark test
236  * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
237  * @tc.desc: Positive test: parameters correctly
238  * @tc.type: FUNC
239  */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,GetStringDescriptor)240 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, GetStringDescriptor)(benchmark::State& state)
241 {
242     ASSERT_TRUE(g_usbInterface != nullptr);
243     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
244     ASSERT_TRUE(subscriber != nullptr);
245     InitPara(subscriber);
246     uint8_t stringId = 0;
247     std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
248     auto ret = 0;
249     for (auto _ : state) {
250         ret = g_usbInterface->GetStringDescriptor(g_dev, stringId, devData);
251     }
252     EXPECT_EQ(0, ret);
253     ReleasePara(subscriber);
254 }
255 
256 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, GetStringDescriptor)->
257     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
258 
259 /**
260  * @tc.name: GetConfigDescriptor
261  * @tc.desc: Test functions to GetConfigDescriptor benchmark test
262  * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
263  * @tc.desc: Positive test: parameters correctly
264  * @tc.type: FUNC
265  */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,GetConfigDescriptor)266 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, GetConfigDescriptor)(benchmark::State& state)
267 {
268     ASSERT_TRUE(g_usbInterface != nullptr);
269     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
270     ASSERT_TRUE(subscriber != nullptr);
271     InitPara(subscriber);
272     uint8_t configId = CONFIG_ID_0;
273     std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
274     auto ret = 0;
275     for (auto _ : state) {
276         ret = g_usbInterface->GetConfigDescriptor(g_dev, configId, devData);
277     }
278     EXPECT_EQ(0, ret);
279     ReleasePara(subscriber);
280 }
281 
282 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, GetConfigDescriptor)->
283     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
284 
285 /**
286  * @tc.name: GetRawDescriptor
287  * @tc.desc: Test functions to GetRawDescriptor benchmark test
288  * @tc.desc: int32_t GetRawDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
289  * @tc.desc: Positive test: parameters correctly
290  * @tc.type: FUNC
291  */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,GetRawDescriptor)292 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, GetRawDescriptor)(benchmark::State& state)
293 {
294     ASSERT_TRUE(g_usbInterface != nullptr);
295     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
296     ASSERT_TRUE(subscriber != nullptr);
297     InitPara(subscriber);
298     std::vector<uint8_t> rawData;
299     auto ret = 0;
300     for (auto _ : state) {
301         ret = g_usbInterface->GetRawDescriptor(g_dev, rawData);
302     }
303     EXPECT_EQ(0, ret);
304     ReleasePara(subscriber);
305 }
306 
307 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, GetRawDescriptor)->
308     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
309 
310 /**
311  * @tc.name: GetFileDescriptor
312  * @tc.desc: Test functions to GetFileDescriptor benchmark test
313  * @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
314  * @tc.desc: Positive test: parameters correctly
315  * @tc.type: FUNC
316  */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,GetFileDescriptor)317 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, GetFileDescriptor)(benchmark::State& state)
318 {
319     ASSERT_TRUE(g_usbInterface != nullptr);
320     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
321     ASSERT_TRUE(subscriber != nullptr);
322     InitPara(subscriber);
323     int32_t fd = 0;
324     auto ret = 0;
325     for (auto _ : state) {
326         ret = g_usbInterface->GetFileDescriptor(g_dev, fd);
327     }
328     EXPECT_EQ(0, ret);
329     ReleasePara(subscriber);
330 }
331 
332 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, GetFileDescriptor)->
333     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
334 
335 /**
336  * @tc.name: RequestQueue
337  * @tc.desc: Test functions to RequestQueue benchmark test
338  * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData,
339         std::vector<uint8_t> &buffer);
340  * @tc.desc: Positive test: parameters correctly
341  * @tc.type: FUNC
342  */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,RequestQueue)343 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, RequestQueue)(benchmark::State& state)
344 {
345     ASSERT_TRUE(g_usbInterface != nullptr);
346     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
347     ASSERT_TRUE(subscriber != nullptr);
348     InitPara(subscriber);
349     uint8_t interfaceId = INTERFACEID_OK;
350     uint8_t pointId = POINTID_DIR_IN;
351     auto ret = g_usbInterface->ClaimInterface(g_dev, interfaceId, 1);
352     EXPECT_EQ(0, ret);
353     OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
354     std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
355     std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
356     for (auto _ : state) {
357         ret = g_usbInterface->RequestQueue(g_dev, pipe, clientData, bufferData);
358     }
359     ReleasePara(subscriber);
360 }
361 
362 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, RequestQueue)->
363     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
364 
365 /**
366  * @tc.name: RequestWait
367  * @tc.desc: Test functions to RequestWait benchmark test
368  * @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer,
369  * int32_t timeout);
370  * @tc.desc: Positive test: parameters correctly
371  * @tc.type: FUNC
372  */
373 
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,RequestWait)374 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, RequestWait)(benchmark::State& state)
375 {
376     ASSERT_TRUE(g_usbInterface != nullptr);
377     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
378     ASSERT_TRUE(subscriber != nullptr);
379     InitPara(subscriber);
380     uint8_t pointId = POINTID_DIR_IN;
381     uint8_t interfaceId = INTERFACEID_OK;
382     auto ret = g_usbInterface->ClaimInterface(g_dev, interfaceId, 1);
383     EXPECT_EQ(0, ret);
384     OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
385     std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
386     std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
387     ret = g_usbInterface->RequestQueue(g_dev, pipe, clientData, bufferData);
388     std::vector<uint8_t> waitData(TAG_NUM_10);
389     for (auto _ : state) {
390         ret = g_usbInterface->RequestWait(g_dev, waitData, bufferData, TIME_WAIT);
391     }
392     ReleasePara(subscriber);
393 }
394 
395 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, RequestWait)->
396     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
397 
398 /**
399  * @tc.name: RequestCancel
400  * @tc.desc: Test functions to RequestCancel benchmark test
401  * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
402  * @tc.desc: Positive test: parameters correctly
403  * @tc.type: FUNC
404  */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,RequestCancel)405 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, RequestCancel)(benchmark::State& state)
406 {
407     ASSERT_TRUE(g_usbInterface != nullptr);
408     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
409     ASSERT_TRUE(subscriber != nullptr);
410     InitPara(subscriber);
411     uint8_t pointId = POINTID_DIR_IN;
412     uint8_t interfaceId = INTERFACEID_OK;
413     auto ret = g_usbInterface->ClaimInterface(g_dev, interfaceId, 1);
414     EXPECT_EQ(0, ret);
415     OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
416     std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
417     std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '1'};
418     ret = g_usbInterface->RequestQueue(g_dev, pipe, clientData, bufferData);
419     EXPECT_EQ(0, ret);
420     for (auto _ : state) {
421         ret = g_usbInterface->RequestCancel(g_dev, pipe);
422     }
423     EXPECT_EQ(0, ret);
424     ReleasePara(subscriber);
425 }
426 
427 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, RequestCancel)->
428     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
429 
430 /**
431  * @tc.name: ReleaseInterface
432  * @tc.desc: Test functions to ReleaseInterface benchmark test
433  * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
434  * @tc.desc: Positive test: parameters correctly
435  * @tc.type: FUNC
436  */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,ReleaseInterface)437 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, ReleaseInterface)(benchmark::State& state)
438 {
439     ASSERT_TRUE(g_usbInterface != nullptr);
440     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
441     ASSERT_TRUE(subscriber != nullptr);
442     InitPara(subscriber);
443     uint8_t interfaceId = INTERFACEID_OK;
444     auto ret = 0;
445     for (auto _ : state) {
446         ret = g_usbInterface->ReleaseInterface(g_dev, interfaceId);
447     }
448     EXPECT_EQ(0, ret);
449     ReleasePara(subscriber);
450 }
451 
452 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, ReleaseInterface)->
453     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
454 
455 /**
456  * @tc.name: BulkCancel
457  * @tc.desc: Test functions to BulkCancel benchmark test
458  * @tc.desc: int32_t BulkCancel(const UsbDev &dev, const UsbPipe &pipe);
459  * @tc.desc: Positive test: parameters correctly
460  * @tc.type: FUNC
461  */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,BulkCancel)462 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, BulkCancel)(benchmark::State& state)
463 {
464     ASSERT_TRUE(g_usbInterface != nullptr);
465     sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
466     ASSERT_TRUE(subscriber != nullptr);
467     InitPara(subscriber);
468     uint8_t interfaceId = INTERFACEID_OK;
469     uint8_t pointId = POINTID_DIR_IN;
470     OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
471     sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
472     auto ret = g_usbInterface->RegBulkCallback(g_dev, pipe, usbdBulkCallback);
473     EXPECT_EQ(ret, 0);
474     for (auto _ : state) {
475         ret = g_usbInterface->BulkCancel(g_dev, pipe);
476     }
477     EXPECT_EQ(0, ret);
478     ret = g_usbInterface->UnRegBulkCallback(g_dev, pipe);
479     EXPECT_EQ(ret, 0);
480     ReleasePara(subscriber);
481 }
482 
483 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, BulkCancel)->
484     Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
485 } // namespace
486 
487 BENCHMARK_MAIN();
488