1 /*
2 * Copyright (c) 2022-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 <iostream>
16 #include <string>
17 #include <vector>
18
19 #include "HdfUsbdBenchmarkRequestTest.h"
20 #include "hdf_log.h"
21 #include "v1_0/usb_types.h"
22 #include "v1_0/iusb_interface.h"
23
24 using namespace benchmark::internal;
25 using namespace OHOS;
26 using namespace OHOS::USB;
27 using namespace std;
28 using namespace OHOS::HDI::Usb::V1_0;
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<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 = 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 = 0;
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 = 0;
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 = 0;
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 = 0;
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 = 0;
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 = 0;
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 = 0;
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 = 0;
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 for (auto _ : st) {
371 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
372 }
373 ASSERT_EQ(0, ret);
374 ReleasePara(subscriber);
375 }
376
377 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HostManager_HDI_Performance_0700)
378 ->Iterations(ITERATION_FREQUENCY)
379 ->Repetitions(REPETITION_FREQUENCY)
380 ->ReportAggregatesOnly();
381
382 /**
383 * @tc.name: SUB_USB_HostManager_HDI_Performance_0800
384 * @tc.desc: Test functions to RequestWait benchmark test
385 * @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer,
386 * int32_t timeout);
387 * @tc.desc: Positive test: parameters correctly
388 * @tc.type: FUNC
389 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HostManager_HDI_Performance_0800)390 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HostManager_HDI_Performance_0800)
391 (benchmark::State& st)
392 {
393 ASSERT_TRUE(g_usbInterface != nullptr);
394 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
395 ASSERT_TRUE(subscriber != nullptr);
396 InitPara(subscriber);
397 struct UsbDev dev = dev_;
398 uint8_t pointId = POINTID_DIR_IN;
399 uint8_t interfaceId = INTERFACEID_OK;
400 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
401 ASSERT_EQ(0, ret);
402 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
403 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
404 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
405 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
406 std::vector<uint8_t> waitData(TAG_NUM_10);
407 for (auto _ : st) {
408 ret = g_usbInterface->RequestWait(dev, waitData, bufferData, TIME_WAIT);
409 }
410 ASSERT_EQ(0, ret);
411 ReleasePara(subscriber);
412 }
413
414 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HostManager_HDI_Performance_0800)
415 ->Iterations(ITERATION_FREQUENCY)
416 ->Repetitions(REPETITION_FREQUENCY)
417 ->ReportAggregatesOnly();
418
419 /**
420 * @tc.name: SUB_USB_HostManager_HDI_Performance_0900
421 * @tc.desc: Test functions to RequestCancel benchmark test
422 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
423 * @tc.desc: Positive test: parameters correctly
424 * @tc.type: FUNC
425 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HostManager_HDI_Performance_0900)426 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HostManager_HDI_Performance_0900)
427 (benchmark::State& st)
428 {
429 ASSERT_TRUE(g_usbInterface != nullptr);
430 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
431 ASSERT_TRUE(subscriber != nullptr);
432 InitPara(subscriber);
433 uint8_t pointId = POINTID_DIR_IN;
434 uint8_t interfaceId = INTERFACEID_OK;
435 struct UsbDev dev = dev_;
436 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
437 ASSERT_EQ(0, ret);
438 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
439 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
440 std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '1'};
441 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
442 for (auto _ : st) {
443 ret = g_usbInterface->RequestCancel(dev, pipe);
444 }
445 ASSERT_EQ(0, ret);
446 ReleasePara(subscriber);
447 }
448
449 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HostManager_HDI_Performance_0900)
450 ->Iterations(ITERATION_FREQUENCY)
451 ->Repetitions(REPETITION_FREQUENCY)
452 ->ReportAggregatesOnly();
453
454 /**
455 * @tc.name: SUB_USB_HostManager_HDI_Performance_1000
456 * @tc.desc: Test functions to ReleaseInterface benchmark test
457 * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
458 * @tc.desc: Positive test: parameters correctly
459 * @tc.type: FUNC
460 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HostManager_HDI_Performance_1000)461 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HostManager_HDI_Performance_1000)
462 (benchmark::State& st)
463 {
464 ASSERT_TRUE(g_usbInterface != nullptr);
465 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
466 ASSERT_TRUE(subscriber != nullptr);
467 InitPara(subscriber);
468 struct UsbDev dev = dev_;
469 uint8_t interfaceId = INTERFACEID_OK;
470 auto ret = 0;
471 for (auto _ : st) {
472 ret = g_usbInterface->ReleaseInterface(dev, interfaceId);
473 }
474 ASSERT_EQ(0, ret);
475 ReleasePara(subscriber);
476 }
477
478 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HostManager_HDI_Performance_1000)
479 ->Iterations(ITERATION_FREQUENCY)
480 ->Repetitions(REPETITION_FREQUENCY)
481 ->ReportAggregatesOnly();
482
483 /**
484 * @tc.name: SUB_USB_HostManager_HDI_Performance_2100
485 * @tc.desc: Test functions to BulkCancel benchmark test
486 * @tc.desc: int32_t BulkCancel(const UsbDev &dev, const UsbPipe &pipe);
487 * @tc.desc: Positive test: parameters correctly
488 * @tc.type: FUNC
489 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HostManager_HDI_Performance_2100)490 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HostManager_HDI_Performance_2100)
491 (benchmark::State& st)
492 {
493 ASSERT_TRUE(g_usbInterface != nullptr);
494 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
495 ASSERT_TRUE(subscriber != nullptr);
496 InitPara(subscriber);
497 struct UsbDev dev = dev_;
498 uint8_t interfaceId = INTERFACEID_OK;
499 uint8_t pointId = POINTID_DIR_IN;
500 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
501 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
502 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
503 ASSERT_EQ(ret, 0);
504 for (auto _ : st) {
505 ret = g_usbInterface->BulkCancel(dev, pipe);
506 }
507 ASSERT_EQ(0, ret);
508 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
509 ASSERT_EQ(ret, 0);
510 ReleasePara(subscriber);
511 }
512
513 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HostManager_HDI_Performance_2100)
514 ->Iterations(ITERATION_FREQUENCY)
515 ->Repetitions(REPETITION_FREQUENCY)
516 ->ReportAggregatesOnly();
517 } // namespace
518
519 BENCHMARK_MAIN();
520