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