1 /*
2 * Copyright (c) 2022-2024 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_1/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 using namespace OHOS::HDI::Usb::V1_1;
29
30 const int SLEEP_TIME = 3;
31 constexpr int32_t ITERATION_FREQUENCY = 100;
32 constexpr int32_t REPETITION_FREQUENCY = 3;
33 const uint8_t INTERFACEID_INVALID = 255;
34 const uint8_t INTERFACEID_OK_NEW = 0;
35
36 namespace {
37 sptr<OHOS::HDI::Usb::V1_1::IUsbInterface> g_usbInterface = nullptr;
38
39 struct UsbDev HdfUsbdBenchmarkDeviceTest::dev_ = { 0, 0 };
40
SwitchErrCode(int32_t ret)41 int32_t SwitchErrCode(int32_t ret)
42 {
43 return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
44 }
45
SetUp(const ::benchmark::State& state)46 void HdfUsbdBenchmarkDeviceTest::SetUp(const ::benchmark::State& state)
47 {
48 g_usbInterface = OHOS::HDI::Usb::V1_1::IUsbInterface::Get();
49 ASSERT_NE(g_usbInterface, nullptr);
50 auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, POWER_ROLE_SOURCE, DATA_ROLE_HOST);
51 sleep(SLEEP_TIME);
52 ret = SwitchErrCode(ret);
53 ASSERT_EQ(0, ret);
54 }
55
TearDown(const ::benchmark::State& state)56 void HdfUsbdBenchmarkDeviceTest::TearDown(const ::benchmark::State& state){}
57
InitPara(const sptr<UsbSubscriberTest> &subscriber)58 void HdfUsbdBenchmarkDeviceTest::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 HdfUsbdBenchmarkDeviceTest::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_HostManager_HDI_Performance_1100
78 * @tc.desc: Test functions to OpenDevice benchmark test
79 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
80 * @tc.desc: Positive test: parameters correctly
81 * @tc.type: FUNC
82 */
BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1100)83 BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1100)
84 (benchmark::State& st)
85 {
86 ASSERT_NE(g_usbInterface, nullptr);
87 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
88 ASSERT_NE(subscriber, nullptr);
89 InitPara(subscriber);
90 struct UsbDev dev = dev_;
91 auto ret = -1;
92 for (auto _ : st) {
93 ret = g_usbInterface->OpenDevice(dev);
94 }
95 ASSERT_EQ(0, ret);
96 ReleasePara(subscriber);
97 }
98
99 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1100)
100 ->Iterations(ITERATION_FREQUENCY)
101 ->Repetitions(REPETITION_FREQUENCY)
102 ->ReportAggregatesOnly();
103
104 /**
105 * @tc.name: SUB_USB_HostManager_HDI_Performance_1200
106 * @tc.desc: Test functions to CloseDevice benchmark test
107 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
108 * @tc.desc: Positive test: parameters correctly
109 * @tc.type: FUNC
110 */
BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1200)111 BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1200)
112 (benchmark::State& st)
113 {
114 ASSERT_NE(g_usbInterface, nullptr);
115 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
116 ASSERT_NE(subscriber, nullptr);
117 InitPara(subscriber);
118 struct UsbDev dev = dev_;
119 int32_t ret;
120 for (auto _ : st) {
121 ret = g_usbInterface->OpenDevice(dev);
122 ASSERT_EQ(0, ret);
123 ret = g_usbInterface->CloseDevice(dev);
124 ASSERT_EQ(0, ret);
125 }
126 ReleasePara(subscriber);
127 }
128
129 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1200)
130 ->Iterations(ITERATION_FREQUENCY)
131 ->Repetitions(REPETITION_FREQUENCY)
132 ->ReportAggregatesOnly();
133
134 /**
135 * @tc.number : SUB_USB_HostManager_HDI_Performance_3100
136 * @tc.name : GetDeviceSpeedBenchmarkTest
137 * @tc.desc : int32_t GetDeviceSpeed(const UsbDev &dev, uint8_t interfaceId, uint8_t speed)
138 * @tc.desc : Positive test: parameters correctly
139 * @tc.size : MediumTest
140 * @tc.type : Function
141 * @tc.level : Level 3
142 */
BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, GetDeviceSpeedBenchmarkTest)143 BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, GetDeviceSpeedBenchmarkTest)
144 (benchmark::State& st)
145 {
146 ASSERT_NE(g_usbInterface, nullptr);
147 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
148 ASSERT_NE(subscriber, nullptr);
149 InitPara(subscriber);
150 struct UsbDev dev = dev_;
151 int32_t ret = -1;
152 uint8_t speed = 0;
153 for (auto _ : st) {
154 ret = g_usbInterface->GetDeviceSpeed(dev, speed);
155 }
156 ASSERT_EQ(0, ret);
157 ReleasePara(subscriber);
158 }
159
160 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkDeviceTest, GetDeviceSpeedBenchmarkTest)
161 ->Iterations(ITERATION_FREQUENCY)
162 ->Repetitions(REPETITION_FREQUENCY)
163 ->ReportAggregatesOnly();
164
165 /**
166 * @tc.number : SUB_USB_HostManager_HDI_Performance_3200
167 * @tc.name : GetInterfaceActiveStatusBenchmarkTest
168 * @tc.desc : int32_t GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool unactived)
169 * @tc.desc : Positive test: parameters correctly
170 * @tc.size : MediumTest
171 * @tc.type : Function
172 * @tc.level : Level 3
173 */
BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, GetInterfaceActiveStatusBenchmarkTest)174 BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, GetInterfaceActiveStatusBenchmarkTest)
175 (benchmark::State& st)
176 {
177 ASSERT_NE(g_usbInterface, nullptr);
178 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
179 ASSERT_NE(subscriber, nullptr);
180 InitPara(subscriber);
181 uint8_t interfaceId = INTERFACEID_OK_NEW;
182 struct UsbDev dev = dev_;
183 int32_t ret = -1;
184 bool unactived = 1;
185 ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
186 ASSERT_EQ(0, ret);
187 for (auto _ : st) {
188 for (; interfaceId < INTERFACEID_INVALID; interfaceId++) {
189 ret = g_usbInterface->GetInterfaceActiveStatus(dev, interfaceId, unactived);
190 if (ret == 0) {
191 break;
192 }
193 }
194 }
195 ASSERT_EQ(0, ret);
196 ReleasePara(subscriber);
197 }
198
199 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkDeviceTest, GetInterfaceActiveStatusBenchmarkTest)
200 ->Iterations(ITERATION_FREQUENCY)
201 ->Repetitions(REPETITION_FREQUENCY)
202 ->ReportAggregatesOnly();
203
204 } // namespace
205
206 BENCHMARK_MAIN();
207