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