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
SetUp(const::benchmark::State & state)47 void HdfUsbdBenchmarkRequestTest::SetUp(const ::benchmark::State& state)
48 {
49 g_usbInterface = 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 ASSERT_EQ(0, ret);
54 }
55
TearDown(const::benchmark::State & state)56 void HdfUsbdBenchmarkRequestTest::TearDown(const ::benchmark::State& state){}
57
InitPara(const sptr<UsbSubscriberTest> & subscriber)58 void HdfUsbdBenchmarkRequestTest::InitPara(const sptr<UsbSubscriberTest> &subscriber)
59 {
60 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber);
61 ASSERT_EQ(0, ret);
62 dev_ = {subscriber->busNum_, subscriber->devAddr_};
63 ret = g_usbInterface->OpenDevice(dev_);
64 ASSERT_EQ(0, ret);
65 }
66
ReleasePara(const sptr<UsbSubscriberTest> & subscriber)67 void HdfUsbdBenchmarkRequestTest::ReleasePara(const sptr<UsbSubscriberTest> &subscriber)
68 {
69 ASSERT_TRUE(g_usbInterface != nullptr);
70 auto ret = g_usbInterface->UnbindUsbdSubscriber(subscriber);
71 EXPECT_EQ(0, ret);
72 ret = g_usbInterface->CloseDevice(dev_);
73 ASSERT_EQ(0, ret);
74 }
75
76 /**
77 * @tc.name: SUB_USB_HDI_Benchmark_0070
78 * @tc.desc: Test functions to SetConfig benchmark test
79 * @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
80 * @tc.desc: Positive test: parameters correctly
81 * @tc.type: FUNC
82 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0070)83 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0070)
84 (benchmark::State& st)
85 {
86 ASSERT_TRUE(g_usbInterface != nullptr);
87 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
88 ASSERT_TRUE(subscriber != nullptr);
89 uint8_t configIndex = INDEX_1;
90 InitPara(subscriber);
91 struct UsbDev dev = dev_;
92 auto ret = 0;
93 for (auto _ : st) {
94 ret = g_usbInterface->SetConfig(dev, configIndex);
95 }
96 ASSERT_EQ(0, ret);
97 ReleasePara(subscriber);
98 }
99
100 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0070)
101 ->Iterations(ITERATION_FREQUENCY)
102 ->Repetitions(REPETITION_FREQUENCY)
103 ->ReportAggregatesOnly();
104
105 /**
106 * @tc.name: SUB_USB_HDI_Benchmark_0080
107 * @tc.desc: Test functions to GetConfig benchmark test
108 * @tc.desc: int32_t GetConfig(const UsbDev &dev, uint8_t &configIndex);
109 * @tc.desc: Positive test: parameters correctly
110 * @tc.type: FUNC
111 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0080)112 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0080)
113 (benchmark::State& st)
114 {
115 ASSERT_TRUE(g_usbInterface != nullptr);
116 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
117 ASSERT_TRUE(subscriber != nullptr);
118 uint8_t configIndex = INDEX_1;
119 InitPara(subscriber);
120 struct UsbDev dev = dev_;
121 auto ret = 0;
122 for (auto _ : st) {
123 ret = g_usbInterface->GetConfig(dev, configIndex);
124 }
125 ASSERT_EQ(0, ret);
126 ReleasePara(subscriber);
127 }
128
129 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0080)
130 ->Iterations(ITERATION_FREQUENCY)
131 ->Repetitions(REPETITION_FREQUENCY)
132 ->ReportAggregatesOnly();
133
134 /**
135 * @tc.name: SUB_USB_HDI_Benchmark_0090
136 * @tc.desc: Test functions to ClaimInterface benchmark test
137 * @tc.desc: int32_t ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
138 * @tc.desc: Positive test: parameters correctly
139 * @tc.type: FUNC
140 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0090)141 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0090)
142 (benchmark::State& st)
143 {
144 ASSERT_TRUE(g_usbInterface != nullptr);
145 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
146 ASSERT_TRUE(subscriber != nullptr);
147 uint8_t interfaceId = INTERFACEID_OK;
148 InitPara(subscriber);
149 struct UsbDev dev = dev_;
150 auto ret = 0;
151 for (auto _ : st) {
152 ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
153 }
154 ASSERT_EQ(0, ret);
155 ReleasePara(subscriber);
156 }
157
158 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0090)
159 ->Iterations(ITERATION_FREQUENCY)
160 ->Repetitions(REPETITION_FREQUENCY)
161 ->ReportAggregatesOnly();
162
163 /**
164 * @tc.name: SUB_USB_HDI_Benchmark_0100
165 * @tc.desc: Test functions to SetInterface benchmark test
166 * @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
167 * @tc.desc: Positive test: parameters correctly
168 * @tc.type: FUNC
169 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0100)170 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0100)
171 (benchmark::State& st)
172 {
173 ASSERT_TRUE(g_usbInterface != nullptr);
174 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
175 ASSERT_TRUE(subscriber != nullptr);
176 InitPara(subscriber);
177 uint8_t interfaceId = INTERFACEID_OK;
178 uint8_t altIndex = INDEX_0;
179 struct UsbDev dev = dev_;
180 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
181 ASSERT_EQ(0, ret);
182 for (auto _ : st) {
183 ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
184 }
185 ASSERT_EQ(0, ret);
186 ReleasePara(subscriber);
187 }
188
189 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0100)
190 ->Iterations(ITERATION_FREQUENCY)
191 ->Repetitions(REPETITION_FREQUENCY)
192 ->ReportAggregatesOnly();
193
194 /**
195 * @tc.name: SUB_USB_HDI_Benchmark_0110
196 * @tc.desc: Test functions to GetDeviceDescriptor benchmark test
197 * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
198 * @tc.desc: Positive test: parameters correctly
199 * @tc.type: FUNC
200 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0110)201 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0110)
202 (benchmark::State& st)
203 {
204 ASSERT_TRUE(g_usbInterface != nullptr);
205 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
206 ASSERT_TRUE(subscriber != nullptr);
207 InitPara(subscriber);
208 struct UsbDev dev = dev_;
209 std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
210 auto ret = 0;
211 for (auto _ : st) {
212 ret = g_usbInterface->GetDeviceDescriptor(dev, devData);
213 }
214 ASSERT_EQ(0, ret);
215 ReleasePara(subscriber);
216 }
217
218 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0110)
219 ->Iterations(ITERATION_FREQUENCY)
220 ->Repetitions(REPETITION_FREQUENCY)
221 ->ReportAggregatesOnly();
222
223 /**
224 * @tc.name: SUB_USB_HDI_Benchmark_0120
225 * @tc.desc: Test functions to GetStringDescriptor benchmark test
226 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
227 * @tc.desc: Positive test: parameters correctly
228 * @tc.type: FUNC
229 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0120)230 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0120)
231 (benchmark::State& st)
232 {
233 ASSERT_TRUE(g_usbInterface != nullptr);
234 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
235 ASSERT_TRUE(subscriber != nullptr);
236 InitPara(subscriber);
237 uint8_t stringId = 0;
238 struct UsbDev dev = dev_;
239 std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
240 auto ret = 0;
241 for (auto _ : st) {
242 ret = g_usbInterface->GetStringDescriptor(dev, stringId, devData);
243 }
244 ASSERT_EQ(0, ret);
245 ReleasePara(subscriber);
246 }
247
248 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0120)
249 ->Iterations(ITERATION_FREQUENCY)
250 ->Repetitions(REPETITION_FREQUENCY)
251 ->ReportAggregatesOnly();
252
253 /**
254 * @tc.name: SUB_USB_HDI_Benchmark_0130
255 * @tc.desc: Test functions to GetConfigDescriptor benchmark test
256 * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
257 * @tc.desc: Positive test: parameters correctly
258 * @tc.type: FUNC
259 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0130)260 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0130)
261 (benchmark::State& st)
262 {
263 ASSERT_TRUE(g_usbInterface != nullptr);
264 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
265 ASSERT_TRUE(subscriber != nullptr);
266 InitPara(subscriber);
267 uint8_t configId = CONFIG_ID_0;
268 struct UsbDev dev = dev_;
269 std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
270 auto ret = 0;
271 for (auto _ : st) {
272 ret = g_usbInterface->GetConfigDescriptor(dev, configId, devData);
273 }
274 ASSERT_EQ(0, ret);
275 ReleasePara(subscriber);
276 }
277
278 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0130)
279 ->Iterations(ITERATION_FREQUENCY)
280 ->Repetitions(REPETITION_FREQUENCY)
281 ->ReportAggregatesOnly();
282
283 /**
284 * @tc.name: SUB_USB_HDI_Benchmark_0140
285 * @tc.desc: Test functions to GetRawDescriptor benchmark test
286 * @tc.desc: int32_t GetRawDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
287 * @tc.desc: Positive test: parameters correctly
288 * @tc.type: FUNC
289 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0140)290 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0140)
291 (benchmark::State& st)
292 {
293 ASSERT_TRUE(g_usbInterface != nullptr);
294 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
295 ASSERT_TRUE(subscriber != nullptr);
296 InitPara(subscriber);
297 struct UsbDev dev = dev_;
298 std::vector<uint8_t> rawData;
299 auto ret = 0;
300 for (auto _ : st) {
301 ret = g_usbInterface->GetRawDescriptor(dev, rawData);
302 }
303 ASSERT_EQ(0, ret);
304 ReleasePara(subscriber);
305 }
306
307 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0140)
308 ->Iterations(ITERATION_FREQUENCY)
309 ->Repetitions(REPETITION_FREQUENCY)
310 ->ReportAggregatesOnly();
311
312 /**
313 * @tc.name: SUB_USB_HDI_Benchmark_0150
314 * @tc.desc: Test functions to GetFileDescriptor benchmark test
315 * @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
316 * @tc.desc: Positive test: parameters correctly
317 * @tc.type: FUNC
318 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0150)319 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0150)
320 (benchmark::State& st)
321 {
322 ASSERT_TRUE(g_usbInterface != nullptr);
323 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
324 ASSERT_TRUE(subscriber != nullptr);
325 InitPara(subscriber);
326 struct UsbDev dev = dev_;
327 int32_t fd = 0;
328 auto ret = 0;
329 for (auto _ : st) {
330 ret = g_usbInterface->GetFileDescriptor(dev, fd);
331 }
332 ASSERT_EQ(0, ret);
333 ReleasePara(subscriber);
334 }
335
336 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0150)
337 ->Iterations(ITERATION_FREQUENCY)
338 ->Repetitions(REPETITION_FREQUENCY)
339 ->ReportAggregatesOnly();
340
341 /**
342 * @tc.name: SUB_USB_HDI_Benchmark_0160
343 * @tc.desc: Test functions to RequestQueue benchmark test
344 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData,
345 std::vector<uint8_t> &buffer);
346 * @tc.desc: Positive test: parameters correctly
347 * @tc.type: FUNC
348 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0160)349 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0160)
350 (benchmark::State& st)
351 {
352 ASSERT_TRUE(g_usbInterface != nullptr);
353 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
354 ASSERT_TRUE(subscriber != nullptr);
355 InitPara(subscriber);
356 struct UsbDev dev = dev_;
357 uint8_t interfaceId = INTERFACEID_OK;
358 uint8_t pointId = POINTID_DIR_IN;
359 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
360 ASSERT_EQ(0, ret);
361 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
362 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
363 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
364 for (auto _ : st) {
365 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
366 }
367 ASSERT_EQ(0, ret);
368 ReleasePara(subscriber);
369 }
370
371 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0160)
372 ->Iterations(ITERATION_FREQUENCY)
373 ->Repetitions(REPETITION_FREQUENCY)
374 ->ReportAggregatesOnly();
375
376 /**
377 * @tc.name: SUB_USB_HDI_Benchmark_0170
378 * @tc.desc: Test functions to RequestWait benchmark test
379 * @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer,
380 * int32_t timeout);
381 * @tc.desc: Positive test: parameters correctly
382 * @tc.type: FUNC
383 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0170)384 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0170)
385 (benchmark::State& st)
386 {
387 ASSERT_TRUE(g_usbInterface != nullptr);
388 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
389 ASSERT_TRUE(subscriber != nullptr);
390 InitPara(subscriber);
391 struct UsbDev dev = dev_;
392 uint8_t pointId = POINTID_DIR_IN;
393 uint8_t interfaceId = INTERFACEID_OK;
394 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
395 ASSERT_EQ(0, ret);
396 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
397 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
398 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
399 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
400 std::vector<uint8_t> waitData(TAG_NUM_10);
401 for (auto _ : st) {
402 ret = g_usbInterface->RequestWait(dev, waitData, bufferData, TIME_WAIT);
403 }
404 ASSERT_EQ(0, ret);
405 ReleasePara(subscriber);
406 }
407
408 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0170)
409 ->Iterations(ITERATION_FREQUENCY)
410 ->Repetitions(REPETITION_FREQUENCY)
411 ->ReportAggregatesOnly();
412
413 /**
414 * @tc.name: SUB_USB_HDI_Benchmark_0180
415 * @tc.desc: Test functions to RequestCancel benchmark test
416 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
417 * @tc.desc: Positive test: parameters correctly
418 * @tc.type: FUNC
419 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0180)420 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0180)
421 (benchmark::State& st)
422 {
423 ASSERT_TRUE(g_usbInterface != nullptr);
424 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
425 ASSERT_TRUE(subscriber != nullptr);
426 InitPara(subscriber);
427 uint8_t pointId = POINTID_DIR_IN;
428 uint8_t interfaceId = INTERFACEID_OK;
429 struct UsbDev dev = dev_;
430 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
431 ASSERT_EQ(0, ret);
432 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
433 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
434 std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '1'};
435 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
436 for (auto _ : st) {
437 ret = g_usbInterface->RequestCancel(dev, pipe);
438 }
439 ASSERT_EQ(0, ret);
440 ReleasePara(subscriber);
441 }
442
443 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0180)
444 ->Iterations(ITERATION_FREQUENCY)
445 ->Repetitions(REPETITION_FREQUENCY)
446 ->ReportAggregatesOnly();
447
448 /**
449 * @tc.name: SUB_USB_HDI_Benchmark_0190
450 * @tc.desc: Test functions to ReleaseInterface benchmark test
451 * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
452 * @tc.desc: Positive test: parameters correctly
453 * @tc.type: FUNC
454 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0190)455 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0190)
456 (benchmark::State& st)
457 {
458 ASSERT_TRUE(g_usbInterface != nullptr);
459 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
460 ASSERT_TRUE(subscriber != nullptr);
461 InitPara(subscriber);
462 struct UsbDev dev = dev_;
463 uint8_t interfaceId = INTERFACEID_OK;
464 auto ret = 0;
465 for (auto _ : st) {
466 ret = g_usbInterface->ReleaseInterface(dev, interfaceId);
467 }
468 ASSERT_EQ(0, ret);
469 ReleasePara(subscriber);
470 }
471
472 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0190)
473 ->Iterations(ITERATION_FREQUENCY)
474 ->Repetitions(REPETITION_FREQUENCY)
475 ->ReportAggregatesOnly();
476
477 /**
478 * @tc.name: SUB_USB_HDI_Benchmark_0280
479 * @tc.desc: Test functions to BulkCancel benchmark test
480 * @tc.desc: int32_t BulkCancel(const UsbDev &dev, const UsbPipe &pipe);
481 * @tc.desc: Positive test: parameters correctly
482 * @tc.type: FUNC
483 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0280)484 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0280)
485 (benchmark::State& st)
486 {
487 ASSERT_TRUE(g_usbInterface != nullptr);
488 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
489 ASSERT_TRUE(subscriber != nullptr);
490 InitPara(subscriber);
491 struct UsbDev dev = dev_;
492 uint8_t interfaceId = INTERFACEID_OK;
493 uint8_t pointId = POINTID_DIR_IN;
494 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
495 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
496 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
497 ASSERT_EQ(ret, 0);
498 for (auto _ : st) {
499 ret = g_usbInterface->BulkCancel(dev, pipe);
500 }
501 ASSERT_EQ(0, ret);
502 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
503 ASSERT_EQ(ret, 0);
504 ReleasePara(subscriber);
505 }
506
507 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0280)
508 ->Iterations(ITERATION_FREQUENCY)
509 ->Repetitions(REPETITION_FREQUENCY)
510 ->ReportAggregatesOnly();
511 } // namespace
512
513 BENCHMARK_MAIN();
514