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
23using namespace benchmark::internal;
24using namespace OHOS;
25using namespace OHOS::USB;
26using namespace std;
27using namespace OHOS::HDI::Usb::V1_0;
28using namespace OHOS::HDI::Usb::V1_1;
29
30const int SLEEP_TIME = 3;
31const uint8_t INDEX_0 = 0;
32const uint8_t INDEX_1 = 1;
33const uint8_t CONFIG_ID_0 = 0;
34const uint32_t MAX_BUFFER_LENGTH = 255;
35const int TAG_NUM_10 = 10;
36const uint8_t INTERFACEID_OK = 1;
37// data interface have 2 point : 1->bulk_out 2->bulk_in
38const uint8_t POINTID_DIR_IN = USB_ENDPOINT_DIR_IN | 2;
39const uint32_t TIME_WAIT = 10000;
40constexpr int32_t ITERATION_FREQUENCY = 100;
41constexpr int32_t REPETITION_FREQUENCY = 3;
42UsbDev HdfUsbdBenchmarkRequestTest::dev_ = { 0, 0 };
43
44namespace {
45sptr<OHOS::HDI::Usb::V1_1::IUsbInterface> g_usbInterface = nullptr;
46
47int32_t SwitchErrCode(int32_t ret)
48{
49    return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
50}
51
52void 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
62void HdfUsbdBenchmarkRequestTest::TearDown(const ::benchmark::State& state){}
63
64void 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
73void 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 */
89BENCHMARK_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
106BENCHMARK_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 */
118BENCHMARK_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
135BENCHMARK_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 */
147BENCHMARK_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
164BENCHMARK_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 */
176BENCHMARK_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
195BENCHMARK_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 */
207BENCHMARK_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
224BENCHMARK_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 */
236BENCHMARK_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
254BENCHMARK_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 */
266BENCHMARK_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
284BENCHMARK_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 */
296BENCHMARK_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
313BENCHMARK_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 */
325BENCHMARK_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
342BENCHMARK_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 */
355BENCHMARK_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
380BENCHMARK_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 */
393BENCHMARK_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
420BENCHMARK_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 */
432BENCHMARK_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
456BENCHMARK_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 */
468BENCHMARK_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
486BENCHMARK_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 */
498BENCHMARK_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
522BENCHMARK_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 */
534BENCHMARK_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
553BENCHMARK_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 */
565BENCHMARK_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
580BENCHMARK_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 */
595BENCHMARK_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
612BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, GetDeviceFileDescriptorBenchmarkTest)
613    ->Iterations(ITERATION_FREQUENCY)
614    ->Repetitions(REPETITION_FREQUENCY)
615    ->ReportAggregatesOnly();
616
617} // namespace
618
619BENCHMARK_MAIN();
620