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 "HdfUsbdBenchmarkDeviceTest.h"
20 #include "hdf_log.h"
21 #include "v1_0/iusb_interface.h"
22
23 using namespace benchmark::internal;
24 using namespace std;
25 using namespace OHOS;
26 using namespace OHOS::USB;
27 using namespace OHOS::HDI::Usb::V1_0;
28
29 const int SLEEP_TIME = 3;
30 constexpr int32_t ITERATION_FREQUENCY = 100;
31 constexpr int32_t REPETITION_FREQUENCY = 3;
32
33 namespace {
34 sptr<IUsbInterface> g_usbInterface = nullptr;
35
36 struct UsbDev HdfUsbdBenchmarkDeviceTest::dev_ = { 0, 0 };
37
SetUp(const::benchmark::State & state)38 void HdfUsbdBenchmarkDeviceTest::SetUp(const ::benchmark::State& state)
39 {
40 g_usbInterface = IUsbInterface::Get();
41 ASSERT_NE(g_usbInterface, nullptr);
42 auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, POWER_ROLE_SOURCE, DATA_ROLE_HOST);
43 sleep(SLEEP_TIME);
44 ASSERT_EQ(0, ret);
45 }
46
TearDown(const::benchmark::State & state)47 void HdfUsbdBenchmarkDeviceTest::TearDown(const ::benchmark::State& state){}
48
InitPara(const sptr<UsbSubscriberTest> & subscriber)49 void HdfUsbdBenchmarkDeviceTest::InitPara(const sptr<UsbSubscriberTest> &subscriber)
50 {
51 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber);
52 ASSERT_EQ(0, ret);
53 dev_ = {subscriber->busNum_, subscriber->devAddr_};
54 ret = g_usbInterface->OpenDevice(dev_);
55 ASSERT_EQ(0, ret);
56 }
57
ReleasePara(const sptr<UsbSubscriberTest> & subscriber)58 void HdfUsbdBenchmarkDeviceTest::ReleasePara(const sptr<UsbSubscriberTest> &subscriber)
59 {
60 ASSERT_TRUE(g_usbInterface != nullptr);
61 auto ret = g_usbInterface->UnbindUsbdSubscriber(subscriber);
62 EXPECT_EQ(0, ret);
63 ret = g_usbInterface->CloseDevice(dev_);
64 ASSERT_EQ(0, ret);
65 }
66
67 /**
68 * @tc.name: SUB_USB_HDI_Benchmark_0010
69 * @tc.desc: Test functions to OpenDevice benchmark test
70 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
71 * @tc.desc: Positive test: parameters correctly
72 * @tc.type: FUNC
73 */
BENCHMARK_F(HdfUsbdBenchmarkDeviceTest,SUB_USB_HDI_Benchmark_0010)74 BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HDI_Benchmark_0010)
75 (benchmark::State& st)
76 {
77 ASSERT_NE(g_usbInterface, nullptr);
78 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
79 ASSERT_NE(subscriber, nullptr);
80 InitPara(subscriber);
81 struct UsbDev dev = dev_;
82 auto ret = 0;
83 for (auto _ : st) {
84 ret = g_usbInterface->OpenDevice(dev);
85 }
86 ASSERT_EQ(0, ret);
87 ReleasePara(subscriber);
88 }
89
90 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HDI_Benchmark_0010)
91 ->Iterations(ITERATION_FREQUENCY)
92 ->Repetitions(REPETITION_FREQUENCY)
93 ->ReportAggregatesOnly();
94
95 /**
96 * @tc.name: SUB_USB_HDI_Benchmark_0020
97 * @tc.desc: Test functions to CloseDevice benchmark test
98 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
99 * @tc.desc: Positive test: parameters correctly
100 * @tc.type: FUNC
101 */
BENCHMARK_F(HdfUsbdBenchmarkDeviceTest,SUB_USB_HDI_Benchmark_0020)102 BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HDI_Benchmark_0020)
103 (benchmark::State& st)
104 {
105 ASSERT_NE(g_usbInterface, nullptr);
106 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
107 ASSERT_NE(subscriber, nullptr);
108 InitPara(subscriber);
109 struct UsbDev dev = dev_;
110 int32_t ret;
111 for (auto _ : st) {
112 ret = g_usbInterface->OpenDevice(dev);
113 ASSERT_EQ(0, ret);
114 ret = g_usbInterface->CloseDevice(dev);
115 ASSERT_EQ(0, ret);
116 }
117 ReleasePara(subscriber);
118 }
119
120 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HDI_Benchmark_0020)
121 ->Iterations(ITERATION_FREQUENCY)
122 ->Repetitions(REPETITION_FREQUENCY)
123 ->ReportAggregatesOnly();
124 } // namespace
125
126 BENCHMARK_MAIN();
127