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