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
SwitchErrCode(int32_t ret)38 int32_t SwitchErrCode(int32_t ret)
39 {
40 return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
41 }
42
SetUp(const::benchmark::State & state)43 void HdfUsbdBenchmarkDeviceTest::SetUp(const ::benchmark::State& state)
44 {
45 g_usbInterface = IUsbInterface::Get();
46 ASSERT_NE(g_usbInterface, nullptr);
47 auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, POWER_ROLE_SOURCE, DATA_ROLE_HOST);
48 sleep(SLEEP_TIME);
49 ret = SwitchErrCode(ret);
50 ASSERT_EQ(0, ret);
51 }
52
TearDown(const::benchmark::State & state)53 void HdfUsbdBenchmarkDeviceTest::TearDown(const ::benchmark::State& state){}
54
InitPara(const sptr<UsbSubscriberTest> & subscriber)55 void HdfUsbdBenchmarkDeviceTest::InitPara(const sptr<UsbSubscriberTest> &subscriber)
56 {
57 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber);
58 ASSERT_EQ(0, ret);
59 dev_ = {subscriber->busNum_, subscriber->devAddr_};
60 ret = g_usbInterface->OpenDevice(dev_);
61 ASSERT_EQ(0, ret);
62 }
63
ReleasePara(const sptr<UsbSubscriberTest> & subscriber)64 void HdfUsbdBenchmarkDeviceTest::ReleasePara(const sptr<UsbSubscriberTest> &subscriber)
65 {
66 ASSERT_TRUE(g_usbInterface != nullptr);
67 auto ret = g_usbInterface->UnbindUsbdSubscriber(subscriber);
68 EXPECT_EQ(0, ret);
69 ret = g_usbInterface->CloseDevice(dev_);
70 ASSERT_EQ(0, ret);
71 }
72
73 /**
74 * @tc.name: SUB_USB_HostManager_HDI_Performance_1100
75 * @tc.desc: Test functions to OpenDevice benchmark test
76 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
77 * @tc.desc: Positive test: parameters correctly
78 * @tc.type: FUNC
79 */
BENCHMARK_F(HdfUsbdBenchmarkDeviceTest,SUB_USB_HostManager_HDI_Performance_1100)80 BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1100)
81 (benchmark::State& st)
82 {
83 ASSERT_NE(g_usbInterface, nullptr);
84 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
85 ASSERT_NE(subscriber, nullptr);
86 InitPara(subscriber);
87 struct UsbDev dev = dev_;
88 auto ret = 0;
89 for (auto _ : st) {
90 ret = g_usbInterface->OpenDevice(dev);
91 }
92 ASSERT_EQ(0, ret);
93 ReleasePara(subscriber);
94 }
95
96 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1100)
97 ->Iterations(ITERATION_FREQUENCY)
98 ->Repetitions(REPETITION_FREQUENCY)
99 ->ReportAggregatesOnly();
100
101 /**
102 * @tc.name: SUB_USB_HostManager_HDI_Performance_1200
103 * @tc.desc: Test functions to CloseDevice benchmark test
104 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
105 * @tc.desc: Positive test: parameters correctly
106 * @tc.type: FUNC
107 */
BENCHMARK_F(HdfUsbdBenchmarkDeviceTest,SUB_USB_HostManager_HDI_Performance_1200)108 BENCHMARK_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1200)
109 (benchmark::State& st)
110 {
111 ASSERT_NE(g_usbInterface, nullptr);
112 sptr<UsbSubscriberTest> subscriber = new UsbSubscriberTest();
113 ASSERT_NE(subscriber, nullptr);
114 InitPara(subscriber);
115 struct UsbDev dev = dev_;
116 int32_t ret;
117 for (auto _ : st) {
118 ret = g_usbInterface->OpenDevice(dev);
119 ASSERT_EQ(0, ret);
120 ret = g_usbInterface->CloseDevice(dev);
121 ASSERT_EQ(0, ret);
122 }
123 ReleasePara(subscriber);
124 }
125
126 BENCHMARK_REGISTER_F(HdfUsbdBenchmarkDeviceTest, SUB_USB_HostManager_HDI_Performance_1200)
127 ->Iterations(ITERATION_FREQUENCY)
128 ->Repetitions(REPETITION_FREQUENCY)
129 ->ReportAggregatesOnly();
130 } // namespace
131
132 BENCHMARK_MAIN();
133