1 /*
2 * Copyright (c) 2021-2022 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 "UsbSubscriberTest.h"
21 #include "hdf_log.h"
22 #include "v1_0/iusb_interface.h"
23 #include "v1_0/usb_types.h"
24
25 using namespace benchmark::internal;
26 using namespace OHOS;
27 using namespace OHOS::USB;
28 using namespace std;
29 using namespace OHOS::HDI::Usb::V1_0;
30
31 const int SLEEP_TIME = 3;
32 const uint8_t INDEX_0 = 0;
33 const uint8_t INDEX_1 = 1;
34 const uint8_t CONFIG_ID_0 = 0;
35 const uint32_t LENGTH_NUM_255 = 255;
36 const uint32_t TAG_LENGTH_NUM_1000 = 1000;
37 const int TAG_NUM_10 = 10;
38 const uint8_t INTERFACEID_1 = 1;
39 const uint8_t POINTID_129 = 130;
40 const uint8_t POINTID_BULK_IN = 0x82;
41 UsbDev HdfUsbdBenchmarkRequestTest::dev_ = { 0, 0 };
42
43 namespace {
44 sptr<IUsbInterface> g_usbInterface = nullptr;
45
SetUp(const::benchmark::State & state)46 void HdfUsbdBenchmarkRequestTest::SetUp(const ::benchmark::State& state)
47 {
48 g_usbInterface = IUsbInterface::Get();
49 if (g_usbInterface == nullptr) {
50 exit(0);
51 }
52 auto ret = g_usbInterface->SetPortRole(1, 1, 1);
53 sleep(SLEEP_TIME);
54 ASSERT_EQ(0, ret);
55 if (ret != 0) {
56 exit(0);
57 }
58
59 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
60 if (g_usbInterface->BindUsbdSubscriber(subscriber) != HDF_SUCCESS) {
61 exit(0);
62 }
63
64 dev_ = { subscriber->busNum_, subscriber->devAddr_ };
65
66 ret = g_usbInterface->OpenDevice(dev_);
67 ASSERT_EQ(0, ret);
68 }
69
TearDown(const::benchmark::State & state)70 void HdfUsbdBenchmarkRequestTest::TearDown(const ::benchmark::State& state)
71 {
72 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
73 if (g_usbInterface->BindUsbdSubscriber(subscriber) != HDF_SUCCESS) {
74 exit(0);
75 }
76 dev_ = { subscriber->busNum_, subscriber->devAddr_ };
77 auto ret = g_usbInterface->CloseDevice(dev_);
78 ASSERT_EQ(0, ret);
79 }
80
81 /**
82 * @tc.name: SUB_USB_HDI_Benchmark_0070
83 * @tc.desc: Test functions to SetConfig benchmark test
84 * @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
85 * @tc.desc: Positive test: parameters correctly
86 * @tc.type: FUNC
87 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0070)88 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0070)
89 (benchmark::State& st)
90 {
91 uint8_t configIndex = INDEX_1;
92 struct UsbDev dev = dev_;
93 auto ret = 0;
94 for (auto _ : st) {
95 ret = g_usbInterface->SetConfig(dev, configIndex);
96 }
97 ASSERT_EQ(0, ret);
98 }
99
100 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0070)
101 ->Iterations(100)
102 ->Repetitions(3)
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 uint8_t configIndex = 1;
116 struct UsbDev dev = dev_;
117 auto ret = 0;
118 for (auto _ : st) {
119 ret = g_usbInterface->GetConfig(dev, configIndex);
120 }
121 ASSERT_EQ(0, ret);
122 }
123
124 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0080)
125 ->Iterations(100)
126 ->Repetitions(3)
127 ->ReportAggregatesOnly();
128
129 /**
130 * @tc.name: SUB_USB_HDI_Benchmark_0090
131 * @tc.desc: Test functions to ClaimInterface benchmark test
132 * @tc.desc: int32_t ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
133 * @tc.desc: Positive test: parameters correctly
134 * @tc.type: FUNC
135 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0090)136 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0090)
137 (benchmark::State& st)
138 {
139 uint8_t interfaceId = INTERFACEID_1;
140 struct UsbDev dev = dev_;
141 auto ret = 0;
142 for (auto _ : st) {
143 ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
144 }
145 ASSERT_EQ(0, ret);
146 }
147
148 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0090)
149 ->Iterations(100)
150 ->Repetitions(3)
151 ->ReportAggregatesOnly();
152
153 /**
154 * @tc.name: SUB_USB_HDI_Benchmark_0100
155 * @tc.desc: Test functions to SetInterface benchmark test
156 * @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
157 * @tc.desc: Positive test: parameters correctly
158 * @tc.type: FUNC
159 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0100)160 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0100)
161 (benchmark::State& st)
162 {
163 uint8_t interfaceId = INTERFACEID_1;
164 uint8_t altIndex = INDEX_0;
165 struct UsbDev dev = dev_;
166 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
167 ASSERT_EQ(0, ret);
168 for (auto _ : st) {
169 ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
170 }
171 ASSERT_EQ(0, ret);
172 }
173
174 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0100)
175 ->Iterations(100)
176 ->Repetitions(3)
177 ->ReportAggregatesOnly();
178
179 /**
180 * @tc.name: SUB_USB_HDI_Benchmark_0110
181 * @tc.desc: Test functions to GetDeviceDescriptor benchmark test
182 * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
183 * @tc.desc: Positive test: parameters correctly
184 * @tc.type: FUNC
185 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0110)186 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0110)
187 (benchmark::State& st)
188 {
189 uint32_t length = LENGTH_NUM_255;
190 uint8_t buffer[LENGTH_NUM_255] = { 0 };
191 struct UsbDev dev = dev_;
192 std::vector<uint8_t> devdata(buffer, buffer + length);
193 auto ret = 0;
194 for (auto _ : st) {
195 ret = g_usbInterface->GetDeviceDescriptor(dev, devdata);
196 }
197 ASSERT_EQ(0, ret);
198 }
199
200 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0110)
201 ->Iterations(100)
202 ->Repetitions(3)
203 ->ReportAggregatesOnly();
204
205 /**
206 * @tc.name: SUB_USB_HDI_Benchmark_0120
207 * @tc.desc: Test functions to GetStringDescriptor benchmark test
208 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
209 * @tc.desc: Positive test: parameters correctly
210 * @tc.type: FUNC
211 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0120)212 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0120)
213 (benchmark::State& st)
214 {
215 uint8_t stringId = 0;
216 uint8_t buffer[LENGTH_NUM_255] = { 0 };
217 uint32_t length = LENGTH_NUM_255;
218 struct UsbDev dev = dev_;
219 std::vector<uint8_t> devdata(buffer, buffer + length);
220 auto ret = 0;
221 for (auto _ : st) {
222 ret = g_usbInterface->GetStringDescriptor(dev, stringId, devdata);
223 }
224 ASSERT_EQ(0, ret);
225 }
226
227 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0120)
228 ->Iterations(100)
229 ->Repetitions(3)
230 ->ReportAggregatesOnly();
231
232 /**
233 * @tc.name: SUB_USB_HDI_Benchmark_0130
234 * @tc.desc: Test functions to GetConfigDescriptor benchmark test
235 * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
236 * @tc.desc: Positive test: parameters correctly
237 * @tc.type: FUNC
238 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0130)239 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0130)
240 (benchmark::State& st)
241 {
242 uint8_t configId = CONFIG_ID_0;
243 uint8_t buffer[LENGTH_NUM_255] = {};
244 uint32_t length = LENGTH_NUM_255;
245 struct UsbDev dev = dev_;
246 std::vector<uint8_t> devdata(buffer, buffer + length);
247 auto ret = 0;
248 for (auto _ : st) {
249 ret = g_usbInterface->GetConfigDescriptor(dev, configId, devdata);
250 }
251 ASSERT_EQ(0, ret);
252 }
253
254 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0130)
255 ->Iterations(100)
256 ->Repetitions(3)
257 ->ReportAggregatesOnly();
258
259 /**
260 * @tc.name: SUB_USB_HDI_Benchmark_0140
261 * @tc.desc: Test functions to GetRawDescriptor benchmark test
262 * @tc.desc: int32_t GetRawDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
263 * @tc.desc: Positive test: parameters correctly
264 * @tc.type: FUNC
265 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0140)266 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0140)
267 (benchmark::State& st)
268 {
269 struct UsbDev dev = dev_;
270 std::vector<uint8_t> rawData;
271 auto ret = 0;
272 for (auto _ : st) {
273 ret = g_usbInterface->GetRawDescriptor(dev, rawData);
274 }
275 ASSERT_EQ(0, ret);
276 }
277
278 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0140)
279 ->Iterations(100)
280 ->Repetitions(3)
281 ->ReportAggregatesOnly();
282
283 /**
284 * @tc.name: SUB_USB_HDI_Benchmark_0150
285 * @tc.desc: Test functions to GetFileDescriptor benchmark test
286 * @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
287 * @tc.desc: Positive test: parameters correctly
288 * @tc.type: FUNC
289 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0150)290 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0150)
291 (benchmark::State& st)
292 {
293 struct UsbDev dev = dev_;
294 int32_t fd = 0;
295 auto ret = 0;
296 for (auto _ : st) {
297 ret = g_usbInterface->GetFileDescriptor(dev, fd);
298 }
299 ASSERT_EQ(0, ret);
300 }
301
302 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0150)
303 ->Iterations(100)
304 ->Repetitions(3)
305 ->ReportAggregatesOnly();
306
307 /**
308 * @tc.name: SUB_USB_HDI_Benchmark_0160
309 * @tc.desc: Test functions to RequestQueue benchmark test
310 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData,
311 std::vector<uint8_t> &buffer);
312 * @tc.desc: Positive test: parameters correctly
313 * @tc.type: FUNC
314 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0160)315 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0160)
316 (benchmark::State& st)
317 {
318 struct UsbDev dev = dev_;
319 uint8_t interfaceId = INTERFACEID_1;
320 uint8_t pointid = POINTID_129;
321 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
322 ASSERT_EQ(0, ret);
323 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
324 uint8_t buffer[LENGTH_NUM_255] = { 0 };
325 uint32_t length = LENGTH_NUM_255;
326 struct UsbPipe pipe = { interfaceId, pointid };
327 std::vector<uint8_t> clientdata = { tag, tag + TAG_NUM_10 };
328 std::vector<uint8_t> bufferdata = { buffer, buffer + length };
329 for (auto _ : st) {
330 ret = g_usbInterface->RequestQueue(dev, pipe, clientdata, bufferdata);
331 }
332 ASSERT_EQ(0, ret);
333 }
334
335 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0160)
336 ->Iterations(100)
337 ->Repetitions(3)
338 ->ReportAggregatesOnly();
339
340 /**
341 * @tc.name: SUB_USB_HDI_Benchmark_0170
342 * @tc.desc: Test functions to RequestWait benchmark test
343 * @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer,
344 * int32_t timeout);
345 * @tc.desc: Positive test: parameters correctly
346 * @tc.type: FUNC
347 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0170)348 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0170)
349 (benchmark::State& st)
350 {
351 struct UsbDev dev = dev_;
352 uint8_t pointid = POINTID_129;
353 uint8_t interfaceId = INTERFACEID_1;
354 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
355 ASSERT_EQ(0, ret);
356 uint8_t buffer[LENGTH_NUM_255] = {};
357 uint32_t length = LENGTH_NUM_255;
358 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
359 struct UsbPipe pipe = { interfaceId, pointid };
360 std::vector<uint8_t> clientdata = { tag, tag + TAG_NUM_10 };
361 std::vector<uint8_t> bufferdata = { buffer, buffer + length };
362 ret = g_usbInterface->RequestQueue(dev, pipe, clientdata, bufferdata);
363 ASSERT_EQ(0, ret);
364 uint8_t* clientObj = new uint8_t[10];
365 std::vector<uint8_t> waitdata = { clientObj, clientObj + 10 };
366 for (auto _ : st) {
367 ret = g_usbInterface->RequestWait(dev, waitdata, bufferdata, 10000);
368 }
369 ASSERT_EQ(0, ret);
370 delete[] clientObj;
371 clientObj = nullptr;
372 }
373
374 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0170)
375 ->Iterations(100)
376 ->Repetitions(3)
377 ->ReportAggregatesOnly();
378
379 /**
380 * @tc.name: SUB_USB_HDI_Benchmark_0180
381 * @tc.desc: Test functions to RequestCancel benchmark test
382 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
383 * @tc.desc: Positive test: parameters correctly
384 * @tc.type: FUNC
385 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0180)386 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0180)
387 (benchmark::State& st)
388 {
389 uint8_t pointid = POINTID_129;
390 uint8_t interfaceId = INTERFACEID_1;
391 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
392 struct UsbDev dev = dev_;
393 uint8_t buffer[LENGTH_NUM_255] = "request001";
394 uint32_t length = LENGTH_NUM_255;
395 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
396 EXPECT_TRUE(ret == 0);
397 struct UsbPipe pipe = { interfaceId, pointid };
398 std::vector<uint8_t> clientdata = { tag, tag + TAG_NUM_10 };
399 std::vector<uint8_t> bufferdata = { buffer, buffer + length };
400 ret = g_usbInterface->RequestQueue(dev, pipe, clientdata, bufferdata);
401 ASSERT_EQ(0, ret);
402 for (auto _ : st) {
403 ret = g_usbInterface->RequestCancel(dev, pipe);
404 }
405 ASSERT_EQ(0, ret);
406 }
407
408 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0180)
409 ->Iterations(100)
410 ->Repetitions(3)
411 ->ReportAggregatesOnly();
412
413 /**
414 * @tc.name: SUB_USB_HDI_Benchmark_0190
415 * @tc.desc: Test functions to ReleaseInterface benchmark test
416 * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
417 * @tc.desc: Positive test: parameters correctly
418 * @tc.type: FUNC
419 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0190)420 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0190)
421 (benchmark::State& st)
422 {
423 struct UsbDev dev = dev_;
424 uint8_t interfaceId = INTERFACEID_1;
425 auto ret = 0;
426 for (auto _ : st) {
427 ret = g_usbInterface->ReleaseInterface(dev, interfaceId);
428 }
429 ASSERT_EQ(0, ret);
430 }
431
432 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0190)
433 ->Iterations(100)
434 ->Repetitions(3)
435 ->ReportAggregatesOnly();
436
437 /**
438 * @tc.name: SUB_USB_HDI_Benchmark_0280
439 * @tc.desc: Test functions to BulkCancel benchmark test
440 * @tc.desc: int32_t BulkCancel(const UsbDev &dev, const UsbPipe &pipe);
441 * @tc.desc: Positive test: parameters correctly
442 * @tc.type: FUNC
443 */
BENCHMARK_F(HdfUsbdBenchmarkRequestTest,SUB_USB_HDI_Benchmark_0280)444 BENCHMARK_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0280)
445 (benchmark::State& st)
446 {
447 struct UsbDev dev = dev_;
448 uint8_t interfaceId = INTERFACEID_1;
449 uint8_t pointid = POINTID_BULK_IN;
450 struct UsbPipe pipe = {interfaceId, pointid};
451 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
452 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
453 ASSERT_EQ(ret, 0);
454 for (auto _ : st) {
455 ret = g_usbInterface->BulkCancel(dev, pipe);
456 }
457 ASSERT_EQ(0, ret);
458 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
459 ASSERT_EQ(ret, 0);
460 }
461
462 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkRequestTest, SUB_USB_HDI_Benchmark_0280)
463 ->Iterations(100)
464 ->Repetitions(3)
465 ->ReportAggregatesOnly();
466 } // namespace
467
468 BENCHMARK_MAIN();
469