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