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 "HdfUsbdBenchmarkTransferTest.h"
20 #include "hdf_log.h"
21 #include "securec.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 uint32_t MAX_BUFFER_LENGTH = 255;
32 const uint8_t INTERFACEID_OK = 1;
33 // data interface have 2 point : 1->bulk_out 2->bulk_in
34 const uint8_t POINTID_BULK_IN = USB_ENDPOINT_DIR_IN | 2;
35 const uint8_t POINTID_BULK_OUT = USB_ENDPOINT_DIR_OUT | 1;
36 const int32_t ASHMEM_MAX_SIZE = 1024;
37 const uint8_t SAMPLE_DATA_1 = 1;
38 const uint8_t SAMPLE_DATA_2 = 2;
39 const uint8_t SAMPLE_DATA_3 = 3;
40 const int32_t TRANSFER_TIME_OUT = 1000;
41 constexpr int32_t ITERATION_FREQUENCY = 100;
42 constexpr int32_t REPETITION_FREQUENCY = 3;
43 UsbDev HdfUsbdBenchmarkTransferTest::dev_ = { 0, 0 };
44
45 namespace {
46 sptr<IUsbInterface> g_usbInterface = nullptr;
47
InitAshmemOne(sptr<Ashmem> & asmptr,int32_t asmSize,uint8_t rflg)48 int32_t InitAshmemOne(sptr<Ashmem>& asmptr, int32_t asmSize, uint8_t rflg)
49 {
50 asmptr = Ashmem::CreateAshmem("ttashmem000", asmSize);
51 if (asmptr == nullptr) {
52 return HDF_FAILURE;
53 }
54
55 asmptr->MapReadAndWriteAshmem();
56
57 if (rflg == 0) {
58 uint8_t tdata[ASHMEM_MAX_SIZE];
59 int32_t offset = 0;
60 int32_t tlen = 0;
61
62 int32_t retSafe = memset_s(tdata, sizeof(tdata), 'Y', ASHMEM_MAX_SIZE);
63 if (retSafe != EOK) {
64 return HDF_FAILURE;
65 }
66 while (offset < asmSize) {
67 tlen = (asmSize - offset) < ASHMEM_MAX_SIZE ? (asmSize - offset) : ASHMEM_MAX_SIZE;
68 asmptr->WriteToAshmem(tdata, tlen, offset);
69 offset += tlen;
70 }
71 }
72 return HDF_SUCCESS;
73 }
74
SetUp(const::benchmark::State & state)75 void HdfUsbdBenchmarkTransferTest::SetUp(const ::benchmark::State& state)
76 {
77 g_usbInterface = IUsbInterface::Get();
78 ASSERT_NE(g_usbInterface, nullptr);
79 auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, POWER_ROLE_SOURCE, DATA_ROLE_HOST);
80 sleep(SLEEP_TIME);
81 ASSERT_EQ(0, ret);
82 }
83
TearDown(const::benchmark::State & state)84 void HdfUsbdBenchmarkTransferTest::TearDown(const ::benchmark::State& state){}
85
InitPara(const sptr<UsbSubscriberTest> & subscriber)86 void HdfUsbdBenchmarkTransferTest::InitPara(const sptr<UsbSubscriberTest> &subscriber)
87 {
88 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber);
89 ASSERT_EQ(0, ret);
90 dev_ = {subscriber->busNum_, subscriber->devAddr_};
91 ret = g_usbInterface->OpenDevice(dev_);
92 ASSERT_EQ(0, ret);
93 }
94
ReleasePara(const sptr<UsbSubscriberTest> & subscriber)95 void HdfUsbdBenchmarkTransferTest::ReleasePara(const sptr<UsbSubscriberTest> &subscriber)
96 {
97 ASSERT_TRUE(g_usbInterface != nullptr);
98 auto ret = g_usbInterface->UnbindUsbdSubscriber(subscriber);
99 EXPECT_EQ(0, ret);
100 ret = g_usbInterface->CloseDevice(dev_);
101 ASSERT_EQ(0, ret);
102 }
103
104 /**
105 * @tc.name: SUB_USB_HDI_Benchmark_0200
106 * @tc.desc: Benchmark test
107 * @tc.desc: Test functions to ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl,
108 * std::vector<uint8_t> &data);
109 * @tc.desc: Positive test: parameters correctly, standard request: get configuration
110 * @tc.type: FUNC
111 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0200)112 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0200)
113 (benchmark::State& st)
114 {
115 ASSERT_TRUE(g_usbInterface != nullptr);
116 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
117 ASSERT_TRUE(subscriber != nullptr);
118 InitPara(subscriber);
119 struct UsbDev dev = dev_;
120 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
121 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
122 auto ret = 0;
123 for (auto _ : st) {
124 ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
125 }
126 ASSERT_EQ(0, ret);
127 ReleasePara(subscriber);
128 }
129
130 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0200)
131 ->Iterations(ITERATION_FREQUENCY)
132 ->Repetitions(REPETITION_FREQUENCY)
133 ->ReportAggregatesOnly();
134
135 /**
136 * @tc.name: SUB_USB_HDI_Benchmark_0270
137 * @tc.desc: Benchmark test
138 * @tc.desc: Test functions to ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl,
139 * std::vector<uint8_t> &data);
140 * @tc.desc: Positive test: parameters correctly
141 * @tc.type: FUNC
142 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0270)143 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0270)
144 (benchmark::State& st)
145 {
146 ASSERT_TRUE(g_usbInterface != nullptr);
147 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
148 ASSERT_TRUE(subscriber != nullptr);
149 InitPara(subscriber);
150 struct UsbDev dev = dev_;
151 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
152 bufferData.push_back(SAMPLE_DATA_1);
153 bufferData.push_back(SAMPLE_DATA_2);
154 bufferData.push_back(SAMPLE_DATA_3);
155 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE,
156 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
157 auto ret = 0;
158 for (auto _ : st) {
159 ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
160 }
161 ASSERT_EQ(0, ret);
162 ReleasePara(subscriber);
163 }
164
165 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0270)
166 ->Iterations(ITERATION_FREQUENCY)
167 ->Repetitions(REPETITION_FREQUENCY)
168 ->ReportAggregatesOnly();
169
170 /**
171 * @tc.name: SUB_USB_HDI_Benchmark_0210
172 * @tc.desc: Benchmark test
173 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
174 * std::vector<uint8_t> &data);
175 * @tc.desc: Positive test: parameters correctly
176 * @tc.type: FUNC
177 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0210)178 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0210)
179 (benchmark::State& st)
180 {
181 ASSERT_TRUE(g_usbInterface != nullptr);
182 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
183 ASSERT_TRUE(subscriber != nullptr);
184 InitPara(subscriber);
185 struct UsbDev dev = dev_;
186 uint8_t interfaceId = INTERFACEID_OK;
187 uint8_t pointId = POINTID_BULK_IN;
188 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
189 ASSERT_EQ(0, ret);
190 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
191 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
192 for (auto _ : st) {
193 ret = g_usbInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
194 }
195 ASSERT_EQ(0, ret);
196 ReleasePara(subscriber);
197 }
198
199 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0210)
200 ->Iterations(ITERATION_FREQUENCY)
201 ->Repetitions(REPETITION_FREQUENCY)
202 ->ReportAggregatesOnly();
203
204 /**
205 * @tc.name: SUB_USB_HDI_Benchmark_0220
206 * @tc.desc: Benchmark test
207 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
208 * std::vector<uint8_t> &data);
209 * @tc.desc: Positive test: parameters correctly
210 * @tc.type: FUNC
211 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0220)212 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0220)
213 (benchmark::State& st)
214 {
215 ASSERT_TRUE(g_usbInterface != nullptr);
216 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
217 ASSERT_TRUE(subscriber != nullptr);
218 InitPara(subscriber);
219 struct UsbDev dev = dev_;
220 uint8_t interfaceId = INTERFACEID_OK;
221 uint8_t pointId = POINTID_BULK_OUT;
222 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
223 ASSERT_EQ(0, ret);
224 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
225 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '1'};
226 for (auto _ : st) {
227 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
228 }
229 ASSERT_EQ(0, ret);
230 ReleasePara(subscriber);
231 }
232
233 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0220)
234 ->Iterations(ITERATION_FREQUENCY)
235 ->Repetitions(REPETITION_FREQUENCY)
236 ->ReportAggregatesOnly();
237
238 /**
239 * @tc.name: SUB_USB_HDI_Benchmark_0230
240 * @tc.desc: Benchmark test
241 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
242 * std::vector<uint8_t> &data);
243 * @tc.desc: Positive test: parameters correctly
244 * @tc.type: FUNC
245 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0230)246 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0230)
247 (benchmark::State& st)
248 {
249 ASSERT_TRUE(g_usbInterface != nullptr);
250 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
251 ASSERT_TRUE(subscriber != nullptr);
252 InitPara(subscriber);
253 struct UsbDev dev = dev_;
254 uint8_t interfaceId = INTERFACEID_OK;
255 uint8_t pointId = POINTID_BULK_IN;
256 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
257 ASSERT_EQ(0, ret);
258 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
259 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
260 for (auto _ : st) {
261 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
262 }
263 ASSERT_EQ(0, ret);
264 ReleasePara(subscriber);
265 }
266
267 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0230)
268 ->Iterations(ITERATION_FREQUENCY)
269 ->Repetitions(REPETITION_FREQUENCY)
270 ->ReportAggregatesOnly();
271
272 /**
273 * @tc.name: SUB_USB_HDI_Benchmark_0240
274 * @tc.desc: Benchmark test
275 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
276 * std::vector<uint8_t> &data);
277 * @tc.desc: Positive test: parameters correctly
278 * @tc.type: FUNC
279 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0240)280 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0240)
281 (benchmark::State& st)
282 {
283 ASSERT_TRUE(g_usbInterface != nullptr);
284 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
285 ASSERT_TRUE(subscriber != nullptr);
286 InitPara(subscriber);
287 struct UsbDev dev = dev_;
288 uint8_t interfaceId = INTERFACEID_OK;
289 uint8_t pointId = POINTID_BULK_OUT;
290 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
291 ASSERT_EQ(0, ret);
292 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
293 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '1'};
294 for (auto _ : st) {
295 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
296 }
297 ASSERT_EQ(0, ret);
298 ReleasePara(subscriber);
299 }
300
301 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0240)
302 ->Iterations(ITERATION_FREQUENCY)
303 ->Repetitions(REPETITION_FREQUENCY)
304 ->ReportAggregatesOnly();
305
306 /**
307 * @tc.name: SUB_USB_HDI_Benchmark_0250
308 * @tc.desc: Benchmark test
309 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
310 * std::vector<uint8_t> &data);
311 * @tc.desc: Positive test: parameters correctly
312 * @tc.type: FUNC
313 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0250)314 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0250)
315 (benchmark::State& st)
316 {
317 ASSERT_TRUE(g_usbInterface != nullptr);
318 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
319 ASSERT_TRUE(subscriber != nullptr);
320 InitPara(subscriber);
321 struct UsbDev dev = dev_;
322 uint8_t interfaceId = INTERFACEID_OK;
323 uint8_t pointId = POINTID_BULK_IN;
324 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
325 ASSERT_EQ(0, ret);
326 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
327 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
328 for (auto _ : st) {
329 ret = g_usbInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
330 }
331 ASSERT_EQ(0, ret);
332 ReleasePara(subscriber);
333 }
334
335 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0250)
336 ->Iterations(ITERATION_FREQUENCY)
337 ->Repetitions(REPETITION_FREQUENCY)
338 ->ReportAggregatesOnly();
339
340 /**
341 * @tc.name: SUB_USB_HDI_Benchmark_0260
342 * @tc.desc: Benchmark test
343 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
344 * std::vector<uint8_t> &data);
345 * @tc.desc: Positive test: parameters correctly
346 * @tc.type: FUNC
347 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0260)348 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0260)
349 (benchmark::State& st)
350 {
351 ASSERT_TRUE(g_usbInterface != nullptr);
352 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
353 ASSERT_TRUE(subscriber != nullptr);
354 InitPara(subscriber);
355 struct UsbDev dev = dev_;
356 uint8_t interfaceId = INTERFACEID_OK;
357 uint8_t pointId = POINTID_BULK_OUT;
358 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
359 ASSERT_EQ(0, ret);
360 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
361 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '1'};
362 for (auto _ : st) {
363 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
364 }
365 ASSERT_EQ(0, ret);
366 ReleasePara(subscriber);
367 }
368
369 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0260)
370 ->Iterations(ITERATION_FREQUENCY)
371 ->Repetitions(REPETITION_FREQUENCY)
372 ->ReportAggregatesOnly();
373
374 /**
375 * @tc.name: SUB_USB_HDI_Benchmark_0290
376 * @tc.desc: Benchmark test
377 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
378 * @tc.desc: Positive test: parameters correctly
379 * @tc.type: FUNC
380 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0290)381 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0290)
382 (benchmark::State& st)
383 {
384 ASSERT_TRUE(g_usbInterface != nullptr);
385 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
386 ASSERT_TRUE(subscriber != nullptr);
387 InitPara(subscriber);
388 sptr<Ashmem> ashmem;
389 uint8_t rflg = 0;
390 int32_t asmSize = MAX_BUFFER_LENGTH;
391 struct UsbDev dev = dev_;
392 uint8_t interfaceId = INTERFACEID_OK;
393 uint8_t pointId = POINTID_BULK_IN;
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 (void)InitAshmemOne(ashmem, asmSize, rflg);
398 for (auto _ : st) {
399 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem);
400 }
401 ASSERT_EQ(ret, 0);
402 ReleasePara(subscriber);
403 }
404
405 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0290)
406 ->Iterations(ITERATION_FREQUENCY)
407 ->Repetitions(REPETITION_FREQUENCY)
408 ->ReportAggregatesOnly();
409
410 /**
411 * @tc.name: SUB_USB_HDI_Benchmark_0300
412 * @tc.desc: Benchmark test
413 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
414 * @tc.desc: Positive test: parameters correctly
415 * @tc.type: FUNC
416 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0300)417 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0300)
418 (benchmark::State& st)
419 {
420 ASSERT_TRUE(g_usbInterface != nullptr);
421 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
422 ASSERT_TRUE(subscriber != nullptr);
423 InitPara(subscriber);
424 sptr<Ashmem> ashmem;
425 uint8_t rflg = 0;
426 int32_t asmSize = MAX_BUFFER_LENGTH;
427 struct UsbDev dev = dev_;
428 uint8_t interfaceId = INTERFACEID_OK;
429 uint8_t pointId = POINTID_BULK_IN;
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 (void)InitAshmemOne(ashmem, asmSize, rflg);
434 for (auto _ : st) {
435 ret = g_usbInterface->BulkRead(dev, pipe, ashmem);
436 }
437 ASSERT_EQ(ret, 0);
438 ReleasePara(subscriber);
439 }
440
441 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0300)
442 ->Iterations(ITERATION_FREQUENCY)
443 ->Repetitions(REPETITION_FREQUENCY)
444 ->ReportAggregatesOnly();
445
446 /**
447 * @tc.name: SUB_USB_HDI_Benchmark_0310
448 * @tc.desc: Benchmark test
449 * @tc.desc: int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<IUsbdBulkCallback> &cb)
450 * @tc.desc: Positive test: parameters correctly
451 * @tc.type: FUNC
452 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0310)453 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0310)
454 (benchmark::State& st)
455 {
456 ASSERT_TRUE(g_usbInterface != nullptr);
457 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
458 ASSERT_TRUE(subscriber != nullptr);
459 InitPara(subscriber);
460 struct UsbDev dev = dev_;
461 uint8_t interfaceId = INTERFACEID_OK;
462 uint8_t pointId = POINTID_BULK_OUT;
463 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
464 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
465 auto ret = 0;
466 for (auto _ : st) {
467 ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
468 }
469 ASSERT_EQ(ret, 0);
470 ReleasePara(subscriber);
471 }
472
473 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0310)
474 ->Iterations(ITERATION_FREQUENCY)
475 ->Repetitions(REPETITION_FREQUENCY)
476 ->ReportAggregatesOnly();
477
478 /**
479 * @tc.name: SUB_USB_HDI_Benchmark_0320
480 * @tc.desc: Benchmark test
481 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
482 * @tc.desc: Positive test: parameters correctly
483 * @tc.type: FUNC
484 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0320)485 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0320)
486 (benchmark::State& st)
487 {
488 ASSERT_TRUE(g_usbInterface != nullptr);
489 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
490 ASSERT_TRUE(subscriber != nullptr);
491 InitPara(subscriber);
492 struct UsbDev dev = dev_;
493 uint8_t interfaceId = INTERFACEID_OK;
494 uint8_t pointId = POINTID_BULK_OUT;
495 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
496 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
497 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
498 ASSERT_EQ(ret, 0);
499 for (auto _ : st) {
500 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
501 }
502 ASSERT_EQ(ret, 0);
503 ReleasePara(subscriber);
504 }
505
506 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0320)
507 ->Iterations(ITERATION_FREQUENCY)
508 ->Repetitions(REPETITION_FREQUENCY)
509 ->ReportAggregatesOnly();
510
511 /**
512 * @tc.name: SUB_USB_HDI_Benchmark_0330
513 * @tc.desc: Benchmark test
514 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
515 * @tc.desc: Positive test: parameters correctly
516 * @tc.type: FUNC
517 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0330)518 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0330)
519 (benchmark::State& st)
520 {
521 ASSERT_TRUE(g_usbInterface != nullptr);
522 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
523 ASSERT_TRUE(subscriber != nullptr);
524 InitPara(subscriber);
525 auto ret = 0;
526 for (auto _ : st) {
527 ret = g_usbInterface->BindUsbdSubscriber(subscriber);
528 }
529 ASSERT_EQ(0, ret);
530 ReleasePara(subscriber);
531 }
532
533 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0330)
534 ->Iterations(ITERATION_FREQUENCY)
535 ->Repetitions(REPETITION_FREQUENCY)
536 ->ReportAggregatesOnly();
537
538 /**
539 * @tc.name: SUB_USB_HDI_Benchmark_0340
540 * @tc.desc: Benchmark test
541 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
542 * @tc.desc: Positive test: parameters correctly
543 * @tc.type: FUNC
544 */
BENCHMARK_F(HdfUsbdBenchmarkTransferTest,SUB_USB_HDI_Benchmark_0340)545 BENCHMARK_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0340)
546 (benchmark::State& st)
547 {
548 ASSERT_TRUE(g_usbInterface != nullptr);
549 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
550 ASSERT_TRUE(subscriber != nullptr);
551 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber);
552 dev_ = {subscriber->busNum_, subscriber->devAddr_};
553 ret = g_usbInterface->OpenDevice(dev_);
554 for (auto _ : st) {
555 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber);
556 }
557 ASSERT_EQ(0, ret);
558 ret = g_usbInterface->CloseDevice(dev_);
559 ASSERT_EQ(0, ret);
560 }
561
562 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkTransferTest, SUB_USB_HDI_Benchmark_0340)
563 ->Iterations(ITERATION_FREQUENCY)
564 ->Repetitions(REPETITION_FREQUENCY)
565 ->ReportAggregatesOnly();
566 } // namespace
567
568 BENCHMARK_MAIN();
569