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