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